@aws-sdk/client-finspace 3.466.0 → 3.470.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,5 +1,5 @@
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { FinspaceServiceException as __BaseException } from "../models/FinspaceServiceException";
 import { AccessDeniedException, ConflictException, InternalServerException, InvalidRequestException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
@@ -79,7 +79,9 @@ export const se_CreateKxClusterCommand = async (input, context) => {
         initializationScript: [],
         releaseLabel: [],
         savedownStorageConfiguration: (_) => _json(_),
+        scalingGroupConfiguration: (_) => se_KxScalingGroupConfiguration(_, context),
         tags: (_) => _json(_),
+        tickerplantLogConfiguration: (_) => _json(_),
         vpcConfiguration: (_) => _json(_),
     }));
     return new __HttpRequest({
@@ -117,6 +119,37 @@ export const se_CreateKxDatabaseCommand = async (input, context) => {
         body,
     });
 };
+export const se_CreateKxDataviewCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/databases/{databaseName}/dataviews";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        autoUpdate: [],
+        availabilityZoneId: [],
+        azMode: [],
+        changesetId: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        dataviewName: [],
+        description: [],
+        segmentConfigurations: (_) => _json(_),
+        tags: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_CreateKxEnvironmentCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -125,7 +158,7 @@ export const se_CreateKxEnvironmentCommand = async (input, context) => {
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments";
     let body;
     body = JSON.stringify(take(input, {
-        clientToken: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
         description: [],
         kmsKeyId: [],
         name: [],
@@ -141,6 +174,32 @@ export const se_CreateKxEnvironmentCommand = async (input, context) => {
         body,
     });
 };
+export const se_CreateKxScalingGroupCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/scalingGroups";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        availabilityZoneId: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        hostType: [],
+        scalingGroupName: [],
+        tags: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_CreateKxUserCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -150,7 +209,7 @@ export const se_CreateKxUserCommand = async (input, context) => {
     resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
     let body;
     body = JSON.stringify(take(input, {
-        clientToken: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
         iamRole: [],
         tags: (_) => _json(_),
         userName: [],
@@ -165,6 +224,35 @@ export const se_CreateKxUserCommand = async (input, context) => {
         body,
     });
 };
+export const se_CreateKxVolumeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/kxvolumes";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        availabilityZoneIds: (_) => _json(_),
+        azMode: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        description: [],
+        nas1Configuration: (_) => _json(_),
+        tags: (_) => _json(_),
+        volumeName: [],
+        volumeType: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DeleteEnvironmentCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -225,11 +313,59 @@ export const se_DeleteKxDatabaseCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteKxDataviewCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "dataviewName", () => input.dataviewName, "{dataviewName}", false);
+    const query = map({
+        clientToken: [, __expectNonNull(input.clientToken, `clientToken`)],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_DeleteKxEnvironmentCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments/{environmentId}";
     resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    const query = map({
+        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_DeleteKxScalingGroupCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/scalingGroups/{scalingGroupName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "scalingGroupName", () => input.scalingGroupName, "{scalingGroupName}", false);
+    const query = map({
+        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+    });
     let body;
     return new __HttpRequest({
         protocol,
@@ -238,6 +374,7 @@ export const se_DeleteKxEnvironmentCommand = async (input, context) => {
         method: "DELETE",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
@@ -248,6 +385,31 @@ export const se_DeleteKxUserCommand = async (input, context) => {
         "/kx/environments/{environmentId}/users/{userName}";
     resolvedPath = __resolvedPath(resolvedPath, input, "userName", () => input.userName, "{userName}", false);
     resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    const query = map({
+        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_DeleteKxVolumeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/kxvolumes/{volumeName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "volumeName", () => input.volumeName, "{volumeName}", false);
+    const query = map({
+        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+    });
     let body;
     return new __HttpRequest({
         protocol,
@@ -256,6 +418,7 @@ export const se_DeleteKxUserCommand = async (input, context) => {
         method: "DELETE",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
@@ -352,6 +515,25 @@ export const se_GetKxDatabaseCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetKxDataviewCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "dataviewName", () => input.dataviewName, "{dataviewName}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_GetKxEnvironmentCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -368,6 +550,24 @@ export const se_GetKxEnvironmentCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetKxScalingGroupCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/scalingGroups/{scalingGroupName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "scalingGroupName", () => input.scalingGroupName, "{scalingGroupName}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_GetKxUserCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -386,6 +586,24 @@ export const se_GetKxUserCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetKxVolumeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/kxvolumes/{volumeName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "volumeName", () => input.volumeName, "{volumeName}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_ListEnvironmentsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -496,6 +714,29 @@ export const se_ListKxDatabasesCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListKxDataviewsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/databases/{databaseName}/dataviews";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
+    const query = map({
+        nextToken: [, input.nextToken],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListKxEnvironmentsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -516,6 +757,28 @@ export const se_ListKxEnvironmentsCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListKxScalingGroupsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/scalingGroups";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListKxUsersCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -537,6 +800,29 @@ export const se_ListKxUsersCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListKxVolumesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/kxvolumes";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+        volumeType: [, input.volumeType],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -697,18 +983,22 @@ export const se_UpdateKxDatabaseCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateKxEnvironmentCommand = async (input, context) => {
+export const se_UpdateKxDataviewCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments/{environmentId}";
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}";
     resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "dataviewName", () => input.dataviewName, "{dataviewName}", false);
     let body;
     body = JSON.stringify(take(input, {
-        clientToken: [],
+        changesetId: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
         description: [],
-        name: [],
+        segmentConfigurations: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -720,17 +1010,40 @@ export const se_UpdateKxEnvironmentCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateKxEnvironmentNetworkCommand = async (input, context) => {
+export const se_UpdateKxEnvironmentCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments/{environmentId}/network";
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments/{environmentId}";
     resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
     let body;
     body = JSON.stringify(take(input, {
-        clientToken: [],
-        customDNSConfiguration: (_) => _json(_),
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        description: [],
+        name: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateKxEnvironmentNetworkCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments/{environmentId}/network";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        customDNSConfiguration: (_) => _json(_),
         transitGatewayConfiguration: (_) => _json(_),
     }));
     return new __HttpRequest({
@@ -754,7 +1067,7 @@ export const se_UpdateKxUserCommand = async (input, context) => {
     resolvedPath = __resolvedPath(resolvedPath, input, "userName", () => input.userName, "{userName}", false);
     let body;
     body = JSON.stringify(take(input, {
-        clientToken: [],
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
         iamRole: [],
     }));
     return new __HttpRequest({
@@ -767,6 +1080,31 @@ export const se_UpdateKxUserCommand = async (input, context) => {
         body,
     });
 };
+export const se_UpdateKxVolumeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/kxvolumes/{volumeName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "volumeName", () => input.volumeName, "{volumeName}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        description: [],
+        nas1Configuration: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const de_CreateEnvironmentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CreateEnvironmentCommandError(output, context);
@@ -902,8 +1240,11 @@ export const de_CreateKxClusterCommand = async (output, context) => {
         lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         releaseLabel: __expectString,
         savedownStorageConfiguration: _json,
+        scalingGroupConfiguration: (_) => de_KxScalingGroupConfiguration(_, context),
         status: __expectString,
         statusReason: __expectString,
+        tickerplantLogConfiguration: _json,
+        volumes: _json,
         vpcConfiguration: _json,
     });
     Object.assign(contents, doc);
@@ -1005,27 +1346,32 @@ const de_CreateKxDatabaseCommandError = async (output, context) => {
             });
     }
 };
-export const de_CreateKxEnvironmentCommand = async (output, context) => {
+export const de_CreateKxDataviewCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateKxEnvironmentCommandError(output, context);
+        return de_CreateKxDataviewCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        creationTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        autoUpdate: __expectBoolean,
+        availabilityZoneId: __expectString,
+        azMode: __expectString,
+        changesetId: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databaseName: __expectString,
+        dataviewName: __expectString,
         description: __expectString,
-        environmentArn: __expectString,
         environmentId: __expectString,
-        kmsKeyId: __expectString,
-        name: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        segmentConfigurations: _json,
         status: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateKxEnvironmentCommandError = async (output, context) => {
+const de_CreateKxDataviewCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1044,9 +1390,12 @@ const de_CreateKxEnvironmentCommandError = async (output, context) => {
         case "LimitExceededException":
         case "com.amazonaws.finspace#LimitExceededException":
             throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.finspace#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ResourceAlreadyExistsException":
+        case "com.amazonaws.finspace#ResourceAlreadyExistsException":
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.finspace#ThrottlingException":
             throw await de_ThrottlingExceptionRes(parsedOutput, context);
@@ -1062,24 +1411,27 @@ const de_CreateKxEnvironmentCommandError = async (output, context) => {
             });
     }
 };
-export const de_CreateKxUserCommand = async (output, context) => {
+export const de_CreateKxEnvironmentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateKxUserCommandError(output, context);
+        return de_CreateKxEnvironmentCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
+        creationTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        description: __expectString,
+        environmentArn: __expectString,
         environmentId: __expectString,
-        iamRole: __expectString,
-        userArn: __expectString,
-        userName: __expectString,
+        kmsKeyId: __expectString,
+        name: __expectString,
+        status: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateKxUserCommandError = async (output, context) => {
+const de_CreateKxEnvironmentCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1098,12 +1450,9 @@ const de_CreateKxUserCommandError = async (output, context) => {
         case "LimitExceededException":
         case "com.amazonaws.finspace#LimitExceededException":
             throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceAlreadyExistsException":
-        case "com.amazonaws.finspace#ResourceAlreadyExistsException":
-            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.finspace#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.finspace#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.finspace#ThrottlingException":
             throw await de_ThrottlingExceptionRes(parsedOutput, context);
@@ -1119,17 +1468,27 @@ const de_CreateKxUserCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteEnvironmentCommand = async (output, context) => {
+export const de_CreateKxScalingGroupCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteEnvironmentCommandError(output, context);
+        return de_CreateKxScalingGroupCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        availabilityZoneId: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        environmentId: __expectString,
+        hostType: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        scalingGroupName: __expectString,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteEnvironmentCommandError = async (output, context) => {
+const de_CreateKxScalingGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1139,9 +1498,15 @@ const de_DeleteEnvironmentCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -1160,17 +1525,24 @@ const de_DeleteEnvironmentCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteKxClusterCommand = async (output, context) => {
+export const de_CreateKxUserCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteKxClusterCommandError(output, context);
+        return de_CreateKxUserCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        environmentId: __expectString,
+        iamRole: __expectString,
+        userArn: __expectString,
+        userName: __expectString,
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteKxClusterCommandError = async (output, context) => {
+const de_CreateKxUserCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1189,6 +1561,9 @@ const de_DeleteKxClusterCommandError = async (output, context) => {
         case "LimitExceededException":
         case "com.amazonaws.finspace#LimitExceededException":
             throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceAlreadyExistsException":
+        case "com.amazonaws.finspace#ResourceAlreadyExistsException":
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -1207,17 +1582,31 @@ const de_DeleteKxClusterCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteKxDatabaseCommand = async (output, context) => {
+export const de_CreateKxVolumeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteKxDatabaseCommandError(output, context);
+        return de_CreateKxVolumeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        availabilityZoneIds: _json,
+        azMode: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        description: __expectString,
+        environmentId: __expectString,
+        nas1Configuration: _json,
+        status: __expectString,
+        statusReason: __expectString,
+        volumeArn: __expectString,
+        volumeName: __expectString,
+        volumeType: __expectString,
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteKxDatabaseCommandError = async (output, context) => {
+const de_CreateKxVolumeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1233,6 +1622,12 @@ const de_DeleteKxDatabaseCommandError = async (output, context) => {
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceAlreadyExistsException":
+        case "com.amazonaws.finspace#ResourceAlreadyExistsException":
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -1251,9 +1646,9 @@ const de_DeleteKxDatabaseCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteKxEnvironmentCommand = async (output, context) => {
+export const de_DeleteEnvironmentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteKxEnvironmentCommandError(output, context);
+        return de_DeleteEnvironmentCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1261,7 +1656,7 @@ export const de_DeleteKxEnvironmentCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteKxEnvironmentCommandError = async (output, context) => {
+const de_DeleteEnvironmentCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1292,9 +1687,9 @@ const de_DeleteKxEnvironmentCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteKxUserCommand = async (output, context) => {
+export const de_DeleteKxClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteKxUserCommandError(output, context);
+        return de_DeleteKxClusterCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1302,7 +1697,7 @@ export const de_DeleteKxUserCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteKxUserCommandError = async (output, context) => {
+const de_DeleteKxClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1312,9 +1707,15 @@ const de_DeleteKxUserCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -1333,21 +1734,17 @@ const de_DeleteKxUserCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetEnvironmentCommand = async (output, context) => {
+export const de_DeleteKxDatabaseCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetEnvironmentCommandError(output, context);
+        return de_DeleteKxDatabaseCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        environment: _json,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_GetEnvironmentCommandError = async (output, context) => {
+const de_DeleteKxDatabaseCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1357,12 +1754,18 @@ const de_GetEnvironmentCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.finspace#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
@@ -1375,29 +1778,17 @@ const de_GetEnvironmentCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetKxChangesetCommand = async (output, context) => {
+export const de_DeleteKxDataviewCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetKxChangesetCommandError(output, context);
+        return de_DeleteKxDataviewCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        activeFromTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        changeRequests: _json,
-        changesetId: __expectString,
-        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        databaseName: __expectString,
-        environmentId: __expectString,
-        errorInfo: _json,
-        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        status: __expectString,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_GetKxChangesetCommandError = async (output, context) => {
+const de_DeleteKxDataviewCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1407,6 +1798,9 @@ const de_GetKxChangesetCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
@@ -1428,40 +1822,17 @@ const de_GetKxChangesetCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetKxClusterCommand = async (output, context) => {
+export const de_DeleteKxEnvironmentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetKxClusterCommandError(output, context);
+        return de_DeleteKxEnvironmentCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        autoScalingConfiguration: (_) => de_AutoScalingConfiguration(_, context),
-        availabilityZoneId: __expectString,
-        azMode: __expectString,
-        cacheStorageConfigurations: _json,
-        capacityConfiguration: _json,
-        clusterDescription: __expectString,
-        clusterName: __expectString,
-        clusterType: __expectString,
-        code: _json,
-        commandLineArguments: _json,
-        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        databases: _json,
-        executionRole: __expectString,
-        initializationScript: __expectString,
-        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        releaseLabel: __expectString,
-        savedownStorageConfiguration: _json,
-        status: __expectString,
-        statusReason: __expectString,
-        vpcConfiguration: _json,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_GetKxClusterCommandError = async (output, context) => {
+const de_DeleteKxEnvironmentCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1477,9 +1848,6 @@ const de_GetKxClusterCommandError = async (output, context) => {
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.finspace#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -1498,21 +1866,17 @@ const de_GetKxClusterCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetKxConnectionStringCommand = async (output, context) => {
+export const de_DeleteKxScalingGroupCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetKxConnectionStringCommandError(output, context);
+        return de_DeleteKxScalingGroupCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        signedConnectionString: __expectString,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_GetKxConnectionStringCommandError = async (output, context) => {
+const de_DeleteKxScalingGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1522,9 +1886,15 @@ const de_GetKxConnectionStringCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -1543,7 +1913,311 @@ const de_GetKxConnectionStringCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetKxDatabaseCommand = async (output, context) => {
+export const de_DeleteKxUserCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteKxUserCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteKxUserCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_DeleteKxVolumeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteKxVolumeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteKxVolumeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetEnvironmentCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetEnvironmentCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        environment: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetEnvironmentCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetKxChangesetCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetKxChangesetCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        activeFromTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        changeRequests: _json,
+        changesetId: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databaseName: __expectString,
+        environmentId: __expectString,
+        errorInfo: _json,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetKxChangesetCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetKxClusterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetKxClusterCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        autoScalingConfiguration: (_) => de_AutoScalingConfiguration(_, context),
+        availabilityZoneId: __expectString,
+        azMode: __expectString,
+        cacheStorageConfigurations: _json,
+        capacityConfiguration: _json,
+        clusterDescription: __expectString,
+        clusterName: __expectString,
+        clusterType: __expectString,
+        code: _json,
+        commandLineArguments: _json,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databases: _json,
+        executionRole: __expectString,
+        initializationScript: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        releaseLabel: __expectString,
+        savedownStorageConfiguration: _json,
+        scalingGroupConfiguration: (_) => de_KxScalingGroupConfiguration(_, context),
+        status: __expectString,
+        statusReason: __expectString,
+        tickerplantLogConfiguration: _json,
+        volumes: _json,
+        vpcConfiguration: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetKxClusterCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetKxConnectionStringCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetKxConnectionStringCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        signedConnectionString: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetKxConnectionStringCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetKxDatabaseCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetKxDatabaseCommandError(output, context);
     }
@@ -1566,7 +2240,65 @@ export const de_GetKxDatabaseCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetKxDatabaseCommandError = async (output, context) => {
+const de_GetKxDatabaseCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetKxDataviewCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetKxDataviewCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        activeVersions: (_) => de_KxDataviewActiveVersionList(_, context),
+        autoUpdate: __expectBoolean,
+        availabilityZoneId: __expectString,
+        azMode: __expectString,
+        changesetId: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databaseName: __expectString,
+        dataviewName: __expectString,
+        description: __expectString,
+        environmentId: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        segmentConfigurations: _json,
+        status: __expectString,
+        statusReason: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetKxDataviewCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1637,12 +2369,74 @@ const de_GetKxEnvironmentCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetKxScalingGroupCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetKxScalingGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        availabilityZoneId: __expectString,
+        clusters: _json,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        hostType: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        scalingGroupArn: __expectString,
+        scalingGroupName: __expectString,
+        status: __expectString,
+        statusReason: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetKxScalingGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.finspace#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
@@ -1703,6 +2497,69 @@ const de_GetKxUserCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetKxVolumeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetKxVolumeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        attachedClusters: _json,
+        availabilityZoneIds: _json,
+        azMode: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        description: __expectString,
+        environmentId: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        nas1Configuration: _json,
+        status: __expectString,
+        statusReason: __expectString,
+        volumeArn: __expectString,
+        volumeName: __expectString,
+        volumeType: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetKxVolumeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListEnvironmentsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListEnvironmentsCommandError(output, context);
@@ -1725,9 +2582,159 @@ const de_ListEnvironmentsCommandError = async (output, context) => {
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListKxChangesetsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListKxChangesetsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        kxChangesets: (_) => de_KxChangesets(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListKxChangesetsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListKxClusterNodesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListKxClusterNodesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        nodes: (_) => de_KxNodeSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListKxClusterNodesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListKxClustersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListKxClustersCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        kxClusterSummaries: (_) => de_KxClusters(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListKxClustersCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.finspace#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
@@ -1740,22 +2747,22 @@ const de_ListEnvironmentsCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListKxChangesetsCommand = async (output, context) => {
+export const de_ListKxDatabasesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListKxChangesetsCommandError(output, context);
+        return de_ListKxDatabasesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        kxChangesets: (_) => de_KxChangesets(_, context),
+        kxDatabases: (_) => de_KxDatabases(_, context),
         nextToken: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListKxChangesetsCommandError = async (output, context) => {
+const de_ListKxDatabasesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1786,22 +2793,22 @@ const de_ListKxChangesetsCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListKxClusterNodesCommand = async (output, context) => {
+export const de_ListKxDataviewsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListKxClusterNodesCommandError(output, context);
+        return de_ListKxDataviewsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
+        kxDataviews: (_) => de_KxDataviews(_, context),
         nextToken: __expectString,
-        nodes: (_) => de_KxNodeSummaries(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListKxClusterNodesCommandError = async (output, context) => {
+const de_ListKxDataviewsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1814,9 +2821,6 @@ const de_ListKxClusterNodesCommandError = async (output, context) => {
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.finspace#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -1835,22 +2839,22 @@ const de_ListKxClusterNodesCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListKxClustersCommand = async (output, context) => {
+export const de_ListKxEnvironmentsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListKxClustersCommandError(output, context);
+        return de_ListKxEnvironmentsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        kxClusterSummaries: (_) => de_KxClusters(_, context),
+        environments: (_) => de_KxEnvironmentList(_, context),
         nextToken: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListKxClustersCommandError = async (output, context) => {
+const de_ListKxEnvironmentsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1860,21 +2864,9 @@ const de_ListKxClustersCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ConflictException":
-        case "com.amazonaws.finspace#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.finspace#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.finspace#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.finspace#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.finspace#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
@@ -1887,22 +2879,22 @@ const de_ListKxClustersCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListKxDatabasesCommand = async (output, context) => {
+export const de_ListKxScalingGroupsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListKxDatabasesCommandError(output, context);
+        return de_ListKxScalingGroupsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        kxDatabases: (_) => de_KxDatabases(_, context),
         nextToken: __expectString,
+        scalingGroups: (_) => de_KxScalingGroupList(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListKxDatabasesCommandError = async (output, context) => {
+const de_ListKxScalingGroupsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1912,9 +2904,15 @@ const de_ListKxDatabasesCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -1933,31 +2931,40 @@ const de_ListKxDatabasesCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListKxEnvironmentsCommand = async (output, context) => {
+export const de_ListKxUsersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListKxEnvironmentsCommandError(output, context);
+        return de_ListKxUsersCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        environments: (_) => de_KxEnvironmentList(_, context),
         nextToken: __expectString,
+        users: (_) => de_KxUserList(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListKxEnvironmentsCommandError = async (output, context) => {
+const de_ListKxUsersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.finspace#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
@@ -1970,22 +2977,22 @@ const de_ListKxEnvironmentsCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListKxUsersCommand = async (output, context) => {
+export const de_ListKxVolumesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListKxUsersCommandError(output, context);
+        return de_ListKxVolumesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
+        kxVolumeSummaries: (_) => de_KxVolumes(_, context),
         nextToken: __expectString,
-        users: (_) => de_KxUserList(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListKxUsersCommandError = async (output, context) => {
+const de_ListKxVolumesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1995,9 +3002,15 @@ const de_ListKxUsersCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.finspace#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.finspace#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.finspace#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
@@ -2315,6 +3328,69 @@ const de_UpdateKxDatabaseCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdateKxDataviewCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateKxDataviewCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        activeVersions: (_) => de_KxDataviewActiveVersionList(_, context),
+        autoUpdate: __expectBoolean,
+        availabilityZoneId: __expectString,
+        azMode: __expectString,
+        changesetId: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databaseName: __expectString,
+        dataviewName: __expectString,
+        description: __expectString,
+        environmentId: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        segmentConfigurations: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateKxDataviewCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceAlreadyExistsException":
+        case "com.amazonaws.finspace#ResourceAlreadyExistsException":
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_UpdateKxEnvironmentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_UpdateKxEnvironmentCommandError(output, context);
@@ -2495,6 +3571,69 @@ const de_UpdateKxUserCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdateKxVolumeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateKxVolumeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        attachedClusters: _json,
+        availabilityZoneIds: _json,
+        azMode: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        description: __expectString,
+        environmentId: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        nas1Configuration: _json,
+        status: __expectString,
+        statusReason: __expectString,
+        volumeArn: __expectString,
+        volumeName: __expectString,
+        volumeType: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateKxVolumeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.finspace#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.finspace#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.finspace#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.finspace#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.finspace#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 const throwDefaultError = withBaseException(__BaseException);
 const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
@@ -2637,6 +3776,15 @@ const se_AutoScalingConfiguration = (input, context) => {
         scaleOutCooldownSeconds: __serializeFloat,
     });
 };
+const se_KxScalingGroupConfiguration = (input, context) => {
+    return take(input, {
+        cpu: __serializeFloat,
+        memoryLimit: [],
+        memoryReservation: [],
+        nodeCount: [],
+        scalingGroupName: [],
+    });
+};
 const de_AutoScalingConfiguration = (output, context) => {
     return take(output, {
         autoScalingMetric: __expectString,
@@ -2678,6 +3826,7 @@ const de_KxCluster = (output, context) => {
         releaseLabel: __expectString,
         status: __expectString,
         statusReason: __expectString,
+        volumes: _json,
     });
 };
 const de_KxClusters = (output, context) => {
@@ -2703,6 +3852,49 @@ const de_KxDatabases = (output, context) => {
     });
     return retVal;
 };
+const de_KxDataviewActiveVersion = (output, context) => {
+    return take(output, {
+        attachedClusters: _json,
+        changesetId: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        segmentConfigurations: _json,
+        versionId: __expectString,
+    });
+};
+const de_KxDataviewActiveVersionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxDataviewActiveVersion(entry, context);
+    });
+    return retVal;
+};
+const de_KxDataviewListEntry = (output, context) => {
+    return take(output, {
+        activeVersions: (_) => de_KxDataviewActiveVersionList(_, context),
+        autoUpdate: __expectBoolean,
+        availabilityZoneId: __expectString,
+        azMode: __expectString,
+        changesetId: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databaseName: __expectString,
+        dataviewName: __expectString,
+        description: __expectString,
+        environmentId: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        segmentConfigurations: _json,
+        status: __expectString,
+        statusReason: __expectString,
+    });
+};
+const de_KxDataviews = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxDataviewListEntry(entry, context);
+    });
+    return retVal;
+};
 const de_KxEnvironment = (output, context) => {
     return take(output, {
         availabilityZoneIds: _json,
@@ -2747,6 +3939,35 @@ const de_KxNodeSummaries = (output, context) => {
     });
     return retVal;
 };
+const de_KxScalingGroup = (output, context) => {
+    return take(output, {
+        availabilityZoneId: __expectString,
+        clusters: _json,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        hostType: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        scalingGroupName: __expectString,
+        status: __expectString,
+        statusReason: __expectString,
+    });
+};
+const de_KxScalingGroupConfiguration = (output, context) => {
+    return take(output, {
+        cpu: __limitedParseDouble,
+        memoryLimit: __expectInt32,
+        memoryReservation: __expectInt32,
+        nodeCount: __expectInt32,
+        scalingGroupName: __expectString,
+    });
+};
+const de_KxScalingGroupList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxScalingGroup(entry, context);
+    });
+    return retVal;
+};
 const de_KxUser = (output, context) => {
     return take(output, {
         createTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
@@ -2764,6 +3985,27 @@ const de_KxUserList = (output, context) => {
     });
     return retVal;
 };
+const de_KxVolume = (output, context) => {
+    return take(output, {
+        availabilityZoneIds: _json,
+        azMode: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        description: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        status: __expectString,
+        statusReason: __expectString,
+        volumeName: __expectString,
+        volumeType: __expectString,
+    });
+};
+const de_KxVolumes = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxVolume(entry, context);
+    });
+    return retVal;
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],