@aws-sdk/client-finspace 3.1075.0 → 3.1076.0

package/dist-cjs/index.js

@@ -1,21 +1,57 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveHttpAuthSchemeConfig, defaultFinspaceHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { CreateEnvironment$, CreateKxChangeset$, CreateKxCluster$, CreateKxDatabase$, CreateKxDataview$, CreateKxEnvironment$, CreateKxScalingGroup$, CreateKxUser$, CreateKxVolume$, DeleteEnvironment$, DeleteKxCluster$, DeleteKxClusterNode$, DeleteKxDatabase$, DeleteKxDataview$, DeleteKxEnvironment$, DeleteKxScalingGroup$, DeleteKxUser$, DeleteKxVolume$, GetEnvironment$, GetKxChangeset$, GetKxCluster$, GetKxConnectionString$, GetKxDatabase$, GetKxDataview$, GetKxEnvironment$, GetKxScalingGroup$, GetKxUser$, GetKxVolume$, ListEnvironments$, ListKxChangesets$, ListKxClusterNodes$, ListKxClusters$, ListKxDatabases$, ListKxDataviews$, ListKxEnvironments$, ListKxScalingGroups$, ListKxUsers$, ListKxVolumes$, ListTagsForResource$, TagResource$, UntagResource$, UpdateEnvironment$, UpdateKxClusterCodeConfiguration$, UpdateKxClusterDatabases$, UpdateKxDatabase$, UpdateKxDataview$, UpdateKxEnvironment$, UpdateKxEnvironmentNetwork$, UpdateKxUser$, UpdateKxVolume$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { FinspaceServiceException } = require("./models/FinspaceServiceException");
-exports.FinspaceServiceException = FinspaceServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { toUtf8, fromUtf8, toBase64, fromBase64, Hash, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsRestJsonProtocol } = require("@aws-sdk/core/protocols");
+
+const defaultFinspaceHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "finspace",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultFinspaceHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -31,6 +67,1621 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1075.0";
+var packageInfo = {
+	version: version};
+
+const k = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = { [k]: "Endpoint" }, h = { [k]: d }, i = {}, j = [{ [k]: "Region" }];
+const _data = {
+    conditions: [
+        [c, [g]],
+        [c, j],
+        ["aws.partition", j, d],
+        [e, [{ [k]: "UseFIPS" }, b]],
+        [e, [{ [k]: "UseDualStack" }, b]],
+        [e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
+        [e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [g, i],
+        ["https://finspace-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://finspace-fips.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://finspace.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        ["https://finspace.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 12, 3,
+    1, 4, r + 11,
+    2, 5, r + 11,
+    3, 8, 6,
+    4, 7, r + 10,
+    5, r + 8, r + 9,
+    4, 10, 9,
+    6, r + 6, r + 7,
+    5, 11, r + 5,
+    6, r + 4, r + 5,
+    3, r + 1, 13,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class FinspaceServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, FinspaceServiceException.prototype);
+    }
+}
+
+class AccessDeniedException extends FinspaceServiceException {
+    name = "AccessDeniedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+    }
+}
+class InternalServerException extends FinspaceServiceException {
+    name = "InternalServerException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+class LimitExceededException extends FinspaceServiceException {
+    name = "LimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+    }
+}
+class ServiceQuotaExceededException extends FinspaceServiceException {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+class ThrottlingException extends FinspaceServiceException {
+    name = "ThrottlingException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+class ValidationException extends FinspaceServiceException {
+    name = "ValidationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+    }
+}
+class ConflictException extends FinspaceServiceException {
+    name = "ConflictException";
+    $fault = "client";
+    reason;
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.reason = opts.reason;
+    }
+}
+class ResourceNotFoundException extends FinspaceServiceException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+class ResourceAlreadyExistsException extends FinspaceServiceException {
+    name = "ResourceAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceAlreadyExistsException.prototype);
+    }
+}
+class InvalidRequestException extends FinspaceServiceException {
+    name = "InvalidRequestException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRequestException.prototype);
+    }
+}
+
+const _ADE = "AccessDeniedException";
+const _ASC = "AutoScalingConfiguration";
+const _CC = "CapacityConfiguration";
+const _CCo = "CodeConfiguration";
+const _CDNSC = "CustomDNSConfiguration";
+const _CDNSS = "CustomDNSServer";
+const _CE = "ConflictException";
+const _CER = "CreateEnvironmentRequest";
+const _CERr = "CreateEnvironmentResponse";
+const _CEr = "CreateEnvironment";
+const _CKC = "CreateKxChangeset";
+const _CKCR = "CreateKxChangesetRequest";
+const _CKCRr = "CreateKxChangesetResponse";
+const _CKCRre = "CreateKxClusterRequest";
+const _CKCRrea = "CreateKxClusterResponse";
+const _CKCr = "CreateKxCluster";
+const _CKD = "CreateKxDatabase";
+const _CKDR = "CreateKxDatabaseRequest";
+const _CKDRr = "CreateKxDatabaseResponse";
+const _CKDRre = "CreateKxDataviewRequest";
+const _CKDRrea = "CreateKxDataviewResponse";
+const _CKDr = "CreateKxDataview";
+const _CKE = "CreateKxEnvironment";
+const _CKER = "CreateKxEnvironmentRequest";
+const _CKERr = "CreateKxEnvironmentResponse";
+const _CKSG = "CreateKxScalingGroup";
+const _CKSGR = "CreateKxScalingGroupRequest";
+const _CKSGRr = "CreateKxScalingGroupResponse";
+const _CKU = "CreateKxUser";
+const _CKUR = "CreateKxUserRequest";
+const _CKURr = "CreateKxUserResponse";
+const _CKV = "CreateKxVolume";
+const _CKVR = "CreateKxVolumeRequest";
+const _CKVRr = "CreateKxVolumeResponse";
+const _CR = "ChangeRequest";
+const _CRh = "ChangeRequests";
+const _DE = "DeleteEnvironment";
+const _DER = "DeleteEnvironmentRequest";
+const _DERe = "DeleteEnvironmentResponse";
+const _DKC = "DeleteKxCluster";
+const _DKCN = "DeleteKxClusterNode";
+const _DKCNR = "DeleteKxClusterNodeRequest";
+const _DKCNRe = "DeleteKxClusterNodeResponse";
+const _DKCR = "DeleteKxClusterRequest";
+const _DKCRe = "DeleteKxClusterResponse";
+const _DKD = "DeleteKxDatabase";
+const _DKDR = "DeleteKxDatabaseRequest";
+const _DKDRe = "DeleteKxDatabaseResponse";
+const _DKDRel = "DeleteKxDataviewRequest";
+const _DKDRele = "DeleteKxDataviewResponse";
+const _DKDe = "DeleteKxDataview";
+const _DKE = "DeleteKxEnvironment";
+const _DKER = "DeleteKxEnvironmentRequest";
+const _DKERe = "DeleteKxEnvironmentResponse";
+const _DKSG = "DeleteKxScalingGroup";
+const _DKSGR = "DeleteKxScalingGroupRequest";
+const _DKSGRe = "DeleteKxScalingGroupResponse";
+const _DKU = "DeleteKxUser";
+const _DKUR = "DeleteKxUserRequest";
+const _DKURe = "DeleteKxUserResponse";
+const _DKV = "DeleteKxVolume";
+const _DKVR = "DeleteKxVolumeRequest";
+const _DKVRe = "DeleteKxVolumeResponse";
+const _E = "Environment";
+const _EI = "EmailId";
+const _EIr = "ErrorInfo";
+const _EL = "EnvironmentList";
+const _FP = "FederationParameters";
+const _GE = "GetEnvironment";
+const _GER = "GetEnvironmentRequest";
+const _GERe = "GetEnvironmentResponse";
+const _GKC = "GetKxChangeset";
+const _GKCR = "GetKxChangesetRequest";
+const _GKCRe = "GetKxChangesetResponse";
+const _GKCRet = "GetKxClusterRequest";
+const _GKCRetx = "GetKxClusterResponse";
+const _GKCS = "GetKxConnectionString";
+const _GKCSR = "GetKxConnectionStringRequest";
+const _GKCSRe = "GetKxConnectionStringResponse";
+const _GKCe = "GetKxCluster";
+const _GKD = "GetKxDatabase";
+const _GKDR = "GetKxDatabaseRequest";
+const _GKDRe = "GetKxDatabaseResponse";
+const _GKDRet = "GetKxDataviewRequest";
+const _GKDRetx = "GetKxDataviewResponse";
+const _GKDe = "GetKxDataview";
+const _GKE = "GetKxEnvironment";
+const _GKER = "GetKxEnvironmentRequest";
+const _GKERe = "GetKxEnvironmentResponse";
+const _GKSG = "GetKxScalingGroup";
+const _GKSGR = "GetKxScalingGroupRequest";
+const _GKSGRe = "GetKxScalingGroupResponse";
+const _GKU = "GetKxUser";
+const _GKUR = "GetKxUserRequest";
+const _GKURe = "GetKxUserResponse";
+const _GKV = "GetKxVolume";
+const _GKVR = "GetKxVolumeRequest";
+const _GKVRe = "GetKxVolumeResponse";
+const _IRE = "InvalidRequestException";
+const _ISE = "InternalServerException";
+const _ITC = "IcmpTypeCode";
+const _KAC = "KxAttachedCluster";
+const _KACx = "KxAttachedClusters";
+const _KC = "KxCluster";
+const _KCCDC = "KxClusterCodeDeploymentConfiguration";
+const _KCLA = "KxCommandLineArgument";
+const _KCLAx = "KxCommandLineArguments";
+const _KCLE = "KxChangesetListEntry";
+const _KCSC = "KxCacheStorageConfiguration";
+const _KCSCx = "KxCacheStorageConfigurations";
+const _KCx = "KxChangesets";
+const _KCxl = "KxClusters";
+const _KD = "KxDatabases";
+const _KDAV = "KxDataviewActiveVersion";
+const _KDAVL = "KxDataviewActiveVersionList";
+const _KDC = "KxDatabaseConfiguration";
+const _KDCC = "KxDatabaseCacheConfiguration";
+const _KDCCx = "KxDatabaseCacheConfigurations";
+const _KDCx = "KxDataviewConfiguration";
+const _KDCxa = "KxDatabaseConfigurations";
+const _KDCxe = "KxDeploymentConfiguration";
+const _KDLE = "KxDatabaseListEntry";
+const _KDLEx = "KxDataviewListEntry";
+const _KDSC = "KxDataviewSegmentConfiguration";
+const _KDSCL = "KxDataviewSegmentConfigurationList";
+const _KDx = "KxDataviews";
+const _KE = "KxEnvironment";
+const _KEL = "KxEnvironmentList";
+const _KN = "KxNode";
+const _KNASC = "KxNAS1Configuration";
+const _KNS = "KxNodeSummaries";
+const _KSG = "KxScalingGroup";
+const _KSGC = "KxScalingGroupConfiguration";
+const _KSGL = "KxScalingGroupList";
+const _KSSC = "KxSavedownStorageConfiguration";
+const _KU = "KxUser";
+const _KUL = "KxUserList";
+const _KV = "KxVolume";
+const _KVx = "KxVolumes";
+const _LE = "ListEnvironments";
+const _LEE = "LimitExceededException";
+const _LER = "ListEnvironmentsRequest";
+const _LERi = "ListEnvironmentsResponse";
+const _LKC = "ListKxChangesets";
+const _LKCN = "ListKxClusterNodes";
+const _LKCNR = "ListKxClusterNodesRequest";
+const _LKCNRi = "ListKxClusterNodesResponse";
+const _LKCR = "ListKxChangesetsRequest";
+const _LKCRi = "ListKxChangesetsResponse";
+const _LKCRis = "ListKxClustersRequest";
+const _LKCRist = "ListKxClustersResponse";
+const _LKCi = "ListKxClusters";
+const _LKD = "ListKxDatabases";
+const _LKDR = "ListKxDatabasesRequest";
+const _LKDRi = "ListKxDatabasesResponse";
+const _LKDRis = "ListKxDataviewsRequest";
+const _LKDRist = "ListKxDataviewsResponse";
+const _LKDi = "ListKxDataviews";
+const _LKE = "ListKxEnvironments";
+const _LKER = "ListKxEnvironmentsRequest";
+const _LKERi = "ListKxEnvironmentsResponse";
+const _LKSG = "ListKxScalingGroups";
+const _LKSGR = "ListKxScalingGroupsRequest";
+const _LKSGRi = "ListKxScalingGroupsResponse";
+const _LKU = "ListKxUsers";
+const _LKUR = "ListKxUsersRequest";
+const _LKURi = "ListKxUsersResponse";
+const _LKV = "ListKxVolumes";
+const _LKVR = "ListKxVolumesRequest";
+const _LKVRi = "ListKxVolumesResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _NACLC = "NetworkACLConfiguration";
+const _NACLE = "NetworkACLEntry";
+const _PR = "PortRange";
+const _RAEE = "ResourceAlreadyExistsException";
+const _RNFE = "ResourceNotFoundException";
+const _SKCS = "SignedKxConnectionString";
+const _SP = "SuperuserParameters";
+const _SQEE = "ServiceQuotaExceededException";
+const _TE = "ThrottlingException";
+const _TGC = "TransitGatewayConfiguration";
+const _TLC = "TickerplantLogConfiguration";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UE = "UpdateEnvironment";
+const _UER = "UpdateEnvironmentRequest";
+const _UERp = "UpdateEnvironmentResponse";
+const _UKCCC = "UpdateKxClusterCodeConfiguration";
+const _UKCCCR = "UpdateKxClusterCodeConfigurationRequest";
+const _UKCCCRp = "UpdateKxClusterCodeConfigurationResponse";
+const _UKCD = "UpdateKxClusterDatabases";
+const _UKCDR = "UpdateKxClusterDatabasesRequest";
+const _UKCDRp = "UpdateKxClusterDatabasesResponse";
+const _UKD = "UpdateKxDatabase";
+const _UKDR = "UpdateKxDatabaseRequest";
+const _UKDRp = "UpdateKxDatabaseResponse";
+const _UKDRpd = "UpdateKxDataviewRequest";
+const _UKDRpda = "UpdateKxDataviewResponse";
+const _UKDp = "UpdateKxDataview";
+const _UKE = "UpdateKxEnvironment";
+const _UKEN = "UpdateKxEnvironmentNetwork";
+const _UKENR = "UpdateKxEnvironmentNetworkRequest";
+const _UKENRp = "UpdateKxEnvironmentNetworkResponse";
+const _UKER = "UpdateKxEnvironmentRequest";
+const _UKERp = "UpdateKxEnvironmentResponse";
+const _UKU = "UpdateKxUser";
+const _UKUR = "UpdateKxUserRequest";
+const _UKURp = "UpdateKxUserResponse";
+const _UKV = "UpdateKxVolume";
+const _UKVR = "UpdateKxVolumeRequest";
+const _UKVRp = "UpdateKxVolumeResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _V = "Volume";
+const _VC = "VpcConfiguration";
+const _VE = "ValidationException";
+const _Vo = "Volumes";
+const _aAI = "awsAccountId";
+const _aC = "attachedClusters";
+const _aCBURL = "applicationCallBackURL";
+const _aFT = "activeFromTimestamp";
+const _aM = "azMode";
+const _aMt = "attributeMap";
+const _aNAC = "attachmentNetworkAclConfiguration";
+const _aSC = "autoScalingConfiguration";
+const _aSM = "autoScalingMetric";
+const _aU = "autoUpdate";
+const _aV = "activeVersions";
+const _aZI = "availabilityZoneId";
+const _aZIv = "availabilityZoneIds";
+const _c = "client";
+const _cAA = "certificateAuthorityArn";
+const _cB = "cidrBlock";
+const _cC = "capacityConfiguration";
+const _cCa = "cacheConfigurations";
+const _cD = "clusterDescription";
+const _cDNSC = "customDNSConfiguration";
+const _cDNSSIP = "customDNSServerIP";
+const _cDNSSN = "customDNSServerName";
+const _cI = "changesetId";
+const _cLA = "commandLineArguments";
+const _cN = "clusterName";
+const _cR = "changeRequests";
+const _cS = "clusterStatus";
+const _cSC = "cacheStorageConfigurations";
+const _cT = "changeType";
+const _cTa = "cacheType";
+const _cTl = "clientToken";
+const _cTlu = "clusterType";
+const _cTr = "createdTimestamp";
+const _cTre = "creationTimestamp";
+const _cTrea = "createTimestamp";
+const _cl = "clusters";
+const _co = "code";
+const _cp = "cpu";
+const _d = "description";
+const _dA = "databaseArn";
+const _dB = "dataBundles";
+const _dC = "dataviewConfiguration";
+const _dCe = "deploymentConfiguration";
+const _dN = "databaseName";
+const _dNa = "dataviewName";
+const _dP = "dbPath";
+const _dPb = "dbPaths";
+const _dS = "dnsStatus";
+const _dSAI = "dedicatedServiceAccountId";
+const _dSe = "deploymentStrategy";
+const _dVI = "dataviewVersionId";
+const _da = "databases";
+const _e = "error";
+const _eA = "environmentArn";
+const _eAm = "emailAddress";
+const _eI = "environmentId";
+const _eIr = "errorInfo";
+const _eM = "errorMessage";
+const _eR = "executionRole";
+const _eT = "errorType";
+const _eU = "environmentUrl";
+const _en = "environment";
+const _env = "environments";
+const _f = "from";
+const _fM = "federationMode";
+const _fN = "firstName";
+const _fP = "federationParameters";
+const _fPN = "federationProviderName";
+const _fURN = "federationURN";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _hT = "hostType";
+const _iAT = "ipAddressType";
+const _iR = "iamRole";
+const _iS = "initializationScript";
+const _iT = "idempotencyToken";
+const _iTC = "icmpTypeCode";
+const _k = "key";
+const _kC = "kxChangesets";
+const _kCS = "kxClusterSummaries";
+const _kD = "kxDatabases";
+const _kDx = "kxDataviews";
+const _kKI = "kmsKeyId";
+const _kVS = "kxVolumeSummaries";
+const _lCCI = "lastCompletedChangesetId";
+const _lMT = "lastModifiedTimestamp";
+const _lN = "lastName";
+const _lT = "launchTime";
+const _m = "message";
+const _mL = "memoryLimit";
+const _mNC = "minNodeCount";
+const _mNCa = "maxNodeCount";
+const _mR = "memoryReservation";
+const _mRa = "maxResults";
+const _mT = "metricTarget";
+const _n = "name";
+const _nB = "numBytes";
+const _nC = "nodeCount";
+const _nCa = "nas1Configuration";
+const _nCu = "numChangesets";
+const _nF = "numFiles";
+const _nI = "nodeId";
+const _nT = "nodeType";
+const _nTe = "nextToken";
+const _no = "nodes";
+const _oD = "onDemand";
+const _p = "protocol";
+const _pR = "portRange";
+const _r = "reason";
+const _rA = "resourceArn";
+const _rAu = "ruleAction";
+const _rCIDRS = "routableCIDRSpace";
+const _rL = "releaseLabel";
+const _rN = "ruleNumber";
+const _rW = "readWrite";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.finspace";
+const _sB = "s3Bucket";
+const _sC = "segmentConfigurations";
+const _sCS = "signedConnectionString";
+const _sG = "scalingGroups";
+const _sGA = "scalingGroupArn";
+const _sGC = "scalingGroupConfiguration";
+const _sGI = "securityGroupIds";
+const _sGN = "scalingGroupName";
+const _sI = "subnetIds";
+const _sICS = "scaleInCooldownSeconds";
+const _sK = "s3Key";
+const _sMD = "samlMetadataDocument";
+const _sMSDU = "sageMakerStudioDomainUrl";
+const _sMURL = "samlMetadataURL";
+const _sOCS = "scaleOutCooldownSeconds";
+const _sOV = "s3ObjectVersion";
+const _sP = "s3Path";
+const _sPu = "superuserParameters";
+const _sR = "statusReason";
+const _sSC = "savedownStorageConfiguration";
+const _se = "server";
+const _si = "size";
+const _st = "status";
+const _t = "tags";
+const _tGC = "transitGatewayConfiguration";
+const _tGID = "transitGatewayID";
+const _tK = "tagKeys";
+const _tLC = "tickerplantLogConfiguration";
+const _tLV = "tickerplantLogVolumes";
+const _tS = "tgwStatus";
+const _to = "to";
+const _ty = "type";
+const _u = "users";
+const _uA = "userArn";
+const _uN = "userName";
+const _uT = "updateTimestamp";
+const _v = "volumes";
+const _vA = "volumeArn";
+const _vC = "vpcConfiguration";
+const _vI = "versionId";
+const _vIp = "vpcId";
+const _vN = "volumeName";
+const _vT = "volumeType";
+const _va = "value";
+const n0 = "com.amazonaws.finspace";
+const _s_registry = TypeRegistry.for(_s);
+var FinspaceServiceException$ = [-3, _s, "FinspaceServiceException", 0, [], []];
+_s_registry.registerError(FinspaceServiceException$, FinspaceServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var AccessDeniedException$ = [-3, n0, _ADE,
+    { [_e]: _c, [_hE]: 403 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(AccessDeniedException$, AccessDeniedException);
+var ConflictException$ = [-3, n0, _CE,
+    { [_e]: _c, [_hE]: 409 },
+    [_m, _r],
+    [0, 0]
+];
+n0_registry.registerError(ConflictException$, ConflictException);
+var InternalServerException$ = [-3, n0, _ISE,
+    { [_e]: _se, [_hE]: 500 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InternalServerException$, InternalServerException);
+var InvalidRequestException$ = [-3, n0, _IRE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidRequestException$, InvalidRequestException);
+var LimitExceededException$ = [-3, n0, _LEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(LimitExceededException$, LimitExceededException);
+var ResourceAlreadyExistsException$ = [-3, n0, _RAEE,
+    { [_e]: _c, [_hE]: 409 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ResourceAlreadyExistsException$, ResourceAlreadyExistsException);
+var ResourceNotFoundException$ = [-3, n0, _RNFE,
+    { [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ResourceNotFoundException$, ResourceNotFoundException);
+var ServiceQuotaExceededException$ = [-3, n0, _SQEE,
+    { [_e]: _c, [_hE]: 402 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServiceQuotaExceededException$, ServiceQuotaExceededException);
+var ThrottlingException$ = [-3, n0, _TE,
+    { [_e]: _c, [_hE]: 429 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ThrottlingException$, ThrottlingException);
+var ValidationException$ = [-3, n0, _VE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ValidationException$, ValidationException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+var EmailId = [0, n0, _EI, 8, 0];
+var SignedKxConnectionString = [0, n0, _SKCS, 8, 0];
+var AutoScalingConfiguration$ = [3, n0, _ASC,
+    0,
+    [_mNC, _mNCa, _aSM, _mT, _sICS, _sOCS],
+    [1, 1, 0, 1, 1, 1]
+];
+var CapacityConfiguration$ = [3, n0, _CC,
+    0,
+    [_nT, _nC],
+    [0, 1]
+];
+var ChangeRequest$ = [3, n0, _CR,
+    0,
+    [_cT, _dP, _sP],
+    [0, 0, 0], 2
+];
+var CodeConfiguration$ = [3, n0, _CCo,
+    0,
+    [_sB, _sK, _sOV],
+    [0, 0, 0]
+];
+var CreateEnvironmentRequest$ = [3, n0, _CER,
+    0,
+    [_n, _d, _kKI, _t, _fM, _fP, _sPu, _dB],
+    [0, 0, 0, 128 | 0, 0, () => FederationParameters$, [() => SuperuserParameters$, 0], 64 | 0], 1
+];
+var CreateEnvironmentResponse$ = [3, n0, _CERr,
+    0,
+    [_eI, _eA, _eU],
+    [0, 0, 0]
+];
+var CreateKxChangesetRequest$ = [3, n0, _CKCR,
+    0,
+    [_eI, _dN, _cR, _cTl],
+    [[0, 1], [0, 1], () => ChangeRequests, [0, 4]], 3
+];
+var CreateKxChangesetResponse$ = [3, n0, _CKCRr,
+    0,
+    [_cI, _dN, _eI, _cR, _cTr, _lMT, _st, _eIr],
+    [0, 0, 0, () => ChangeRequests, 4, 4, 0, () => ErrorInfo$]
+];
+var CreateKxClusterRequest$ = [3, n0, _CKCRre,
+    0,
+    [_eI, _cN, _cTlu, _rL, _vC, _aM, _cTl, _tLC, _da, _cSC, _aSC, _cD, _cC, _iS, _cLA, _co, _eR, _sSC, _aZI, _t, _sGC],
+    [[0, 1], 0, 0, 0, () => VpcConfiguration$, 0, [0, 4], () => TickerplantLogConfiguration$, () => KxDatabaseConfigurations, () => KxCacheStorageConfigurations, () => AutoScalingConfiguration$, 0, () => CapacityConfiguration$, 0, () => KxCommandLineArguments, () => CodeConfiguration$, 0, () => KxSavedownStorageConfiguration$, 0, 128 | 0, () => KxScalingGroupConfiguration$], 6
+];
+var CreateKxClusterResponse$ = [3, n0, _CKCRrea,
+    0,
+    [_eI, _st, _sR, _cN, _cTlu, _tLC, _v, _da, _cSC, _aSC, _cD, _cC, _rL, _vC, _iS, _cLA, _co, _eR, _lMT, _sSC, _aM, _aZI, _cTr, _sGC],
+    [0, 0, 0, 0, 0, () => TickerplantLogConfiguration$, () => Volumes, () => KxDatabaseConfigurations, () => KxCacheStorageConfigurations, () => AutoScalingConfiguration$, 0, () => CapacityConfiguration$, 0, () => VpcConfiguration$, 0, () => KxCommandLineArguments, () => CodeConfiguration$, 0, 4, () => KxSavedownStorageConfiguration$, 0, 0, 4, () => KxScalingGroupConfiguration$]
+];
+var CreateKxDatabaseRequest$ = [3, n0, _CKDR,
+    0,
+    [_eI, _dN, _d, _t, _cTl],
+    [[0, 1], 0, 0, 128 | 0, [0, 4]], 2
+];
+var CreateKxDatabaseResponse$ = [3, n0, _CKDRr,
+    0,
+    [_dN, _dA, _eI, _d, _cTr, _lMT],
+    [0, 0, 0, 0, 4, 4]
+];
+var CreateKxDataviewRequest$ = [3, n0, _CKDRre,
+    0,
+    [_eI, _dN, _dNa, _aM, _aZI, _cI, _sC, _aU, _rW, _d, _t, _cTl],
+    [[0, 1], [0, 1], 0, 0, 0, 0, () => KxDataviewSegmentConfigurationList, 2, 2, 0, 128 | 0, [0, 4]], 4
+];
+var CreateKxDataviewResponse$ = [3, n0, _CKDRrea,
+    0,
+    [_dNa, _dN, _eI, _aM, _aZI, _cI, _sC, _d, _aU, _rW, _cTr, _lMT, _st],
+    [0, 0, 0, 0, 0, 0, () => KxDataviewSegmentConfigurationList, 0, 2, 2, 4, 4, 0]
+];
+var CreateKxEnvironmentRequest$ = [3, n0, _CKER,
+    0,
+    [_n, _kKI, _d, _t, _cTl],
+    [0, 0, 0, 128 | 0, [0, 4]], 2
+];
+var CreateKxEnvironmentResponse$ = [3, n0, _CKERr,
+    0,
+    [_n, _st, _eI, _d, _eA, _kKI, _cTre],
+    [0, 0, 0, 0, 0, 0, 4]
+];
+var CreateKxScalingGroupRequest$ = [3, n0, _CKSGR,
+    0,
+    [_eI, _sGN, _hT, _aZI, _cTl, _t],
+    [[0, 1], 0, 0, 0, [0, 4], 128 | 0], 4
+];
+var CreateKxScalingGroupResponse$ = [3, n0, _CKSGRr,
+    0,
+    [_eI, _sGN, _hT, _aZI, _st, _lMT, _cTr],
+    [0, 0, 0, 0, 0, 4, 4]
+];
+var CreateKxUserRequest$ = [3, n0, _CKUR,
+    0,
+    [_eI, _uN, _iR, _t, _cTl],
+    [[0, 1], 0, 0, 128 | 0, [0, 4]], 3
+];
+var CreateKxUserResponse$ = [3, n0, _CKURr,
+    0,
+    [_uN, _uA, _eI, _iR],
+    [0, 0, 0, 0]
+];
+var CreateKxVolumeRequest$ = [3, n0, _CKVR,
+    0,
+    [_eI, _vT, _vN, _aM, _aZIv, _cTl, _d, _nCa, _t],
+    [[0, 1], 0, 0, 0, 64 | 0, [0, 4], 0, () => KxNAS1Configuration$, 128 | 0], 5
+];
+var CreateKxVolumeResponse$ = [3, n0, _CKVRr,
+    0,
+    [_eI, _vN, _vT, _vA, _nCa, _st, _sR, _aM, _d, _aZIv, _cTr],
+    [0, 0, 0, 0, () => KxNAS1Configuration$, 0, 0, 0, 0, 64 | 0, 4]
+];
+var CustomDNSServer$ = [3, n0, _CDNSS,
+    0,
+    [_cDNSSN, _cDNSSIP],
+    [0, 0], 2
+];
+var DeleteEnvironmentRequest$ = [3, n0, _DER,
+    0,
+    [_eI],
+    [[0, 1]], 1
+];
+var DeleteEnvironmentResponse$ = [3, n0, _DERe,
+    0,
+    [],
+    []
+];
+var DeleteKxClusterNodeRequest$ = [3, n0, _DKCNR,
+    0,
+    [_eI, _cN, _nI],
+    [[0, 1], [0, 1], [0, 1]], 3
+];
+var DeleteKxClusterNodeResponse$ = [3, n0, _DKCNRe,
+    0,
+    [],
+    []
+];
+var DeleteKxClusterRequest$ = [3, n0, _DKCR,
+    0,
+    [_eI, _cN, _cTl],
+    [[0, 1], [0, 1], [0, { [_hQ]: _cTl, [_iT]: 1 }]], 2
+];
+var DeleteKxClusterResponse$ = [3, n0, _DKCRe,
+    0,
+    [],
+    []
+];
+var DeleteKxDatabaseRequest$ = [3, n0, _DKDR,
+    0,
+    [_eI, _dN, _cTl],
+    [[0, 1], [0, 1], [0, { [_hQ]: _cTl, [_iT]: 1 }]], 2
+];
+var DeleteKxDatabaseResponse$ = [3, n0, _DKDRe,
+    0,
+    [],
+    []
+];
+var DeleteKxDataviewRequest$ = [3, n0, _DKDRel,
+    0,
+    [_eI, _dN, _dNa, _cTl],
+    [[0, 1], [0, 1], [0, 1], [0, { [_hQ]: _cTl, [_iT]: 1 }]], 3
+];
+var DeleteKxDataviewResponse$ = [3, n0, _DKDRele,
+    0,
+    [],
+    []
+];
+var DeleteKxEnvironmentRequest$ = [3, n0, _DKER,
+    0,
+    [_eI, _cTl],
+    [[0, 1], [0, { [_hQ]: _cTl, [_iT]: 1 }]], 1
+];
+var DeleteKxEnvironmentResponse$ = [3, n0, _DKERe,
+    0,
+    [],
+    []
+];
+var DeleteKxScalingGroupRequest$ = [3, n0, _DKSGR,
+    0,
+    [_eI, _sGN, _cTl],
+    [[0, 1], [0, 1], [0, { [_hQ]: _cTl, [_iT]: 1 }]], 2
+];
+var DeleteKxScalingGroupResponse$ = [3, n0, _DKSGRe,
+    0,
+    [],
+    []
+];
+var DeleteKxUserRequest$ = [3, n0, _DKUR,
+    0,
+    [_uN, _eI, _cTl],
+    [[0, 1], [0, 1], [0, { [_hQ]: _cTl, [_iT]: 1 }]], 2
+];
+var DeleteKxUserResponse$ = [3, n0, _DKURe,
+    0,
+    [],
+    []
+];
+var DeleteKxVolumeRequest$ = [3, n0, _DKVR,
+    0,
+    [_eI, _vN, _cTl],
+    [[0, 1], [0, 1], [0, { [_hQ]: _cTl, [_iT]: 1 }]], 2
+];
+var DeleteKxVolumeResponse$ = [3, n0, _DKVRe,
+    0,
+    [],
+    []
+];
+var Environment$ = [3, n0, _E,
+    0,
+    [_n, _eI, _aAI, _st, _eU, _d, _eA, _sMSDU, _kKI, _dSAI, _fM, _fP],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, () => FederationParameters$]
+];
+var ErrorInfo$ = [3, n0, _EIr,
+    0,
+    [_eM, _eT],
+    [0, 0]
+];
+var FederationParameters$ = [3, n0, _FP,
+    0,
+    [_sMD, _sMURL, _aCBURL, _fURN, _fPN, _aMt],
+    [0, 0, 0, 0, 0, 128 | 0]
+];
+var GetEnvironmentRequest$ = [3, n0, _GER,
+    0,
+    [_eI],
+    [[0, 1]], 1
+];
+var GetEnvironmentResponse$ = [3, n0, _GERe,
+    0,
+    [_en],
+    [() => Environment$]
+];
+var GetKxChangesetRequest$ = [3, n0, _GKCR,
+    0,
+    [_eI, _dN, _cI],
+    [[0, 1], [0, 1], [0, 1]], 3
+];
+var GetKxChangesetResponse$ = [3, n0, _GKCRe,
+    0,
+    [_cI, _dN, _eI, _cR, _cTr, _aFT, _lMT, _st, _eIr],
+    [0, 0, 0, () => ChangeRequests, 4, 4, 4, 0, () => ErrorInfo$]
+];
+var GetKxClusterRequest$ = [3, n0, _GKCRet,
+    0,
+    [_eI, _cN],
+    [[0, 1], [0, 1]], 2
+];
+var GetKxClusterResponse$ = [3, n0, _GKCRetx,
+    0,
+    [_st, _sR, _cN, _cTlu, _tLC, _v, _da, _cSC, _aSC, _cD, _cC, _rL, _vC, _iS, _cLA, _co, _eR, _lMT, _sSC, _aM, _aZI, _cTr, _sGC],
+    [0, 0, 0, 0, () => TickerplantLogConfiguration$, () => Volumes, () => KxDatabaseConfigurations, () => KxCacheStorageConfigurations, () => AutoScalingConfiguration$, 0, () => CapacityConfiguration$, 0, () => VpcConfiguration$, 0, () => KxCommandLineArguments, () => CodeConfiguration$, 0, 4, () => KxSavedownStorageConfiguration$, 0, 0, 4, () => KxScalingGroupConfiguration$]
+];
+var GetKxConnectionStringRequest$ = [3, n0, _GKCSR,
+    0,
+    [_uA, _eI, _cN],
+    [[0, { [_hQ]: _uA }], [0, 1], [0, { [_hQ]: _cN }]], 3
+];
+var GetKxConnectionStringResponse$ = [3, n0, _GKCSRe,
+    0,
+    [_sCS],
+    [[() => SignedKxConnectionString, 0]]
+];
+var GetKxDatabaseRequest$ = [3, n0, _GKDR,
+    0,
+    [_eI, _dN],
+    [[0, 1], [0, 1]], 2
+];
+var GetKxDatabaseResponse$ = [3, n0, _GKDRe,
+    0,
+    [_dN, _dA, _eI, _d, _cTr, _lMT, _lCCI, _nB, _nCu, _nF],
+    [0, 0, 0, 0, 4, 4, 0, 1, 1, 1]
+];
+var GetKxDataviewRequest$ = [3, n0, _GKDRet,
+    0,
+    [_eI, _dN, _dNa],
+    [[0, 1], [0, 1], [0, 1]], 3
+];
+var GetKxDataviewResponse$ = [3, n0, _GKDRetx,
+    0,
+    [_dN, _dNa, _aM, _aZI, _cI, _sC, _aV, _d, _aU, _rW, _eI, _cTr, _lMT, _st, _sR],
+    [0, 0, 0, 0, 0, () => KxDataviewSegmentConfigurationList, () => KxDataviewActiveVersionList, 0, 2, 2, 0, 4, 4, 0, 0]
+];
+var GetKxEnvironmentRequest$ = [3, n0, _GKER,
+    0,
+    [_eI],
+    [[0, 1]], 1
+];
+var GetKxEnvironmentResponse$ = [3, n0, _GKERe,
+    0,
+    [_n, _eI, _aAI, _st, _tS, _dS, _eM, _d, _eA, _kKI, _dSAI, _tGC, _cDNSC, _cTre, _uT, _aZIv, _cAA],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, () => TransitGatewayConfiguration$, () => CustomDNSConfiguration, 4, 4, 64 | 0, 0]
+];
+var GetKxScalingGroupRequest$ = [3, n0, _GKSGR,
+    0,
+    [_eI, _sGN],
+    [[0, 1], [0, 1]], 2
+];
+var GetKxScalingGroupResponse$ = [3, n0, _GKSGRe,
+    0,
+    [_sGN, _sGA, _hT, _cl, _aZI, _st, _sR, _lMT, _cTr],
+    [0, 0, 0, 64 | 0, 0, 0, 0, 4, 4]
+];
+var GetKxUserRequest$ = [3, n0, _GKUR,
+    0,
+    [_uN, _eI],
+    [[0, 1], [0, 1]], 2
+];
+var GetKxUserResponse$ = [3, n0, _GKURe,
+    0,
+    [_uN, _uA, _eI, _iR],
+    [0, 0, 0, 0]
+];
+var GetKxVolumeRequest$ = [3, n0, _GKVR,
+    0,
+    [_eI, _vN],
+    [[0, 1], [0, 1]], 2
+];
+var GetKxVolumeResponse$ = [3, n0, _GKVRe,
+    0,
+    [_eI, _vN, _vT, _vA, _nCa, _st, _sR, _cTr, _d, _aM, _aZIv, _lMT, _aC],
+    [0, 0, 0, 0, () => KxNAS1Configuration$, 0, 0, 4, 0, 0, 64 | 0, 4, () => KxAttachedClusters]
+];
+var IcmpTypeCode$ = [3, n0, _ITC,
+    0,
+    [_ty, _co],
+    [1, 1], 2
+];
+var KxAttachedCluster$ = [3, n0, _KAC,
+    0,
+    [_cN, _cTlu, _cS],
+    [0, 0, 0]
+];
+var KxCacheStorageConfiguration$ = [3, n0, _KCSC,
+    0,
+    [_ty, _si],
+    [0, 1], 2
+];
+var KxChangesetListEntry$ = [3, n0, _KCLE,
+    0,
+    [_cI, _cTr, _aFT, _lMT, _st],
+    [0, 4, 4, 4, 0]
+];
+var KxCluster$ = [3, n0, _KC,
+    0,
+    [_st, _sR, _cN, _cTlu, _cD, _rL, _v, _iS, _eR, _aM, _aZI, _lMT, _cTr],
+    [0, 0, 0, 0, 0, 0, () => Volumes, 0, 0, 0, 0, 4, 4]
+];
+var KxClusterCodeDeploymentConfiguration$ = [3, n0, _KCCDC,
+    0,
+    [_dSe],
+    [0], 1
+];
+var KxCommandLineArgument$ = [3, n0, _KCLA,
+    0,
+    [_k, _va],
+    [0, 0]
+];
+var KxDatabaseCacheConfiguration$ = [3, n0, _KDCC,
+    0,
+    [_cTa, _dPb, _dNa],
+    [0, 64 | 0, 0], 2
+];
+var KxDatabaseConfiguration$ = [3, n0, _KDC,
+    0,
+    [_dN, _cCa, _cI, _dNa, _dC],
+    [0, () => KxDatabaseCacheConfigurations, 0, 0, () => KxDataviewConfiguration$], 1
+];
+var KxDatabaseListEntry$ = [3, n0, _KDLE,
+    0,
+    [_dN, _cTr, _lMT],
+    [0, 4, 4]
+];
+var KxDataviewActiveVersion$ = [3, n0, _KDAV,
+    0,
+    [_cI, _sC, _aC, _cTr, _vI],
+    [0, () => KxDataviewSegmentConfigurationList, 64 | 0, 4, 0]
+];
+var KxDataviewConfiguration$ = [3, n0, _KDCx,
+    0,
+    [_dNa, _dVI, _cI, _sC],
+    [0, 0, 0, () => KxDataviewSegmentConfigurationList]
+];
+var KxDataviewListEntry$ = [3, n0, _KDLEx,
+    0,
+    [_eI, _dN, _dNa, _aM, _aZI, _cI, _sC, _aV, _st, _d, _aU, _rW, _cTr, _lMT, _sR],
+    [0, 0, 0, 0, 0, 0, () => KxDataviewSegmentConfigurationList, () => KxDataviewActiveVersionList, 0, 0, 2, 2, 4, 4, 0]
+];
+var KxDataviewSegmentConfiguration$ = [3, n0, _KDSC,
+    0,
+    [_dPb, _vN, _oD],
+    [64 | 0, 0, 2], 2
+];
+var KxDeploymentConfiguration$ = [3, n0, _KDCxe,
+    0,
+    [_dSe],
+    [0], 1
+];
+var KxEnvironment$ = [3, n0, _KE,
+    0,
+    [_n, _eI, _aAI, _st, _tS, _dS, _eM, _d, _eA, _kKI, _dSAI, _tGC, _cDNSC, _cTre, _uT, _aZIv, _cAA],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, () => TransitGatewayConfiguration$, () => CustomDNSConfiguration, 4, 4, 64 | 0, 0]
+];
+var KxNAS1Configuration$ = [3, n0, _KNASC,
+    0,
+    [_ty, _si],
+    [0, 1]
+];
+var KxNode$ = [3, n0, _KN,
+    0,
+    [_nI, _aZI, _lT, _st],
+    [0, 0, 4, 0]
+];
+var KxSavedownStorageConfiguration$ = [3, n0, _KSSC,
+    0,
+    [_ty, _si, _vN],
+    [0, 1, 0]
+];
+var KxScalingGroup$ = [3, n0, _KSG,
+    0,
+    [_sGN, _hT, _cl, _aZI, _st, _sR, _lMT, _cTr],
+    [0, 0, 64 | 0, 0, 0, 0, 4, 4]
+];
+var KxScalingGroupConfiguration$ = [3, n0, _KSGC,
+    0,
+    [_sGN, _mR, _nC, _mL, _cp],
+    [0, 1, 1, 1, 1], 3
+];
+var KxUser$ = [3, n0, _KU,
+    0,
+    [_uA, _uN, _iR, _cTrea, _uT],
+    [0, 0, 0, 4, 4]
+];
+var KxVolume$ = [3, n0, _KV,
+    0,
+    [_vN, _vT, _st, _d, _sR, _aM, _aZIv, _cTr, _lMT],
+    [0, 0, 0, 0, 0, 0, 64 | 0, 4, 4]
+];
+var ListEnvironmentsRequest$ = [3, n0, _LER,
+    0,
+    [_nTe, _mRa],
+    [[0, { [_hQ]: _nTe }], [1, { [_hQ]: _mRa }]]
+];
+var ListEnvironmentsResponse$ = [3, n0, _LERi,
+    0,
+    [_env, _nTe],
+    [() => EnvironmentList, 0]
+];
+var ListKxChangesetsRequest$ = [3, n0, _LKCR,
+    0,
+    [_eI, _dN, _nTe, _mRa],
+    [[0, 1], [0, 1], [0, { [_hQ]: _nTe }], [1, { [_hQ]: _mRa }]], 2
+];
+var ListKxChangesetsResponse$ = [3, n0, _LKCRi,
+    0,
+    [_kC, _nTe],
+    [() => KxChangesets, 0]
+];
+var ListKxClusterNodesRequest$ = [3, n0, _LKCNR,
+    0,
+    [_eI, _cN, _nTe, _mRa],
+    [[0, 1], [0, 1], [0, { [_hQ]: _nTe }], [1, { [_hQ]: _mRa }]], 2
+];
+var ListKxClusterNodesResponse$ = [3, n0, _LKCNRi,
+    0,
+    [_no, _nTe],
+    [() => KxNodeSummaries, 0]
+];
+var ListKxClustersRequest$ = [3, n0, _LKCRis,
+    0,
+    [_eI, _cTlu, _mRa, _nTe],
+    [[0, 1], [0, { [_hQ]: _cTlu }], [1, { [_hQ]: _mRa }], [0, { [_hQ]: _nTe }]], 1
+];
+var ListKxClustersResponse$ = [3, n0, _LKCRist,
+    0,
+    [_kCS, _nTe],
+    [() => KxClusters, 0]
+];
+var ListKxDatabasesRequest$ = [3, n0, _LKDR,
+    0,
+    [_eI, _nTe, _mRa],
+    [[0, 1], [0, { [_hQ]: _nTe }], [1, { [_hQ]: _mRa }]], 1
+];
+var ListKxDatabasesResponse$ = [3, n0, _LKDRi,
+    0,
+    [_kD, _nTe],
+    [() => KxDatabases, 0]
+];
+var ListKxDataviewsRequest$ = [3, n0, _LKDRis,
+    0,
+    [_eI, _dN, _nTe, _mRa],
+    [[0, 1], [0, 1], [0, { [_hQ]: _nTe }], [1, { [_hQ]: _mRa }]], 2
+];
+var ListKxDataviewsResponse$ = [3, n0, _LKDRist,
+    0,
+    [_kDx, _nTe],
+    [() => KxDataviews, 0]
+];
+var ListKxEnvironmentsRequest$ = [3, n0, _LKER,
+    0,
+    [_nTe, _mRa],
+    [[0, { [_hQ]: _nTe }], [1, { [_hQ]: _mRa }]]
+];
+var ListKxEnvironmentsResponse$ = [3, n0, _LKERi,
+    0,
+    [_env, _nTe],
+    [() => KxEnvironmentList, 0]
+];
+var ListKxScalingGroupsRequest$ = [3, n0, _LKSGR,
+    0,
+    [_eI, _mRa, _nTe],
+    [[0, 1], [1, { [_hQ]: _mRa }], [0, { [_hQ]: _nTe }]], 1
+];
+var ListKxScalingGroupsResponse$ = [3, n0, _LKSGRi,
+    0,
+    [_sG, _nTe],
+    [() => KxScalingGroupList, 0]
+];
+var ListKxUsersRequest$ = [3, n0, _LKUR,
+    0,
+    [_eI, _nTe, _mRa],
+    [[0, 1], [0, { [_hQ]: _nTe }], [1, { [_hQ]: _mRa }]], 1
+];
+var ListKxUsersResponse$ = [3, n0, _LKURi,
+    0,
+    [_u, _nTe],
+    [() => KxUserList, 0]
+];
+var ListKxVolumesRequest$ = [3, n0, _LKVR,
+    0,
+    [_eI, _mRa, _nTe, _vT],
+    [[0, 1], [1, { [_hQ]: _mRa }], [0, { [_hQ]: _nTe }], [0, { [_hQ]: _vT }]], 1
+];
+var ListKxVolumesResponse$ = [3, n0, _LKVRi,
+    0,
+    [_kVS, _nTe],
+    [() => KxVolumes, 0]
+];
+var ListTagsForResourceRequest$ = [3, n0, _LTFRR,
+    0,
+    [_rA],
+    [[0, 1]], 1
+];
+var ListTagsForResourceResponse$ = [3, n0, _LTFRRi,
+    0,
+    [_t],
+    [128 | 0]
+];
+var NetworkACLEntry$ = [3, n0, _NACLE,
+    0,
+    [_rN, _p, _rAu, _cB, _pR, _iTC],
+    [1, 0, 0, 0, () => PortRange$, () => IcmpTypeCode$], 4
+];
+var PortRange$ = [3, n0, _PR,
+    0,
+    [_f, _to],
+    [1, 1], 2
+];
+var SuperuserParameters$ = [3, n0, _SP,
+    0,
+    [_eAm, _fN, _lN],
+    [[() => EmailId, 0], 0, 0], 3
+];
+var TagResourceRequest$ = [3, n0, _TRR,
+    0,
+    [_rA, _t],
+    [[0, 1], 128 | 0], 2
+];
+var TagResourceResponse$ = [3, n0, _TRRa,
+    0,
+    [],
+    []
+];
+var TickerplantLogConfiguration$ = [3, n0, _TLC,
+    0,
+    [_tLV],
+    [64 | 0]
+];
+var TransitGatewayConfiguration$ = [3, n0, _TGC,
+    0,
+    [_tGID, _rCIDRS, _aNAC],
+    [0, 0, () => NetworkACLConfiguration], 2
+];
+var UntagResourceRequest$ = [3, n0, _URR,
+    0,
+    [_rA, _tK],
+    [[0, 1], [64 | 0, { [_hQ]: _tK }]], 2
+];
+var UntagResourceResponse$ = [3, n0, _URRn,
+    0,
+    [],
+    []
+];
+var UpdateEnvironmentRequest$ = [3, n0, _UER,
+    0,
+    [_eI, _n, _d, _fM, _fP],
+    [[0, 1], 0, 0, 0, () => FederationParameters$], 1
+];
+var UpdateEnvironmentResponse$ = [3, n0, _UERp,
+    0,
+    [_en],
+    [() => Environment$]
+];
+var UpdateKxClusterCodeConfigurationRequest$ = [3, n0, _UKCCCR,
+    0,
+    [_eI, _cN, _co, _cTl, _iS, _cLA, _dCe],
+    [[0, 1], [0, 1], () => CodeConfiguration$, [0, 4], 0, () => KxCommandLineArguments, () => KxClusterCodeDeploymentConfiguration$], 3
+];
+var UpdateKxClusterCodeConfigurationResponse$ = [3, n0, _UKCCCRp,
+    0,
+    [],
+    []
+];
+var UpdateKxClusterDatabasesRequest$ = [3, n0, _UKCDR,
+    0,
+    [_eI, _cN, _da, _cTl, _dCe],
+    [[0, 1], [0, 1], () => KxDatabaseConfigurations, [0, 4], () => KxDeploymentConfiguration$], 3
+];
+var UpdateKxClusterDatabasesResponse$ = [3, n0, _UKCDRp,
+    0,
+    [],
+    []
+];
+var UpdateKxDatabaseRequest$ = [3, n0, _UKDR,
+    0,
+    [_eI, _dN, _d, _cTl],
+    [[0, 1], [0, 1], 0, [0, 4]], 2
+];
+var UpdateKxDatabaseResponse$ = [3, n0, _UKDRp,
+    0,
+    [_dN, _eI, _d, _lMT],
+    [0, 0, 0, 4]
+];
+var UpdateKxDataviewRequest$ = [3, n0, _UKDRpd,
+    0,
+    [_eI, _dN, _dNa, _d, _cI, _sC, _cTl],
+    [[0, 1], [0, 1], [0, 1], 0, 0, () => KxDataviewSegmentConfigurationList, [0, 4]], 3
+];
+var UpdateKxDataviewResponse$ = [3, n0, _UKDRpda,
+    0,
+    [_eI, _dN, _dNa, _aM, _aZI, _cI, _sC, _aV, _st, _aU, _rW, _d, _cTr, _lMT],
+    [0, 0, 0, 0, 0, 0, () => KxDataviewSegmentConfigurationList, () => KxDataviewActiveVersionList, 0, 2, 2, 0, 4, 4]
+];
+var UpdateKxEnvironmentNetworkRequest$ = [3, n0, _UKENR,
+    0,
+    [_eI, _tGC, _cDNSC, _cTl],
+    [[0, 1], () => TransitGatewayConfiguration$, () => CustomDNSConfiguration, [0, 4]], 1
+];
+var UpdateKxEnvironmentNetworkResponse$ = [3, n0, _UKENRp,
+    0,
+    [_n, _eI, _aAI, _st, _tS, _dS, _eM, _d, _eA, _kKI, _dSAI, _tGC, _cDNSC, _cTre, _uT, _aZIv],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, () => TransitGatewayConfiguration$, () => CustomDNSConfiguration, 4, 4, 64 | 0]
+];
+var UpdateKxEnvironmentRequest$ = [3, n0, _UKER,
+    0,
+    [_eI, _n, _d, _cTl],
+    [[0, 1], 0, 0, [0, 4]], 1
+];
+var UpdateKxEnvironmentResponse$ = [3, n0, _UKERp,
+    0,
+    [_n, _eI, _aAI, _st, _tS, _dS, _eM, _d, _eA, _kKI, _dSAI, _tGC, _cDNSC, _cTre, _uT, _aZIv],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, () => TransitGatewayConfiguration$, () => CustomDNSConfiguration, 4, 4, 64 | 0]
+];
+var UpdateKxUserRequest$ = [3, n0, _UKUR,
+    0,
+    [_eI, _uN, _iR, _cTl],
+    [[0, 1], [0, 1], 0, [0, 4]], 3
+];
+var UpdateKxUserResponse$ = [3, n0, _UKURp,
+    0,
+    [_uN, _uA, _eI, _iR],
+    [0, 0, 0, 0]
+];
+var UpdateKxVolumeRequest$ = [3, n0, _UKVR,
+    0,
+    [_eI, _vN, _d, _cTl, _nCa],
+    [[0, 1], [0, 1], 0, [0, 4], () => KxNAS1Configuration$], 2
+];
+var UpdateKxVolumeResponse$ = [3, n0, _UKVRp,
+    0,
+    [_eI, _vN, _vT, _vA, _nCa, _st, _d, _sR, _cTr, _aM, _aZIv, _lMT, _aC],
+    [0, 0, 0, 0, () => KxNAS1Configuration$, 0, 0, 0, 4, 0, 64 | 0, 4, () => KxAttachedClusters]
+];
+var Volume$ = [3, n0, _V,
+    0,
+    [_vN, _vT],
+    [0, 0]
+];
+var VpcConfiguration$ = [3, n0, _VC,
+    0,
+    [_vIp, _sGI, _sI, _iAT],
+    [0, 64 | 0, 64 | 0, 0]
+];
+var ChangeRequests = [1, n0, _CRh,
+    0, () => ChangeRequest$
+];
+var CustomDNSConfiguration = [1, n0, _CDNSC,
+    0, () => CustomDNSServer$
+];
+var EnvironmentList = [1, n0, _EL,
+    0, () => Environment$
+];
+var KxAttachedClusters = [1, n0, _KACx,
+    0, () => KxAttachedCluster$
+];
+var KxCacheStorageConfigurations = [1, n0, _KCSCx,
+    0, () => KxCacheStorageConfiguration$
+];
+var KxChangesets = [1, n0, _KCx,
+    0, () => KxChangesetListEntry$
+];
+var KxClusters = [1, n0, _KCxl,
+    0, () => KxCluster$
+];
+var KxCommandLineArguments = [1, n0, _KCLAx,
+    0, () => KxCommandLineArgument$
+];
+var KxDatabaseCacheConfigurations = [1, n0, _KDCCx,
+    0, () => KxDatabaseCacheConfiguration$
+];
+var KxDatabaseConfigurations = [1, n0, _KDCxa,
+    0, () => KxDatabaseConfiguration$
+];
+var KxDatabases = [1, n0, _KD,
+    0, () => KxDatabaseListEntry$
+];
+var KxDataviewActiveVersionList = [1, n0, _KDAVL,
+    0, () => KxDataviewActiveVersion$
+];
+var KxDataviews = [1, n0, _KDx,
+    0, () => KxDataviewListEntry$
+];
+var KxDataviewSegmentConfigurationList = [1, n0, _KDSCL,
+    0, () => KxDataviewSegmentConfiguration$
+];
+var KxEnvironmentList = [1, n0, _KEL,
+    0, () => KxEnvironment$
+];
+var KxNodeSummaries = [1, n0, _KNS,
+    0, () => KxNode$
+];
+var KxScalingGroupList = [1, n0, _KSGL,
+    0, () => KxScalingGroup$
+];
+var KxUserList = [1, n0, _KUL,
+    0, () => KxUser$
+];
+var KxVolumes = [1, n0, _KVx,
+    0, () => KxVolume$
+];
+var NetworkACLConfiguration = [1, n0, _NACLC,
+    0, () => NetworkACLEntry$
+];
+var Volumes = [1, n0, _Vo,
+    0, () => Volume$
+];
+var CreateEnvironment$ = [9, n0, _CEr,
+    { [_h]: ["POST", "/environment", 200] }, () => CreateEnvironmentRequest$, () => CreateEnvironmentResponse$
+];
+var CreateKxChangeset$ = [9, n0, _CKC,
+    { [_h]: ["POST", "/kx/environments/{environmentId}/databases/{databaseName}/changesets", 200] }, () => CreateKxChangesetRequest$, () => CreateKxChangesetResponse$
+];
+var CreateKxCluster$ = [9, n0, _CKCr,
+    { [_h]: ["POST", "/kx/environments/{environmentId}/clusters", 200] }, () => CreateKxClusterRequest$, () => CreateKxClusterResponse$
+];
+var CreateKxDatabase$ = [9, n0, _CKD,
+    { [_h]: ["POST", "/kx/environments/{environmentId}/databases", 200] }, () => CreateKxDatabaseRequest$, () => CreateKxDatabaseResponse$
+];
+var CreateKxDataview$ = [9, n0, _CKDr,
+    { [_h]: ["POST", "/kx/environments/{environmentId}/databases/{databaseName}/dataviews", 200] }, () => CreateKxDataviewRequest$, () => CreateKxDataviewResponse$
+];
+var CreateKxEnvironment$ = [9, n0, _CKE,
+    { [_h]: ["POST", "/kx/environments", 200] }, () => CreateKxEnvironmentRequest$, () => CreateKxEnvironmentResponse$
+];
+var CreateKxScalingGroup$ = [9, n0, _CKSG,
+    { [_h]: ["POST", "/kx/environments/{environmentId}/scalingGroups", 200] }, () => CreateKxScalingGroupRequest$, () => CreateKxScalingGroupResponse$
+];
+var CreateKxUser$ = [9, n0, _CKU,
+    { [_h]: ["POST", "/kx/environments/{environmentId}/users", 200] }, () => CreateKxUserRequest$, () => CreateKxUserResponse$
+];
+var CreateKxVolume$ = [9, n0, _CKV,
+    { [_h]: ["POST", "/kx/environments/{environmentId}/kxvolumes", 200] }, () => CreateKxVolumeRequest$, () => CreateKxVolumeResponse$
+];
+var DeleteEnvironment$ = [9, n0, _DE,
+    { [_h]: ["DELETE", "/environment/{environmentId}", 200] }, () => DeleteEnvironmentRequest$, () => DeleteEnvironmentResponse$
+];
+var DeleteKxCluster$ = [9, n0, _DKC,
+    { [_h]: ["DELETE", "/kx/environments/{environmentId}/clusters/{clusterName}", 200] }, () => DeleteKxClusterRequest$, () => DeleteKxClusterResponse$
+];
+var DeleteKxClusterNode$ = [9, n0, _DKCN,
+    { [_h]: ["DELETE", "/kx/environments/{environmentId}/clusters/{clusterName}/nodes/{nodeId}", 200] }, () => DeleteKxClusterNodeRequest$, () => DeleteKxClusterNodeResponse$
+];
+var DeleteKxDatabase$ = [9, n0, _DKD,
+    { [_h]: ["DELETE", "/kx/environments/{environmentId}/databases/{databaseName}", 200] }, () => DeleteKxDatabaseRequest$, () => DeleteKxDatabaseResponse$
+];
+var DeleteKxDataview$ = [9, n0, _DKDe,
+    { [_h]: ["DELETE", "/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}", 200] }, () => DeleteKxDataviewRequest$, () => DeleteKxDataviewResponse$
+];
+var DeleteKxEnvironment$ = [9, n0, _DKE,
+    { [_h]: ["DELETE", "/kx/environments/{environmentId}", 200] }, () => DeleteKxEnvironmentRequest$, () => DeleteKxEnvironmentResponse$
+];
+var DeleteKxScalingGroup$ = [9, n0, _DKSG,
+    { [_h]: ["DELETE", "/kx/environments/{environmentId}/scalingGroups/{scalingGroupName}", 200] }, () => DeleteKxScalingGroupRequest$, () => DeleteKxScalingGroupResponse$
+];
+var DeleteKxUser$ = [9, n0, _DKU,
+    { [_h]: ["DELETE", "/kx/environments/{environmentId}/users/{userName}", 200] }, () => DeleteKxUserRequest$, () => DeleteKxUserResponse$
+];
+var DeleteKxVolume$ = [9, n0, _DKV,
+    { [_h]: ["DELETE", "/kx/environments/{environmentId}/kxvolumes/{volumeName}", 200] }, () => DeleteKxVolumeRequest$, () => DeleteKxVolumeResponse$
+];
+var GetEnvironment$ = [9, n0, _GE,
+    { [_h]: ["GET", "/environment/{environmentId}", 200] }, () => GetEnvironmentRequest$, () => GetEnvironmentResponse$
+];
+var GetKxChangeset$ = [9, n0, _GKC,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/databases/{databaseName}/changesets/{changesetId}", 200] }, () => GetKxChangesetRequest$, () => GetKxChangesetResponse$
+];
+var GetKxCluster$ = [9, n0, _GKCe,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/clusters/{clusterName}", 200] }, () => GetKxClusterRequest$, () => GetKxClusterResponse$
+];
+var GetKxConnectionString$ = [9, n0, _GKCS,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/connectionString", 200] }, () => GetKxConnectionStringRequest$, () => GetKxConnectionStringResponse$
+];
+var GetKxDatabase$ = [9, n0, _GKD,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/databases/{databaseName}", 200] }, () => GetKxDatabaseRequest$, () => GetKxDatabaseResponse$
+];
+var GetKxDataview$ = [9, n0, _GKDe,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}", 200] }, () => GetKxDataviewRequest$, () => GetKxDataviewResponse$
+];
+var GetKxEnvironment$ = [9, n0, _GKE,
+    { [_h]: ["GET", "/kx/environments/{environmentId}", 200] }, () => GetKxEnvironmentRequest$, () => GetKxEnvironmentResponse$
+];
+var GetKxScalingGroup$ = [9, n0, _GKSG,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/scalingGroups/{scalingGroupName}", 200] }, () => GetKxScalingGroupRequest$, () => GetKxScalingGroupResponse$
+];
+var GetKxUser$ = [9, n0, _GKU,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/users/{userName}", 200] }, () => GetKxUserRequest$, () => GetKxUserResponse$
+];
+var GetKxVolume$ = [9, n0, _GKV,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/kxvolumes/{volumeName}", 200] }, () => GetKxVolumeRequest$, () => GetKxVolumeResponse$
+];
+var ListEnvironments$ = [9, n0, _LE,
+    { [_h]: ["GET", "/environment", 200] }, () => ListEnvironmentsRequest$, () => ListEnvironmentsResponse$
+];
+var ListKxChangesets$ = [9, n0, _LKC,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/databases/{databaseName}/changesets", 200] }, () => ListKxChangesetsRequest$, () => ListKxChangesetsResponse$
+];
+var ListKxClusterNodes$ = [9, n0, _LKCN,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/clusters/{clusterName}/nodes", 200] }, () => ListKxClusterNodesRequest$, () => ListKxClusterNodesResponse$
+];
+var ListKxClusters$ = [9, n0, _LKCi,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/clusters", 200] }, () => ListKxClustersRequest$, () => ListKxClustersResponse$
+];
+var ListKxDatabases$ = [9, n0, _LKD,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/databases", 200] }, () => ListKxDatabasesRequest$, () => ListKxDatabasesResponse$
+];
+var ListKxDataviews$ = [9, n0, _LKDi,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/databases/{databaseName}/dataviews", 200] }, () => ListKxDataviewsRequest$, () => ListKxDataviewsResponse$
+];
+var ListKxEnvironments$ = [9, n0, _LKE,
+    { [_h]: ["GET", "/kx/environments", 200] }, () => ListKxEnvironmentsRequest$, () => ListKxEnvironmentsResponse$
+];
+var ListKxScalingGroups$ = [9, n0, _LKSG,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/scalingGroups", 200] }, () => ListKxScalingGroupsRequest$, () => ListKxScalingGroupsResponse$
+];
+var ListKxUsers$ = [9, n0, _LKU,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/users", 200] }, () => ListKxUsersRequest$, () => ListKxUsersResponse$
+];
+var ListKxVolumes$ = [9, n0, _LKV,
+    { [_h]: ["GET", "/kx/environments/{environmentId}/kxvolumes", 200] }, () => ListKxVolumesRequest$, () => ListKxVolumesResponse$
+];
+var ListTagsForResource$ = [9, n0, _LTFR,
+    { [_h]: ["GET", "/tags/{resourceArn}", 200] }, () => ListTagsForResourceRequest$, () => ListTagsForResourceResponse$
+];
+var TagResource$ = [9, n0, _TR,
+    { [_h]: ["POST", "/tags/{resourceArn}", 200] }, () => TagResourceRequest$, () => TagResourceResponse$
+];
+var UntagResource$ = [9, n0, _UR,
+    { [_h]: ["DELETE", "/tags/{resourceArn}", 200] }, () => UntagResourceRequest$, () => UntagResourceResponse$
+];
+var UpdateEnvironment$ = [9, n0, _UE,
+    { [_h]: ["PUT", "/environment/{environmentId}", 200] }, () => UpdateEnvironmentRequest$, () => UpdateEnvironmentResponse$
+];
+var UpdateKxClusterCodeConfiguration$ = [9, n0, _UKCCC,
+    { [_h]: ["PUT", "/kx/environments/{environmentId}/clusters/{clusterName}/configuration/code", 200] }, () => UpdateKxClusterCodeConfigurationRequest$, () => UpdateKxClusterCodeConfigurationResponse$
+];
+var UpdateKxClusterDatabases$ = [9, n0, _UKCD,
+    { [_h]: ["PUT", "/kx/environments/{environmentId}/clusters/{clusterName}/configuration/databases", 200] }, () => UpdateKxClusterDatabasesRequest$, () => UpdateKxClusterDatabasesResponse$
+];
+var UpdateKxDatabase$ = [9, n0, _UKD,
+    { [_h]: ["PUT", "/kx/environments/{environmentId}/databases/{databaseName}", 200] }, () => UpdateKxDatabaseRequest$, () => UpdateKxDatabaseResponse$
+];
+var UpdateKxDataview$ = [9, n0, _UKDp,
+    { [_h]: ["PUT", "/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}", 200] }, () => UpdateKxDataviewRequest$, () => UpdateKxDataviewResponse$
+];
+var UpdateKxEnvironment$ = [9, n0, _UKE,
+    { [_h]: ["PUT", "/kx/environments/{environmentId}", 200] }, () => UpdateKxEnvironmentRequest$, () => UpdateKxEnvironmentResponse$
+];
+var UpdateKxEnvironmentNetwork$ = [9, n0, _UKEN,
+    { [_h]: ["PUT", "/kx/environments/{environmentId}/network", 200] }, () => UpdateKxEnvironmentNetworkRequest$, () => UpdateKxEnvironmentNetworkResponse$
+];
+var UpdateKxUser$ = [9, n0, _UKU,
+    { [_h]: ["PUT", "/kx/environments/{environmentId}/users/{userName}", 200] }, () => UpdateKxUserRequest$, () => UpdateKxUserResponse$
+];
+var UpdateKxVolume$ = [9, n0, _UKV,
+    { [_h]: ["PATCH", "/kx/environments/{environmentId}/kxvolumes/{volumeName}", 200] }, () => UpdateKxVolumeRequest$, () => UpdateKxVolumeResponse$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2021-03-12",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultFinspaceHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsRestJsonProtocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.finspace",
+            errorTypeRegistries,
+            version: "2021-03-12",
+            serviceTarget: "AWSHabaneroManagementService",
+        },
+        serviceId: config?.serviceId ?? "finspace",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -925,81 +2576,292 @@ const KxDeploymentStrategy = {
     ROLLING: "ROLLING",
 };
 
+exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException$ = AccessDeniedException$;
+exports.AutoScalingConfiguration$ = AutoScalingConfiguration$;
 exports.AutoScalingMetric = AutoScalingMetric;
+exports.CapacityConfiguration$ = CapacityConfiguration$;
+exports.ChangeRequest$ = ChangeRequest$;
 exports.ChangeType = ChangeType;
 exports.ChangesetStatus = ChangesetStatus;
+exports.CodeConfiguration$ = CodeConfiguration$;
+exports.ConflictException = ConflictException;
+exports.ConflictException$ = ConflictException$;
+exports.CreateEnvironment$ = CreateEnvironment$;
 exports.CreateEnvironmentCommand = CreateEnvironmentCommand;
+exports.CreateEnvironmentRequest$ = CreateEnvironmentRequest$;
+exports.CreateEnvironmentResponse$ = CreateEnvironmentResponse$;
+exports.CreateKxChangeset$ = CreateKxChangeset$;
 exports.CreateKxChangesetCommand = CreateKxChangesetCommand;
+exports.CreateKxChangesetRequest$ = CreateKxChangesetRequest$;
+exports.CreateKxChangesetResponse$ = CreateKxChangesetResponse$;
+exports.CreateKxCluster$ = CreateKxCluster$;
 exports.CreateKxClusterCommand = CreateKxClusterCommand;
+exports.CreateKxClusterRequest$ = CreateKxClusterRequest$;
+exports.CreateKxClusterResponse$ = CreateKxClusterResponse$;
+exports.CreateKxDatabase$ = CreateKxDatabase$;
 exports.CreateKxDatabaseCommand = CreateKxDatabaseCommand;
+exports.CreateKxDatabaseRequest$ = CreateKxDatabaseRequest$;
+exports.CreateKxDatabaseResponse$ = CreateKxDatabaseResponse$;
+exports.CreateKxDataview$ = CreateKxDataview$;
 exports.CreateKxDataviewCommand = CreateKxDataviewCommand;
+exports.CreateKxDataviewRequest$ = CreateKxDataviewRequest$;
+exports.CreateKxDataviewResponse$ = CreateKxDataviewResponse$;
+exports.CreateKxEnvironment$ = CreateKxEnvironment$;
 exports.CreateKxEnvironmentCommand = CreateKxEnvironmentCommand;
+exports.CreateKxEnvironmentRequest$ = CreateKxEnvironmentRequest$;
+exports.CreateKxEnvironmentResponse$ = CreateKxEnvironmentResponse$;
+exports.CreateKxScalingGroup$ = CreateKxScalingGroup$;
 exports.CreateKxScalingGroupCommand = CreateKxScalingGroupCommand;
+exports.CreateKxScalingGroupRequest$ = CreateKxScalingGroupRequest$;
+exports.CreateKxScalingGroupResponse$ = CreateKxScalingGroupResponse$;
+exports.CreateKxUser$ = CreateKxUser$;
 exports.CreateKxUserCommand = CreateKxUserCommand;
+exports.CreateKxUserRequest$ = CreateKxUserRequest$;
+exports.CreateKxUserResponse$ = CreateKxUserResponse$;
+exports.CreateKxVolume$ = CreateKxVolume$;
 exports.CreateKxVolumeCommand = CreateKxVolumeCommand;
+exports.CreateKxVolumeRequest$ = CreateKxVolumeRequest$;
+exports.CreateKxVolumeResponse$ = CreateKxVolumeResponse$;
+exports.CustomDNSServer$ = CustomDNSServer$;
+exports.DeleteEnvironment$ = DeleteEnvironment$;
 exports.DeleteEnvironmentCommand = DeleteEnvironmentCommand;
+exports.DeleteEnvironmentRequest$ = DeleteEnvironmentRequest$;
+exports.DeleteEnvironmentResponse$ = DeleteEnvironmentResponse$;
+exports.DeleteKxCluster$ = DeleteKxCluster$;
 exports.DeleteKxClusterCommand = DeleteKxClusterCommand;
+exports.DeleteKxClusterNode$ = DeleteKxClusterNode$;
 exports.DeleteKxClusterNodeCommand = DeleteKxClusterNodeCommand;
+exports.DeleteKxClusterNodeRequest$ = DeleteKxClusterNodeRequest$;
+exports.DeleteKxClusterNodeResponse$ = DeleteKxClusterNodeResponse$;
+exports.DeleteKxClusterRequest$ = DeleteKxClusterRequest$;
+exports.DeleteKxClusterResponse$ = DeleteKxClusterResponse$;
+exports.DeleteKxDatabase$ = DeleteKxDatabase$;
 exports.DeleteKxDatabaseCommand = DeleteKxDatabaseCommand;
+exports.DeleteKxDatabaseRequest$ = DeleteKxDatabaseRequest$;
+exports.DeleteKxDatabaseResponse$ = DeleteKxDatabaseResponse$;
+exports.DeleteKxDataview$ = DeleteKxDataview$;
 exports.DeleteKxDataviewCommand = DeleteKxDataviewCommand;
+exports.DeleteKxDataviewRequest$ = DeleteKxDataviewRequest$;
+exports.DeleteKxDataviewResponse$ = DeleteKxDataviewResponse$;
+exports.DeleteKxEnvironment$ = DeleteKxEnvironment$;
 exports.DeleteKxEnvironmentCommand = DeleteKxEnvironmentCommand;
+exports.DeleteKxEnvironmentRequest$ = DeleteKxEnvironmentRequest$;
+exports.DeleteKxEnvironmentResponse$ = DeleteKxEnvironmentResponse$;
+exports.DeleteKxScalingGroup$ = DeleteKxScalingGroup$;
 exports.DeleteKxScalingGroupCommand = DeleteKxScalingGroupCommand;
+exports.DeleteKxScalingGroupRequest$ = DeleteKxScalingGroupRequest$;
+exports.DeleteKxScalingGroupResponse$ = DeleteKxScalingGroupResponse$;
+exports.DeleteKxUser$ = DeleteKxUser$;
 exports.DeleteKxUserCommand = DeleteKxUserCommand;
+exports.DeleteKxUserRequest$ = DeleteKxUserRequest$;
+exports.DeleteKxUserResponse$ = DeleteKxUserResponse$;
+exports.DeleteKxVolume$ = DeleteKxVolume$;
 exports.DeleteKxVolumeCommand = DeleteKxVolumeCommand;
+exports.DeleteKxVolumeRequest$ = DeleteKxVolumeRequest$;
+exports.DeleteKxVolumeResponse$ = DeleteKxVolumeResponse$;
 exports.DnsStatus = DnsStatus;
+exports.Environment$ = Environment$;
 exports.EnvironmentStatus = EnvironmentStatus;
 exports.ErrorDetails = ErrorDetails;
+exports.ErrorInfo$ = ErrorInfo$;
 exports.FederationMode = FederationMode;
+exports.FederationParameters$ = FederationParameters$;
 exports.Finspace = Finspace;
 exports.FinspaceClient = FinspaceClient;
+exports.FinspaceServiceException = FinspaceServiceException;
+exports.FinspaceServiceException$ = FinspaceServiceException$;
+exports.GetEnvironment$ = GetEnvironment$;
 exports.GetEnvironmentCommand = GetEnvironmentCommand;
+exports.GetEnvironmentRequest$ = GetEnvironmentRequest$;
+exports.GetEnvironmentResponse$ = GetEnvironmentResponse$;
+exports.GetKxChangeset$ = GetKxChangeset$;
 exports.GetKxChangesetCommand = GetKxChangesetCommand;
+exports.GetKxChangesetRequest$ = GetKxChangesetRequest$;
+exports.GetKxChangesetResponse$ = GetKxChangesetResponse$;
+exports.GetKxCluster$ = GetKxCluster$;
 exports.GetKxClusterCommand = GetKxClusterCommand;
+exports.GetKxClusterRequest$ = GetKxClusterRequest$;
+exports.GetKxClusterResponse$ = GetKxClusterResponse$;
+exports.GetKxConnectionString$ = GetKxConnectionString$;
 exports.GetKxConnectionStringCommand = GetKxConnectionStringCommand;
+exports.GetKxConnectionStringRequest$ = GetKxConnectionStringRequest$;
+exports.GetKxConnectionStringResponse$ = GetKxConnectionStringResponse$;
+exports.GetKxDatabase$ = GetKxDatabase$;
 exports.GetKxDatabaseCommand = GetKxDatabaseCommand;
+exports.GetKxDatabaseRequest$ = GetKxDatabaseRequest$;
+exports.GetKxDatabaseResponse$ = GetKxDatabaseResponse$;
+exports.GetKxDataview$ = GetKxDataview$;
 exports.GetKxDataviewCommand = GetKxDataviewCommand;
+exports.GetKxDataviewRequest$ = GetKxDataviewRequest$;
+exports.GetKxDataviewResponse$ = GetKxDataviewResponse$;
+exports.GetKxEnvironment$ = GetKxEnvironment$;
 exports.GetKxEnvironmentCommand = GetKxEnvironmentCommand;
+exports.GetKxEnvironmentRequest$ = GetKxEnvironmentRequest$;
+exports.GetKxEnvironmentResponse$ = GetKxEnvironmentResponse$;
+exports.GetKxScalingGroup$ = GetKxScalingGroup$;
 exports.GetKxScalingGroupCommand = GetKxScalingGroupCommand;
+exports.GetKxScalingGroupRequest$ = GetKxScalingGroupRequest$;
+exports.GetKxScalingGroupResponse$ = GetKxScalingGroupResponse$;
+exports.GetKxUser$ = GetKxUser$;
 exports.GetKxUserCommand = GetKxUserCommand;
+exports.GetKxUserRequest$ = GetKxUserRequest$;
+exports.GetKxUserResponse$ = GetKxUserResponse$;
+exports.GetKxVolume$ = GetKxVolume$;
 exports.GetKxVolumeCommand = GetKxVolumeCommand;
+exports.GetKxVolumeRequest$ = GetKxVolumeRequest$;
+exports.GetKxVolumeResponse$ = GetKxVolumeResponse$;
 exports.IPAddressType = IPAddressType;
+exports.IcmpTypeCode$ = IcmpTypeCode$;
+exports.InternalServerException = InternalServerException;
+exports.InternalServerException$ = InternalServerException$;
+exports.InvalidRequestException = InvalidRequestException;
+exports.InvalidRequestException$ = InvalidRequestException$;
+exports.KxAttachedCluster$ = KxAttachedCluster$;
 exports.KxAzMode = KxAzMode;
+exports.KxCacheStorageConfiguration$ = KxCacheStorageConfiguration$;
+exports.KxChangesetListEntry$ = KxChangesetListEntry$;
+exports.KxCluster$ = KxCluster$;
+exports.KxClusterCodeDeploymentConfiguration$ = KxClusterCodeDeploymentConfiguration$;
 exports.KxClusterCodeDeploymentStrategy = KxClusterCodeDeploymentStrategy;
 exports.KxClusterStatus = KxClusterStatus;
 exports.KxClusterType = KxClusterType;
+exports.KxCommandLineArgument$ = KxCommandLineArgument$;
+exports.KxDatabaseCacheConfiguration$ = KxDatabaseCacheConfiguration$;
+exports.KxDatabaseConfiguration$ = KxDatabaseConfiguration$;
+exports.KxDatabaseListEntry$ = KxDatabaseListEntry$;
+exports.KxDataviewActiveVersion$ = KxDataviewActiveVersion$;
+exports.KxDataviewConfiguration$ = KxDataviewConfiguration$;
+exports.KxDataviewListEntry$ = KxDataviewListEntry$;
+exports.KxDataviewSegmentConfiguration$ = KxDataviewSegmentConfiguration$;
 exports.KxDataviewStatus = KxDataviewStatus;
+exports.KxDeploymentConfiguration$ = KxDeploymentConfiguration$;
 exports.KxDeploymentStrategy = KxDeploymentStrategy;
+exports.KxEnvironment$ = KxEnvironment$;
+exports.KxNAS1Configuration$ = KxNAS1Configuration$;
 exports.KxNAS1Type = KxNAS1Type;
+exports.KxNode$ = KxNode$;
 exports.KxNodeStatus = KxNodeStatus;
+exports.KxSavedownStorageConfiguration$ = KxSavedownStorageConfiguration$;
 exports.KxSavedownStorageType = KxSavedownStorageType;
+exports.KxScalingGroup$ = KxScalingGroup$;
+exports.KxScalingGroupConfiguration$ = KxScalingGroupConfiguration$;
 exports.KxScalingGroupStatus = KxScalingGroupStatus;
+exports.KxUser$ = KxUser$;
+exports.KxVolume$ = KxVolume$;
 exports.KxVolumeStatus = KxVolumeStatus;
 exports.KxVolumeType = KxVolumeType;
+exports.LimitExceededException = LimitExceededException;
+exports.LimitExceededException$ = LimitExceededException$;
+exports.ListEnvironments$ = ListEnvironments$;
 exports.ListEnvironmentsCommand = ListEnvironmentsCommand;
+exports.ListEnvironmentsRequest$ = ListEnvironmentsRequest$;
+exports.ListEnvironmentsResponse$ = ListEnvironmentsResponse$;
+exports.ListKxChangesets$ = ListKxChangesets$;
 exports.ListKxChangesetsCommand = ListKxChangesetsCommand;
+exports.ListKxChangesetsRequest$ = ListKxChangesetsRequest$;
+exports.ListKxChangesetsResponse$ = ListKxChangesetsResponse$;
+exports.ListKxClusterNodes$ = ListKxClusterNodes$;
 exports.ListKxClusterNodesCommand = ListKxClusterNodesCommand;
+exports.ListKxClusterNodesRequest$ = ListKxClusterNodesRequest$;
+exports.ListKxClusterNodesResponse$ = ListKxClusterNodesResponse$;
+exports.ListKxClusters$ = ListKxClusters$;
 exports.ListKxClustersCommand = ListKxClustersCommand;
+exports.ListKxClustersRequest$ = ListKxClustersRequest$;
+exports.ListKxClustersResponse$ = ListKxClustersResponse$;
+exports.ListKxDatabases$ = ListKxDatabases$;
 exports.ListKxDatabasesCommand = ListKxDatabasesCommand;
+exports.ListKxDatabasesRequest$ = ListKxDatabasesRequest$;
+exports.ListKxDatabasesResponse$ = ListKxDatabasesResponse$;
+exports.ListKxDataviews$ = ListKxDataviews$;
 exports.ListKxDataviewsCommand = ListKxDataviewsCommand;
+exports.ListKxDataviewsRequest$ = ListKxDataviewsRequest$;
+exports.ListKxDataviewsResponse$ = ListKxDataviewsResponse$;
+exports.ListKxEnvironments$ = ListKxEnvironments$;
 exports.ListKxEnvironmentsCommand = ListKxEnvironmentsCommand;
+exports.ListKxEnvironmentsRequest$ = ListKxEnvironmentsRequest$;
+exports.ListKxEnvironmentsResponse$ = ListKxEnvironmentsResponse$;
+exports.ListKxScalingGroups$ = ListKxScalingGroups$;
 exports.ListKxScalingGroupsCommand = ListKxScalingGroupsCommand;
+exports.ListKxScalingGroupsRequest$ = ListKxScalingGroupsRequest$;
+exports.ListKxScalingGroupsResponse$ = ListKxScalingGroupsResponse$;
+exports.ListKxUsers$ = ListKxUsers$;
 exports.ListKxUsersCommand = ListKxUsersCommand;
+exports.ListKxUsersRequest$ = ListKxUsersRequest$;
+exports.ListKxUsersResponse$ = ListKxUsersResponse$;
+exports.ListKxVolumes$ = ListKxVolumes$;
 exports.ListKxVolumesCommand = ListKxVolumesCommand;
+exports.ListKxVolumesRequest$ = ListKxVolumesRequest$;
+exports.ListKxVolumesResponse$ = ListKxVolumesResponse$;
+exports.ListTagsForResource$ = ListTagsForResource$;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListTagsForResourceRequest$ = ListTagsForResourceRequest$;
+exports.ListTagsForResourceResponse$ = ListTagsForResourceResponse$;
+exports.NetworkACLEntry$ = NetworkACLEntry$;
+exports.PortRange$ = PortRange$;
+exports.ResourceAlreadyExistsException = ResourceAlreadyExistsException;
+exports.ResourceAlreadyExistsException$ = ResourceAlreadyExistsException$;
+exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException$ = ResourceNotFoundException$;
 exports.RuleAction = RuleAction;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException$ = ServiceQuotaExceededException$;
+exports.SuperuserParameters$ = SuperuserParameters$;
+exports.TagResource$ = TagResource$;
 exports.TagResourceCommand = TagResourceCommand;
+exports.TagResourceRequest$ = TagResourceRequest$;
+exports.TagResourceResponse$ = TagResourceResponse$;
 exports.TgwStatus = TgwStatus;
+exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException$ = ThrottlingException$;
+exports.TickerplantLogConfiguration$ = TickerplantLogConfiguration$;
+exports.TransitGatewayConfiguration$ = TransitGatewayConfiguration$;
+exports.UntagResource$ = UntagResource$;
 exports.UntagResourceCommand = UntagResourceCommand;
+exports.UntagResourceRequest$ = UntagResourceRequest$;
+exports.UntagResourceResponse$ = UntagResourceResponse$;
+exports.UpdateEnvironment$ = UpdateEnvironment$;
 exports.UpdateEnvironmentCommand = UpdateEnvironmentCommand;
+exports.UpdateEnvironmentRequest$ = UpdateEnvironmentRequest$;
+exports.UpdateEnvironmentResponse$ = UpdateEnvironmentResponse$;
+exports.UpdateKxClusterCodeConfiguration$ = UpdateKxClusterCodeConfiguration$;
 exports.UpdateKxClusterCodeConfigurationCommand = UpdateKxClusterCodeConfigurationCommand;
+exports.UpdateKxClusterCodeConfigurationRequest$ = UpdateKxClusterCodeConfigurationRequest$;
+exports.UpdateKxClusterCodeConfigurationResponse$ = UpdateKxClusterCodeConfigurationResponse$;
+exports.UpdateKxClusterDatabases$ = UpdateKxClusterDatabases$;
 exports.UpdateKxClusterDatabasesCommand = UpdateKxClusterDatabasesCommand;
+exports.UpdateKxClusterDatabasesRequest$ = UpdateKxClusterDatabasesRequest$;
+exports.UpdateKxClusterDatabasesResponse$ = UpdateKxClusterDatabasesResponse$;
+exports.UpdateKxDatabase$ = UpdateKxDatabase$;
 exports.UpdateKxDatabaseCommand = UpdateKxDatabaseCommand;
+exports.UpdateKxDatabaseRequest$ = UpdateKxDatabaseRequest$;
+exports.UpdateKxDatabaseResponse$ = UpdateKxDatabaseResponse$;
+exports.UpdateKxDataview$ = UpdateKxDataview$;
 exports.UpdateKxDataviewCommand = UpdateKxDataviewCommand;
+exports.UpdateKxDataviewRequest$ = UpdateKxDataviewRequest$;
+exports.UpdateKxDataviewResponse$ = UpdateKxDataviewResponse$;
+exports.UpdateKxEnvironment$ = UpdateKxEnvironment$;
 exports.UpdateKxEnvironmentCommand = UpdateKxEnvironmentCommand;
+exports.UpdateKxEnvironmentNetwork$ = UpdateKxEnvironmentNetwork$;
 exports.UpdateKxEnvironmentNetworkCommand = UpdateKxEnvironmentNetworkCommand;
+exports.UpdateKxEnvironmentNetworkRequest$ = UpdateKxEnvironmentNetworkRequest$;
+exports.UpdateKxEnvironmentNetworkResponse$ = UpdateKxEnvironmentNetworkResponse$;
+exports.UpdateKxEnvironmentRequest$ = UpdateKxEnvironmentRequest$;
+exports.UpdateKxEnvironmentResponse$ = UpdateKxEnvironmentResponse$;
+exports.UpdateKxUser$ = UpdateKxUser$;
 exports.UpdateKxUserCommand = UpdateKxUserCommand;
+exports.UpdateKxUserRequest$ = UpdateKxUserRequest$;
+exports.UpdateKxUserResponse$ = UpdateKxUserResponse$;
+exports.UpdateKxVolume$ = UpdateKxVolume$;
 exports.UpdateKxVolumeCommand = UpdateKxVolumeCommand;
+exports.UpdateKxVolumeRequest$ = UpdateKxVolumeRequest$;
+exports.UpdateKxVolumeResponse$ = UpdateKxVolumeResponse$;
+exports.ValidationException = ValidationException;
+exports.ValidationException$ = ValidationException$;
+exports.Volume$ = Volume$;
 exports.VolumeType = VolumeType;
+exports.VpcConfiguration$ = VpcConfiguration$;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateListKxChangesets = paginateListKxChangesets;
 exports.paginateListKxClusterNodes = paginateListKxClusterNodes;
 exports.paginateListKxDatabases = paginateListKxDatabases;