@aws-sdk/client-finspace 3.344.0 → 3.346.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,7 +1,8 @@
-import { _json, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, resolvedPath as __resolvedPath, take, withBaseException, } from "@aws-sdk/smithy-client";
+import { _json, 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 "@aws-sdk/smithy-client";
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
+import { v4 as generateIdempotencyToken } from "uuid";
 import { FinspaceServiceException as __BaseException } from "../models/FinspaceServiceException";
-import { AccessDeniedException, InternalServerException, InvalidRequestException, LimitExceededException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, ConflictException, InternalServerException, InvalidRequestException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
 export const se_CreateEnvironmentCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -29,6 +30,141 @@ export const se_CreateEnvironmentCommand = async (input, context) => {
         body,
     });
 };
+export const se_CreateKxChangesetCommand = 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}/changesets";
+    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, {
+        changeRequests: (_) => _json(_),
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_CreateKxClusterCommand = 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}/clusters";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        autoScalingConfiguration: (_) => se_AutoScalingConfiguration(_, context),
+        availabilityZoneId: [],
+        azMode: [],
+        cacheStorageConfigurations: (_) => _json(_),
+        capacityConfiguration: (_) => _json(_),
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        clusterDescription: [],
+        clusterName: [],
+        clusterType: [],
+        code: (_) => _json(_),
+        commandLineArguments: (_) => _json(_),
+        databases: (_) => _json(_),
+        executionRole: [],
+        initializationScript: [],
+        releaseLabel: [],
+        savedownStorageConfiguration: (_) => _json(_),
+        tags: (_) => _json(_),
+        vpcConfiguration: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_CreateKxDatabaseCommand = 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";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        databaseName: [],
+        description: [],
+        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 = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments";
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [],
+        description: [],
+        kmsKeyId: [],
+        name: [],
+        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 = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments/{environmentId}/users";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [],
+        iamRole: [],
+        tags: (_) => _json(_),
+        userName: [],
+    }));
+    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 = {};
@@ -45,6 +181,84 @@ export const se_DeleteEnvironmentCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteKxClusterCommand = 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}/clusters/{clusterName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", 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_DeleteKxDatabaseCommand = 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}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", 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);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_DeleteKxUserCommand = 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}/users/{userName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "userName", () => input.userName, "{userName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_GetEnvironmentCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -61,13 +275,52 @@ export const se_GetEnvironmentCommand = async (input, context) => {
         body,
     });
 };
-export const se_ListEnvironmentsCommand = async (input, context) => {
+export const se_GetKxChangesetCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/environment";
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/databases/{databaseName}/changesets/{changesetId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "changesetId", () => input.changesetId, "{changesetId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_GetKxClusterCommand = 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}/clusters/{clusterName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_GetKxConnectionStringCommand = 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}/connectionString";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        userArn: [, __expectNonNull(input.userArn, `userArn`)],
+        clusterName: [, __expectNonNull(input.clusterName, `clusterName`)],
     });
     let body;
     return new __HttpRequest({
@@ -81,11 +334,13 @@ export const se_ListEnvironmentsCommand = async (input, context) => {
         body,
     });
 };
-export const se_ListTagsForResourceCommand = async (input, context) => {
+export const se_GetKxDatabaseCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/databases/{databaseName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
     let body;
     return new __HttpRequest({
         protocol,
@@ -97,91 +352,1612 @@ export const se_ListTagsForResourceCommand = async (input, context) => {
         body,
     });
 };
-export const se_TagResourceCommand = async (input, context) => {
+export const se_GetKxEnvironmentCommand = 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 || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const headers = {};
+    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, {
-        tags: (_) => _json(_),
-    }));
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "POST",
+        method: "GET",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const se_UntagResourceCommand = async (input, context) => {
+export const se_GetKxUserCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/users/{userName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "userName", () => input.userName, "{userName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", 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 = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/environment";
     const query = map({
-        tagKeys: [
-            __expectNonNull(input.tagKeys, `tagKeys`) != null,
-            () => (input.tagKeys || []).map((_entry) => _entry),
-        ],
+        nextToken: [, input.nextToken],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
     });
     let body;
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "DELETE",
+        method: "GET",
         headers,
         path: resolvedPath,
         query,
         body,
     });
 };
