'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');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "kms",
    });
};
const commonParams = {
    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
    Endpoint: { type: "builtInParams", name: "endpoint" },
    Region: { type: "builtInParams", name: "region" },
    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
};

const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
    let _credentials = runtimeConfig.credentials;
    return {
        setHttpAuthScheme(httpAuthScheme) {
            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
            if (index === -1) {
                _httpAuthSchemes.push(httpAuthScheme);
            }
            else {
                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
            }
        },
        httpAuthSchemes() {
            return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
            _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
            return _httpAuthSchemeProvider;
        },
        setCredentials(credentials) {
            _credentials = credentials;
        },
        credentials() {
            return _credentials;
        },
    };
};
const resolveHttpAuthRuntimeConfig = (config) => {
    return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials(),
    };
};

const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.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));
};

class KMSClient extends smithyClient.Client {
    config;
    constructor(...[configuration]) {
        const _config_0 = runtimeConfig.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_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({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

class KMSServiceException extends smithyClient.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 _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 _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 _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 _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 _KEA = "KeyEncryptionAlgorithm";
const _KI = "KeyId";
const _KL = "KeyList";
const _KLE = "KeyListEntry";
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 _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 _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 _RT = "ReplicaTags";
const _RTo = "RotationType";
const _Re = "Region";
const _Ro = "Rotations";
const _S = "Signature";
const _SA = "SigningAlgorithms";
const _SAi = "SigningAlgorithm";
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 _TV = "TagValue";
const _Ta = "Tag";
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 = "server";
const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.kms";
const n0 = "com.amazonaws.kms";
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 AlreadyExistsException$ = [-3, n0, _AEE,
    { [_aQE]: [`AlreadyExists`, 409], [_e]: _c, [_hE]: 409 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(AlreadyExistsException$, AlreadyExistsException);
var CancelKeyDeletionRequest$ = [3, n0, _CKDR,
    0,
    [_KI],
    [0], 1
];
var CancelKeyDeletionResponse$ = [3, n0, _CKDRa,
    0,
    [_KI],
    [0]
];
var CloudHsmClusterInUseException$ = [-3, n0, _CHCIUE,
    { [_aQE]: [`CloudHsmClusterInUseException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CloudHsmClusterInUseException$, CloudHsmClusterInUseException);
var CloudHsmClusterInvalidConfigurationException$ = [-3, n0, _CHCICE,
    { [_aQE]: [`CloudHsmClusterInvalidConfigurationException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CloudHsmClusterInvalidConfigurationException$, CloudHsmClusterInvalidConfigurationException);
var CloudHsmClusterNotActiveException$ = [-3, n0, _CHCNAE,
    { [_aQE]: [`CloudHsmClusterNotActiveException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CloudHsmClusterNotActiveException$, CloudHsmClusterNotActiveException);
var CloudHsmClusterNotFoundException$ = [-3, n0, _CHCNFE,
    { [_aQE]: [`CloudHsmClusterNotFoundException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CloudHsmClusterNotFoundException$, CloudHsmClusterNotFoundException);
var CloudHsmClusterNotRelatedException$ = [-3, n0, _CHCNRE,
    { [_aQE]: [`CloudHsmClusterNotRelatedException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CloudHsmClusterNotRelatedException$, CloudHsmClusterNotRelatedException);
var ConflictException$ = [-3, n0, _CE,
    { [_aQE]: [`ConflictException`, 409], [_e]: _c, [_hE]: 409 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(ConflictException$, ConflictException);
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, _GP, _O, _RP, _C, _GT, _N, _DR],
    [0, 0, 64 | 0, 0, () => GrantConstraints$, 64 | 0, 0, 2], 3
];
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 CustomKeyStoreHasCMKsException$ = [-3, n0, _CKSHCMKE,
    { [_aQE]: [`CustomKeyStoreHasCMKsException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CustomKeyStoreHasCMKsException$, CustomKeyStoreHasCMKsException);
var CustomKeyStoreInvalidStateException$ = [-3, n0, _CKSISE,
    { [_aQE]: [`CustomKeyStoreInvalidStateException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CustomKeyStoreInvalidStateException$, CustomKeyStoreInvalidStateException);
var CustomKeyStoreNameInUseException$ = [-3, n0, _CKSNIUE,
    { [_aQE]: [`CustomKeyStoreNameInUseException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CustomKeyStoreNameInUseException$, CustomKeyStoreNameInUseException);
var CustomKeyStoreNotFoundException$ = [-3, n0, _CKSNFE,
    { [_aQE]: [`CustomKeyStoreNotFoundException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(CustomKeyStoreNotFoundException$, CustomKeyStoreNotFoundException);
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],
    [21, 128 | 0, 64 | 0, 0, 0, () => RecipientInfo$, 2], 1
];
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 DependencyTimeoutException$ = [-3, n0, _DTE,
    { [_aQE]: [`DependencyTimeout`, 503], [_e]: _s, [_hE]: 503 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(DependencyTimeoutException$, DependencyTimeoutException);
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 DisabledException$ = [-3, n0, _DE,
    { [_aQE]: [`Disabled`, 409], [_e]: _c, [_hE]: 409 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(DisabledException$, DisabledException);
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 DryRunOperationException$ = [-3, n0, _DROE,
    { [_aQE]: [`DryRunOperation`, 412], [_e]: _c, [_hE]: 412 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(DryRunOperationException$, DryRunOperationException);
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 ExpiredImportTokenException$ = [-3, n0, _EITE,
    { [_aQE]: [`ExpiredImportTokenException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(ExpiredImportTokenException$, ExpiredImportTokenException);
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 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],
    [128 | 0, 128 | 0]
];
var GrantListEntry$ = [3, n0, _GLE,
    0,
    [_KI, _GI, _N, _CD, _GP, _RP, _IA, _O, _C],
    [0, 0, 0, 4, 0, 0, 0, 64 | 0, () => GrantConstraints$]
];
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 IncorrectKeyException$ = [-3, n0, _IKE,
    { [_aQE]: [`IncorrectKeyException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(IncorrectKeyException$, IncorrectKeyException);
var IncorrectKeyMaterialException$ = [-3, n0, _IKME,
    { [_aQE]: [`IncorrectKeyMaterialException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(IncorrectKeyMaterialException$, IncorrectKeyMaterialException);
var IncorrectTrustAnchorException$ = [-3, n0, _ITAE,
    { [_aQE]: [`IncorrectTrustAnchorException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(IncorrectTrustAnchorException$, IncorrectTrustAnchorException);
var InvalidAliasNameException$ = [-3, n0, _IANE,
    { [_aQE]: [`InvalidAliasName`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(InvalidAliasNameException$, InvalidAliasNameException);
var InvalidArnException$ = [-3, n0, _IAE,
    { [_aQE]: [`InvalidArn`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(InvalidArnException$, InvalidArnException);
var InvalidCiphertextException$ = [-3, n0, _ICE,
    { [_aQE]: [`InvalidCiphertext`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(InvalidCiphertextException$, InvalidCiphertextException);
var InvalidGrantIdException$ = [-3, n0, _IGIE,
    { [_aQE]: [`InvalidGrantId`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(InvalidGrantIdException$, InvalidGrantIdException);
var InvalidGrantTokenException$ = [-3, n0, _IGTE,
    { [_aQE]: [`InvalidGrantToken`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(InvalidGrantTokenException$, InvalidGrantTokenException);
var InvalidImportTokenException$ = [-3, n0, _IITE,
    { [_aQE]: [`InvalidImportTokenException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(InvalidImportTokenException$, InvalidImportTokenException);
var InvalidKeyUsageException$ = [-3, n0, _IKUE,
    { [_aQE]: [`InvalidKeyUsage`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(InvalidKeyUsageException$, InvalidKeyUsageException);
var InvalidMarkerException$ = [-3, n0, _IME,
    { [_aQE]: [`InvalidMarker`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(InvalidMarkerException$, InvalidMarkerException);
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 KeyUnavailableException$ = [-3, n0, _KUE,
    { [_aQE]: [`KeyUnavailable`, 500], [_e]: _s, [_hE]: 500 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(KeyUnavailableException$, KeyUnavailableException);
var KMSInternalException$ = [-3, n0, _KMSIE,
    { [_aQE]: [`KMSInternal`, 500], [_e]: _s, [_hE]: 500 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(KMSInternalException$, KMSInternalException);
var KMSInvalidMacException$ = [-3, n0, _KMSIME,
    { [_aQE]: [`KMSInvalidMac`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(KMSInvalidMacException$, KMSInvalidMacException);
var KMSInvalidSignatureException$ = [-3, n0, _KMSISE,
    { [_aQE]: [`KMSInvalidSignature`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(KMSInvalidSignatureException$, KMSInvalidSignatureException);
var KMSInvalidStateException$ = [-3, n0, _KMSISEn,
    { [_aQE]: [`KMSInvalidStateException`, 409], [_e]: _c, [_hE]: 409 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(KMSInvalidStateException$, KMSInvalidStateException);
var LimitExceededException$ = [-3, n0, _LEE,
    { [_aQE]: [`LimitExceeded`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(LimitExceededException$, LimitExceededException);
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],
    [0, 1, 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,
    [_RP, _L, _M],
    [0, 1, 0], 1
];
var MalformedPolicyDocumentException$ = [-3, n0, _MPDE,
    { [_aQE]: [`MalformedPolicyDocument`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(MalformedPolicyDocumentException$, MalformedPolicyDocumentException);
var MultiRegionConfiguration$ = [3, n0, _MRC,
    0,
    [_MRKT, _PKr, _RK],
    [0, () => MultiRegionKey$, () => MultiRegionKeyList]
];
var MultiRegionKey$ = [3, n0, _MRK,
    0,
    [_A, _Re],
    [0, 0]
];
var NotFoundException$ = [-3, n0, _NFE,
    { [_aQE]: [`NotFound`, 404], [_e]: _c, [_hE]: 404 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(NotFoundException$, NotFoundException);
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,
    [_CB, _DKI, _SEC, _SKI, _DEC, _SEA, _DEA, _GT, _DR],
    [21, 0, 128 | 0, 0, 128 | 0, 0, 0, 64 | 0, 2], 2
];
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 TagException$ = [-3, n0, _TE,
    { [_aQE]: [`TagException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(TagException$, TagException);
var TagResourceRequest$ = [3, n0, _TRR,
    0,
    [_KI, _T],
    [0, () => TagList], 2
];
var UnsupportedOperationException$ = [-3, n0, _UOE,
    { [_aQE]: [`UnsupportedOperation`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(UnsupportedOperationException$, UnsupportedOperationException);
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 XksKeyAlreadyInUseException$ = [-3, n0, _XKAIUE,
    { [_aQE]: [`XksKeyAlreadyInUse`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksKeyAlreadyInUseException$, XksKeyAlreadyInUseException);
var XksKeyConfigurationType$ = [3, n0, _XKCT,
    0,
    [_I],
    [0]
];
var XksKeyInvalidConfigurationException$ = [-3, n0, _XKICE,
    { [_aQE]: [`XksKeyInvalidConfiguration`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksKeyInvalidConfigurationException$, XksKeyInvalidConfigurationException);
var XksKeyNotFoundException$ = [-3, n0, _XKNFE,
    { [_aQE]: [`XksKeyNotFoundException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksKeyNotFoundException$, XksKeyNotFoundException);
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 XksProxyIncorrectAuthenticationCredentialException$ = [-3, n0, _XPIACE,
    { [_aQE]: [`XksProxyIncorrectAuthenticationCredentialException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyIncorrectAuthenticationCredentialException$, XksProxyIncorrectAuthenticationCredentialException);
var XksProxyInvalidConfigurationException$ = [-3, n0, _XPICE,
    { [_aQE]: [`XksProxyInvalidConfigurationException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyInvalidConfigurationException$, XksProxyInvalidConfigurationException);
var XksProxyInvalidResponseException$ = [-3, n0, _XPIRE,
    { [_aQE]: [`XksProxyInvalidResponseException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyInvalidResponseException$, XksProxyInvalidResponseException);
var XksProxyUriEndpointInUseException$ = [-3, n0, _XPUEIUE,
    { [_aQE]: [`XksProxyUriEndpointInUseException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyUriEndpointInUseException$, XksProxyUriEndpointInUseException);
var XksProxyUriInUseException$ = [-3, n0, _XPUIUE,
    { [_aQE]: [`XksProxyUriInUseException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyUriInUseException$, XksProxyUriInUseException);
var XksProxyUriUnreachableException$ = [-3, n0, _XPUUE,
    { [_aQE]: [`XksProxyUriUnreachableException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyUriUnreachableException$, XksProxyUriUnreachableException);
var XksProxyVpcEndpointServiceInUseException$ = [-3, n0, _XPVESIUE,
    { [_aQE]: [`XksProxyVpcEndpointServiceInUseException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyVpcEndpointServiceInUseException$, XksProxyVpcEndpointServiceInUseException);
var XksProxyVpcEndpointServiceInvalidConfigurationException$ = [-3, n0, _XPVESICE,
    { [_aQE]: [`XksProxyVpcEndpointServiceInvalidConfigurationException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyVpcEndpointServiceInvalidConfigurationException$, XksProxyVpcEndpointServiceInvalidConfigurationException);
var XksProxyVpcEndpointServiceNotFoundException$ = [-3, n0, _XPVESNFE,
    { [_aQE]: [`XksProxyVpcEndpointServiceNotFoundException`, 400], [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
schema.TypeRegistry.for(n0).registerError(XksProxyVpcEndpointServiceNotFoundException$, XksProxyVpcEndpointServiceNotFoundException);
var __Unit = "unit";
var KMSServiceException$ = [-3, _sm, "KMSServiceException", 0, [], []];
schema.TypeRegistry.for(_sm).registerError(KMSServiceException$, KMSServiceException);
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 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$
];

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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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 commands = {
    CancelKeyDeletionCommand,
    ConnectCustomKeyStoreCommand,
    CreateAliasCommand,
    CreateCustomKeyStoreCommand,
    CreateGrantCommand,
    CreateKeyCommand,
    DecryptCommand,
    DeleteAliasCommand,
    DeleteCustomKeyStoreCommand,
    DeleteImportedKeyMaterialCommand,
    DeriveSharedSecretCommand,
    DescribeCustomKeyStoresCommand,
    DescribeKeyCommand,
    DisableKeyCommand,
    DisableKeyRotationCommand,
    DisconnectCustomKeyStoreCommand,
    EnableKeyCommand,
    EnableKeyRotationCommand,
    EncryptCommand,
    GenerateDataKeyCommand,
    GenerateDataKeyPairCommand,
    GenerateDataKeyPairWithoutPlaintextCommand,
    GenerateDataKeyWithoutPlaintextCommand,
    GenerateMacCommand,
    GenerateRandomCommand,
    GetKeyPolicyCommand,
    GetKeyRotationStatusCommand,
    GetParametersForImportCommand,
    GetPublicKeyCommand,
    ImportKeyMaterialCommand,
    ListAliasesCommand,
    ListGrantsCommand,
    ListKeyPoliciesCommand,
    ListKeyRotationsCommand,
    ListKeysCommand,
    ListResourceTagsCommand,
    ListRetirableGrantsCommand,
    PutKeyPolicyCommand,
    ReEncryptCommand,
    ReplicateKeyCommand,
    RetireGrantCommand,
    RevokeGrantCommand,
    RotateKeyOnDemandCommand,
    ScheduleKeyDeletionCommand,
    SignCommand,
    TagResourceCommand,
    UntagResourceCommand,
    UpdateAliasCommand,
    UpdateCustomKeyStoreCommand,
    UpdateKeyDescriptionCommand,
    UpdatePrimaryRegionCommand,
    VerifyCommand,
    VerifyMacCommand,
};
const paginators = {
    paginateDescribeCustomKeyStores,
    paginateListAliases,
    paginateListGrants,
    paginateListKeyPolicies,
    paginateListKeyRotations,
    paginateListKeys,
    paginateListResourceTags,
    paginateListRetirableGrants,
};
class KMS extends KMSClient {
}
smithyClient.createAggregatedClient(commands, KMS, { paginators });

const AlgorithmSpec = {
    RSAES_OAEP_SHA_1: "RSAES_OAEP_SHA_1",
    RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256",
    RSAES_PKCS1_V1_5: "RSAES_PKCS1_V1_5",
    RSA_AES_KEY_WRAP_SHA_1: "RSA_AES_KEY_WRAP_SHA_1",
    RSA_AES_KEY_WRAP_SHA_256: "RSA_AES_KEY_WRAP_SHA_256",
    SM2PKE: "SM2PKE",
};
const ConnectionErrorCodeType = {
    CLUSTER_NOT_FOUND: "CLUSTER_NOT_FOUND",
    INSUFFICIENT_CLOUDHSM_HSMS: "INSUFFICIENT_CLOUDHSM_HSMS",
    INSUFFICIENT_FREE_ADDRESSES_IN_SUBNET: "INSUFFICIENT_FREE_ADDRESSES_IN_SUBNET",
    INTERNAL_ERROR: "INTERNAL_ERROR",
    INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
    NETWORK_ERRORS: "NETWORK_ERRORS",
    SUBNET_NOT_FOUND: "SUBNET_NOT_FOUND",
    USER_LOCKED_OUT: "USER_LOCKED_OUT",
    USER_LOGGED_IN: "USER_LOGGED_IN",
    USER_NOT_FOUND: "USER_NOT_FOUND",
    XKS_PROXY_ACCESS_DENIED: "XKS_PROXY_ACCESS_DENIED",
    XKS_PROXY_INVALID_CONFIGURATION: "XKS_PROXY_INVALID_CONFIGURATION",
    XKS_PROXY_INVALID_RESPONSE: "XKS_PROXY_INVALID_RESPONSE",
    XKS_PROXY_INVALID_TLS_CONFIGURATION: "XKS_PROXY_INVALID_TLS_CONFIGURATION",
    XKS_PROXY_NOT_REACHABLE: "XKS_PROXY_NOT_REACHABLE",
    XKS_PROXY_TIMED_OUT: "XKS_PROXY_TIMED_OUT",
    XKS_VPC_ENDPOINT_SERVICE_INVALID_CONFIGURATION: "XKS_VPC_ENDPOINT_SERVICE_INVALID_CONFIGURATION",
    XKS_VPC_ENDPOINT_SERVICE_NOT_FOUND: "XKS_VPC_ENDPOINT_SERVICE_NOT_FOUND",
};
const ConnectionStateType = {
    CONNECTED: "CONNECTED",
    CONNECTING: "CONNECTING",
    DISCONNECTED: "DISCONNECTED",
    DISCONNECTING: "DISCONNECTING",
    FAILED: "FAILED",
};
const CustomKeyStoreType = {
    AWS_CLOUDHSM: "AWS_CLOUDHSM",
    EXTERNAL_KEY_STORE: "EXTERNAL_KEY_STORE",
};
const XksProxyConnectivityType = {
    PUBLIC_ENDPOINT: "PUBLIC_ENDPOINT",
    VPC_ENDPOINT_SERVICE: "VPC_ENDPOINT_SERVICE",
};
const GrantOperation = {
    CreateGrant: "CreateGrant",
    Decrypt: "Decrypt",
    DeriveSharedSecret: "DeriveSharedSecret",
    DescribeKey: "DescribeKey",
    Encrypt: "Encrypt",
    GenerateDataKey: "GenerateDataKey",
    GenerateDataKeyPair: "GenerateDataKeyPair",
    GenerateDataKeyPairWithoutPlaintext: "GenerateDataKeyPairWithoutPlaintext",
    GenerateDataKeyWithoutPlaintext: "GenerateDataKeyWithoutPlaintext",
    GenerateMac: "GenerateMac",
    GetPublicKey: "GetPublicKey",
    ReEncryptFrom: "ReEncryptFrom",
    ReEncryptTo: "ReEncryptTo",
    RetireGrant: "RetireGrant",
    Sign: "Sign",
    Verify: "Verify",
    VerifyMac: "VerifyMac",
};
const CustomerMasterKeySpec = {
    ECC_NIST_P256: "ECC_NIST_P256",
    ECC_NIST_P384: "ECC_NIST_P384",
    ECC_NIST_P521: "ECC_NIST_P521",
    ECC_SECG_P256K1: "ECC_SECG_P256K1",
    HMAC_224: "HMAC_224",
    HMAC_256: "HMAC_256",
    HMAC_384: "HMAC_384",
    HMAC_512: "HMAC_512",
    RSA_2048: "RSA_2048",
    RSA_3072: "RSA_3072",
    RSA_4096: "RSA_4096",
    SM2: "SM2",
    SYMMETRIC_DEFAULT: "SYMMETRIC_DEFAULT",
};
const KeySpec = {
    ECC_NIST_EDWARDS25519: "ECC_NIST_EDWARDS25519",
    ECC_NIST_P256: "ECC_NIST_P256",
    ECC_NIST_P384: "ECC_NIST_P384",
    ECC_NIST_P521: "ECC_NIST_P521",
    ECC_SECG_P256K1: "ECC_SECG_P256K1",
    HMAC_224: "HMAC_224",
    HMAC_256: "HMAC_256",
    HMAC_384: "HMAC_384",
    HMAC_512: "HMAC_512",
    ML_DSA_44: "ML_DSA_44",
    ML_DSA_65: "ML_DSA_65",
    ML_DSA_87: "ML_DSA_87",
    RSA_2048: "RSA_2048",
    RSA_3072: "RSA_3072",
    RSA_4096: "RSA_4096",
    SM2: "SM2",
    SYMMETRIC_DEFAULT: "SYMMETRIC_DEFAULT",
};
const KeyUsageType = {
    ENCRYPT_DECRYPT: "ENCRYPT_DECRYPT",
    GENERATE_VERIFY_MAC: "GENERATE_VERIFY_MAC",
    KEY_AGREEMENT: "KEY_AGREEMENT",
    SIGN_VERIFY: "SIGN_VERIFY",
};
const OriginType = {
    AWS_CLOUDHSM: "AWS_CLOUDHSM",
    AWS_KMS: "AWS_KMS",
    EXTERNAL: "EXTERNAL",
    EXTERNAL_KEY_STORE: "EXTERNAL_KEY_STORE",
};
const EncryptionAlgorithmSpec = {
    RSAES_OAEP_SHA_1: "RSAES_OAEP_SHA_1",
    RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256",
    SM2PKE: "SM2PKE",
    SYMMETRIC_DEFAULT: "SYMMETRIC_DEFAULT",
};
const ExpirationModelType = {
    KEY_MATERIAL_DOES_NOT_EXPIRE: "KEY_MATERIAL_DOES_NOT_EXPIRE",
    KEY_MATERIAL_EXPIRES: "KEY_MATERIAL_EXPIRES",
};
const KeyAgreementAlgorithmSpec = {
    ECDH: "ECDH",
};
const KeyManagerType = {
    AWS: "AWS",
    CUSTOMER: "CUSTOMER",
};
const KeyState = {
    Creating: "Creating",
    Disabled: "Disabled",
    Enabled: "Enabled",
    PendingDeletion: "PendingDeletion",
    PendingImport: "PendingImport",
    PendingReplicaDeletion: "PendingReplicaDeletion",
    Unavailable: "Unavailable",
    Updating: "Updating",
};
const MacAlgorithmSpec = {
    HMAC_SHA_224: "HMAC_SHA_224",
    HMAC_SHA_256: "HMAC_SHA_256",
    HMAC_SHA_384: "HMAC_SHA_384",
    HMAC_SHA_512: "HMAC_SHA_512",
};
const MultiRegionKeyType = {
    PRIMARY: "PRIMARY",
    REPLICA: "REPLICA",
};
const SigningAlgorithmSpec = {
    ECDSA_SHA_256: "ECDSA_SHA_256",
    ECDSA_SHA_384: "ECDSA_SHA_384",
    ECDSA_SHA_512: "ECDSA_SHA_512",
    ED25519_PH_SHA_512: "ED25519_PH_SHA_512",
    ED25519_SHA_512: "ED25519_SHA_512",
    ML_DSA_SHAKE_256: "ML_DSA_SHAKE_256",
    RSASSA_PKCS1_V1_5_SHA_256: "RSASSA_PKCS1_V1_5_SHA_256",
    RSASSA_PKCS1_V1_5_SHA_384: "RSASSA_PKCS1_V1_5_SHA_384",
    RSASSA_PKCS1_V1_5_SHA_512: "RSASSA_PKCS1_V1_5_SHA_512",
    RSASSA_PSS_SHA_256: "RSASSA_PSS_SHA_256",
    RSASSA_PSS_SHA_384: "RSASSA_PSS_SHA_384",
    RSASSA_PSS_SHA_512: "RSASSA_PSS_SHA_512",
    SM2DSA: "SM2DSA",
};
const DataKeyPairSpec = {
    ECC_NIST_EDWARDS25519: "ECC_NIST_EDWARDS25519",
    ECC_NIST_P256: "ECC_NIST_P256",
    ECC_NIST_P384: "ECC_NIST_P384",
    ECC_NIST_P521: "ECC_NIST_P521",
    ECC_SECG_P256K1: "ECC_SECG_P256K1",
    RSA_2048: "RSA_2048",
    RSA_3072: "RSA_3072",
    RSA_4096: "RSA_4096",
    SM2: "SM2",
};
const DataKeySpec = {
    AES_128: "AES_128",
    AES_256: "AES_256",
};
const KeyEncryptionMechanism = {
    RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256",
};
const WrappingKeySpec = {
    RSA_2048: "RSA_2048",
    RSA_3072: "RSA_3072",
    RSA_4096: "RSA_4096",
    SM2: "SM2",
};
const ImportType = {
    EXISTING_KEY_MATERIAL: "EXISTING_KEY_MATERIAL",
    NEW_KEY_MATERIAL: "NEW_KEY_MATERIAL",
};
const ImportState = {
    IMPORTED: "IMPORTED",
    PENDING_IMPORT: "PENDING_IMPORT",
};
const IncludeKeyMaterial = {
    ALL_KEY_MATERIAL: "ALL_KEY_MATERIAL",
    ROTATIONS_ONLY: "ROTATIONS_ONLY",
};
const KeyMaterialState = {
    CURRENT: "CURRENT",
    NON_CURRENT: "NON_CURRENT",
    PENDING_MULTI_REGION_IMPORT_AND_ROTATION: "PENDING_MULTI_REGION_IMPORT_AND_ROTATION",
    PENDING_ROTATION: "PENDING_ROTATION",
};
const RotationType = {
    AUTOMATIC: "AUTOMATIC",
    ON_DEMAND: "ON_DEMAND",
};
const MessageType = {
    DIGEST: "DIGEST",
    EXTERNAL_MU: "EXTERNAL_MU",
    RAW: "RAW",
};

Object.defineProperty(exports, "$Command", {
    enumerable: true,
    get: function () { return smithyClient.Command; }
});
Object.defineProperty(exports, "__Client", {
    enumerable: true,
    get: function () { return smithyClient.Client; }
});
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.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.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.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.paginateDescribeCustomKeyStores = paginateDescribeCustomKeyStores;
exports.paginateListAliases = paginateListAliases;
exports.paginateListGrants = paginateListGrants;
exports.paginateListKeyPolicies = paginateListKeyPolicies;
exports.paginateListKeyRotations = paginateListKeyRotations;
exports.paginateListKeys = paginateListKeys;
exports.paginateListResourceTags = paginateListResourceTags;
exports.paginateListRetirableGrants = paginateListRetirableGrants;
