@aws-sdk/client-finspace-data 3.40.0 → 3.45.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeAws_restJson1GetWorkingLocationCommand = exports.deserializeAws_restJson1GetProgrammaticAccessCredentialsCommand = exports.deserializeAws_restJson1CreateChangesetCommand = exports.serializeAws_restJson1GetWorkingLocationCommand = exports.serializeAws_restJson1GetProgrammaticAccessCredentialsCommand = exports.serializeAws_restJson1CreateChangesetCommand = void 0;
+exports.deserializeAws_restJson1UpdateDatasetCommand = exports.deserializeAws_restJson1UpdateChangesetCommand = exports.deserializeAws_restJson1ListDataViewsCommand = exports.deserializeAws_restJson1ListDatasetsCommand = exports.deserializeAws_restJson1ListChangesetsCommand = exports.deserializeAws_restJson1GetWorkingLocationCommand = exports.deserializeAws_restJson1GetProgrammaticAccessCredentialsCommand = exports.deserializeAws_restJson1GetDataViewCommand = exports.deserializeAws_restJson1GetDatasetCommand = exports.deserializeAws_restJson1GetChangesetCommand = exports.deserializeAws_restJson1DeleteDatasetCommand = exports.deserializeAws_restJson1CreateDataViewCommand = exports.deserializeAws_restJson1CreateDatasetCommand = exports.deserializeAws_restJson1CreateChangesetCommand = exports.serializeAws_restJson1UpdateDatasetCommand = exports.serializeAws_restJson1UpdateChangesetCommand = exports.serializeAws_restJson1ListDataViewsCommand = exports.serializeAws_restJson1ListDatasetsCommand = exports.serializeAws_restJson1ListChangesetsCommand = exports.serializeAws_restJson1GetWorkingLocationCommand = exports.serializeAws_restJson1GetProgrammaticAccessCredentialsCommand = exports.serializeAws_restJson1GetDataViewCommand = exports.serializeAws_restJson1GetDatasetCommand = exports.serializeAws_restJson1GetChangesetCommand = exports.serializeAws_restJson1DeleteDatasetCommand = exports.serializeAws_restJson1CreateDataViewCommand = exports.serializeAws_restJson1CreateDatasetCommand = exports.serializeAws_restJson1CreateChangesetCommand = void 0;
 const protocol_http_1 = require("@aws-sdk/protocol-http");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
+const uuid_1 = require("uuid");
 const serializeAws_restJson1CreateChangesetCommand = async (input, context) => {
+    var _a;
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasets/{datasetId}/changesets";
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasets/{datasetId}/changesetsv2";
     if (input.datasetId !== undefined) {
         const labelValue = input.datasetId;
         if (labelValue.length <= 0) {
@@ -22,14 +24,11 @@ const serializeAws_restJson1CreateChangesetCommand = async (input, context) => {
     let body;
     body = JSON.stringify({
         ...(input.changeType !== undefined && input.changeType !== null && { changeType: input.changeType }),
+        clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : uuid_1.v4(),
         ...(input.formatParams !== undefined &&
-            input.formatParams !== null && { formatParams: serializeAws_restJson1stringMap(input.formatParams, context) }),
-        ...(input.formatType !== undefined && input.formatType !== null && { formatType: input.formatType }),
+            input.formatParams !== null && { formatParams: serializeAws_restJson1FormatParams(input.formatParams, context) }),
         ...(input.sourceParams !== undefined &&
-            input.sourceParams !== null && { sourceParams: serializeAws_restJson1stringMap(input.sourceParams, context) }),
-        ...(input.sourceType !== undefined && input.sourceType !== null && { sourceType: input.sourceType }),
-        ...(input.tags !== undefined &&
-            input.tags !== null && { tags: serializeAws_restJson1stringMap(input.tags, context) }),
+            input.sourceParams !== null && { sourceParams: serializeAws_restJson1SourceParams(input.sourceParams, context) }),
     });
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -42,6 +41,217 @@ const serializeAws_restJson1CreateChangesetCommand = async (input, context) => {
     });
 };
 exports.serializeAws_restJson1CreateChangesetCommand = serializeAws_restJson1CreateChangesetCommand;
