@jjrawlins/cdk-ami-builder 0.0.191 → 0.0.193

package/node_modules/@aws-sdk/client-kms/dist-cjs/index.js

@@ -1,23 +1,59 @@
-'use strict';
-
-var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
-var middlewareLogger = require('@aws-sdk/middleware-logger');
-var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
-var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
-var configResolver = require('@smithy/config-resolver');
-var core = require('@smithy/core');
-var schema = require('@smithy/core/schema');
-var middlewareContentLength = require('@smithy/middleware-content-length');
-var middlewareEndpoint = require('@smithy/middleware-endpoint');
-var middlewareRetry = require('@smithy/middleware-retry');
-var smithyClient = require('@smithy/smithy-client');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var regionConfigResolver = require('@aws-sdk/region-config-resolver');
-var protocolHttp = require('@smithy/protocol-http');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var KMSServiceException = require('./models/KMSServiceException');
+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 { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require("@smithy/core/client");
+const { Command: $Command } = require("@smithy/core/client");
+exports.$Command = $Command;
+exports.__Client = Client;
+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, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsJson1_1Protocol } = require("@aws-sdk/core/protocols");
+const { Sha256 } = require("@smithy/core/checksum");
+
+const defaultKMSHttpAuthSchemeParametersProvider = 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: "kms",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultKMSHttpAuthSchemeProvider = (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, {
@@ -33,6 +69,2126 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1084.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://kms-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://kms-fips.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://kms.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        ["https://kms.{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 KMSServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, KMSServiceException.prototype);
+    }
+}
+
+class AlreadyExistsException extends KMSServiceException {
+    name = "AlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "AlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AlreadyExistsException.prototype);
+    }
+}
+class DependencyTimeoutException extends KMSServiceException {
+    name = "DependencyTimeoutException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "DependencyTimeoutException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DependencyTimeoutException.prototype);
+    }
+}
+class InvalidArnException extends KMSServiceException {
+    name = "InvalidArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidArnException.prototype);
+    }
+}
+class KMSInternalException extends KMSServiceException {
+    name = "KMSInternalException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "KMSInternalException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KMSInternalException.prototype);
+    }
+}
+class KMSInvalidStateException extends KMSServiceException {
+    name = "KMSInvalidStateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "KMSInvalidStateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KMSInvalidStateException.prototype);
+    }
+}
+class NotFoundException extends KMSServiceException {
+    name = "NotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NotFoundException.prototype);
+    }
+}
+class CloudHsmClusterInUseException extends KMSServiceException {
+    name = "CloudHsmClusterInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CloudHsmClusterInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CloudHsmClusterInUseException.prototype);
+    }
+}
+class CloudHsmClusterInvalidConfigurationException extends KMSServiceException {
+    name = "CloudHsmClusterInvalidConfigurationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CloudHsmClusterInvalidConfigurationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CloudHsmClusterInvalidConfigurationException.prototype);
+    }
+}
+class CloudHsmClusterNotActiveException extends KMSServiceException {
+    name = "CloudHsmClusterNotActiveException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CloudHsmClusterNotActiveException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CloudHsmClusterNotActiveException.prototype);
+    }
+}
+class CloudHsmClusterNotFoundException extends KMSServiceException {
+    name = "CloudHsmClusterNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CloudHsmClusterNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CloudHsmClusterNotFoundException.prototype);
+    }
+}
+class CloudHsmClusterNotRelatedException extends KMSServiceException {
+    name = "CloudHsmClusterNotRelatedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CloudHsmClusterNotRelatedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CloudHsmClusterNotRelatedException.prototype);
+    }
+}
+class ConflictException extends KMSServiceException {
+    name = "ConflictException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+class CustomKeyStoreInvalidStateException extends KMSServiceException {
+    name = "CustomKeyStoreInvalidStateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CustomKeyStoreInvalidStateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CustomKeyStoreInvalidStateException.prototype);
+    }
+}
+class CustomKeyStoreNotFoundException extends KMSServiceException {
+    name = "CustomKeyStoreNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CustomKeyStoreNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CustomKeyStoreNotFoundException.prototype);
+    }
+}
+class InvalidAliasNameException extends KMSServiceException {
+    name = "InvalidAliasNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidAliasNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidAliasNameException.prototype);
+    }
+}
+class LimitExceededException extends KMSServiceException {
+    name = "LimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+    }
+}
+class CustomKeyStoreNameInUseException extends KMSServiceException {
+    name = "CustomKeyStoreNameInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CustomKeyStoreNameInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CustomKeyStoreNameInUseException.prototype);
+    }
+}
+class IncorrectTrustAnchorException extends KMSServiceException {
+    name = "IncorrectTrustAnchorException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "IncorrectTrustAnchorException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, IncorrectTrustAnchorException.prototype);
+    }
+}
+class XksProxyIncorrectAuthenticationCredentialException extends KMSServiceException {
+    name = "XksProxyIncorrectAuthenticationCredentialException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyIncorrectAuthenticationCredentialException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyIncorrectAuthenticationCredentialException.prototype);
+    }
+}
+class XksProxyInvalidConfigurationException extends KMSServiceException {
+    name = "XksProxyInvalidConfigurationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyInvalidConfigurationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyInvalidConfigurationException.prototype);
+    }
+}
+class XksProxyInvalidResponseException extends KMSServiceException {
+    name = "XksProxyInvalidResponseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyInvalidResponseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyInvalidResponseException.prototype);
+    }
+}
+class XksProxyUriEndpointInUseException extends KMSServiceException {
+    name = "XksProxyUriEndpointInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyUriEndpointInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyUriEndpointInUseException.prototype);
+    }
+}
+class XksProxyUriInUseException extends KMSServiceException {
+    name = "XksProxyUriInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyUriInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyUriInUseException.prototype);
+    }
+}
+class XksProxyUriUnreachableException extends KMSServiceException {
+    name = "XksProxyUriUnreachableException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyUriUnreachableException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyUriUnreachableException.prototype);
+    }
+}
+class XksProxyVpcEndpointServiceInUseException extends KMSServiceException {
+    name = "XksProxyVpcEndpointServiceInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyVpcEndpointServiceInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyVpcEndpointServiceInUseException.prototype);
+    }
+}
+class XksProxyVpcEndpointServiceInvalidConfigurationException extends KMSServiceException {
+    name = "XksProxyVpcEndpointServiceInvalidConfigurationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyVpcEndpointServiceInvalidConfigurationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyVpcEndpointServiceInvalidConfigurationException.prototype);
+    }
+}
+class XksProxyVpcEndpointServiceNotFoundException extends KMSServiceException {
+    name = "XksProxyVpcEndpointServiceNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksProxyVpcEndpointServiceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksProxyVpcEndpointServiceNotFoundException.prototype);
+    }
+}
+class DisabledException extends KMSServiceException {
+    name = "DisabledException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DisabledException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DisabledException.prototype);
+    }
+}
+class DryRunOperationException extends KMSServiceException {
+    name = "DryRunOperationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DryRunOperationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DryRunOperationException.prototype);
+    }
+}
+class InvalidGrantTokenException extends KMSServiceException {
+    name = "InvalidGrantTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidGrantTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidGrantTokenException.prototype);
+    }
+}
+class MalformedPolicyDocumentException extends KMSServiceException {
+    name = "MalformedPolicyDocumentException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MalformedPolicyDocumentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MalformedPolicyDocumentException.prototype);
+    }
+}
+class TagException extends KMSServiceException {
+    name = "TagException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagException.prototype);
+    }
+}
+class UnsupportedOperationException extends KMSServiceException {
+    name = "UnsupportedOperationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnsupportedOperationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnsupportedOperationException.prototype);
+    }
+}
+class XksKeyAlreadyInUseException extends KMSServiceException {
+    name = "XksKeyAlreadyInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksKeyAlreadyInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksKeyAlreadyInUseException.prototype);
+    }
+}
+class XksKeyInvalidConfigurationException extends KMSServiceException {
+    name = "XksKeyInvalidConfigurationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksKeyInvalidConfigurationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksKeyInvalidConfigurationException.prototype);
+    }
+}
+class XksKeyNotFoundException extends KMSServiceException {
+    name = "XksKeyNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "XksKeyNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, XksKeyNotFoundException.prototype);
+    }
+}
+class CustomKeyStoreHasCMKsException extends KMSServiceException {
+    name = "CustomKeyStoreHasCMKsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CustomKeyStoreHasCMKsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CustomKeyStoreHasCMKsException.prototype);
+    }
+}
+class IncorrectKeyException extends KMSServiceException {
+    name = "IncorrectKeyException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "IncorrectKeyException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, IncorrectKeyException.prototype);
+    }
+}
+class InvalidCiphertextException extends KMSServiceException {
+    name = "InvalidCiphertextException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidCiphertextException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCiphertextException.prototype);
+    }
+}
+class InvalidKeyUsageException extends KMSServiceException {
+    name = "InvalidKeyUsageException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidKeyUsageException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidKeyUsageException.prototype);
+    }
+}
+class KeyUnavailableException extends KMSServiceException {
+    name = "KeyUnavailableException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "KeyUnavailableException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KeyUnavailableException.prototype);
+    }
+}
+class InvalidMarkerException extends KMSServiceException {
+    name = "InvalidMarkerException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidMarkerException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidMarkerException.prototype);
+    }
+}
+class ExpiredImportTokenException extends KMSServiceException {
+    name = "ExpiredImportTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExpiredImportTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExpiredImportTokenException.prototype);
+    }
+}
+class IncorrectKeyMaterialException extends KMSServiceException {
+    name = "IncorrectKeyMaterialException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "IncorrectKeyMaterialException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, IncorrectKeyMaterialException.prototype);
+    }
+}
+class InvalidImportTokenException extends KMSServiceException {
+    name = "InvalidImportTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidImportTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidImportTokenException.prototype);
+    }
+}
+class InvalidGrantIdException extends KMSServiceException {
+    name = "InvalidGrantIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidGrantIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidGrantIdException.prototype);
+    }
+}
+class KMSInvalidMacException extends KMSServiceException {
+    name = "KMSInvalidMacException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "KMSInvalidMacException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KMSInvalidMacException.prototype);
+    }
+}
+class KMSInvalidSignatureException extends KMSServiceException {
+    name = "KMSInvalidSignatureException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "KMSInvalidSignatureException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KMSInvalidSignatureException.prototype);
+    }
+}
+
+const _A = "Arn";
+const _AA = "AliasArn";
+const _AD = "AttestationDocument";
+const _AEE = "AlreadyExistsException";
+const _AKI = "AccessKeyId";
+const _AL = "AliasList";
+const _ALE = "AliasListEntry";
+const _AN = "AliasName";
+const _AWSAI = "AWSAccountId";
+const _Al = "Aliases";
+const _BPLSC = "BypassPolicyLockoutSafetyCheck";
+const _C = "Constraints";
+const _CA = "CreateAlias";
+const _CAR = "CreateAliasRequest";
+const _CB = "CiphertextBlob";
+const _CCKS = "ConnectCustomKeyStore";
+const _CCKSR = "ConnectCustomKeyStoreRequest";
+const _CCKSRo = "ConnectCustomKeyStoreResponse";
+const _CCKSRr = "CreateCustomKeyStoreRequest";
+const _CCKSRre = "CreateCustomKeyStoreResponse";
+const _CCKSr = "CreateCustomKeyStore";
+const _CD = "CreationDate";
+const _CE = "ConflictException";
+const _CEC = "ConnectionErrorCode";
+const _CFR = "CiphertextForRecipient";
+const _CG = "CreateGrant";
+const _CGR = "CreateGrantRequest";
+const _CGRr = "CreateGrantResponse";
+const _CHCI = "CloudHsmClusterId";
+const _CHCICE = "CloudHsmClusterInvalidConfigurationException";
+const _CHCIUE = "CloudHsmClusterInUseException";
+const _CHCNAE = "CloudHsmClusterNotActiveException";
+const _CHCNFE = "CloudHsmClusterNotFoundException";
+const _CHCNRE = "CloudHsmClusterNotRelatedException";
+const _CK = "CreateKey";
+const _CKD = "CancelKeyDeletion";
+const _CKDR = "CancelKeyDeletionRequest";
+const _CKDRa = "CancelKeyDeletionResponse";
+const _CKMI = "CurrentKeyMaterialId";
+const _CKR = "CreateKeyRequest";
+const _CKRr = "CreateKeyResponse";
+const _CKS = "CustomKeyStores";
+const _CKSHCMKE = "CustomKeyStoreHasCMKsException";
+const _CKSI = "CustomKeyStoreId";
+const _CKSISE = "CustomKeyStoreInvalidStateException";
+const _CKSL = "CustomKeyStoresList";
+const _CKSLE = "CustomKeyStoresListEntry";
+const _CKSN = "CustomKeyStoreName";
+const _CKSNFE = "CustomKeyStoreNotFoundException";
+const _CKSNIUE = "CustomKeyStoreNameInUseException";
+const _CKST = "CustomKeyStoreType";
+const _CMKS = "CustomerMasterKeySpec";
+const _CS = "ConnectionState";
+const _CTEI = "CloudTrailEventId";
+const _Co = "Connectivity";
+const _D = "Description";
+const _DA = "DeleteAlias";
+const _DAR = "DeleteAliasRequest";
+const _DCKS = "DeleteCustomKeyStore";
+const _DCKSR = "DeleteCustomKeyStoreRequest";
+const _DCKSRe = "DeleteCustomKeyStoreResponse";
+const _DCKSRes = "DescribeCustomKeyStoresRequest";
+const _DCKSResc = "DescribeCustomKeyStoresResponse";
+const _DCKSRi = "DisconnectCustomKeyStoreRequest";
+const _DCKSRis = "DisconnectCustomKeyStoreResponse";
+const _DCKSe = "DescribeCustomKeyStores";
+const _DCKSi = "DisconnectCustomKeyStore";
+const _DD = "DeletionDate";
+const _DE = "DisabledException";
+const _DEA = "DestinationEncryptionAlgorithm";
+const _DEC = "DestinationEncryptionContext";
+const _DIKM = "DeleteImportedKeyMaterial";
+const _DIKMR = "DeleteImportedKeyMaterialRequest";
+const _DIKMRe = "DeleteImportedKeyMaterialResponse";
+const _DK = "DescribeKey";
+const _DKI = "DestinationKeyId";
+const _DKMI = "DestinationKeyMaterialId";
+const _DKR = "DescribeKeyRequest";
+const _DKRR = "DisableKeyRotationRequest";
+const _DKRe = "DescribeKeyResponse";
+const _DKRi = "DisableKeyRequest";
+const _DKRis = "DisableKeyRotation";
+const _DKi = "DisableKey";
+const _DR = "DryRun";
+const _DRM = "DryRunModifiers";
+const _DROE = "DryRunOperationException";
+const _DRe = "DecryptRequest";
+const _DRec = "DecryptResponse";
+const _DSS = "DeriveSharedSecret";
+const _DSSR = "DeriveSharedSecretRequest";
+const _DSSRe = "DeriveSharedSecretResponse";
+const _DTE = "DependencyTimeoutException";
+const _De = "Decrypt";
+const _E = "Enabled";
+const _EA = "EncryptionAlgorithm";
+const _EAn = "EncryptionAlgorithms";
+const _EC = "EncryptionContext";
+const _ECE = "EncryptionContextEquals";
+const _ECS = "EncryptionContextSubset";
+const _EITE = "ExpiredImportTokenException";
+const _EK = "EnableKey";
+const _EKM = "EncryptedKeyMaterial";
+const _EKR = "EnableKeyRequest";
+const _EKRR = "EnableKeyRotationRequest";
+const _EKRn = "EnableKeyRotation";
+const _EM = "ExpirationModel";
+const _ER = "EncryptRequest";
+const _ERn = "EncryptResponse";
+const _En = "Encrypt";
+const _G = "Grants";
+const _GC = "GrantConstraints";
+const _GDK = "GenerateDataKey";
+const _GDKP = "GenerateDataKeyPair";
+const _GDKPR = "GenerateDataKeyPairRequest";
+const _GDKPRe = "GenerateDataKeyPairResponse";
+const _GDKPWP = "GenerateDataKeyPairWithoutPlaintext";
+const _GDKPWPR = "GenerateDataKeyPairWithoutPlaintextRequest";
+const _GDKPWPRe = "GenerateDataKeyPairWithoutPlaintextResponse";
+const _GDKR = "GenerateDataKeyRequest";
+const _GDKRe = "GenerateDataKeyResponse";
+const _GDKWP = "GenerateDataKeyWithoutPlaintext";
+const _GDKWPR = "GenerateDataKeyWithoutPlaintextRequest";
+const _GDKWPRe = "GenerateDataKeyWithoutPlaintextResponse";
+const _GI = "GrantId";
+const _GKLU = "GetKeyLastUsage";
+const _GKLUR = "GetKeyLastUsageRequest";
+const _GKLURe = "GetKeyLastUsageResponse";
+const _GKP = "GetKeyPolicy";
+const _GKPR = "GetKeyPolicyRequest";
+const _GKPRe = "GetKeyPolicyResponse";
+const _GKRS = "GetKeyRotationStatus";
+const _GKRSR = "GetKeyRotationStatusRequest";
+const _GKRSRe = "GetKeyRotationStatusResponse";
+const _GL = "GrantList";
+const _GLE = "GrantListEntry";
+const _GM = "GenerateMac";
+const _GMR = "GenerateMacRequest";
+const _GMRe = "GenerateMacResponse";
+const _GP = "GranteePrincipal";
+const _GPFI = "GetParametersForImport";
+const _GPFIR = "GetParametersForImportRequest";
+const _GPFIRe = "GetParametersForImportResponse";
+const _GPK = "GetPublicKey";
+const _GPKR = "GetPublicKeyRequest";
+const _GPKRe = "GetPublicKeyResponse";
+const _GR = "GenerateRandom";
+const _GRR = "GenerateRandomRequest";
+const _GRRe = "GenerateRandomResponse";
+const _GSP = "GranteeServicePrincipal";
+const _GT = "GrantTokens";
+const _GTr = "GrantToken";
+const _I = "Id";
+const _IA = "IssuingAccount";
+const _IAE = "InvalidArnException";
+const _IANE = "InvalidAliasNameException";
+const _ICE = "InvalidCiphertextException";
+const _IGIE = "InvalidGrantIdException";
+const _IGTE = "InvalidGrantTokenException";
+const _IITE = "InvalidImportTokenException";
+const _IKE = "IncorrectKeyException";
+const _IKM = "IncludeKeyMaterial";
+const _IKME = "IncorrectKeyMaterialException";
+const _IKMR = "ImportKeyMaterialRequest";
+const _IKMRm = "ImportKeyMaterialResponse";
+const _IKMm = "ImportKeyMaterial";
+const _IKUE = "InvalidKeyUsageException";
+const _IME = "InvalidMarkerException";
+const _IS = "ImportState";
+const _IT = "ImportToken";
+const _ITAE = "IncorrectTrustAnchorException";
+const _ITm = "ImportType";
+const _K = "Keys";
+const _KA = "KeyArn";
+const _KAA = "KeyAgreementAlgorithm";
+const _KAAe = "KeyAgreementAlgorithms";
+const _KCD = "KeyCreationDate";
+const _KEA = "KeyEncryptionAlgorithm";
+const _KI = "KeyId";
+const _KL = "KeyList";
+const _KLE = "KeyListEntry";
+const _KLU = "KeyLastUsage";
+const _KLUD = "KeyLastUsageData";
+const _KM = "KeyMetadata";
+const _KMD = "KeyMaterialDescription";
+const _KMI = "KeyMaterialId";
+const _KMS = "KeyMaterialState";
+const _KMSIE = "KMSInternalException";
+const _KMSIME = "KMSInvalidMacException";
+const _KMSISE = "KMSInvalidSignatureException";
+const _KMSISEn = "KMSInvalidStateException";
+const _KMe = "KeyManager";
+const _KO = "KeyOrigin";
+const _KPS = "KeyPairSpec";
+const _KRE = "KeyRotationEnabled";
+const _KRI = "KmsRequestId";
+const _KS = "KeySpec";
+const _KSP = "KeyStorePassword";
+const _KSPT = "KeyStorePasswordType";
+const _KSe = "KeyState";
+const _KU = "KeyUsage";
+const _KUE = "KeyUnavailableException";
+const _L = "Limit";
+const _LA = "ListAliases";
+const _LAR = "ListAliasesRequest";
+const _LARi = "ListAliasesResponse";
+const _LEE = "LimitExceededException";
+const _LG = "ListGrants";
+const _LGR = "ListGrantsRequest";
+const _LGRi = "ListGrantsResponse";
+const _LK = "ListKeys";
+const _LKP = "ListKeyPolicies";
+const _LKPR = "ListKeyPoliciesRequest";
+const _LKPRi = "ListKeyPoliciesResponse";
+const _LKR = "ListKeysRequest";
+const _LKRR = "ListKeyRotationsRequest";
+const _LKRRi = "ListKeyRotationsResponse";
+const _LKRi = "ListKeysResponse";
+const _LKRis = "ListKeyRotations";
+const _LRG = "ListRetirableGrants";
+const _LRGR = "ListRetirableGrantsRequest";
+const _LRT = "ListResourceTags";
+const _LRTR = "ListResourceTagsRequest";
+const _LRTRi = "ListResourceTagsResponse";
+const _LUD = "LastUpdatedDate";
+const _M = "Marker";
+const _MA = "MacAlgorithm";
+const _MAa = "MacAlgorithms";
+const _MPDE = "MalformedPolicyDocumentException";
+const _MR = "MultiRegion";
+const _MRC = "MultiRegionConfiguration";
+const _MRK = "MultiRegionKey";
+const _MRKL = "MultiRegionKeyList";
+const _MRKT = "MultiRegionKeyType";
+const _MT = "MessageType";
+const _MV = "MacValid";
+const _Ma = "Mac";
+const _Me = "Message";
+const _N = "Name";
+const _NCKSN = "NewCustomKeyStoreName";
+const _NFE = "NotFoundException";
+const _NM = "NextMarker";
+const _NOB = "NumberOfBytes";
+const _NRD = "NextRotationDate";
+const _O = "Operations";
+const _ODRSD = "OnDemandRotationStartDate";
+const _Op = "Operation";
+const _Or = "Origin";
+const _P = "Policy";
+const _PDWID = "PendingDeletionWindowInDays";
+const _PK = "PublicKey";
+const _PKCB = "PrivateKeyCiphertextBlob";
+const _PKP = "PrivateKeyPlaintext";
+const _PKPR = "PutKeyPolicyRequest";
+const _PKPu = "PutKeyPolicy";
+const _PKr = "PrimaryKey";
+const _PN = "PolicyName";
+const _PNo = "PolicyNames";
+const _PR = "PrimaryRegion";
+const _PT = "PlaintextType";
+const _PVT = "ParametersValidTo";
+const _PWID = "PendingWindowInDays";
+const _Pl = "Plaintext";
+const _R = "Recipient";
+const _RD = "RotationDate";
+const _RE = "ReEncrypt";
+const _RER = "ReEncryptRequest";
+const _RERe = "ReEncryptResponse";
+const _RG = "RetireGrant";
+const _RGR = "RetireGrantRequest";
+const _RGRe = "RevokeGrantRequest";
+const _RGe = "RevokeGrant";
+const _RI = "RecipientInfo";
+const _RK = "ReplicaKeys";
+const _RKM = "ReplicaKeyMetadata";
+const _RKOD = "RotateKeyOnDemand";
+const _RKODR = "RotateKeyOnDemandRequest";
+const _RKODRo = "RotateKeyOnDemandResponse";
+const _RKR = "ReplicateKeyRequest";
+const _RKRe = "ReplicateKeyResponse";
+const _RKe = "ReplicateKey";
+const _RL = "RotationsList";
+const _RLE = "RotationsListEntry";
+const _RP = "RetiringPrincipal";
+const _RPID = "RotationPeriodInDays";
+const _RPe = "ReplicaPolicy";
+const _RR = "ReplicaRegion";
+const _RSAK = "RawSecretAccessKey";
+const _RSP = "RetiringServicePrincipal";
+const _RT = "ReplicaTags";
+const _RTo = "RotationType";
+const _Re = "Region";
+const _Ro = "Rotations";
+const _S = "Signature";
+const _SA = "SigningAlgorithms";
+const _SAi = "SigningAlgorithm";
+const _SAo = "SourceArn";
+const _SEA = "SourceEncryptionAlgorithm";
+const _SEC = "SourceEncryptionContext";
+const _SKD = "ScheduleKeyDeletion";
+const _SKDR = "ScheduleKeyDeletionRequest";
+const _SKDRc = "ScheduleKeyDeletionResponse";
+const _SKI = "SourceKeyId";
+const _SKMI = "SourceKeyMaterialId";
+const _SR = "SignRequest";
+const _SRi = "SignResponse";
+const _SS = "SharedSecret";
+const _SV = "SignatureValid";
+const _Si = "Sign";
+const _T = "Tags";
+const _TAC = "TrustAnchorCertificate";
+const _TE = "TagException";
+const _TK = "TagKey";
+const _TKI = "TargetKeyId";
+const _TKa = "TagKeys";
+const _TL = "TagList";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TSD = "TrackingStartDate";
+const _TV = "TagValue";
+const _Ta = "Tag";
+const _Ti = "Timestamp";
+const _Tr = "Truncated";
+const _UA = "UpdateAlias";
+const _UAR = "UpdateAliasRequest";
+const _UCKS = "UpdateCustomKeyStore";
+const _UCKSR = "UpdateCustomKeyStoreRequest";
+const _UCKSRp = "UpdateCustomKeyStoreResponse";
+const _UE = "UriEndpoint";
+const _UKD = "UpdateKeyDescription";
+const _UKDR = "UpdateKeyDescriptionRequest";
+const _UOE = "UnsupportedOperationException";
+const _UP = "UriPath";
+const _UPR = "UpdatePrimaryRegion";
+const _UPRR = "UpdatePrimaryRegionRequest";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _V = "Verify";
+const _VESN = "VpcEndpointServiceName";
+const _VESO = "VpcEndpointServiceOwner";
+const _VM = "VerifyMac";
+const _VMR = "VerifyMacRequest";
+const _VMRe = "VerifyMacResponse";
+const _VR = "VerifyRequest";
+const _VRe = "VerifyResponse";
+const _VT = "ValidTo";
+const _WA = "WrappingAlgorithm";
+const _WKS = "WrappingKeySpec";
+const _XKAIUE = "XksKeyAlreadyInUseException";
+const _XKC = "XksKeyConfiguration";
+const _XKCT = "XksKeyConfigurationType";
+const _XKI = "XksKeyId";
+const _XKICE = "XksKeyInvalidConfigurationException";
+const _XKNFE = "XksKeyNotFoundException";
+const _XPAAKIT = "XksProxyAuthenticationAccessKeyIdType";
+const _XPAC = "XksProxyAuthenticationCredential";
+const _XPACT = "XksProxyAuthenticationCredentialType";
+const _XPARSAKT = "XksProxyAuthenticationRawSecretAccessKeyType";
+const _XPC = "XksProxyConnectivity";
+const _XPCT = "XksProxyConfigurationType";
+const _XPCk = "XksProxyConfiguration";
+const _XPIACE = "XksProxyIncorrectAuthenticationCredentialException";
+const _XPICE = "XksProxyInvalidConfigurationException";
+const _XPIRE = "XksProxyInvalidResponseException";
+const _XPUE = "XksProxyUriEndpoint";
+const _XPUEIUE = "XksProxyUriEndpointInUseException";
+const _XPUIUE = "XksProxyUriInUseException";
+const _XPUP = "XksProxyUriPath";
+const _XPUUE = "XksProxyUriUnreachableException";
+const _XPVESICE = "XksProxyVpcEndpointServiceInvalidConfigurationException";
+const _XPVESIUE = "XksProxyVpcEndpointServiceInUseException";
+const _XPVESN = "XksProxyVpcEndpointServiceName";
+const _XPVESNFE = "XksProxyVpcEndpointServiceNotFoundException";
+const _XPVESO = "XksProxyVpcEndpointServiceOwner";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _hE = "httpError";
+const _m = "message";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.kms";
+const _se = "server";
+const n0 = "com.amazonaws.kms";
+const _s_registry = TypeRegistry.for(_s);
+var KMSServiceException$ = [-3, _s, "KMSServiceException", 0, [], []];
+_s_registry.registerError(KMSServiceException$, KMSServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var AlreadyExistsException$ = [-3, n0, _AEE,
+    { [_aQE]: [`AlreadyExists`, 409], [_e]: _c, [_hE]: 409 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(AlreadyExistsException$, AlreadyExistsException);
+var CloudHsmClusterInUseException$ = [-3, n0, _CHCIUE,
+    { [_aQE]: [`CloudHsmClusterInUseException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CloudHsmClusterInUseException$, CloudHsmClusterInUseException);
+var CloudHsmClusterInvalidConfigurationException$ = [-3, n0, _CHCICE,
+    { [_aQE]: [`CloudHsmClusterInvalidConfigurationException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CloudHsmClusterInvalidConfigurationException$, CloudHsmClusterInvalidConfigurationException);
+var CloudHsmClusterNotActiveException$ = [-3, n0, _CHCNAE,
+    { [_aQE]: [`CloudHsmClusterNotActiveException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CloudHsmClusterNotActiveException$, CloudHsmClusterNotActiveException);
+var CloudHsmClusterNotFoundException$ = [-3, n0, _CHCNFE,
+    { [_aQE]: [`CloudHsmClusterNotFoundException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CloudHsmClusterNotFoundException$, CloudHsmClusterNotFoundException);
+var CloudHsmClusterNotRelatedException$ = [-3, n0, _CHCNRE,
+    { [_aQE]: [`CloudHsmClusterNotRelatedException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CloudHsmClusterNotRelatedException$, CloudHsmClusterNotRelatedException);
+var ConflictException$ = [-3, n0, _CE,
+    { [_aQE]: [`ConflictException`, 409], [_e]: _c, [_hE]: 409 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ConflictException$, ConflictException);
+var CustomKeyStoreHasCMKsException$ = [-3, n0, _CKSHCMKE,
+    { [_aQE]: [`CustomKeyStoreHasCMKsException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CustomKeyStoreHasCMKsException$, CustomKeyStoreHasCMKsException);
+var CustomKeyStoreInvalidStateException$ = [-3, n0, _CKSISE,
+    { [_aQE]: [`CustomKeyStoreInvalidStateException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CustomKeyStoreInvalidStateException$, CustomKeyStoreInvalidStateException);
+var CustomKeyStoreNameInUseException$ = [-3, n0, _CKSNIUE,
+    { [_aQE]: [`CustomKeyStoreNameInUseException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CustomKeyStoreNameInUseException$, CustomKeyStoreNameInUseException);
+var CustomKeyStoreNotFoundException$ = [-3, n0, _CKSNFE,
+    { [_aQE]: [`CustomKeyStoreNotFoundException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CustomKeyStoreNotFoundException$, CustomKeyStoreNotFoundException);
+var DependencyTimeoutException$ = [-3, n0, _DTE,
+    { [_aQE]: [`DependencyTimeout`, 503], [_e]: _se, [_hE]: 503 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DependencyTimeoutException$, DependencyTimeoutException);
+var DisabledException$ = [-3, n0, _DE,
+    { [_aQE]: [`Disabled`, 409], [_e]: _c, [_hE]: 409 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DisabledException$, DisabledException);
+var DryRunOperationException$ = [-3, n0, _DROE,
+    { [_aQE]: [`DryRunOperation`, 412], [_e]: _c, [_hE]: 412 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DryRunOperationException$, DryRunOperationException);
+var ExpiredImportTokenException$ = [-3, n0, _EITE,
+    { [_aQE]: [`ExpiredImportTokenException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ExpiredImportTokenException$, ExpiredImportTokenException);
+var IncorrectKeyException$ = [-3, n0, _IKE,
+    { [_aQE]: [`IncorrectKeyException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(IncorrectKeyException$, IncorrectKeyException);
+var IncorrectKeyMaterialException$ = [-3, n0, _IKME,
+    { [_aQE]: [`IncorrectKeyMaterialException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(IncorrectKeyMaterialException$, IncorrectKeyMaterialException);
+var IncorrectTrustAnchorException$ = [-3, n0, _ITAE,
+    { [_aQE]: [`IncorrectTrustAnchorException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(IncorrectTrustAnchorException$, IncorrectTrustAnchorException);
+var InvalidAliasNameException$ = [-3, n0, _IANE,
+    { [_aQE]: [`InvalidAliasName`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidAliasNameException$, InvalidAliasNameException);
+var InvalidArnException$ = [-3, n0, _IAE,
+    { [_aQE]: [`InvalidArn`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidArnException$, InvalidArnException);
+var InvalidCiphertextException$ = [-3, n0, _ICE,
+    { [_aQE]: [`InvalidCiphertext`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidCiphertextException$, InvalidCiphertextException);
+var InvalidGrantIdException$ = [-3, n0, _IGIE,
+    { [_aQE]: [`InvalidGrantId`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidGrantIdException$, InvalidGrantIdException);
+var InvalidGrantTokenException$ = [-3, n0, _IGTE,
+    { [_aQE]: [`InvalidGrantToken`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidGrantTokenException$, InvalidGrantTokenException);
+var InvalidImportTokenException$ = [-3, n0, _IITE,
+    { [_aQE]: [`InvalidImportTokenException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidImportTokenException$, InvalidImportTokenException);
+var InvalidKeyUsageException$ = [-3, n0, _IKUE,
+    { [_aQE]: [`InvalidKeyUsage`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidKeyUsageException$, InvalidKeyUsageException);
+var InvalidMarkerException$ = [-3, n0, _IME,
+    { [_aQE]: [`InvalidMarker`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidMarkerException$, InvalidMarkerException);
+var KeyUnavailableException$ = [-3, n0, _KUE,
+    { [_aQE]: [`KeyUnavailable`, 500], [_e]: _se, [_hE]: 500 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(KeyUnavailableException$, KeyUnavailableException);
+var KMSInternalException$ = [-3, n0, _KMSIE,
+    { [_aQE]: [`KMSInternal`, 500], [_e]: _se, [_hE]: 500 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(KMSInternalException$, KMSInternalException);
+var KMSInvalidMacException$ = [-3, n0, _KMSIME,
+    { [_aQE]: [`KMSInvalidMac`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(KMSInvalidMacException$, KMSInvalidMacException);
+var KMSInvalidSignatureException$ = [-3, n0, _KMSISE,
+    { [_aQE]: [`KMSInvalidSignature`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(KMSInvalidSignatureException$, KMSInvalidSignatureException);
+var KMSInvalidStateException$ = [-3, n0, _KMSISEn,
+    { [_aQE]: [`KMSInvalidStateException`, 409], [_e]: _c, [_hE]: 409 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(KMSInvalidStateException$, KMSInvalidStateException);
+var LimitExceededException$ = [-3, n0, _LEE,
+    { [_aQE]: [`LimitExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(LimitExceededException$, LimitExceededException);
+var MalformedPolicyDocumentException$ = [-3, n0, _MPDE,
+    { [_aQE]: [`MalformedPolicyDocument`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(MalformedPolicyDocumentException$, MalformedPolicyDocumentException);
+var NotFoundException$ = [-3, n0, _NFE,
+    { [_aQE]: [`NotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(NotFoundException$, NotFoundException);
+var TagException$ = [-3, n0, _TE,
+    { [_aQE]: [`TagException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TagException$, TagException);
+var UnsupportedOperationException$ = [-3, n0, _UOE,
+    { [_aQE]: [`UnsupportedOperation`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UnsupportedOperationException$, UnsupportedOperationException);
+var XksKeyAlreadyInUseException$ = [-3, n0, _XKAIUE,
+    { [_aQE]: [`XksKeyAlreadyInUse`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksKeyAlreadyInUseException$, XksKeyAlreadyInUseException);
+var XksKeyInvalidConfigurationException$ = [-3, n0, _XKICE,
+    { [_aQE]: [`XksKeyInvalidConfiguration`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksKeyInvalidConfigurationException$, XksKeyInvalidConfigurationException);
+var XksKeyNotFoundException$ = [-3, n0, _XKNFE,
+    { [_aQE]: [`XksKeyNotFoundException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksKeyNotFoundException$, XksKeyNotFoundException);
+var XksProxyIncorrectAuthenticationCredentialException$ = [-3, n0, _XPIACE,
+    { [_aQE]: [`XksProxyIncorrectAuthenticationCredentialException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyIncorrectAuthenticationCredentialException$, XksProxyIncorrectAuthenticationCredentialException);
+var XksProxyInvalidConfigurationException$ = [-3, n0, _XPICE,
+    { [_aQE]: [`XksProxyInvalidConfigurationException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyInvalidConfigurationException$, XksProxyInvalidConfigurationException);
+var XksProxyInvalidResponseException$ = [-3, n0, _XPIRE,
+    { [_aQE]: [`XksProxyInvalidResponseException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyInvalidResponseException$, XksProxyInvalidResponseException);
+var XksProxyUriEndpointInUseException$ = [-3, n0, _XPUEIUE,
+    { [_aQE]: [`XksProxyUriEndpointInUseException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyUriEndpointInUseException$, XksProxyUriEndpointInUseException);
+var XksProxyUriInUseException$ = [-3, n0, _XPUIUE,
+    { [_aQE]: [`XksProxyUriInUseException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyUriInUseException$, XksProxyUriInUseException);
+var XksProxyUriUnreachableException$ = [-3, n0, _XPUUE,
+    { [_aQE]: [`XksProxyUriUnreachableException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyUriUnreachableException$, XksProxyUriUnreachableException);
+var XksProxyVpcEndpointServiceInUseException$ = [-3, n0, _XPVESIUE,
+    { [_aQE]: [`XksProxyVpcEndpointServiceInUseException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyVpcEndpointServiceInUseException$, XksProxyVpcEndpointServiceInUseException);
+var XksProxyVpcEndpointServiceInvalidConfigurationException$ = [-3, n0, _XPVESICE,
+    { [_aQE]: [`XksProxyVpcEndpointServiceInvalidConfigurationException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyVpcEndpointServiceInvalidConfigurationException$, XksProxyVpcEndpointServiceInvalidConfigurationException);
+var XksProxyVpcEndpointServiceNotFoundException$ = [-3, n0, _XPVESNFE,
+    { [_aQE]: [`XksProxyVpcEndpointServiceNotFoundException`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(XksProxyVpcEndpointServiceNotFoundException$, XksProxyVpcEndpointServiceNotFoundException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+var KeyStorePasswordType = [0, n0, _KSPT, 8, 0];
+var PlaintextType = [0, n0, _PT, 8, 21];
+var XksProxyAuthenticationAccessKeyIdType = [0, n0, _XPAAKIT, 8, 0];
+var XksProxyAuthenticationRawSecretAccessKeyType = [0, n0, _XPARSAKT, 8, 0];
+var AliasListEntry$ = [3, n0, _ALE,
+    0,
+    [_AN, _AA, _TKI, _CD, _LUD],
+    [0, 0, 0, 4, 4]
+];
+var CancelKeyDeletionRequest$ = [3, n0, _CKDR,
+    0,
+    [_KI],
+    [0], 1
+];
+var CancelKeyDeletionResponse$ = [3, n0, _CKDRa,
+    0,
+    [_KI],
+    [0]
+];
+var ConnectCustomKeyStoreRequest$ = [3, n0, _CCKSR,
+    0,
+    [_CKSI],
+    [0], 1
+];
+var ConnectCustomKeyStoreResponse$ = [3, n0, _CCKSRo,
+    0,
+    [],
+    []
+];
+var CreateAliasRequest$ = [3, n0, _CAR,
+    0,
+    [_AN, _TKI],
+    [0, 0], 2
+];
+var CreateCustomKeyStoreRequest$ = [3, n0, _CCKSRr,
+    0,
+    [_CKSN, _CHCI, _TAC, _KSP, _CKST, _XPUE, _XPUP, _XPVESN, _XPVESO, _XPAC, _XPC],
+    [0, 0, 0, [() => KeyStorePasswordType, 0], 0, 0, 0, 0, 0, [() => XksProxyAuthenticationCredentialType$, 0], 0], 1
+];
+var CreateCustomKeyStoreResponse$ = [3, n0, _CCKSRre,
+    0,
+    [_CKSI],
+    [0]
+];
+var CreateGrantRequest$ = [3, n0, _CGR,
+    0,
+    [_KI, _O, _GP, _RP, _C, _GT, _N, _DR, _GSP, _RSP],
+    [0, 64 | 0, 0, 0, () => GrantConstraints$, 64 | 0, 0, 2, 0, 0], 2
+];
+var CreateGrantResponse$ = [3, n0, _CGRr,
+    0,
+    [_GTr, _GI],
+    [0, 0]
+];
+var CreateKeyRequest$ = [3, n0, _CKR,
+    0,
+    [_P, _D, _KU, _CMKS, _KS, _Or, _CKSI, _BPLSC, _T, _MR, _XKI],
+    [0, 0, 0, 0, 0, 0, 0, 2, () => TagList, 2, 0]
+];
+var CreateKeyResponse$ = [3, n0, _CKRr,
+    0,
+    [_KM],
+    [() => KeyMetadata$]
+];
+var CustomKeyStoresListEntry$ = [3, n0, _CKSLE,
+    0,
+    [_CKSI, _CKSN, _CHCI, _TAC, _CS, _CEC, _CD, _CKST, _XPCk],
+    [0, 0, 0, 0, 0, 0, 4, 0, [() => XksProxyConfigurationType$, 0]]
+];
+var DecryptRequest$ = [3, n0, _DRe,
+    0,
+    [_CB, _EC, _GT, _KI, _EA, _R, _DR, _DRM],
+    [21, 128 | 0, 64 | 0, 0, 0, () => RecipientInfo$, 2, 64 | 0]
+];
+var DecryptResponse$ = [3, n0, _DRec,
+    0,
+    [_KI, _Pl, _EA, _CFR, _KMI],
+    [0, [() => PlaintextType, 0], 0, 21, 0]
+];
+var DeleteAliasRequest$ = [3, n0, _DAR,
+    0,
+    [_AN],
+    [0], 1
+];
+var DeleteCustomKeyStoreRequest$ = [3, n0, _DCKSR,
+    0,
+    [_CKSI],
+    [0], 1
+];
+var DeleteCustomKeyStoreResponse$ = [3, n0, _DCKSRe,
+    0,
+    [],
+    []
+];
+var DeleteImportedKeyMaterialRequest$ = [3, n0, _DIKMR,
+    0,
+    [_KI, _KMI],
+    [0, 0], 1
+];
+var DeleteImportedKeyMaterialResponse$ = [3, n0, _DIKMRe,
+    0,
+    [_KI, _KMI],
+    [0, 0]
+];
+var DeriveSharedSecretRequest$ = [3, n0, _DSSR,
+    0,
+    [_KI, _KAA, _PK, _GT, _DR, _R],
+    [0, 0, 21, 64 | 0, 2, () => RecipientInfo$], 3
+];
+var DeriveSharedSecretResponse$ = [3, n0, _DSSRe,
+    0,
+    [_KI, _SS, _CFR, _KAA, _KO],
+    [0, [() => PlaintextType, 0], 21, 0, 0]
+];
+var DescribeCustomKeyStoresRequest$ = [3, n0, _DCKSRes,
+    0,
+    [_CKSI, _CKSN, _L, _M],
+    [0, 0, 1, 0]
+];
+var DescribeCustomKeyStoresResponse$ = [3, n0, _DCKSResc,
+    0,
+    [_CKS, _NM, _Tr],
+    [[() => CustomKeyStoresList, 0], 0, 2]
+];
+var DescribeKeyRequest$ = [3, n0, _DKR,
+    0,
+    [_KI, _GT],
+    [0, 64 | 0], 1
+];
+var DescribeKeyResponse$ = [3, n0, _DKRe,
+    0,
+    [_KM],
+    [() => KeyMetadata$]
+];
+var DisableKeyRequest$ = [3, n0, _DKRi,
+    0,
+    [_KI],
+    [0], 1
+];
+var DisableKeyRotationRequest$ = [3, n0, _DKRR,
+    0,
+    [_KI],
+    [0], 1
+];
+var DisconnectCustomKeyStoreRequest$ = [3, n0, _DCKSRi,
+    0,
+    [_CKSI],
+    [0], 1
+];
+var DisconnectCustomKeyStoreResponse$ = [3, n0, _DCKSRis,
+    0,
+    [],
+    []
+];
+var EnableKeyRequest$ = [3, n0, _EKR,
+    0,
+    [_KI],
+    [0], 1
+];
+var EnableKeyRotationRequest$ = [3, n0, _EKRR,
+    0,
+    [_KI, _RPID],
+    [0, 1], 1
+];
+var EncryptRequest$ = [3, n0, _ER,
+    0,
+    [_KI, _Pl, _EC, _GT, _EA, _DR],
+    [0, [() => PlaintextType, 0], 128 | 0, 64 | 0, 0, 2], 2
+];
+var EncryptResponse$ = [3, n0, _ERn,
+    0,
+    [_CB, _KI, _EA],
+    [21, 0, 0]
+];
+var GenerateDataKeyPairRequest$ = [3, n0, _GDKPR,
+    0,
+    [_KI, _KPS, _EC, _GT, _R, _DR],
+    [0, 0, 128 | 0, 64 | 0, () => RecipientInfo$, 2], 2
+];
+var GenerateDataKeyPairResponse$ = [3, n0, _GDKPRe,
+    0,
+    [_PKCB, _PKP, _PK, _KI, _KPS, _CFR, _KMI],
+    [21, [() => PlaintextType, 0], 21, 0, 0, 21, 0]
+];
+var GenerateDataKeyPairWithoutPlaintextRequest$ = [3, n0, _GDKPWPR,
+    0,
+    [_KI, _KPS, _EC, _GT, _DR],
+    [0, 0, 128 | 0, 64 | 0, 2], 2
+];
+var GenerateDataKeyPairWithoutPlaintextResponse$ = [3, n0, _GDKPWPRe,
+    0,
+    [_PKCB, _PK, _KI, _KPS, _KMI],
+    [21, 21, 0, 0, 0]
+];
+var GenerateDataKeyRequest$ = [3, n0, _GDKR,
+    0,
+    [_KI, _EC, _NOB, _KS, _GT, _R, _DR],
+    [0, 128 | 0, 1, 0, 64 | 0, () => RecipientInfo$, 2], 1
+];
+var GenerateDataKeyResponse$ = [3, n0, _GDKRe,
+    0,
+    [_CB, _Pl, _KI, _CFR, _KMI],
+    [21, [() => PlaintextType, 0], 0, 21, 0]
+];
+var GenerateDataKeyWithoutPlaintextRequest$ = [3, n0, _GDKWPR,
+    0,
+    [_KI, _EC, _KS, _NOB, _GT, _DR],
+    [0, 128 | 0, 0, 1, 64 | 0, 2], 1
+];
+var GenerateDataKeyWithoutPlaintextResponse$ = [3, n0, _GDKWPRe,
+    0,
+    [_CB, _KI, _KMI],
+    [21, 0, 0]
+];
+var GenerateMacRequest$ = [3, n0, _GMR,
+    0,
+    [_Me, _KI, _MA, _GT, _DR],
+    [[() => PlaintextType, 0], 0, 0, 64 | 0, 2], 3
+];
+var GenerateMacResponse$ = [3, n0, _GMRe,
+    0,
+    [_Ma, _MA, _KI],
+    [21, 0, 0]
+];
+var GenerateRandomRequest$ = [3, n0, _GRR,
+    0,
+    [_NOB, _CKSI, _R],
+    [1, 0, () => RecipientInfo$]
+];
+var GenerateRandomResponse$ = [3, n0, _GRRe,
+    0,
+    [_Pl, _CFR],
+    [[() => PlaintextType, 0], 21]
+];
+var GetKeyLastUsageRequest$ = [3, n0, _GKLUR,
+    0,
+    [_KI],
+    [0], 1
+];
+var GetKeyLastUsageResponse$ = [3, n0, _GKLURe,
+    0,
+    [_KI, _KLU, _TSD, _KCD],
+    [0, () => KeyLastUsageData$, 4, 4]
+];
+var GetKeyPolicyRequest$ = [3, n0, _GKPR,
+    0,
+    [_KI, _PN],
+    [0, 0], 1
+];
+var GetKeyPolicyResponse$ = [3, n0, _GKPRe,
+    0,
+    [_P, _PN],
+    [0, 0]
+];
+var GetKeyRotationStatusRequest$ = [3, n0, _GKRSR,
+    0,
+    [_KI],
+    [0], 1
+];
+var GetKeyRotationStatusResponse$ = [3, n0, _GKRSRe,
+    0,
+    [_KRE, _KI, _RPID, _NRD, _ODRSD],
+    [2, 0, 1, 4, 4]
+];
+var GetParametersForImportRequest$ = [3, n0, _GPFIR,
+    0,
+    [_KI, _WA, _WKS],
+    [0, 0, 0], 3
+];
+var GetParametersForImportResponse$ = [3, n0, _GPFIRe,
+    0,
+    [_KI, _IT, _PK, _PVT],
+    [0, 21, [() => PlaintextType, 0], 4]
+];
+var GetPublicKeyRequest$ = [3, n0, _GPKR,
+    0,
+    [_KI, _GT],
+    [0, 64 | 0], 1
+];
+var GetPublicKeyResponse$ = [3, n0, _GPKRe,
+    0,
+    [_KI, _PK, _CMKS, _KS, _KU, _EAn, _SA, _KAAe],
+    [0, 21, 0, 0, 0, 64 | 0, 64 | 0, 64 | 0]
+];
+var GrantConstraints$ = [3, n0, _GC,
+    0,
+    [_ECS, _ECE, _SAo],
+    [128 | 0, 128 | 0, 0]
+];
+var GrantListEntry$ = [3, n0, _GLE,
+    0,
+    [_KI, _GI, _N, _CD, _GP, _RP, _IA, _O, _C, _GSP, _RSP],
+    [0, 0, 0, 4, 0, 0, 0, 64 | 0, () => GrantConstraints$, 0, 0]
+];
+var ImportKeyMaterialRequest$ = [3, n0, _IKMR,
+    0,
+    [_KI, _IT, _EKM, _VT, _EM, _ITm, _KMD, _KMI],
+    [0, 21, 21, 4, 0, 0, 0, 0], 3
+];
+var ImportKeyMaterialResponse$ = [3, n0, _IKMRm,
+    0,
+    [_KI, _KMI],
+    [0, 0]
+];
+var KeyLastUsageData$ = [3, n0, _KLUD,
+    0,
+    [_Op, _Ti, _CTEI, _KRI],
+    [0, 4, 0, 0]
+];
+var KeyListEntry$ = [3, n0, _KLE,
+    0,
+    [_KI, _KA],
+    [0, 0]
+];
+var KeyMetadata$ = [3, n0, _KM,
+    0,
+    [_KI, _AWSAI, _A, _CD, _E, _D, _KU, _KSe, _DD, _VT, _Or, _CKSI, _CHCI, _EM, _KMe, _CMKS, _KS, _EAn, _SA, _KAAe, _MR, _MRC, _PDWID, _MAa, _XKC, _CKMI],
+    [0, 0, 0, 4, 2, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0, 64 | 0, 64 | 0, 64 | 0, 2, () => MultiRegionConfiguration$, 1, 64 | 0, () => XksKeyConfigurationType$, 0], 1
+];
+var ListAliasesRequest$ = [3, n0, _LAR,
+    0,
+    [_KI, _L, _M],
+    [0, 1, 0]
+];
+var ListAliasesResponse$ = [3, n0, _LARi,
+    0,
+    [_Al, _NM, _Tr],
+    [() => AliasList, 0, 2]
+];
+var ListGrantsRequest$ = [3, n0, _LGR,
+    0,
+    [_KI, _L, _M, _GI, _GP, _GSP],
+    [0, 1, 0, 0, 0, 0], 1
+];
+var ListGrantsResponse$ = [3, n0, _LGRi,
+    0,
+    [_G, _NM, _Tr],
+    [() => GrantList, 0, 2]
+];
+var ListKeyPoliciesRequest$ = [3, n0, _LKPR,
+    0,
+    [_KI, _L, _M],
+    [0, 1, 0], 1
+];
+var ListKeyPoliciesResponse$ = [3, n0, _LKPRi,
+    0,
+    [_PNo, _NM, _Tr],
+    [64 | 0, 0, 2]
+];
+var ListKeyRotationsRequest$ = [3, n0, _LKRR,
+    0,
+    [_KI, _IKM, _L, _M],
+    [0, 0, 1, 0], 1
+];
+var ListKeyRotationsResponse$ = [3, n0, _LKRRi,
+    0,
+    [_Ro, _NM, _Tr],
+    [() => RotationsList, 0, 2]
+];
+var ListKeysRequest$ = [3, n0, _LKR,
+    0,
+    [_L, _M],
+    [1, 0]
+];
+var ListKeysResponse$ = [3, n0, _LKRi,
+    0,
+    [_K, _NM, _Tr],
+    [() => KeyList, 0, 2]
+];
+var ListResourceTagsRequest$ = [3, n0, _LRTR,
+    0,
+    [_KI, _L, _M],
+    [0, 1, 0], 1
+];
+var ListResourceTagsResponse$ = [3, n0, _LRTRi,
+    0,
+    [_T, _NM, _Tr],
+    [() => TagList, 0, 2]
+];
+var ListRetirableGrantsRequest$ = [3, n0, _LRGR,
+    0,
+    [_L, _M, _RP, _RSP],
+    [1, 0, 0, 0]
+];
+var MultiRegionConfiguration$ = [3, n0, _MRC,
+    0,
+    [_MRKT, _PKr, _RK],
+    [0, () => MultiRegionKey$, () => MultiRegionKeyList]
+];
+var MultiRegionKey$ = [3, n0, _MRK,
+    0,
+    [_A, _Re],
+    [0, 0]
+];
+var PutKeyPolicyRequest$ = [3, n0, _PKPR,
+    0,
+    [_KI, _P, _PN, _BPLSC],
+    [0, 0, 0, 2], 2
+];
+var RecipientInfo$ = [3, n0, _RI,
+    0,
+    [_KEA, _AD],
+    [0, 21]
+];
+var ReEncryptRequest$ = [3, n0, _RER,
+    0,
+    [_DKI, _CB, _SEC, _SKI, _DEC, _SEA, _DEA, _GT, _DR, _DRM],
+    [0, 21, 128 | 0, 0, 128 | 0, 0, 0, 64 | 0, 2, 64 | 0], 1
+];
+var ReEncryptResponse$ = [3, n0, _RERe,
+    0,
+    [_CB, _SKI, _KI, _SEA, _DEA, _SKMI, _DKMI],
+    [21, 0, 0, 0, 0, 0, 0]
+];
+var ReplicateKeyRequest$ = [3, n0, _RKR,
+    0,
+    [_KI, _RR, _P, _BPLSC, _D, _T],
+    [0, 0, 0, 2, 0, () => TagList], 2
+];
+var ReplicateKeyResponse$ = [3, n0, _RKRe,
+    0,
+    [_RKM, _RPe, _RT],
+    [() => KeyMetadata$, 0, () => TagList]
+];
+var RetireGrantRequest$ = [3, n0, _RGR,
+    0,
+    [_GTr, _KI, _GI, _DR],
+    [0, 0, 0, 2]
+];
+var RevokeGrantRequest$ = [3, n0, _RGRe,
+    0,
+    [_KI, _GI, _DR],
+    [0, 0, 2], 2
+];
+var RotateKeyOnDemandRequest$ = [3, n0, _RKODR,
+    0,
+    [_KI],
+    [0], 1
+];
+var RotateKeyOnDemandResponse$ = [3, n0, _RKODRo,
+    0,
+    [_KI],
+    [0]
+];
+var RotationsListEntry$ = [3, n0, _RLE,
+    0,
+    [_KI, _KMI, _KMD, _IS, _KMS, _EM, _VT, _RD, _RTo],
+    [0, 0, 0, 0, 0, 0, 4, 4, 0]
+];
+var ScheduleKeyDeletionRequest$ = [3, n0, _SKDR,
+    0,
+    [_KI, _PWID],
+    [0, 1], 1
+];
+var ScheduleKeyDeletionResponse$ = [3, n0, _SKDRc,
+    0,
+    [_KI, _DD, _KSe, _PWID],
+    [0, 4, 0, 1]
+];
+var SignRequest$ = [3, n0, _SR,
+    0,
+    [_KI, _Me, _SAi, _MT, _GT, _DR],
+    [0, [() => PlaintextType, 0], 0, 0, 64 | 0, 2], 3
+];
+var SignResponse$ = [3, n0, _SRi,
+    0,
+    [_KI, _S, _SAi],
+    [0, 21, 0]
+];
+var Tag$ = [3, n0, _Ta,
+    0,
+    [_TK, _TV],
+    [0, 0], 2
+];
+var TagResourceRequest$ = [3, n0, _TRR,
+    0,
+    [_KI, _T],
+    [0, () => TagList], 2
+];
+var UntagResourceRequest$ = [3, n0, _URR,
+    0,
+    [_KI, _TKa],
+    [0, 64 | 0], 2
+];
+var UpdateAliasRequest$ = [3, n0, _UAR,
+    0,
+    [_AN, _TKI],
+    [0, 0], 2
+];
+var UpdateCustomKeyStoreRequest$ = [3, n0, _UCKSR,
+    0,
+    [_CKSI, _NCKSN, _KSP, _CHCI, _XPUE, _XPUP, _XPVESN, _XPVESO, _XPAC, _XPC],
+    [0, 0, [() => KeyStorePasswordType, 0], 0, 0, 0, 0, 0, [() => XksProxyAuthenticationCredentialType$, 0], 0], 1
+];
+var UpdateCustomKeyStoreResponse$ = [3, n0, _UCKSRp,
+    0,
+    [],
+    []
+];
+var UpdateKeyDescriptionRequest$ = [3, n0, _UKDR,
+    0,
+    [_KI, _D],
+    [0, 0], 2
+];
+var UpdatePrimaryRegionRequest$ = [3, n0, _UPRR,
+    0,
+    [_KI, _PR],
+    [0, 0], 2
+];
+var VerifyMacRequest$ = [3, n0, _VMR,
+    0,
+    [_Me, _KI, _MA, _Ma, _GT, _DR],
+    [[() => PlaintextType, 0], 0, 0, 21, 64 | 0, 2], 4
+];
+var VerifyMacResponse$ = [3, n0, _VMRe,
+    0,
+    [_KI, _MV, _MA],
+    [0, 2, 0]
+];
+var VerifyRequest$ = [3, n0, _VR,
+    0,
+    [_KI, _Me, _S, _SAi, _MT, _GT, _DR],
+    [0, [() => PlaintextType, 0], 21, 0, 0, 64 | 0, 2], 4
+];
+var VerifyResponse$ = [3, n0, _VRe,
+    0,
+    [_KI, _SV, _SAi],
+    [0, 2, 0]
+];
+var XksKeyConfigurationType$ = [3, n0, _XKCT,
+    0,
+    [_I],
+    [0]
+];
+var XksProxyAuthenticationCredentialType$ = [3, n0, _XPACT,
+    0,
+    [_AKI, _RSAK],
+    [[() => XksProxyAuthenticationAccessKeyIdType, 0], [() => XksProxyAuthenticationRawSecretAccessKeyType, 0]], 2
+];
+var XksProxyConfigurationType$ = [3, n0, _XPCT,
+    0,
+    [_Co, _AKI, _UE, _UP, _VESN, _VESO],
+    [0, [() => XksProxyAuthenticationAccessKeyIdType, 0], 0, 0, 0, 0]
+];
+var __Unit = "unit";
+var AliasList = [1, n0, _AL,
+    0, () => AliasListEntry$
+];
+var CustomKeyStoresList = [1, n0, _CKSL,
+    0, [() => CustomKeyStoresListEntry$,
+        0]
+];
+var GrantList = [1, n0, _GL,
+    0, () => GrantListEntry$
+];
+var KeyList = [1, n0, _KL,
+    0, () => KeyListEntry$
+];
+var MultiRegionKeyList = [1, n0, _MRKL,
+    0, () => MultiRegionKey$
+];
+var RotationsList = [1, n0, _RL,
+    0, () => RotationsListEntry$
+];
+var TagList = [1, n0, _TL,
+    0, () => Tag$
+];
+var CancelKeyDeletion$ = [9, n0, _CKD,
+    0, () => CancelKeyDeletionRequest$, () => CancelKeyDeletionResponse$
+];
+var ConnectCustomKeyStore$ = [9, n0, _CCKS,
+    0, () => ConnectCustomKeyStoreRequest$, () => ConnectCustomKeyStoreResponse$
+];
+var CreateAlias$ = [9, n0, _CA,
+    0, () => CreateAliasRequest$, () => __Unit
+];
+var CreateCustomKeyStore$ = [9, n0, _CCKSr,
+    0, () => CreateCustomKeyStoreRequest$, () => CreateCustomKeyStoreResponse$
+];
+var CreateGrant$ = [9, n0, _CG,
+    0, () => CreateGrantRequest$, () => CreateGrantResponse$
+];
+var CreateKey$ = [9, n0, _CK,
+    0, () => CreateKeyRequest$, () => CreateKeyResponse$
+];
+var Decrypt$ = [9, n0, _De,
+    0, () => DecryptRequest$, () => DecryptResponse$
+];
+var DeleteAlias$ = [9, n0, _DA,
+    0, () => DeleteAliasRequest$, () => __Unit
+];
+var DeleteCustomKeyStore$ = [9, n0, _DCKS,
+    0, () => DeleteCustomKeyStoreRequest$, () => DeleteCustomKeyStoreResponse$
+];
+var DeleteImportedKeyMaterial$ = [9, n0, _DIKM,
+    0, () => DeleteImportedKeyMaterialRequest$, () => DeleteImportedKeyMaterialResponse$
+];
+var DeriveSharedSecret$ = [9, n0, _DSS,
+    0, () => DeriveSharedSecretRequest$, () => DeriveSharedSecretResponse$
+];
+var DescribeCustomKeyStores$ = [9, n0, _DCKSe,
+    0, () => DescribeCustomKeyStoresRequest$, () => DescribeCustomKeyStoresResponse$
+];
+var DescribeKey$ = [9, n0, _DK,
+    0, () => DescribeKeyRequest$, () => DescribeKeyResponse$
+];
+var DisableKey$ = [9, n0, _DKi,
+    0, () => DisableKeyRequest$, () => __Unit
+];
+var DisableKeyRotation$ = [9, n0, _DKRis,
+    0, () => DisableKeyRotationRequest$, () => __Unit
+];
+var DisconnectCustomKeyStore$ = [9, n0, _DCKSi,
+    0, () => DisconnectCustomKeyStoreRequest$, () => DisconnectCustomKeyStoreResponse$
+];
+var EnableKey$ = [9, n0, _EK,
+    0, () => EnableKeyRequest$, () => __Unit
+];
+var EnableKeyRotation$ = [9, n0, _EKRn,
+    0, () => EnableKeyRotationRequest$, () => __Unit
+];
+var Encrypt$ = [9, n0, _En,
+    0, () => EncryptRequest$, () => EncryptResponse$
+];
+var GenerateDataKey$ = [9, n0, _GDK,
+    0, () => GenerateDataKeyRequest$, () => GenerateDataKeyResponse$
+];
+var GenerateDataKeyPair$ = [9, n0, _GDKP,
+    0, () => GenerateDataKeyPairRequest$, () => GenerateDataKeyPairResponse$
+];
+var GenerateDataKeyPairWithoutPlaintext$ = [9, n0, _GDKPWP,
+    0, () => GenerateDataKeyPairWithoutPlaintextRequest$, () => GenerateDataKeyPairWithoutPlaintextResponse$
+];
+var GenerateDataKeyWithoutPlaintext$ = [9, n0, _GDKWP,
+    0, () => GenerateDataKeyWithoutPlaintextRequest$, () => GenerateDataKeyWithoutPlaintextResponse$
+];
+var GenerateMac$ = [9, n0, _GM,
+    0, () => GenerateMacRequest$, () => GenerateMacResponse$
+];
+var GenerateRandom$ = [9, n0, _GR,
+    0, () => GenerateRandomRequest$, () => GenerateRandomResponse$
+];
+var GetKeyLastUsage$ = [9, n0, _GKLU,
+    0, () => GetKeyLastUsageRequest$, () => GetKeyLastUsageResponse$
+];
+var GetKeyPolicy$ = [9, n0, _GKP,
+    0, () => GetKeyPolicyRequest$, () => GetKeyPolicyResponse$
+];
+var GetKeyRotationStatus$ = [9, n0, _GKRS,
+    0, () => GetKeyRotationStatusRequest$, () => GetKeyRotationStatusResponse$
+];
+var GetParametersForImport$ = [9, n0, _GPFI,
+    0, () => GetParametersForImportRequest$, () => GetParametersForImportResponse$
+];
+var GetPublicKey$ = [9, n0, _GPK,
+    0, () => GetPublicKeyRequest$, () => GetPublicKeyResponse$
+];
+var ImportKeyMaterial$ = [9, n0, _IKMm,
+    0, () => ImportKeyMaterialRequest$, () => ImportKeyMaterialResponse$
+];
+var ListAliases$ = [9, n0, _LA,
+    0, () => ListAliasesRequest$, () => ListAliasesResponse$
+];
+var ListGrants$ = [9, n0, _LG,
+    0, () => ListGrantsRequest$, () => ListGrantsResponse$
+];
+var ListKeyPolicies$ = [9, n0, _LKP,
+    0, () => ListKeyPoliciesRequest$, () => ListKeyPoliciesResponse$
+];
+var ListKeyRotations$ = [9, n0, _LKRis,
+    0, () => ListKeyRotationsRequest$, () => ListKeyRotationsResponse$
+];
+var ListKeys$ = [9, n0, _LK,
+    0, () => ListKeysRequest$, () => ListKeysResponse$
+];
+var ListResourceTags$ = [9, n0, _LRT,
+    0, () => ListResourceTagsRequest$, () => ListResourceTagsResponse$
+];
+var ListRetirableGrants$ = [9, n0, _LRG,
+    0, () => ListRetirableGrantsRequest$, () => ListGrantsResponse$
+];
+var PutKeyPolicy$ = [9, n0, _PKPu,
+    0, () => PutKeyPolicyRequest$, () => __Unit
+];
+var ReEncrypt$ = [9, n0, _RE,
+    0, () => ReEncryptRequest$, () => ReEncryptResponse$
+];
+var ReplicateKey$ = [9, n0, _RKe,
+    0, () => ReplicateKeyRequest$, () => ReplicateKeyResponse$
+];
+var RetireGrant$ = [9, n0, _RG,
+    0, () => RetireGrantRequest$, () => __Unit
+];
+var RevokeGrant$ = [9, n0, _RGe,
+    0, () => RevokeGrantRequest$, () => __Unit
+];
+var RotateKeyOnDemand$ = [9, n0, _RKOD,
+    0, () => RotateKeyOnDemandRequest$, () => RotateKeyOnDemandResponse$
+];
+var ScheduleKeyDeletion$ = [9, n0, _SKD,
+    0, () => ScheduleKeyDeletionRequest$, () => ScheduleKeyDeletionResponse$
+];
+var Sign$ = [9, n0, _Si,
+    0, () => SignRequest$, () => SignResponse$
+];
+var TagResource$ = [9, n0, _TR,
+    0, () => TagResourceRequest$, () => __Unit
+];
+var UntagResource$ = [9, n0, _UR,
+    0, () => UntagResourceRequest$, () => __Unit
+];
+var UpdateAlias$ = [9, n0, _UA,
+    0, () => UpdateAliasRequest$, () => __Unit
+];
+var UpdateCustomKeyStore$ = [9, n0, _UCKS,
+    0, () => UpdateCustomKeyStoreRequest$, () => UpdateCustomKeyStoreResponse$
+];
+var UpdateKeyDescription$ = [9, n0, _UKD,
+    0, () => UpdateKeyDescriptionRequest$, () => __Unit
+];
+var UpdatePrimaryRegion$ = [9, n0, _UPR,
+    0, () => UpdatePrimaryRegionRequest$, () => __Unit
+];
+var Verify$ = [9, n0, _V,
+    0, () => VerifyRequest$, () => VerifyResponse$
+];
+var VerifyMac$ = [9, n0, _VM,
+    0, () => VerifyMacRequest$, () => VerifyMacResponse$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2014-11-01",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultKMSHttpAuthSchemeProvider,
+        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 ?? AwsJson1_1Protocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.kms",
+            errorTypeRegistries,
+            xmlNamespace: "https://trent.amazonaws.com/doc/2014-11-01/",
+            version: "2014-11-01",
+            serviceTarget: "TrentService",
+        },
+        serviceId: config?.serviceId ?? "KMS",
+        sha256: config?.sha256 ?? Sha256,
+        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),
+        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;
@@ -73,697 +2229,227 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class KMSClient extends smithyClient.Client {
+class KMSClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
-        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
-        const _config_4 = configResolver.resolveRegionConfig(_config_3);
-        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
-        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
-        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
-        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultKMSHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultKMSHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class CancelKeyDeletionCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "CancelKeyDeletion", {})
-    .n("KMSClient", "CancelKeyDeletionCommand")
-    .sc(schemas_0.CancelKeyDeletion$)
-    .build() {
-}
-
-class ConnectCustomKeyStoreCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ConnectCustomKeyStore", {})
-    .n("KMSClient", "ConnectCustomKeyStoreCommand")
-    .sc(schemas_0.ConnectCustomKeyStore$)
-    .build() {
-}
-
-class CreateAliasCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "CreateAlias", {})
-    .n("KMSClient", "CreateAliasCommand")
-    .sc(schemas_0.CreateAlias$)
-    .build() {
-}
-
-class CreateCustomKeyStoreCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "CreateCustomKeyStore", {})
-    .n("KMSClient", "CreateCustomKeyStoreCommand")
-    .sc(schemas_0.CreateCustomKeyStore$)
-    .build() {
-}
-
-class CreateGrantCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "CreateGrant", {})
-    .n("KMSClient", "CreateGrantCommand")
-    .sc(schemas_0.CreateGrant$)
-    .build() {
-}
-
-class CreateKeyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "CreateKey", {})
-    .n("KMSClient", "CreateKeyCommand")
-    .sc(schemas_0.CreateKey$)
-    .build() {
-}
-
-class DecryptCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "Decrypt", {})
-    .n("KMSClient", "DecryptCommand")
-    .sc(schemas_0.Decrypt$)
-    .build() {
-}
-
-class DeleteAliasCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DeleteAlias", {})
-    .n("KMSClient", "DeleteAliasCommand")
-    .sc(schemas_0.DeleteAlias$)
-    .build() {
-}
-
-class DeleteCustomKeyStoreCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DeleteCustomKeyStore", {})
-    .n("KMSClient", "DeleteCustomKeyStoreCommand")
-    .sc(schemas_0.DeleteCustomKeyStore$)
-    .build() {
-}
-
-class DeleteImportedKeyMaterialCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DeleteImportedKeyMaterial", {})
-    .n("KMSClient", "DeleteImportedKeyMaterialCommand")
-    .sc(schemas_0.DeleteImportedKeyMaterial$)
-    .build() {
-}
-
-class DeriveSharedSecretCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DeriveSharedSecret", {})
-    .n("KMSClient", "DeriveSharedSecretCommand")
-    .sc(schemas_0.DeriveSharedSecret$)
-    .build() {
-}
-
-class DescribeCustomKeyStoresCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DescribeCustomKeyStores", {})
-    .n("KMSClient", "DescribeCustomKeyStoresCommand")
-    .sc(schemas_0.DescribeCustomKeyStores$)
-    .build() {
-}
-
-class DescribeKeyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DescribeKey", {})
-    .n("KMSClient", "DescribeKeyCommand")
-    .sc(schemas_0.DescribeKey$)
-    .build() {
-}
-
-class DisableKeyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DisableKey", {})
-    .n("KMSClient", "DisableKeyCommand")
-    .sc(schemas_0.DisableKey$)
-    .build() {
-}
-
-class DisableKeyRotationCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DisableKeyRotation", {})
-    .n("KMSClient", "DisableKeyRotationCommand")
-    .sc(schemas_0.DisableKeyRotation$)
-    .build() {
-}
-
-class DisconnectCustomKeyStoreCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "DisconnectCustomKeyStore", {})
-    .n("KMSClient", "DisconnectCustomKeyStoreCommand")
-    .sc(schemas_0.DisconnectCustomKeyStore$)
-    .build() {
-}
-
-class EnableKeyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "EnableKey", {})
-    .n("KMSClient", "EnableKeyCommand")
-    .sc(schemas_0.EnableKey$)
-    .build() {
-}
-
-class EnableKeyRotationCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "EnableKeyRotation", {})
-    .n("KMSClient", "EnableKeyRotationCommand")
-    .sc(schemas_0.EnableKeyRotation$)
-    .build() {
-}
-
-class EncryptCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "Encrypt", {})
-    .n("KMSClient", "EncryptCommand")
-    .sc(schemas_0.Encrypt$)
-    .build() {
-}
-
-class GenerateDataKeyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GenerateDataKey", {})
-    .n("KMSClient", "GenerateDataKeyCommand")
-    .sc(schemas_0.GenerateDataKey$)
-    .build() {
-}
-
-class GenerateDataKeyPairCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GenerateDataKeyPair", {})
-    .n("KMSClient", "GenerateDataKeyPairCommand")
-    .sc(schemas_0.GenerateDataKeyPair$)
-    .build() {
-}
-
-class GenerateDataKeyPairWithoutPlaintextCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GenerateDataKeyPairWithoutPlaintext", {})
-    .n("KMSClient", "GenerateDataKeyPairWithoutPlaintextCommand")
-    .sc(schemas_0.GenerateDataKeyPairWithoutPlaintext$)
-    .build() {
-}
-
-class GenerateDataKeyWithoutPlaintextCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GenerateDataKeyWithoutPlaintext", {})
-    .n("KMSClient", "GenerateDataKeyWithoutPlaintextCommand")
-    .sc(schemas_0.GenerateDataKeyWithoutPlaintext$)
-    .build() {
-}
-
-class GenerateMacCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GenerateMac", {})
-    .n("KMSClient", "GenerateMacCommand")
-    .sc(schemas_0.GenerateMac$)
-    .build() {
-}
-
-class GenerateRandomCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GenerateRandom", {})
-    .n("KMSClient", "GenerateRandomCommand")
-    .sc(schemas_0.GenerateRandom$)
-    .build() {
-}
-
-class GetKeyPolicyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GetKeyPolicy", {})
-    .n("KMSClient", "GetKeyPolicyCommand")
-    .sc(schemas_0.GetKeyPolicy$)
-    .build() {
-}
-
-class GetKeyRotationStatusCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GetKeyRotationStatus", {})
-    .n("KMSClient", "GetKeyRotationStatusCommand")
-    .sc(schemas_0.GetKeyRotationStatus$)
-    .build() {
-}
-
-class GetParametersForImportCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GetParametersForImport", {})
-    .n("KMSClient", "GetParametersForImportCommand")
-    .sc(schemas_0.GetParametersForImport$)
-    .build() {
-}
-
-class GetPublicKeyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "GetPublicKey", {})
-    .n("KMSClient", "GetPublicKeyCommand")
-    .sc(schemas_0.GetPublicKey$)
-    .build() {
-}
-
-class ImportKeyMaterialCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ImportKeyMaterial", {})
-    .n("KMSClient", "ImportKeyMaterialCommand")
-    .sc(schemas_0.ImportKeyMaterial$)
-    .build() {
-}
-
-class ListAliasesCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ListAliases", {})
-    .n("KMSClient", "ListAliasesCommand")
-    .sc(schemas_0.ListAliases$)
-    .build() {
-}
-
-class ListGrantsCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ListGrants", {})
-    .n("KMSClient", "ListGrantsCommand")
-    .sc(schemas_0.ListGrants$)
-    .build() {
-}
-
-class ListKeyPoliciesCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ListKeyPolicies", {})
-    .n("KMSClient", "ListKeyPoliciesCommand")
-    .sc(schemas_0.ListKeyPolicies$)
-    .build() {
-}
-
-class ListKeyRotationsCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ListKeyRotations", {})
-    .n("KMSClient", "ListKeyRotationsCommand")
-    .sc(schemas_0.ListKeyRotations$)
-    .build() {
-}
-
-class ListKeysCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ListKeys", {})
-    .n("KMSClient", "ListKeysCommand")
-    .sc(schemas_0.ListKeys$)
-    .build() {
-}
-
-class ListResourceTagsCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ListResourceTags", {})
-    .n("KMSClient", "ListResourceTagsCommand")
-    .sc(schemas_0.ListResourceTags$)
-    .build() {
-}
-
-class ListRetirableGrantsCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ListRetirableGrants", {})
-    .n("KMSClient", "ListRetirableGrantsCommand")
-    .sc(schemas_0.ListRetirableGrants$)
-    .build() {
-}
-
-class PutKeyPolicyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "PutKeyPolicy", {})
-    .n("KMSClient", "PutKeyPolicyCommand")
-    .sc(schemas_0.PutKeyPolicy$)
-    .build() {
-}
-
-class ReEncryptCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ReEncrypt", {})
-    .n("KMSClient", "ReEncryptCommand")
-    .sc(schemas_0.ReEncrypt$)
-    .build() {
-}
-
-class ReplicateKeyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ReplicateKey", {})
-    .n("KMSClient", "ReplicateKeyCommand")
-    .sc(schemas_0.ReplicateKey$)
-    .build() {
-}
-
-class RetireGrantCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "RetireGrant", {})
-    .n("KMSClient", "RetireGrantCommand")
-    .sc(schemas_0.RetireGrant$)
-    .build() {
-}
-
-class RevokeGrantCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "RevokeGrant", {})
-    .n("KMSClient", "RevokeGrantCommand")
-    .sc(schemas_0.RevokeGrant$)
-    .build() {
-}
-
-class RotateKeyOnDemandCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "RotateKeyOnDemand", {})
-    .n("KMSClient", "RotateKeyOnDemandCommand")
-    .sc(schemas_0.RotateKeyOnDemand$)
-    .build() {
-}
-
-class ScheduleKeyDeletionCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "ScheduleKeyDeletion", {})
-    .n("KMSClient", "ScheduleKeyDeletionCommand")
-    .sc(schemas_0.ScheduleKeyDeletion$)
-    .build() {
-}
-
-class SignCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "Sign", {})
-    .n("KMSClient", "SignCommand")
-    .sc(schemas_0.Sign$)
-    .build() {
-}
-
-class TagResourceCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "TagResource", {})
-    .n("KMSClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
-    .build() {
-}
-
-class UntagResourceCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "UntagResource", {})
-    .n("KMSClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
-    .build() {
-}
-
-class UpdateAliasCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "UpdateAlias", {})
-    .n("KMSClient", "UpdateAliasCommand")
-    .sc(schemas_0.UpdateAlias$)
-    .build() {
-}
-
-class UpdateCustomKeyStoreCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "UpdateCustomKeyStore", {})
-    .n("KMSClient", "UpdateCustomKeyStoreCommand")
-    .sc(schemas_0.UpdateCustomKeyStore$)
-    .build() {
-}
-
-class UpdateKeyDescriptionCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "UpdateKeyDescription", {})
-    .n("KMSClient", "UpdateKeyDescriptionCommand")
-    .sc(schemas_0.UpdateKeyDescription$)
-    .build() {
-}
-
-class UpdatePrimaryRegionCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "UpdatePrimaryRegion", {})
-    .n("KMSClient", "UpdatePrimaryRegionCommand")
-    .sc(schemas_0.UpdatePrimaryRegion$)
-    .build() {
-}
-
-class VerifyCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "Verify", {})
-    .n("KMSClient", "VerifyCommand")
-    .sc(schemas_0.Verify$)
-    .build() {
-}
-
-class VerifyMacCommand extends smithyClient.Command
-    .classBuilder()
-    .ep(commonParams)
-    .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
-})
-    .s("TrentService", "VerifyMac", {})
-    .n("KMSClient", "VerifyMacCommand")
-    .sc(schemas_0.VerifyMac$)
-    .build() {
-}
-
-const paginateDescribeCustomKeyStores = core.createPaginator(KMSClient, DescribeCustomKeyStoresCommand, "Marker", "NextMarker", "Limit");
-
-const paginateListAliases = core.createPaginator(KMSClient, ListAliasesCommand, "Marker", "NextMarker", "Limit");
-
-const paginateListGrants = core.createPaginator(KMSClient, ListGrantsCommand, "Marker", "NextMarker", "Limit");
-
-const paginateListKeyPolicies = core.createPaginator(KMSClient, ListKeyPoliciesCommand, "Marker", "NextMarker", "Limit");
-
-const paginateListKeyRotations = core.createPaginator(KMSClient, ListKeyRotationsCommand, "Marker", "NextMarker", "Limit");
-
-const paginateListKeys = core.createPaginator(KMSClient, ListKeysCommand, "Marker", "NextMarker", "Limit");
-
-const paginateListResourceTags = core.createPaginator(KMSClient, ListResourceTagsCommand, "Marker", "NextMarker", "Limit");
-
-const paginateListRetirableGrants = core.createPaginator(KMSClient, ListRetirableGrantsCommand, "Marker", "NextMarker", "Limit");
+const command = makeBuilder(commonParams, "TrentService", "KMSClient", getEndpointPlugin);
+const _ep0 = {};
+const _mw0 = (Command, cs, config, o) => [];
+
+class CancelKeyDeletionCommand extends command(_ep0, _mw0, "CancelKeyDeletion", CancelKeyDeletion$) {
+}
+
+class ConnectCustomKeyStoreCommand extends command(_ep0, _mw0, "ConnectCustomKeyStore", ConnectCustomKeyStore$) {
+}
+
+class CreateAliasCommand extends command(_ep0, _mw0, "CreateAlias", CreateAlias$) {
+}
+
+class CreateCustomKeyStoreCommand extends command(_ep0, _mw0, "CreateCustomKeyStore", CreateCustomKeyStore$) {
+}
+
+class CreateGrantCommand extends command(_ep0, _mw0, "CreateGrant", CreateGrant$) {
+}
+
+class CreateKeyCommand extends command(_ep0, _mw0, "CreateKey", CreateKey$) {
+}
+
+class DecryptCommand extends command(_ep0, _mw0, "Decrypt", Decrypt$) {
+}
+
+class DeleteAliasCommand extends command(_ep0, _mw0, "DeleteAlias", DeleteAlias$) {
+}
+
+class DeleteCustomKeyStoreCommand extends command(_ep0, _mw0, "DeleteCustomKeyStore", DeleteCustomKeyStore$) {
+}
+
+class DeleteImportedKeyMaterialCommand extends command(_ep0, _mw0, "DeleteImportedKeyMaterial", DeleteImportedKeyMaterial$) {
+}
+
+class DeriveSharedSecretCommand extends command(_ep0, _mw0, "DeriveSharedSecret", DeriveSharedSecret$) {
+}
+
+class DescribeCustomKeyStoresCommand extends command(_ep0, _mw0, "DescribeCustomKeyStores", DescribeCustomKeyStores$) {
+}
+
+class DescribeKeyCommand extends command(_ep0, _mw0, "DescribeKey", DescribeKey$) {
+}
+
+class DisableKeyCommand extends command(_ep0, _mw0, "DisableKey", DisableKey$) {
+}
+
+class DisableKeyRotationCommand extends command(_ep0, _mw0, "DisableKeyRotation", DisableKeyRotation$) {
+}
+
+class DisconnectCustomKeyStoreCommand extends command(_ep0, _mw0, "DisconnectCustomKeyStore", DisconnectCustomKeyStore$) {
+}
+
+class EnableKeyCommand extends command(_ep0, _mw0, "EnableKey", EnableKey$) {
+}
+
+class EnableKeyRotationCommand extends command(_ep0, _mw0, "EnableKeyRotation", EnableKeyRotation$) {
+}
+
+class EncryptCommand extends command(_ep0, _mw0, "Encrypt", Encrypt$) {
+}
+
+class GenerateDataKeyCommand extends command(_ep0, _mw0, "GenerateDataKey", GenerateDataKey$) {
+}
+
+class GenerateDataKeyPairCommand extends command(_ep0, _mw0, "GenerateDataKeyPair", GenerateDataKeyPair$) {
+}
+
+class GenerateDataKeyPairWithoutPlaintextCommand extends command(_ep0, _mw0, "GenerateDataKeyPairWithoutPlaintext", GenerateDataKeyPairWithoutPlaintext$) {
+}
+
+class GenerateDataKeyWithoutPlaintextCommand extends command(_ep0, _mw0, "GenerateDataKeyWithoutPlaintext", GenerateDataKeyWithoutPlaintext$) {
+}
+
+class GenerateMacCommand extends command(_ep0, _mw0, "GenerateMac", GenerateMac$) {
+}
+
+class GenerateRandomCommand extends command(_ep0, _mw0, "GenerateRandom", GenerateRandom$) {
+}
+
+class GetKeyLastUsageCommand extends command(_ep0, _mw0, "GetKeyLastUsage", GetKeyLastUsage$) {
+}
+
+class GetKeyPolicyCommand extends command(_ep0, _mw0, "GetKeyPolicy", GetKeyPolicy$) {
+}
+
+class GetKeyRotationStatusCommand extends command(_ep0, _mw0, "GetKeyRotationStatus", GetKeyRotationStatus$) {
+}
+
+class GetParametersForImportCommand extends command(_ep0, _mw0, "GetParametersForImport", GetParametersForImport$) {
+}
+
+class GetPublicKeyCommand extends command(_ep0, _mw0, "GetPublicKey", GetPublicKey$) {
+}
+
+class ImportKeyMaterialCommand extends command(_ep0, _mw0, "ImportKeyMaterial", ImportKeyMaterial$) {
+}
+
+class ListAliasesCommand extends command(_ep0, _mw0, "ListAliases", ListAliases$) {
+}
+
+class ListGrantsCommand extends command(_ep0, _mw0, "ListGrants", ListGrants$) {
+}
+
+class ListKeyPoliciesCommand extends command(_ep0, _mw0, "ListKeyPolicies", ListKeyPolicies$) {
+}
+
+class ListKeyRotationsCommand extends command(_ep0, _mw0, "ListKeyRotations", ListKeyRotations$) {
+}
+
+class ListKeysCommand extends command(_ep0, _mw0, "ListKeys", ListKeys$) {
+}
+
+class ListResourceTagsCommand extends command(_ep0, _mw0, "ListResourceTags", ListResourceTags$) {
+}
+
+class ListRetirableGrantsCommand extends command(_ep0, _mw0, "ListRetirableGrants", ListRetirableGrants$) {
+}
+
+class PutKeyPolicyCommand extends command(_ep0, _mw0, "PutKeyPolicy", PutKeyPolicy$) {
+}
+
+class ReEncryptCommand extends command(_ep0, _mw0, "ReEncrypt", ReEncrypt$) {
+}
+
+class ReplicateKeyCommand extends command(_ep0, _mw0, "ReplicateKey", ReplicateKey$) {
+}
+
+class RetireGrantCommand extends command(_ep0, _mw0, "RetireGrant", RetireGrant$) {
+}
+
+class RevokeGrantCommand extends command(_ep0, _mw0, "RevokeGrant", RevokeGrant$) {
+}
+
+class RotateKeyOnDemandCommand extends command(_ep0, _mw0, "RotateKeyOnDemand", RotateKeyOnDemand$) {
+}
+
+class ScheduleKeyDeletionCommand extends command(_ep0, _mw0, "ScheduleKeyDeletion", ScheduleKeyDeletion$) {
+}
+
+class SignCommand extends command(_ep0, _mw0, "Sign", Sign$) {
+}
+
+class TagResourceCommand extends command(_ep0, _mw0, "TagResource", TagResource$) {
+}
+
+class UntagResourceCommand extends command(_ep0, _mw0, "UntagResource", UntagResource$) {
+}
+
+class UpdateAliasCommand extends command(_ep0, _mw0, "UpdateAlias", UpdateAlias$) {
+}
+
+class UpdateCustomKeyStoreCommand extends command(_ep0, _mw0, "UpdateCustomKeyStore", UpdateCustomKeyStore$) {
+}
+
+class UpdateKeyDescriptionCommand extends command(_ep0, _mw0, "UpdateKeyDescription", UpdateKeyDescription$) {
+}
+
+class UpdatePrimaryRegionCommand extends command(_ep0, _mw0, "UpdatePrimaryRegion", UpdatePrimaryRegion$) {
+}
+
+class VerifyCommand extends command(_ep0, _mw0, "Verify", Verify$) {
+}
+
+class VerifyMacCommand extends command(_ep0, _mw0, "VerifyMac", VerifyMac$) {
+}
+
+const paginateDescribeCustomKeyStores = createPaginator(KMSClient, DescribeCustomKeyStoresCommand, "Marker", "NextMarker", "Limit");
+
+const paginateListAliases = createPaginator(KMSClient, ListAliasesCommand, "Marker", "NextMarker", "Limit");
+
+const paginateListGrants = createPaginator(KMSClient, ListGrantsCommand, "Marker", "NextMarker", "Limit");
+
+const paginateListKeyPolicies = createPaginator(KMSClient, ListKeyPoliciesCommand, "Marker", "NextMarker", "Limit");
+
+const paginateListKeyRotations = createPaginator(KMSClient, ListKeyRotationsCommand, "Marker", "NextMarker", "Limit");
+
+const paginateListKeys = createPaginator(KMSClient, ListKeysCommand, "Marker", "NextMarker", "Limit");
+
+const paginateListResourceTags = createPaginator(KMSClient, ListResourceTagsCommand, "Marker", "NextMarker", "Limit");
+
+const paginateListRetirableGrants = createPaginator(KMSClient, ListRetirableGrantsCommand, "Marker", "NextMarker", "Limit");
 
 const commands = {
     CancelKeyDeletionCommand,
@@ -791,6 +2477,7 @@ const commands = {
     GenerateDataKeyWithoutPlaintextCommand,
     GenerateMacCommand,
     GenerateRandomCommand,
+    GetKeyLastUsageCommand,
     GetKeyPolicyCommand,
     GetKeyRotationStatusCommand,
     GetParametersForImportCommand,
@@ -832,7 +2519,7 @@ const paginators = {
 };
 class KMS extends KMSClient {
 }
-smithyClient.createAggregatedClient(commands, KMS, { paginators });
+createAggregatedClient(commands, KMS, { paginators });
 
 const AlgorithmSpec = {
     RSAES_OAEP_SHA_1: "RSAES_OAEP_SHA_1",
@@ -1015,6 +2702,20 @@ const DryRunModifierType = {
 const KeyEncryptionMechanism = {
     RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256",
 };
+const KeyLastUsageTrackingOperation = {
+    Decrypt: "Decrypt",
+    DeriveSharedSecret: "DeriveSharedSecret",
+    Encrypt: "Encrypt",
+    GenerateDataKey: "GenerateDataKey",
+    GenerateDataKeyPair: "GenerateDataKeyPair",
+    GenerateDataKeyPairWithoutPlaintext: "GenerateDataKeyPairWithoutPlaintext",
+    GenerateDataKeyWithoutPlaintext: "GenerateDataKeyWithoutPlaintext",
+    GenerateMac: "GenerateMac",
+    ReEncrypt: "ReEncrypt",
+    Sign: "Sign",
+    Verify: "Verify",
+    VerifyMac: "VerifyMac",
+};
 const WrappingKeySpec = {
     RSA_2048: "RSA_2048",
     RSA_3072: "RSA_3072",
@@ -1049,93 +2750,353 @@ const MessageType = {
     RAW: "RAW",
 };
 
-exports.$Command = smithyClient.Command;
-exports.__Client = smithyClient.Client;
-exports.KMSServiceException = KMSServiceException.KMSServiceException;
 exports.AlgorithmSpec = AlgorithmSpec;
+exports.AliasListEntry$ = AliasListEntry$;
+exports.AlreadyExistsException = AlreadyExistsException;
+exports.AlreadyExistsException$ = AlreadyExistsException$;
+exports.CancelKeyDeletion$ = CancelKeyDeletion$;
 exports.CancelKeyDeletionCommand = CancelKeyDeletionCommand;
+exports.CancelKeyDeletionRequest$ = CancelKeyDeletionRequest$;
+exports.CancelKeyDeletionResponse$ = CancelKeyDeletionResponse$;
+exports.CloudHsmClusterInUseException = CloudHsmClusterInUseException;
+exports.CloudHsmClusterInUseException$ = CloudHsmClusterInUseException$;
+exports.CloudHsmClusterInvalidConfigurationException = CloudHsmClusterInvalidConfigurationException;
+exports.CloudHsmClusterInvalidConfigurationException$ = CloudHsmClusterInvalidConfigurationException$;
+exports.CloudHsmClusterNotActiveException = CloudHsmClusterNotActiveException;
+exports.CloudHsmClusterNotActiveException$ = CloudHsmClusterNotActiveException$;
+exports.CloudHsmClusterNotFoundException = CloudHsmClusterNotFoundException;
+exports.CloudHsmClusterNotFoundException$ = CloudHsmClusterNotFoundException$;
+exports.CloudHsmClusterNotRelatedException = CloudHsmClusterNotRelatedException;
+exports.CloudHsmClusterNotRelatedException$ = CloudHsmClusterNotRelatedException$;
+exports.ConflictException = ConflictException;
+exports.ConflictException$ = ConflictException$;
+exports.ConnectCustomKeyStore$ = ConnectCustomKeyStore$;
 exports.ConnectCustomKeyStoreCommand = ConnectCustomKeyStoreCommand;
+exports.ConnectCustomKeyStoreRequest$ = ConnectCustomKeyStoreRequest$;
+exports.ConnectCustomKeyStoreResponse$ = ConnectCustomKeyStoreResponse$;
 exports.ConnectionErrorCodeType = ConnectionErrorCodeType;
 exports.ConnectionStateType = ConnectionStateType;
+exports.CreateAlias$ = CreateAlias$;
 exports.CreateAliasCommand = CreateAliasCommand;
+exports.CreateAliasRequest$ = CreateAliasRequest$;
+exports.CreateCustomKeyStore$ = CreateCustomKeyStore$;
 exports.CreateCustomKeyStoreCommand = CreateCustomKeyStoreCommand;
+exports.CreateCustomKeyStoreRequest$ = CreateCustomKeyStoreRequest$;
+exports.CreateCustomKeyStoreResponse$ = CreateCustomKeyStoreResponse$;
+exports.CreateGrant$ = CreateGrant$;
 exports.CreateGrantCommand = CreateGrantCommand;
+exports.CreateGrantRequest$ = CreateGrantRequest$;
+exports.CreateGrantResponse$ = CreateGrantResponse$;
+exports.CreateKey$ = CreateKey$;
 exports.CreateKeyCommand = CreateKeyCommand;
+exports.CreateKeyRequest$ = CreateKeyRequest$;
+exports.CreateKeyResponse$ = CreateKeyResponse$;
+exports.CustomKeyStoreHasCMKsException = CustomKeyStoreHasCMKsException;
+exports.CustomKeyStoreHasCMKsException$ = CustomKeyStoreHasCMKsException$;
+exports.CustomKeyStoreInvalidStateException = CustomKeyStoreInvalidStateException;
+exports.CustomKeyStoreInvalidStateException$ = CustomKeyStoreInvalidStateException$;
+exports.CustomKeyStoreNameInUseException = CustomKeyStoreNameInUseException;
+exports.CustomKeyStoreNameInUseException$ = CustomKeyStoreNameInUseException$;
+exports.CustomKeyStoreNotFoundException = CustomKeyStoreNotFoundException;
+exports.CustomKeyStoreNotFoundException$ = CustomKeyStoreNotFoundException$;
 exports.CustomKeyStoreType = CustomKeyStoreType;
+exports.CustomKeyStoresListEntry$ = CustomKeyStoresListEntry$;
 exports.CustomerMasterKeySpec = CustomerMasterKeySpec;
 exports.DataKeyPairSpec = DataKeyPairSpec;
 exports.DataKeySpec = DataKeySpec;
+exports.Decrypt$ = Decrypt$;
 exports.DecryptCommand = DecryptCommand;
+exports.DecryptRequest$ = DecryptRequest$;
+exports.DecryptResponse$ = DecryptResponse$;
+exports.DeleteAlias$ = DeleteAlias$;
 exports.DeleteAliasCommand = DeleteAliasCommand;
+exports.DeleteAliasRequest$ = DeleteAliasRequest$;
+exports.DeleteCustomKeyStore$ = DeleteCustomKeyStore$;
 exports.DeleteCustomKeyStoreCommand = DeleteCustomKeyStoreCommand;
+exports.DeleteCustomKeyStoreRequest$ = DeleteCustomKeyStoreRequest$;
+exports.DeleteCustomKeyStoreResponse$ = DeleteCustomKeyStoreResponse$;
+exports.DeleteImportedKeyMaterial$ = DeleteImportedKeyMaterial$;
 exports.DeleteImportedKeyMaterialCommand = DeleteImportedKeyMaterialCommand;
+exports.DeleteImportedKeyMaterialRequest$ = DeleteImportedKeyMaterialRequest$;
+exports.DeleteImportedKeyMaterialResponse$ = DeleteImportedKeyMaterialResponse$;
+exports.DependencyTimeoutException = DependencyTimeoutException;
+exports.DependencyTimeoutException$ = DependencyTimeoutException$;
+exports.DeriveSharedSecret$ = DeriveSharedSecret$;
 exports.DeriveSharedSecretCommand = DeriveSharedSecretCommand;
+exports.DeriveSharedSecretRequest$ = DeriveSharedSecretRequest$;
+exports.DeriveSharedSecretResponse$ = DeriveSharedSecretResponse$;
+exports.DescribeCustomKeyStores$ = DescribeCustomKeyStores$;
 exports.DescribeCustomKeyStoresCommand = DescribeCustomKeyStoresCommand;
+exports.DescribeCustomKeyStoresRequest$ = DescribeCustomKeyStoresRequest$;
+exports.DescribeCustomKeyStoresResponse$ = DescribeCustomKeyStoresResponse$;
+exports.DescribeKey$ = DescribeKey$;
 exports.DescribeKeyCommand = DescribeKeyCommand;
+exports.DescribeKeyRequest$ = DescribeKeyRequest$;
+exports.DescribeKeyResponse$ = DescribeKeyResponse$;
+exports.DisableKey$ = DisableKey$;
 exports.DisableKeyCommand = DisableKeyCommand;
+exports.DisableKeyRequest$ = DisableKeyRequest$;
+exports.DisableKeyRotation$ = DisableKeyRotation$;
 exports.DisableKeyRotationCommand = DisableKeyRotationCommand;
+exports.DisableKeyRotationRequest$ = DisableKeyRotationRequest$;
+exports.DisabledException = DisabledException;
+exports.DisabledException$ = DisabledException$;
+exports.DisconnectCustomKeyStore$ = DisconnectCustomKeyStore$;
 exports.DisconnectCustomKeyStoreCommand = DisconnectCustomKeyStoreCommand;
+exports.DisconnectCustomKeyStoreRequest$ = DisconnectCustomKeyStoreRequest$;
+exports.DisconnectCustomKeyStoreResponse$ = DisconnectCustomKeyStoreResponse$;
 exports.DryRunModifierType = DryRunModifierType;
+exports.DryRunOperationException = DryRunOperationException;
+exports.DryRunOperationException$ = DryRunOperationException$;
+exports.EnableKey$ = EnableKey$;
 exports.EnableKeyCommand = EnableKeyCommand;
+exports.EnableKeyRequest$ = EnableKeyRequest$;
+exports.EnableKeyRotation$ = EnableKeyRotation$;
 exports.EnableKeyRotationCommand = EnableKeyRotationCommand;
+exports.EnableKeyRotationRequest$ = EnableKeyRotationRequest$;
+exports.Encrypt$ = Encrypt$;
 exports.EncryptCommand = EncryptCommand;
+exports.EncryptRequest$ = EncryptRequest$;
+exports.EncryptResponse$ = EncryptResponse$;
 exports.EncryptionAlgorithmSpec = EncryptionAlgorithmSpec;
 exports.ExpirationModelType = ExpirationModelType;
+exports.ExpiredImportTokenException = ExpiredImportTokenException;
+exports.ExpiredImportTokenException$ = ExpiredImportTokenException$;
+exports.GenerateDataKey$ = GenerateDataKey$;
 exports.GenerateDataKeyCommand = GenerateDataKeyCommand;
+exports.GenerateDataKeyPair$ = GenerateDataKeyPair$;
 exports.GenerateDataKeyPairCommand = GenerateDataKeyPairCommand;
+exports.GenerateDataKeyPairRequest$ = GenerateDataKeyPairRequest$;
+exports.GenerateDataKeyPairResponse$ = GenerateDataKeyPairResponse$;
+exports.GenerateDataKeyPairWithoutPlaintext$ = GenerateDataKeyPairWithoutPlaintext$;
 exports.GenerateDataKeyPairWithoutPlaintextCommand = GenerateDataKeyPairWithoutPlaintextCommand;
+exports.GenerateDataKeyPairWithoutPlaintextRequest$ = GenerateDataKeyPairWithoutPlaintextRequest$;
+exports.GenerateDataKeyPairWithoutPlaintextResponse$ = GenerateDataKeyPairWithoutPlaintextResponse$;
+exports.GenerateDataKeyRequest$ = GenerateDataKeyRequest$;
+exports.GenerateDataKeyResponse$ = GenerateDataKeyResponse$;
+exports.GenerateDataKeyWithoutPlaintext$ = GenerateDataKeyWithoutPlaintext$;
 exports.GenerateDataKeyWithoutPlaintextCommand = GenerateDataKeyWithoutPlaintextCommand;
+exports.GenerateDataKeyWithoutPlaintextRequest$ = GenerateDataKeyWithoutPlaintextRequest$;
+exports.GenerateDataKeyWithoutPlaintextResponse$ = GenerateDataKeyWithoutPlaintextResponse$;
+exports.GenerateMac$ = GenerateMac$;
 exports.GenerateMacCommand = GenerateMacCommand;
+exports.GenerateMacRequest$ = GenerateMacRequest$;
+exports.GenerateMacResponse$ = GenerateMacResponse$;
+exports.GenerateRandom$ = GenerateRandom$;
 exports.GenerateRandomCommand = GenerateRandomCommand;
+exports.GenerateRandomRequest$ = GenerateRandomRequest$;
+exports.GenerateRandomResponse$ = GenerateRandomResponse$;
+exports.GetKeyLastUsage$ = GetKeyLastUsage$;
+exports.GetKeyLastUsageCommand = GetKeyLastUsageCommand;
+exports.GetKeyLastUsageRequest$ = GetKeyLastUsageRequest$;
+exports.GetKeyLastUsageResponse$ = GetKeyLastUsageResponse$;
+exports.GetKeyPolicy$ = GetKeyPolicy$;
 exports.GetKeyPolicyCommand = GetKeyPolicyCommand;
+exports.GetKeyPolicyRequest$ = GetKeyPolicyRequest$;
+exports.GetKeyPolicyResponse$ = GetKeyPolicyResponse$;
+exports.GetKeyRotationStatus$ = GetKeyRotationStatus$;
 exports.GetKeyRotationStatusCommand = GetKeyRotationStatusCommand;
+exports.GetKeyRotationStatusRequest$ = GetKeyRotationStatusRequest$;
+exports.GetKeyRotationStatusResponse$ = GetKeyRotationStatusResponse$;
+exports.GetParametersForImport$ = GetParametersForImport$;
 exports.GetParametersForImportCommand = GetParametersForImportCommand;
+exports.GetParametersForImportRequest$ = GetParametersForImportRequest$;
+exports.GetParametersForImportResponse$ = GetParametersForImportResponse$;
+exports.GetPublicKey$ = GetPublicKey$;
 exports.GetPublicKeyCommand = GetPublicKeyCommand;
+exports.GetPublicKeyRequest$ = GetPublicKeyRequest$;
+exports.GetPublicKeyResponse$ = GetPublicKeyResponse$;
+exports.GrantConstraints$ = GrantConstraints$;
+exports.GrantListEntry$ = GrantListEntry$;
 exports.GrantOperation = GrantOperation;
+exports.ImportKeyMaterial$ = ImportKeyMaterial$;
 exports.ImportKeyMaterialCommand = ImportKeyMaterialCommand;
+exports.ImportKeyMaterialRequest$ = ImportKeyMaterialRequest$;
+exports.ImportKeyMaterialResponse$ = ImportKeyMaterialResponse$;
 exports.ImportState = ImportState;
 exports.ImportType = ImportType;
 exports.IncludeKeyMaterial = IncludeKeyMaterial;
+exports.IncorrectKeyException = IncorrectKeyException;
+exports.IncorrectKeyException$ = IncorrectKeyException$;
+exports.IncorrectKeyMaterialException = IncorrectKeyMaterialException;
+exports.IncorrectKeyMaterialException$ = IncorrectKeyMaterialException$;
+exports.IncorrectTrustAnchorException = IncorrectTrustAnchorException;
+exports.IncorrectTrustAnchorException$ = IncorrectTrustAnchorException$;
+exports.InvalidAliasNameException = InvalidAliasNameException;
+exports.InvalidAliasNameException$ = InvalidAliasNameException$;
+exports.InvalidArnException = InvalidArnException;
+exports.InvalidArnException$ = InvalidArnException$;
+exports.InvalidCiphertextException = InvalidCiphertextException;
+exports.InvalidCiphertextException$ = InvalidCiphertextException$;
+exports.InvalidGrantIdException = InvalidGrantIdException;
+exports.InvalidGrantIdException$ = InvalidGrantIdException$;
+exports.InvalidGrantTokenException = InvalidGrantTokenException;
+exports.InvalidGrantTokenException$ = InvalidGrantTokenException$;
+exports.InvalidImportTokenException = InvalidImportTokenException;
+exports.InvalidImportTokenException$ = InvalidImportTokenException$;
+exports.InvalidKeyUsageException = InvalidKeyUsageException;
+exports.InvalidKeyUsageException$ = InvalidKeyUsageException$;
+exports.InvalidMarkerException = InvalidMarkerException;
+exports.InvalidMarkerException$ = InvalidMarkerException$;
 exports.KMS = KMS;
 exports.KMSClient = KMSClient;
+exports.KMSInternalException = KMSInternalException;
+exports.KMSInternalException$ = KMSInternalException$;
+exports.KMSInvalidMacException = KMSInvalidMacException;
+exports.KMSInvalidMacException$ = KMSInvalidMacException$;
+exports.KMSInvalidSignatureException = KMSInvalidSignatureException;
+exports.KMSInvalidSignatureException$ = KMSInvalidSignatureException$;
+exports.KMSInvalidStateException = KMSInvalidStateException;
+exports.KMSInvalidStateException$ = KMSInvalidStateException$;
+exports.KMSServiceException = KMSServiceException;
+exports.KMSServiceException$ = KMSServiceException$;
 exports.KeyAgreementAlgorithmSpec = KeyAgreementAlgorithmSpec;
 exports.KeyEncryptionMechanism = KeyEncryptionMechanism;
+exports.KeyLastUsageData$ = KeyLastUsageData$;
+exports.KeyLastUsageTrackingOperation = KeyLastUsageTrackingOperation;
+exports.KeyListEntry$ = KeyListEntry$;
 exports.KeyManagerType = KeyManagerType;
 exports.KeyMaterialState = KeyMaterialState;
+exports.KeyMetadata$ = KeyMetadata$;
 exports.KeySpec = KeySpec;
 exports.KeyState = KeyState;
+exports.KeyUnavailableException = KeyUnavailableException;
+exports.KeyUnavailableException$ = KeyUnavailableException$;
 exports.KeyUsageType = KeyUsageType;
+exports.LimitExceededException = LimitExceededException;
+exports.LimitExceededException$ = LimitExceededException$;
+exports.ListAliases$ = ListAliases$;
 exports.ListAliasesCommand = ListAliasesCommand;
+exports.ListAliasesRequest$ = ListAliasesRequest$;
+exports.ListAliasesResponse$ = ListAliasesResponse$;
+exports.ListGrants$ = ListGrants$;
 exports.ListGrantsCommand = ListGrantsCommand;
+exports.ListGrantsRequest$ = ListGrantsRequest$;
+exports.ListGrantsResponse$ = ListGrantsResponse$;
+exports.ListKeyPolicies$ = ListKeyPolicies$;
 exports.ListKeyPoliciesCommand = ListKeyPoliciesCommand;
+exports.ListKeyPoliciesRequest$ = ListKeyPoliciesRequest$;
+exports.ListKeyPoliciesResponse$ = ListKeyPoliciesResponse$;
+exports.ListKeyRotations$ = ListKeyRotations$;
 exports.ListKeyRotationsCommand = ListKeyRotationsCommand;
+exports.ListKeyRotationsRequest$ = ListKeyRotationsRequest$;
+exports.ListKeyRotationsResponse$ = ListKeyRotationsResponse$;
+exports.ListKeys$ = ListKeys$;
 exports.ListKeysCommand = ListKeysCommand;
+exports.ListKeysRequest$ = ListKeysRequest$;
+exports.ListKeysResponse$ = ListKeysResponse$;
+exports.ListResourceTags$ = ListResourceTags$;
 exports.ListResourceTagsCommand = ListResourceTagsCommand;
+exports.ListResourceTagsRequest$ = ListResourceTagsRequest$;
+exports.ListResourceTagsResponse$ = ListResourceTagsResponse$;
+exports.ListRetirableGrants$ = ListRetirableGrants$;
 exports.ListRetirableGrantsCommand = ListRetirableGrantsCommand;
+exports.ListRetirableGrantsRequest$ = ListRetirableGrantsRequest$;
 exports.MacAlgorithmSpec = MacAlgorithmSpec;
+exports.MalformedPolicyDocumentException = MalformedPolicyDocumentException;
+exports.MalformedPolicyDocumentException$ = MalformedPolicyDocumentException$;
 exports.MessageType = MessageType;
+exports.MultiRegionConfiguration$ = MultiRegionConfiguration$;
+exports.MultiRegionKey$ = MultiRegionKey$;
 exports.MultiRegionKeyType = MultiRegionKeyType;
+exports.NotFoundException = NotFoundException;
+exports.NotFoundException$ = NotFoundException$;
 exports.OriginType = OriginType;
+exports.PutKeyPolicy$ = PutKeyPolicy$;
 exports.PutKeyPolicyCommand = PutKeyPolicyCommand;
+exports.PutKeyPolicyRequest$ = PutKeyPolicyRequest$;
+exports.ReEncrypt$ = ReEncrypt$;
 exports.ReEncryptCommand = ReEncryptCommand;
+exports.ReEncryptRequest$ = ReEncryptRequest$;
+exports.ReEncryptResponse$ = ReEncryptResponse$;
+exports.RecipientInfo$ = RecipientInfo$;
+exports.ReplicateKey$ = ReplicateKey$;
 exports.ReplicateKeyCommand = ReplicateKeyCommand;
+exports.ReplicateKeyRequest$ = ReplicateKeyRequest$;
+exports.ReplicateKeyResponse$ = ReplicateKeyResponse$;
+exports.RetireGrant$ = RetireGrant$;
 exports.RetireGrantCommand = RetireGrantCommand;
+exports.RetireGrantRequest$ = RetireGrantRequest$;
+exports.RevokeGrant$ = RevokeGrant$;
 exports.RevokeGrantCommand = RevokeGrantCommand;
+exports.RevokeGrantRequest$ = RevokeGrantRequest$;
+exports.RotateKeyOnDemand$ = RotateKeyOnDemand$;
 exports.RotateKeyOnDemandCommand = RotateKeyOnDemandCommand;
+exports.RotateKeyOnDemandRequest$ = RotateKeyOnDemandRequest$;
+exports.RotateKeyOnDemandResponse$ = RotateKeyOnDemandResponse$;
 exports.RotationType = RotationType;
+exports.RotationsListEntry$ = RotationsListEntry$;
+exports.ScheduleKeyDeletion$ = ScheduleKeyDeletion$;
 exports.ScheduleKeyDeletionCommand = ScheduleKeyDeletionCommand;
+exports.ScheduleKeyDeletionRequest$ = ScheduleKeyDeletionRequest$;
+exports.ScheduleKeyDeletionResponse$ = ScheduleKeyDeletionResponse$;
+exports.Sign$ = Sign$;
 exports.SignCommand = SignCommand;
+exports.SignRequest$ = SignRequest$;
+exports.SignResponse$ = SignResponse$;
 exports.SigningAlgorithmSpec = SigningAlgorithmSpec;
+exports.Tag$ = Tag$;
+exports.TagException = TagException;
+exports.TagException$ = TagException$;
+exports.TagResource$ = TagResource$;
 exports.TagResourceCommand = TagResourceCommand;
+exports.TagResourceRequest$ = TagResourceRequest$;
+exports.UnsupportedOperationException = UnsupportedOperationException;
+exports.UnsupportedOperationException$ = UnsupportedOperationException$;
+exports.UntagResource$ = UntagResource$;
 exports.UntagResourceCommand = UntagResourceCommand;
+exports.UntagResourceRequest$ = UntagResourceRequest$;
+exports.UpdateAlias$ = UpdateAlias$;
 exports.UpdateAliasCommand = UpdateAliasCommand;
+exports.UpdateAliasRequest$ = UpdateAliasRequest$;
+exports.UpdateCustomKeyStore$ = UpdateCustomKeyStore$;
 exports.UpdateCustomKeyStoreCommand = UpdateCustomKeyStoreCommand;
+exports.UpdateCustomKeyStoreRequest$ = UpdateCustomKeyStoreRequest$;
+exports.UpdateCustomKeyStoreResponse$ = UpdateCustomKeyStoreResponse$;
+exports.UpdateKeyDescription$ = UpdateKeyDescription$;
 exports.UpdateKeyDescriptionCommand = UpdateKeyDescriptionCommand;
+exports.UpdateKeyDescriptionRequest$ = UpdateKeyDescriptionRequest$;
+exports.UpdatePrimaryRegion$ = UpdatePrimaryRegion$;
 exports.UpdatePrimaryRegionCommand = UpdatePrimaryRegionCommand;
+exports.UpdatePrimaryRegionRequest$ = UpdatePrimaryRegionRequest$;
+exports.Verify$ = Verify$;
 exports.VerifyCommand = VerifyCommand;
+exports.VerifyMac$ = VerifyMac$;
 exports.VerifyMacCommand = VerifyMacCommand;
+exports.VerifyMacRequest$ = VerifyMacRequest$;
+exports.VerifyMacResponse$ = VerifyMacResponse$;
+exports.VerifyRequest$ = VerifyRequest$;
+exports.VerifyResponse$ = VerifyResponse$;
 exports.WrappingKeySpec = WrappingKeySpec;
+exports.XksKeyAlreadyInUseException = XksKeyAlreadyInUseException;
+exports.XksKeyAlreadyInUseException$ = XksKeyAlreadyInUseException$;
+exports.XksKeyConfigurationType$ = XksKeyConfigurationType$;
+exports.XksKeyInvalidConfigurationException = XksKeyInvalidConfigurationException;
+exports.XksKeyInvalidConfigurationException$ = XksKeyInvalidConfigurationException$;
+exports.XksKeyNotFoundException = XksKeyNotFoundException;
+exports.XksKeyNotFoundException$ = XksKeyNotFoundException$;
+exports.XksProxyAuthenticationCredentialType$ = XksProxyAuthenticationCredentialType$;
+exports.XksProxyConfigurationType$ = XksProxyConfigurationType$;
 exports.XksProxyConnectivityType = XksProxyConnectivityType;
+exports.XksProxyIncorrectAuthenticationCredentialException = XksProxyIncorrectAuthenticationCredentialException;
+exports.XksProxyIncorrectAuthenticationCredentialException$ = XksProxyIncorrectAuthenticationCredentialException$;
+exports.XksProxyInvalidConfigurationException = XksProxyInvalidConfigurationException;
+exports.XksProxyInvalidConfigurationException$ = XksProxyInvalidConfigurationException$;
+exports.XksProxyInvalidResponseException = XksProxyInvalidResponseException;
+exports.XksProxyInvalidResponseException$ = XksProxyInvalidResponseException$;
+exports.XksProxyUriEndpointInUseException = XksProxyUriEndpointInUseException;
+exports.XksProxyUriEndpointInUseException$ = XksProxyUriEndpointInUseException$;
+exports.XksProxyUriInUseException = XksProxyUriInUseException;
+exports.XksProxyUriInUseException$ = XksProxyUriInUseException$;
+exports.XksProxyUriUnreachableException = XksProxyUriUnreachableException;
+exports.XksProxyUriUnreachableException$ = XksProxyUriUnreachableException$;
+exports.XksProxyVpcEndpointServiceInUseException = XksProxyVpcEndpointServiceInUseException;
+exports.XksProxyVpcEndpointServiceInUseException$ = XksProxyVpcEndpointServiceInUseException$;
+exports.XksProxyVpcEndpointServiceInvalidConfigurationException = XksProxyVpcEndpointServiceInvalidConfigurationException;
+exports.XksProxyVpcEndpointServiceInvalidConfigurationException$ = XksProxyVpcEndpointServiceInvalidConfigurationException$;
+exports.XksProxyVpcEndpointServiceNotFoundException = XksProxyVpcEndpointServiceNotFoundException;
+exports.XksProxyVpcEndpointServiceNotFoundException$ = XksProxyVpcEndpointServiceNotFoundException$;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateDescribeCustomKeyStores = paginateDescribeCustomKeyStores;
 exports.paginateListAliases = paginateListAliases;
 exports.paginateListGrants = paginateListGrants;
@@ -1144,23 +3105,3 @@ exports.paginateListKeyRotations = paginateListKeyRotations;
 exports.paginateListKeys = paginateListKeys;
 exports.paginateListResourceTags = paginateListResourceTags;
 exports.paginateListRetirableGrants = paginateListRetirableGrants;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});