-export const se_UpdateEnvironmentCommand = async (input, context) => {
+export const se_ListKxChangesetsCommand = 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 || ""}` + "/environment/{environmentId}";
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/kx/environments/{environmentId}/databases/{databaseName}/changesets";
     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;
-    body = JSON.stringify(take(input, {
-        description: [],
-        federationMode: [],
-        federationParameters: (_) => _json(_),
-        name: [],
-    }));
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "PUT",
+        method: "GET",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
-export const de_CreateEnvironmentCommand = async (output, context) => {
+export const se_ListKxClusterNodesCommand = 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}/clusters/{clusterName}/nodes";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", 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_ListKxClustersCommand = 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}/clusters";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    const query = map({
+        clusterType: [, input.clusterType],
+        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_ListKxDatabasesCommand = 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";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", 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 = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/kx/environments";
+    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_ListKxUsersCommand = 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}/users";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", 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_ListTagsForResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_TagResourceCommand = 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 || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        tags: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UntagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const query = map({
+        tagKeys: [
+            __expectNonNull(input.tagKeys, `tagKeys`) != null,
+            () => (input.tagKeys || []).map((_entry) => _entry),
+        ],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_UpdateEnvironmentCommand = 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 || ""}` + "/environment/{environmentId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        federationMode: [],
+        federationParameters: (_) => _json(_),
+        name: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateKxClusterDatabasesCommand = 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}/clusters/{clusterName}/configuration/databases";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [],
+        databases: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateKxDatabaseCommand = 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}";
+    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, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        description: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+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}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [],
+        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: [],
+        customDNSConfiguration: (_) => _json(_),
+        transitGatewayConfiguration: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateKxUserCommand = 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}/users/{userName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "userName", () => input.userName, "{userName}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [],
+        iamRole: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const de_CreateEnvironmentCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateEnvironmentCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        environmentArn: __expectString,
+        environmentId: __expectString,
+        environmentUrl: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreateEnvironmentCommandError = 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 "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);
+        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_CreateKxChangesetCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateKxChangesetCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        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_CreateKxChangesetCommandError = 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_CreateKxClusterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateKxClusterCommandError(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,
+        environmentId: __expectString,
+        executionRole: __expectString,
+        initializationScript: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        releaseLabel: __expectString,
+        savedownStorageConfiguration: _json,
+        status: __expectString,
+        statusReason: __expectString,
+        vpcConfiguration: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreateKxClusterCommandError = 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_CreateKxDatabaseCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateKxDatabaseCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databaseArn: __expectString,
+        databaseName: __expectString,
+        description: __expectString,
+        environmentId: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreateKxDatabaseCommandError = 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 "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_CreateKxEnvironmentCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        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,
+        kmsKeyId: __expectString,
+        name: __expectString,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreateKxEnvironmentCommandError = 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 "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);
+        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_CreateKxUserCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateKxUserCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    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_CreateKxUserCommandError = 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 "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_DeleteEnvironmentCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteEnvironmentCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteEnvironmentCommandError = 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_DeleteKxClusterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteKxClusterCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteKxClusterCommandError = 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_DeleteKxDatabaseCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteKxDatabaseCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteKxDatabaseCommandError = 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_DeleteKxEnvironmentCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteKxEnvironmentCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteKxEnvironmentCommandError = 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_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 "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_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,
+        status: __expectString,
+        statusReason: __expectString,
+        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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databaseArn: __expectString,
+        databaseName: __expectString,
+        description: __expectString,
+        environmentId: __expectString,
+        lastCompletedChangesetId: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        numBytes: __expectLong,
+        numChangesets: __expectInt32,
+        numFiles: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+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_GetKxEnvironmentCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetKxEnvironmentCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        availabilityZoneIds: _json,
+        awsAccountId: __expectString,
+        certificateAuthorityArn: __expectString,
+        creationTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        customDNSConfiguration: _json,
+        dedicatedServiceAccountId: __expectString,
+        description: __expectString,
+        dnsStatus: __expectString,
+        environmentArn: __expectString,
+        environmentId: __expectString,
+        errorMessage: __expectString,
+        kmsKeyId: __expectString,
+        name: __expectString,
+        status: __expectString,
+        tgwStatus: __expectString,
+        transitGatewayConfiguration: _json,
+        updateTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetKxEnvironmentCommandError = 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_GetKxUserCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetKxUserCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    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_GetKxUserCommandError = 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_ListEnvironmentsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateEnvironmentCommandError(output, context);
+        return de_ListEnvironmentsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        environmentArn: __expectString,
-        environmentId: __expectString,
-        environmentUrl: __expectString,
+        environments: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListEnvironmentsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        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);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListKxDatabasesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        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, {
+        kxDatabases: (_) => de_KxDatabases(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListKxDatabasesCommandError = 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_ListKxEnvironmentsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        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, {
+        environments: (_) => de_KxEnvironmentList(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListKxEnvironmentsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        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_ListKxUsersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        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, {
+        nextToken: __expectString,
+        users: (_) => de_KxUserList(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateEnvironmentCommandError = async (output, context) => {
+const de_ListKxUsersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -194,12 +1970,9 @@ const de_CreateEnvironmentCommandError = 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 "ServiceQuotaExceededException":
-        case "com.amazonaws.finspace#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(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);
@@ -215,9 +1988,48 @@ const de_CreateEnvironmentCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteEnvironmentCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteEnvironmentCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        tags: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.finspace#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_TagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -225,28 +2037,22 @@ export const de_DeleteEnvironmentCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteEnvironmentCommandError = async (output, context) => {
+const de_TagResourceCommandError = 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 "InvalidRequestException":
+        case "com.amazonaws.finspace#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(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({
@@ -256,9 +2062,44 @@ const de_DeleteEnvironmentCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetEnvironmentCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetEnvironmentCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.finspace#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.finspace#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.finspace#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateEnvironmentCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateEnvironmentCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -270,7 +2111,7 @@ export const de_GetEnvironmentCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetEnvironmentCommandError = async (output, context) => {
+const de_UpdateEnvironmentCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -286,6 +2127,9 @@ const de_GetEnvironmentCommandError = async (output, 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);
@@ -298,31 +2142,38 @@ const de_GetEnvironmentCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListEnvironmentsCommand = async (output, context) => {
+export const de_UpdateKxClusterDatabasesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListEnvironmentsCommandError(output, context);
+        return de_UpdateKxClusterDatabasesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        environments: _json,
-        nextToken: __expectString,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_ListEnvironmentsCommandError = async (output, context) => {
+const de_UpdateKxClusterDatabasesCommandError = 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);
@@ -335,36 +2186,48 @@ const de_ListEnvironmentsCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListTagsForResourceCommand = async (output, context) => {
+export const de_UpdateKxDatabaseCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListTagsForResourceCommandError(output, context);
+        return de_UpdateKxDatabaseCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        tags: _json,
+        databaseName: __expectString,
+        description: __expectString,
+        environmentId: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListTagsForResourceCommandError = async (output, context) => {
+const de_UpdateKxDatabaseCommandError = 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 "InvalidRequestException":
-        case "com.amazonaws.finspace#InvalidRequestException":
-            throw await de_InvalidRequestExceptionRes(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({
@@ -374,32 +2237,60 @@ const de_ListTagsForResourceCommandError = async (output, context) => {
             });
     }
 };
-export const de_TagResourceCommand = async (output, context) => {
+export const de_UpdateKxEnvironmentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_TagResourceCommandError(output, context);
+        return de_UpdateKxEnvironmentCommandError(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,
+        awsAccountId: __expectString,
+        creationTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        customDNSConfiguration: _json,
+        dedicatedServiceAccountId: __expectString,
+        description: __expectString,
+        dnsStatus: __expectString,
+        environmentArn: __expectString,
+        environmentId: __expectString,
+        errorMessage: __expectString,
+        kmsKeyId: __expectString,
+        name: __expectString,
+        status: __expectString,
+        tgwStatus: __expectString,
+        transitGatewayConfiguration: _json,
+        updateTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_TagResourceCommandError = async (output, context) => {
+const de_UpdateKxEnvironmentCommandError = 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 "InvalidRequestException":
-        case "com.amazonaws.finspace#InvalidRequestException":
-            throw await de_InvalidRequestExceptionRes(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({
@@ -409,32 +2300,60 @@ const de_TagResourceCommandError = async (output, context) => {
             });
     }
 };
-export const de_UntagResourceCommand = async (output, context) => {
+export const de_UpdateKxEnvironmentNetworkCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UntagResourceCommandError(output, context);
+        return de_UpdateKxEnvironmentNetworkCommandError(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,
+        awsAccountId: __expectString,
+        creationTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        customDNSConfiguration: _json,
+        dedicatedServiceAccountId: __expectString,
+        description: __expectString,
+        dnsStatus: __expectString,
+        environmentArn: __expectString,
+        environmentId: __expectString,
+        errorMessage: __expectString,
+        kmsKeyId: __expectString,
+        name: __expectString,
+        status: __expectString,
+        tgwStatus: __expectString,
+        transitGatewayConfiguration: _json,
+        updateTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_UntagResourceCommandError = async (output, context) => {
+const de_UpdateKxEnvironmentNetworkCommandError = 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 "InvalidRequestException":
-        case "com.amazonaws.finspace#InvalidRequestException":
-            throw await de_InvalidRequestExceptionRes(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({
@@ -444,21 +2363,24 @@ const de_UntagResourceCommandError = async (output, context) => {
             });
     }
 };
-export const de_UpdateEnvironmentCommand = async (output, context) => {
+export const de_UpdateKxUserCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateEnvironmentCommandError(output, context);
+        return de_UpdateKxUserCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        environment: _json,
+        environmentId: __expectString,
+        iamRole: __expectString,
+        userArn: __expectString,
+        userName: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateEnvironmentCommandError = async (output, context) => {
+const de_UpdateKxUserCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -468,9 +2390,15 @@ const de_UpdateEnvironmentCommandError = 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);
@@ -501,6 +2429,20 @@ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+        reason: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_InternalServerExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -540,6 +2482,19 @@ const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ResourceAlreadyExistsExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ResourceAlreadyExistsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -590,6 +2545,143 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const se_AutoScalingConfiguration = (input, context) => {
+    return take(input, {
+        autoScalingMetric: [],
+        maxNodeCount: [],
+        metricTarget: __serializeFloat,
+        minNodeCount: [],
+        scaleInCooldownSeconds: __serializeFloat,
+        scaleOutCooldownSeconds: __serializeFloat,
+    });
+};
+const de_AutoScalingConfiguration = (output, context) => {
+    return take(output, {
+        autoScalingMetric: __expectString,
+        maxNodeCount: __expectInt32,
+        metricTarget: __limitedParseDouble,
+        minNodeCount: __expectInt32,
+        scaleInCooldownSeconds: __limitedParseDouble,
+        scaleOutCooldownSeconds: __limitedParseDouble,
+    });
+};
+const de_KxChangesetListEntry = (output, context) => {
+    return take(output, {
+        activeFromTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        changesetId: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        status: __expectString,
+    });
+};
+const de_KxChangesets = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxChangesetListEntry(entry, context);
+    });
+    return retVal;
+};
+const de_KxCluster = (output, context) => {
+    return take(output, {
+        availabilityZoneId: __expectString,
+        azMode: __expectString,
+        clusterDescription: __expectString,
+        clusterName: __expectString,
+        clusterType: __expectString,
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        executionRole: __expectString,
+        initializationScript: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        releaseLabel: __expectString,
+        status: __expectString,
+        statusReason: __expectString,
+    });
+};
+const de_KxClusters = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxCluster(entry, context);
+    });
+    return retVal;
+};
+const de_KxDatabaseListEntry = (output, context) => {
+    return take(output, {
+        createdTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        databaseName: __expectString,
+        lastModifiedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+};
+const de_KxDatabases = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxDatabaseListEntry(entry, context);
+    });
+    return retVal;
+};
+const de_KxEnvironment = (output, context) => {
+    return take(output, {
+        availabilityZoneIds: _json,
+        awsAccountId: __expectString,
+        certificateAuthorityArn: __expectString,
+        creationTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        customDNSConfiguration: _json,
+        dedicatedServiceAccountId: __expectString,
+        description: __expectString,
+        dnsStatus: __expectString,
+        environmentArn: __expectString,
+        environmentId: __expectString,
+        errorMessage: __expectString,
+        kmsKeyId: __expectString,
+        name: __expectString,
+        status: __expectString,
+        tgwStatus: __expectString,
+        transitGatewayConfiguration: _json,
+        updateTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+};
+const de_KxEnvironmentList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxEnvironment(entry, context);
+    });
+    return retVal;
+};
+const de_KxNode = (output, context) => {
+    return take(output, {
+        availabilityZoneId: __expectString,
+        launchTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        nodeId: __expectString,
+    });
+};
+const de_KxNodeSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxNode(entry, context);
+    });
+    return retVal;
+};
+const de_KxUser = (output, context) => {
+    return take(output, {
+        createTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        iamRole: __expectString,
+        updateTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        userArn: __expectString,
+        userName: __expectString,
+    });
+};
+const de_KxUserList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KxUser(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"],