+const serializeAws_restJson1CreateDatasetCommand = async (input, context) => {
+    var _a;
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasetsv2";
+    let body;
+    body = JSON.stringify({
+        ...(input.alias !== undefined && input.alias !== null && { alias: input.alias }),
+        clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : uuid_1.v4(),
+        ...(input.datasetDescription !== undefined &&
+            input.datasetDescription !== null && { datasetDescription: input.datasetDescription }),
+        ...(input.datasetTitle !== undefined && input.datasetTitle !== null && { datasetTitle: input.datasetTitle }),
+        ...(input.kind !== undefined && input.kind !== null && { kind: input.kind }),
+        ...(input.ownerInfo !== undefined &&
+            input.ownerInfo !== null && { ownerInfo: serializeAws_restJson1DatasetOwnerInfo(input.ownerInfo, context) }),
+        ...(input.permissionGroupParams !== undefined &&
+            input.permissionGroupParams !== null && {
+            permissionGroupParams: serializeAws_restJson1PermissionGroupParams(input.permissionGroupParams, context),
+        }),
+        ...(input.schemaDefinition !== undefined &&
+            input.schemaDefinition !== null && {
+            schemaDefinition: serializeAws_restJson1SchemaUnion(input.schemaDefinition, context),
+        }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateDatasetCommand = serializeAws_restJson1CreateDatasetCommand;
+const serializeAws_restJson1CreateDataViewCommand = async (input, context) => {
+    var _a;
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasets/{datasetId}/dataviewsv2";
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.asOfTimestamp !== undefined && input.asOfTimestamp !== null && { asOfTimestamp: input.asOfTimestamp }),
+        ...(input.autoUpdate !== undefined && input.autoUpdate !== null && { autoUpdate: input.autoUpdate }),
+        clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : uuid_1.v4(),
+        ...(input.destinationTypeParams !== undefined &&
+            input.destinationTypeParams !== null && {
+            destinationTypeParams: serializeAws_restJson1DataViewDestinationTypeParams(input.destinationTypeParams, context),
+        }),
+        ...(input.partitionColumns !== undefined &&
+            input.partitionColumns !== null && {
+            partitionColumns: serializeAws_restJson1PartitionColumnList(input.partitionColumns, context),
+        }),
+        ...(input.sortColumns !== undefined &&
+            input.sortColumns !== null && { sortColumns: serializeAws_restJson1SortColumnList(input.sortColumns, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateDataViewCommand = serializeAws_restJson1CreateDataViewCommand;
+const serializeAws_restJson1DeleteDatasetCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasetsv2/{datasetId}";
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    const query = {
+        ...(input.clientToken !== undefined && { clientToken: input.clientToken }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteDatasetCommand = serializeAws_restJson1DeleteDatasetCommand;
+const serializeAws_restJson1GetChangesetCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/datasets/{datasetId}/changesetsv2/{changesetId}";
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    if (input.changesetId !== undefined) {
+        const labelValue = input.changesetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: changesetId.");
+        }
+        resolvedPath = resolvedPath.replace("{changesetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: changesetId.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetChangesetCommand = serializeAws_restJson1GetChangesetCommand;
+const serializeAws_restJson1GetDatasetCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasetsv2/{datasetId}";
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetDatasetCommand = serializeAws_restJson1GetDatasetCommand;
+const serializeAws_restJson1GetDataViewCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/datasets/{datasetId}/dataviewsv2/{dataViewId}";
+    if (input.dataViewId !== undefined) {
+        const labelValue = input.dataViewId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: dataViewId.");
+        }
+        resolvedPath = resolvedPath.replace("{dataViewId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: dataViewId.");
+    }
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetDataViewCommand = serializeAws_restJson1GetDataViewCommand;
 const serializeAws_restJson1GetProgrammaticAccessCredentialsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -83,23 +293,1298 @@ const serializeAws_restJson1GetWorkingLocationCommand = async (input, context) =
         body,
     });
 };
-exports.serializeAws_restJson1GetWorkingLocationCommand = serializeAws_restJson1GetWorkingLocationCommand;
-const deserializeAws_restJson1CreateChangesetCommand = async (output, context) => {
+exports.serializeAws_restJson1GetWorkingLocationCommand = serializeAws_restJson1GetWorkingLocationCommand;
+const serializeAws_restJson1ListChangesetsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasets/{datasetId}/changesetsv2";
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    const query = {
+        ...(input.maxResults !== undefined && { maxResults: input.maxResults.toString() }),
+        ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListChangesetsCommand = serializeAws_restJson1ListChangesetsCommand;
+const serializeAws_restJson1ListDatasetsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasetsv2";
+    const query = {
+        ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
+        ...(input.maxResults !== undefined && { maxResults: input.maxResults.toString() }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListDatasetsCommand = serializeAws_restJson1ListDatasetsCommand;
+const serializeAws_restJson1ListDataViewsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasets/{datasetId}/dataviewsv2";
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    const query = {
+        ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
+        ...(input.maxResults !== undefined && { maxResults: input.maxResults.toString() }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListDataViewsCommand = serializeAws_restJson1ListDataViewsCommand;
+const serializeAws_restJson1UpdateChangesetCommand = async (input, context) => {
+    var _a;
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/datasets/{datasetId}/changesetsv2/{changesetId}";
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    if (input.changesetId !== undefined) {
+        const labelValue = input.changesetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: changesetId.");
+        }
+        resolvedPath = resolvedPath.replace("{changesetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: changesetId.");
+    }
+    let body;
+    body = JSON.stringify({
+        clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : uuid_1.v4(),
+        ...(input.formatParams !== undefined &&
+            input.formatParams !== null && { formatParams: serializeAws_restJson1FormatParams(input.formatParams, context) }),
+        ...(input.sourceParams !== undefined &&
+            input.sourceParams !== null && { sourceParams: serializeAws_restJson1SourceParams(input.sourceParams, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateChangesetCommand = serializeAws_restJson1UpdateChangesetCommand;
+const serializeAws_restJson1UpdateDatasetCommand = async (input, context) => {
+    var _a;
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/datasetsv2/{datasetId}";
+    if (input.datasetId !== undefined) {
+        const labelValue = input.datasetId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: datasetId.");
+        }
+        resolvedPath = resolvedPath.replace("{datasetId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: datasetId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.alias !== undefined && input.alias !== null && { alias: input.alias }),
+        clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : uuid_1.v4(),
+        ...(input.datasetDescription !== undefined &&
+            input.datasetDescription !== null && { datasetDescription: input.datasetDescription }),
+        ...(input.datasetTitle !== undefined && input.datasetTitle !== null && { datasetTitle: input.datasetTitle }),
+        ...(input.kind !== undefined && input.kind !== null && { kind: input.kind }),
+        ...(input.schemaDefinition !== undefined &&
+            input.schemaDefinition !== null && {
+            schemaDefinition: serializeAws_restJson1SchemaUnion(input.schemaDefinition, context),
+        }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateDatasetCommand = serializeAws_restJson1UpdateDatasetCommand;
+const deserializeAws_restJson1CreateChangesetCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateChangesetCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        changesetId: undefined,
+        datasetId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.changesetId !== undefined && data.changesetId !== null) {
+        contents.changesetId = smithy_client_1.expectString(data.changesetId);
+    }
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateChangesetCommand = deserializeAws_restJson1CreateChangesetCommand;
+const deserializeAws_restJson1CreateChangesetCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspacedata#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "LimitExceededException":
+        case "com.amazonaws.finspacedata#LimitExceededException":
+            response = {
+                ...(await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1CreateDatasetCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateDatasetCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        datasetId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateDatasetCommand = deserializeAws_restJson1CreateDatasetCommand;
+const deserializeAws_restJson1CreateDatasetCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspacedata#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "LimitExceededException":
+        case "com.amazonaws.finspacedata#LimitExceededException":
+            response = {
+                ...(await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1CreateDataViewCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateDataViewCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        dataViewId: undefined,
+        datasetId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.dataViewId !== undefined && data.dataViewId !== null) {
+        contents.dataViewId = smithy_client_1.expectString(data.dataViewId);
+    }
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateDataViewCommand = deserializeAws_restJson1CreateDataViewCommand;
+const deserializeAws_restJson1CreateDataViewCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "LimitExceededException":
+        case "com.amazonaws.finspacedata#LimitExceededException":
+            response = {
+                ...(await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1DeleteDatasetCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteDatasetCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        datasetId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1DeleteDatasetCommand = deserializeAws_restJson1DeleteDatasetCommand;
+const deserializeAws_restJson1DeleteDatasetCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspacedata#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "LimitExceededException":
+        case "com.amazonaws.finspacedata#LimitExceededException":
+            response = {
+                ...(await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetChangesetCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetChangesetCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        activeFromTimestamp: undefined,
+        activeUntilTimestamp: undefined,
+        changeType: undefined,
+        changesetArn: undefined,
+        changesetId: undefined,
+        createTime: undefined,
+        datasetId: undefined,
+        errorInfo: undefined,
+        formatParams: undefined,
+        sourceParams: undefined,
+        status: undefined,
+        updatedByChangesetId: undefined,
+        updatesChangesetId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.activeFromTimestamp !== undefined && data.activeFromTimestamp !== null) {
+        contents.activeFromTimestamp = smithy_client_1.expectLong(data.activeFromTimestamp);
+    }
+    if (data.activeUntilTimestamp !== undefined && data.activeUntilTimestamp !== null) {
+        contents.activeUntilTimestamp = smithy_client_1.expectLong(data.activeUntilTimestamp);
+    }
+    if (data.changeType !== undefined && data.changeType !== null) {
+        contents.changeType = smithy_client_1.expectString(data.changeType);
+    }
+    if (data.changesetArn !== undefined && data.changesetArn !== null) {
+        contents.changesetArn = smithy_client_1.expectString(data.changesetArn);
+    }
+    if (data.changesetId !== undefined && data.changesetId !== null) {
+        contents.changesetId = smithy_client_1.expectString(data.changesetId);
+    }
+    if (data.createTime !== undefined && data.createTime !== null) {
+        contents.createTime = smithy_client_1.expectLong(data.createTime);
+    }
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
+    }
+    if (data.errorInfo !== undefined && data.errorInfo !== null) {
+        contents.errorInfo = deserializeAws_restJson1ChangesetErrorInfo(data.errorInfo, context);
+    }
+    if (data.formatParams !== undefined && data.formatParams !== null) {
+        contents.formatParams = deserializeAws_restJson1FormatParams(data.formatParams, context);
+    }
+    if (data.sourceParams !== undefined && data.sourceParams !== null) {
+        contents.sourceParams = deserializeAws_restJson1SourceParams(data.sourceParams, context);
+    }
+    if (data.status !== undefined && data.status !== null) {
+        contents.status = smithy_client_1.expectString(data.status);
+    }
+    if (data.updatedByChangesetId !== undefined && data.updatedByChangesetId !== null) {
+        contents.updatedByChangesetId = smithy_client_1.expectString(data.updatedByChangesetId);
+    }
+    if (data.updatesChangesetId !== undefined && data.updatesChangesetId !== null) {
+        contents.updatesChangesetId = smithy_client_1.expectString(data.updatesChangesetId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetChangesetCommand = deserializeAws_restJson1GetChangesetCommand;
+const deserializeAws_restJson1GetChangesetCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspacedata#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetDatasetCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetDatasetCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        alias: undefined,
+        createTime: undefined,
+        datasetArn: undefined,
+        datasetDescription: undefined,
+        datasetId: undefined,
+        datasetTitle: undefined,
+        kind: undefined,
+        lastModifiedTime: undefined,
+        schemaDefinition: undefined,
+        status: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.alias !== undefined && data.alias !== null) {
+        contents.alias = smithy_client_1.expectString(data.alias);
+    }
+    if (data.createTime !== undefined && data.createTime !== null) {
+        contents.createTime = smithy_client_1.expectLong(data.createTime);
+    }
+    if (data.datasetArn !== undefined && data.datasetArn !== null) {
+        contents.datasetArn = smithy_client_1.expectString(data.datasetArn);
+    }
+    if (data.datasetDescription !== undefined && data.datasetDescription !== null) {
+        contents.datasetDescription = smithy_client_1.expectString(data.datasetDescription);
+    }
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
+    }
+    if (data.datasetTitle !== undefined && data.datasetTitle !== null) {
+        contents.datasetTitle = smithy_client_1.expectString(data.datasetTitle);
+    }
+    if (data.kind !== undefined && data.kind !== null) {
+        contents.kind = smithy_client_1.expectString(data.kind);
+    }
+    if (data.lastModifiedTime !== undefined && data.lastModifiedTime !== null) {
+        contents.lastModifiedTime = smithy_client_1.expectLong(data.lastModifiedTime);
+    }
+    if (data.schemaDefinition !== undefined && data.schemaDefinition !== null) {
+        contents.schemaDefinition = deserializeAws_restJson1SchemaUnion(data.schemaDefinition, context);
+    }
+    if (data.status !== undefined && data.status !== null) {
+        contents.status = smithy_client_1.expectString(data.status);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetDatasetCommand = deserializeAws_restJson1GetDatasetCommand;
+const deserializeAws_restJson1GetDatasetCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspacedata#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetDataViewCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetDataViewCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        asOfTimestamp: undefined,
+        autoUpdate: undefined,
+        createTime: undefined,
+        dataViewArn: undefined,
+        dataViewId: undefined,
+        datasetId: undefined,
+        destinationTypeParams: undefined,
+        errorInfo: undefined,
+        lastModifiedTime: undefined,
+        partitionColumns: undefined,
+        sortColumns: undefined,
+        status: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.asOfTimestamp !== undefined && data.asOfTimestamp !== null) {
+        contents.asOfTimestamp = smithy_client_1.expectLong(data.asOfTimestamp);
+    }
+    if (data.autoUpdate !== undefined && data.autoUpdate !== null) {
+        contents.autoUpdate = smithy_client_1.expectBoolean(data.autoUpdate);
+    }
+    if (data.createTime !== undefined && data.createTime !== null) {
+        contents.createTime = smithy_client_1.expectLong(data.createTime);
+    }
+    if (data.dataViewArn !== undefined && data.dataViewArn !== null) {
+        contents.dataViewArn = smithy_client_1.expectString(data.dataViewArn);
+    }
+    if (data.dataViewId !== undefined && data.dataViewId !== null) {
+        contents.dataViewId = smithy_client_1.expectString(data.dataViewId);
+    }
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
+    }
+    if (data.destinationTypeParams !== undefined && data.destinationTypeParams !== null) {
+        contents.destinationTypeParams = deserializeAws_restJson1DataViewDestinationTypeParams(data.destinationTypeParams, context);
+    }
+    if (data.errorInfo !== undefined && data.errorInfo !== null) {
+        contents.errorInfo = deserializeAws_restJson1DataViewErrorInfo(data.errorInfo, context);
+    }
+    if (data.lastModifiedTime !== undefined && data.lastModifiedTime !== null) {
+        contents.lastModifiedTime = smithy_client_1.expectLong(data.lastModifiedTime);
+    }
+    if (data.partitionColumns !== undefined && data.partitionColumns !== null) {
+        contents.partitionColumns = deserializeAws_restJson1PartitionColumnList(data.partitionColumns, context);
+    }
+    if (data.sortColumns !== undefined && data.sortColumns !== null) {
+        contents.sortColumns = deserializeAws_restJson1SortColumnList(data.sortColumns, context);
+    }
+    if (data.status !== undefined && data.status !== null) {
+        contents.status = smithy_client_1.expectString(data.status);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetDataViewCommand = deserializeAws_restJson1GetDataViewCommand;
+const deserializeAws_restJson1GetDataViewCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetProgrammaticAccessCredentialsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetProgrammaticAccessCredentialsCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        credentials: undefined,
+        durationInMinutes: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.credentials !== undefined && data.credentials !== null) {
+        contents.credentials = deserializeAws_restJson1Credentials(data.credentials, context);
+    }
+    if (data.durationInMinutes !== undefined && data.durationInMinutes !== null) {
+        contents.durationInMinutes = smithy_client_1.expectLong(data.durationInMinutes);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetProgrammaticAccessCredentialsCommand = deserializeAws_restJson1GetProgrammaticAccessCredentialsCommand;
+const deserializeAws_restJson1GetProgrammaticAccessCredentialsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspacedata#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetWorkingLocationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetWorkingLocationCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        s3Bucket: undefined,
+        s3Path: undefined,
+        s3Uri: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.s3Bucket !== undefined && data.s3Bucket !== null) {
+        contents.s3Bucket = smithy_client_1.expectString(data.s3Bucket);
+    }
+    if (data.s3Path !== undefined && data.s3Path !== null) {
+        contents.s3Path = smithy_client_1.expectString(data.s3Path);
+    }
+    if (data.s3Uri !== undefined && data.s3Uri !== null) {
+        contents.s3Uri = smithy_client_1.expectString(data.s3Uri);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetWorkingLocationCommand = deserializeAws_restJson1GetWorkingLocationCommand;
+const deserializeAws_restJson1GetWorkingLocationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspacedata#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListChangesetsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListChangesetsCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        changesets: undefined,
+        nextToken: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.changesets !== undefined && data.changesets !== null) {
+        contents.changesets = deserializeAws_restJson1ChangesetList(data.changesets, context);
+    }
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListChangesetsCommand = deserializeAws_restJson1ListChangesetsCommand;
+const deserializeAws_restJson1ListChangesetsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspacedata#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListDatasetsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListDatasetsCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        datasets: undefined,
+        nextToken: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.datasets !== undefined && data.datasets !== null) {
+        contents.datasets = deserializeAws_restJson1DatasetList(data.datasets, context);
+    }
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListDatasetsCommand = deserializeAws_restJson1ListDatasetsCommand;
+const deserializeAws_restJson1ListDatasetsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.finspacedata#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.finspacedata#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListDataViewsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateChangesetCommandError(output, context);
+        return deserializeAws_restJson1ListDataViewsCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
-        changeset: undefined,
+        dataViews: undefined,
+        nextToken: undefined,
     };
     const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.changeset !== undefined && data.changeset !== null) {
-        contents.changeset = deserializeAws_restJson1ChangesetInfo(data.changeset, context);
+    if (data.dataViews !== undefined && data.dataViews !== null) {
+        contents.dataViews = deserializeAws_restJson1DataViewList(data.dataViews, context);
+    }
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
     }
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1CreateChangesetCommand = deserializeAws_restJson1CreateChangesetCommand;
-const deserializeAws_restJson1CreateChangesetCommandError = async (output, context) => {
+exports.deserializeAws_restJson1ListDataViewsCommand = deserializeAws_restJson1ListDataViewsCommand;
+const deserializeAws_restJson1ListDataViewsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -108,10 +1593,10 @@ const deserializeAws_restJson1CreateChangesetCommandError = async (output, conte
     let errorCode = "UnknownError";
     errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.finspacedata#AccessDeniedException":
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
             response = {
-                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
                 name: errorCode,
                 $metadata: deserializeMetadata(output),
             };
@@ -164,26 +1649,26 @@ const deserializeAws_restJson1CreateChangesetCommandError = async (output, conte
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1GetProgrammaticAccessCredentialsCommand = async (output, context) => {
+const deserializeAws_restJson1UpdateChangesetCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetProgrammaticAccessCredentialsCommandError(output, context);
+        return deserializeAws_restJson1UpdateChangesetCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
-        credentials: undefined,
-        durationInMinutes: undefined,
+        changesetId: undefined,
+        datasetId: undefined,
     };
     const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.credentials !== undefined && data.credentials !== null) {
-        contents.credentials = deserializeAws_restJson1Credentials(data.credentials, context);
+    if (data.changesetId !== undefined && data.changesetId !== null) {
+        contents.changesetId = smithy_client_1.expectString(data.changesetId);
     }
-    if (data.durationInMinutes !== undefined && data.durationInMinutes !== null) {
-        contents.durationInMinutes = smithy_client_1.expectLong(data.durationInMinutes);
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
     }
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1GetProgrammaticAccessCredentialsCommand = deserializeAws_restJson1GetProgrammaticAccessCredentialsCommand;
-const deserializeAws_restJson1GetProgrammaticAccessCredentialsCommandError = async (output, context) => {
+exports.deserializeAws_restJson1UpdateChangesetCommand = deserializeAws_restJson1UpdateChangesetCommand;
+const deserializeAws_restJson1UpdateChangesetCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -200,6 +1685,14 @@ const deserializeAws_restJson1GetProgrammaticAccessCredentialsCommandError = asy
                 $metadata: deserializeMetadata(output),
             };
             break;
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "InternalServerException":
         case "com.amazonaws.finspacedata#InternalServerException":
             response = {
@@ -208,6 +1701,14 @@ const deserializeAws_restJson1GetProgrammaticAccessCredentialsCommandError = asy
                 $metadata: deserializeMetadata(output),
             };
             break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "ThrottlingException":
         case "com.amazonaws.finspacedata#ThrottlingException":
             response = {
@@ -216,6 +1717,14 @@ const deserializeAws_restJson1GetProgrammaticAccessCredentialsCommandError = asy
                 $metadata: deserializeMetadata(output),
             };
             break;
+        case "ValidationException":
+        case "com.amazonaws.finspacedata#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         default:
             const parsedBody = parsedOutput.body;
             errorCode = parsedBody.code || parsedBody.Code || errorCode;
@@ -232,30 +1741,22 @@ const deserializeAws_restJson1GetProgrammaticAccessCredentialsCommandError = asy
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1GetWorkingLocationCommand = async (output, context) => {
+const deserializeAws_restJson1UpdateDatasetCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetWorkingLocationCommandError(output, context);
+        return deserializeAws_restJson1UpdateDatasetCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
-        s3Bucket: undefined,
-        s3Path: undefined,
-        s3Uri: undefined,
+        datasetId: undefined,
     };
     const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.s3Bucket !== undefined && data.s3Bucket !== null) {
-        contents.s3Bucket = smithy_client_1.expectString(data.s3Bucket);
-    }
-    if (data.s3Path !== undefined && data.s3Path !== null) {
-        contents.s3Path = smithy_client_1.expectString(data.s3Path);
-    }
-    if (data.s3Uri !== undefined && data.s3Uri !== null) {
-        contents.s3Uri = smithy_client_1.expectString(data.s3Uri);
+    if (data.datasetId !== undefined && data.datasetId !== null) {
+        contents.datasetId = smithy_client_1.expectString(data.datasetId);
     }
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1GetWorkingLocationCommand = deserializeAws_restJson1GetWorkingLocationCommand;
-const deserializeAws_restJson1GetWorkingLocationCommandError = async (output, context) => {
+exports.deserializeAws_restJson1UpdateDatasetCommand = deserializeAws_restJson1UpdateDatasetCommand;
+const deserializeAws_restJson1UpdateDatasetCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -272,6 +1773,14 @@ const deserializeAws_restJson1GetWorkingLocationCommandError = async (output, co
                 $metadata: deserializeMetadata(output),
             };
             break;
+        case "ConflictException":
+        case "com.amazonaws.finspacedata#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "InternalServerException":
         case "com.amazonaws.finspacedata#InternalServerException":
             response = {
@@ -280,6 +1789,14 @@ const deserializeAws_restJson1GetWorkingLocationCommandError = async (output, co
                 $metadata: deserializeMetadata(output),
             };
             break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspacedata#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "ThrottlingException":
         case "com.amazonaws.finspacedata#ThrottlingException":
             response = {
@@ -325,6 +1842,19 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     }
     return contents;
 };
+const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "ConflictException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
 const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
     const contents = {
         name: "InternalServerException",
@@ -338,6 +1868,19 @@ const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOut
     }
     return contents;
 };
+const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "LimitExceededException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
 const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
     const contents = {
         name: "ResourceNotFoundException",
@@ -373,7 +1916,141 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     }
     return contents;
 };
-const serializeAws_restJson1stringMap = (input, context) => {
+const serializeAws_restJson1ColumnDefinition = (input, context) => {
+    return {
+        ...(input.columnDescription !== undefined &&
+            input.columnDescription !== null && { columnDescription: input.columnDescription }),
+        ...(input.columnName !== undefined && input.columnName !== null && { columnName: input.columnName }),
+        ...(input.dataType !== undefined && input.dataType !== null && { dataType: input.dataType }),
+    };
+};
+const serializeAws_restJson1ColumnList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1ColumnDefinition(entry, context);
+    });
+};
+const serializeAws_restJson1ColumnNameList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1DatasetOwnerInfo = (input, context) => {
+    return {
+        ...(input.email !== undefined && input.email !== null && { email: input.email }),
+        ...(input.name !== undefined && input.name !== null && { name: input.name }),
+        ...(input.phoneNumber !== undefined && input.phoneNumber !== null && { phoneNumber: input.phoneNumber }),
+    };
+};
+const serializeAws_restJson1DataViewDestinationTypeParams = (input, context) => {
+    return {
+        ...(input.destinationType !== undefined &&
+            input.destinationType !== null && { destinationType: input.destinationType }),
+        ...(input.s3DestinationExportFileFormat !== undefined &&
+            input.s3DestinationExportFileFormat !== null && {
+            s3DestinationExportFileFormat: input.s3DestinationExportFileFormat,
+        }),
+        ...(input.s3DestinationExportFileFormatOptions !== undefined &&
+            input.s3DestinationExportFileFormatOptions !== null && {
+            s3DestinationExportFileFormatOptions: serializeAws_restJson1S3DestinationFormatOptions(input.s3DestinationExportFileFormatOptions, context),
+        }),
+    };
+};
+const serializeAws_restJson1FormatParams = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+};
+const serializeAws_restJson1PartitionColumnList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1PermissionGroupParams = (input, context) => {
+    return {
+        ...(input.datasetPermissions !== undefined &&
+            input.datasetPermissions !== null && {
+            datasetPermissions: serializeAws_restJson1ResourcePermissionsList(input.datasetPermissions, context),
+        }),
+        ...(input.permissionGroupId !== undefined &&
+            input.permissionGroupId !== null && { permissionGroupId: input.permissionGroupId }),
+    };
+};
+const serializeAws_restJson1ResourcePermission = (input, context) => {
+    return {
+        ...(input.permission !== undefined && input.permission !== null && { permission: input.permission }),
+    };
+};
+const serializeAws_restJson1ResourcePermissionsList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1ResourcePermission(entry, context);
+    });
+};
+const serializeAws_restJson1S3DestinationFormatOptions = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+};
+const serializeAws_restJson1SchemaDefinition = (input, context) => {
+    return {
+        ...(input.columns !== undefined &&
+            input.columns !== null && { columns: serializeAws_restJson1ColumnList(input.columns, context) }),
+        ...(input.primaryKeyColumns !== undefined &&
+            input.primaryKeyColumns !== null && {
+            primaryKeyColumns: serializeAws_restJson1ColumnNameList(input.primaryKeyColumns, context),
+        }),
+    };
+};
+const serializeAws_restJson1SchemaUnion = (input, context) => {
+    return {
+        ...(input.tabularSchemaConfig !== undefined &&
+            input.tabularSchemaConfig !== null && {
+            tabularSchemaConfig: serializeAws_restJson1SchemaDefinition(input.tabularSchemaConfig, context),
+        }),
+    };
+};
+const serializeAws_restJson1SortColumnList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1SourceParams = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -384,34 +2061,72 @@ const serializeAws_restJson1stringMap = (input, context) => {
         };
     }, {});
 };
-const deserializeAws_restJson1ChangesetInfo = (output, context) => {
+const deserializeAws_restJson1ChangesetErrorInfo = (output, context) => {
+    return {
+        errorCategory: smithy_client_1.expectString(output.errorCategory),
+        errorMessage: smithy_client_1.expectString(output.errorMessage),
+    };
+};
+const deserializeAws_restJson1ChangesetList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ChangesetSummary(entry, context);
+    });
+};
+const deserializeAws_restJson1ChangesetSummary = (output, context) => {
     return {
+        activeFromTimestamp: smithy_client_1.expectLong(output.activeFromTimestamp),
+        activeUntilTimestamp: smithy_client_1.expectLong(output.activeUntilTimestamp),
         changeType: smithy_client_1.expectString(output.changeType),
         changesetArn: smithy_client_1.expectString(output.changesetArn),
-        changesetLabels: output.changesetLabels !== undefined && output.changesetLabels !== null
-            ? deserializeAws_restJson1stringMap(output.changesetLabels, context)
-            : undefined,
-        createTimestamp: output.createTimestamp !== undefined && output.createTimestamp !== null
-            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.createTimestamp)))
-            : undefined,
+        changesetId: smithy_client_1.expectString(output.changesetId),
+        createTime: smithy_client_1.expectLong(output.createTime),
         datasetId: smithy_client_1.expectString(output.datasetId),
         errorInfo: output.errorInfo !== undefined && output.errorInfo !== null
-            ? deserializeAws_restJson1ErrorInfo(output.errorInfo, context)
+            ? deserializeAws_restJson1ChangesetErrorInfo(output.errorInfo, context)
             : undefined,
         formatParams: output.formatParams !== undefined && output.formatParams !== null
-            ? deserializeAws_restJson1stringMap(output.formatParams, context)
+            ? deserializeAws_restJson1FormatParams(output.formatParams, context)
             : undefined,
-        formatType: smithy_client_1.expectString(output.formatType),
-        id: smithy_client_1.expectString(output.id),
         sourceParams: output.sourceParams !== undefined && output.sourceParams !== null
-            ? deserializeAws_restJson1stringMap(output.sourceParams, context)
+            ? deserializeAws_restJson1SourceParams(output.sourceParams, context)
             : undefined,
-        sourceType: smithy_client_1.expectString(output.sourceType),
         status: smithy_client_1.expectString(output.status),
         updatedByChangesetId: smithy_client_1.expectString(output.updatedByChangesetId),
         updatesChangesetId: smithy_client_1.expectString(output.updatesChangesetId),
     };
 };
+const deserializeAws_restJson1ColumnDefinition = (output, context) => {
+    return {
+        columnDescription: smithy_client_1.expectString(output.columnDescription),
+        columnName: smithy_client_1.expectString(output.columnName),
+        dataType: smithy_client_1.expectString(output.dataType),
+    };
+};
+const deserializeAws_restJson1ColumnList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ColumnDefinition(entry, context);
+    });
+};
+const deserializeAws_restJson1ColumnNameList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
 const deserializeAws_restJson1Credentials = (output, context) => {
     return {
         accessKeyId: smithy_client_1.expectString(output.accessKeyId),
@@ -419,13 +2134,150 @@ const deserializeAws_restJson1Credentials = (output, context) => {
         sessionToken: smithy_client_1.expectString(output.sessionToken),
     };
 };
-const deserializeAws_restJson1ErrorInfo = (output, context) => {
+const deserializeAws_restJson1Dataset = (output, context) => {
+    return {
+        alias: smithy_client_1.expectString(output.alias),
+        createTime: smithy_client_1.expectLong(output.createTime),
+        datasetArn: smithy_client_1.expectString(output.datasetArn),
+        datasetDescription: smithy_client_1.expectString(output.datasetDescription),
+        datasetId: smithy_client_1.expectString(output.datasetId),
+        datasetTitle: smithy_client_1.expectString(output.datasetTitle),
+        kind: smithy_client_1.expectString(output.kind),
+        lastModifiedTime: smithy_client_1.expectLong(output.lastModifiedTime),
+        ownerInfo: output.ownerInfo !== undefined && output.ownerInfo !== null
+            ? deserializeAws_restJson1DatasetOwnerInfo(output.ownerInfo, context)
+            : undefined,
+        schemaDefinition: output.schemaDefinition !== undefined && output.schemaDefinition !== null
+            ? deserializeAws_restJson1SchemaUnion(output.schemaDefinition, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1DatasetList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Dataset(entry, context);
+    });
+};
+const deserializeAws_restJson1DatasetOwnerInfo = (output, context) => {
+    return {
+        email: smithy_client_1.expectString(output.email),
+        name: smithy_client_1.expectString(output.name),
+        phoneNumber: smithy_client_1.expectString(output.phoneNumber),
+    };
+};
+const deserializeAws_restJson1DataViewDestinationTypeParams = (output, context) => {
+    return {
+        destinationType: smithy_client_1.expectString(output.destinationType),
+        s3DestinationExportFileFormat: smithy_client_1.expectString(output.s3DestinationExportFileFormat),
+        s3DestinationExportFileFormatOptions: output.s3DestinationExportFileFormatOptions !== undefined && output.s3DestinationExportFileFormatOptions !== null
+            ? deserializeAws_restJson1S3DestinationFormatOptions(output.s3DestinationExportFileFormatOptions, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1DataViewErrorInfo = (output, context) => {
     return {
         errorCategory: smithy_client_1.expectString(output.errorCategory),
         errorMessage: smithy_client_1.expectString(output.errorMessage),
     };
 };
-const deserializeAws_restJson1stringMap = (output, context) => {
+const deserializeAws_restJson1DataViewList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1DataViewSummary(entry, context);
+    });
+};
+const deserializeAws_restJson1DataViewSummary = (output, context) => {
+    return {
+        asOfTimestamp: smithy_client_1.expectLong(output.asOfTimestamp),
+        autoUpdate: smithy_client_1.expectBoolean(output.autoUpdate),
+        createTime: smithy_client_1.expectLong(output.createTime),
+        dataViewArn: smithy_client_1.expectString(output.dataViewArn),
+        dataViewId: smithy_client_1.expectString(output.dataViewId),
+        datasetId: smithy_client_1.expectString(output.datasetId),
+        destinationTypeProperties: output.destinationTypeProperties !== undefined && output.destinationTypeProperties !== null
+            ? deserializeAws_restJson1DataViewDestinationTypeParams(output.destinationTypeProperties, context)
+            : undefined,
+        errorInfo: output.errorInfo !== undefined && output.errorInfo !== null
+            ? deserializeAws_restJson1DataViewErrorInfo(output.errorInfo, context)
+            : undefined,
+        lastModifiedTime: smithy_client_1.expectLong(output.lastModifiedTime),
+        partitionColumns: output.partitionColumns !== undefined && output.partitionColumns !== null
+            ? deserializeAws_restJson1PartitionColumnList(output.partitionColumns, context)
+            : undefined,
+        sortColumns: output.sortColumns !== undefined && output.sortColumns !== null
+            ? deserializeAws_restJson1SortColumnList(output.sortColumns, context)
+            : undefined,
+        status: smithy_client_1.expectString(output.status),
+    };
+};
+const deserializeAws_restJson1FormatParams = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: smithy_client_1.expectString(value),
+        };
+    }, {});
+};
+const deserializeAws_restJson1PartitionColumnList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_restJson1S3DestinationFormatOptions = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: smithy_client_1.expectString(value),
+        };
+    }, {});
+};
+const deserializeAws_restJson1SchemaDefinition = (output, context) => {
+    return {
+        columns: output.columns !== undefined && output.columns !== null
+            ? deserializeAws_restJson1ColumnList(output.columns, context)
+            : undefined,
+        primaryKeyColumns: output.primaryKeyColumns !== undefined && output.primaryKeyColumns !== null
+            ? deserializeAws_restJson1ColumnNameList(output.primaryKeyColumns, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1SchemaUnion = (output, context) => {
+    return {
+        tabularSchemaConfig: output.tabularSchemaConfig !== undefined && output.tabularSchemaConfig !== null
+            ? deserializeAws_restJson1SchemaDefinition(output.tabularSchemaConfig, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1SortColumnList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_restJson1SourceParams = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;