cdk-encrypted-secret/node_modules/@aws-sdk/client-kms/dist-cjs/index.js

CDK Construct that creates an AWS Secret Manager Secret and sets the value from an encrypted Ciphertext.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  AlgorithmSpec: () => AlgorithmSpec,
  AlreadyExistsException: () => AlreadyExistsException,
  CancelKeyDeletionCommand: () => CancelKeyDeletionCommand,
  CloudHsmClusterInUseException: () => CloudHsmClusterInUseException,
  CloudHsmClusterInvalidConfigurationException: () => CloudHsmClusterInvalidConfigurationException,
  CloudHsmClusterNotActiveException: () => CloudHsmClusterNotActiveException,
  CloudHsmClusterNotFoundException: () => CloudHsmClusterNotFoundException,
  CloudHsmClusterNotRelatedException: () => CloudHsmClusterNotRelatedException,
  ConflictException: () => ConflictException,
  ConnectCustomKeyStoreCommand: () => ConnectCustomKeyStoreCommand,
  ConnectionErrorCodeType: () => ConnectionErrorCodeType,
  ConnectionStateType: () => ConnectionStateType,
  CreateAliasCommand: () => CreateAliasCommand,
  CreateCustomKeyStoreCommand: () => CreateCustomKeyStoreCommand,
  CreateCustomKeyStoreRequestFilterSensitiveLog: () => CreateCustomKeyStoreRequestFilterSensitiveLog,
  CreateGrantCommand: () => CreateGrantCommand,
  CreateKeyCommand: () => CreateKeyCommand,
  CustomKeyStoreHasCMKsException: () => CustomKeyStoreHasCMKsException,
  CustomKeyStoreInvalidStateException: () => CustomKeyStoreInvalidStateException,
  CustomKeyStoreNameInUseException: () => CustomKeyStoreNameInUseException,
  CustomKeyStoreNotFoundException: () => CustomKeyStoreNotFoundException,
  CustomKeyStoreType: () => CustomKeyStoreType,
  CustomKeyStoresListEntryFilterSensitiveLog: () => CustomKeyStoresListEntryFilterSensitiveLog,
  CustomerMasterKeySpec: () => CustomerMasterKeySpec,
  DataKeyPairSpec: () => DataKeyPairSpec,
  DataKeySpec: () => DataKeySpec,
  DecryptCommand: () => DecryptCommand,
  DecryptResponseFilterSensitiveLog: () => DecryptResponseFilterSensitiveLog,
  DeleteAliasCommand: () => DeleteAliasCommand,
  DeleteCustomKeyStoreCommand: () => DeleteCustomKeyStoreCommand,
  DeleteImportedKeyMaterialCommand: () => DeleteImportedKeyMaterialCommand,
  DependencyTimeoutException: () => DependencyTimeoutException,
  DeriveSharedSecretCommand: () => DeriveSharedSecretCommand,
  DeriveSharedSecretResponseFilterSensitiveLog: () => DeriveSharedSecretResponseFilterSensitiveLog,
  DescribeCustomKeyStoresCommand: () => DescribeCustomKeyStoresCommand,
  DescribeCustomKeyStoresResponseFilterSensitiveLog: () => DescribeCustomKeyStoresResponseFilterSensitiveLog,
  DescribeKeyCommand: () => DescribeKeyCommand,
  DisableKeyCommand: () => DisableKeyCommand,
  DisableKeyRotationCommand: () => DisableKeyRotationCommand,
  DisabledException: () => DisabledException,
  DisconnectCustomKeyStoreCommand: () => DisconnectCustomKeyStoreCommand,
  DryRunOperationException: () => DryRunOperationException,
  EnableKeyCommand: () => EnableKeyCommand,
  EnableKeyRotationCommand: () => EnableKeyRotationCommand,
  EncryptCommand: () => EncryptCommand,
  EncryptRequestFilterSensitiveLog: () => EncryptRequestFilterSensitiveLog,
  EncryptionAlgorithmSpec: () => EncryptionAlgorithmSpec,
  ExpirationModelType: () => ExpirationModelType,
  ExpiredImportTokenException: () => ExpiredImportTokenException,
  GenerateDataKeyCommand: () => GenerateDataKeyCommand,
  GenerateDataKeyPairCommand: () => GenerateDataKeyPairCommand,
  GenerateDataKeyPairResponseFilterSensitiveLog: () => GenerateDataKeyPairResponseFilterSensitiveLog,
  GenerateDataKeyPairWithoutPlaintextCommand: () => GenerateDataKeyPairWithoutPlaintextCommand,
  GenerateDataKeyResponseFilterSensitiveLog: () => GenerateDataKeyResponseFilterSensitiveLog,
  GenerateDataKeyWithoutPlaintextCommand: () => GenerateDataKeyWithoutPlaintextCommand,
  GenerateMacCommand: () => GenerateMacCommand,
  GenerateMacRequestFilterSensitiveLog: () => GenerateMacRequestFilterSensitiveLog,
  GenerateRandomCommand: () => GenerateRandomCommand,
  GenerateRandomResponseFilterSensitiveLog: () => GenerateRandomResponseFilterSensitiveLog,
  GetKeyPolicyCommand: () => GetKeyPolicyCommand,
  GetKeyRotationStatusCommand: () => GetKeyRotationStatusCommand,
  GetParametersForImportCommand: () => GetParametersForImportCommand,
  GetParametersForImportResponseFilterSensitiveLog: () => GetParametersForImportResponseFilterSensitiveLog,
  GetPublicKeyCommand: () => GetPublicKeyCommand,
  GrantOperation: () => GrantOperation,
  ImportKeyMaterialCommand: () => ImportKeyMaterialCommand,
  ImportState: () => ImportState,
  ImportType: () => ImportType,
  IncludeKeyMaterial: () => IncludeKeyMaterial,
  IncorrectKeyException: () => IncorrectKeyException,
  IncorrectKeyMaterialException: () => IncorrectKeyMaterialException,
  IncorrectTrustAnchorException: () => IncorrectTrustAnchorException,
  InvalidAliasNameException: () => InvalidAliasNameException,
  InvalidArnException: () => InvalidArnException,
  InvalidCiphertextException: () => InvalidCiphertextException,
  InvalidGrantIdException: () => InvalidGrantIdException,
  InvalidGrantTokenException: () => InvalidGrantTokenException,
  InvalidImportTokenException: () => InvalidImportTokenException,
  InvalidKeyUsageException: () => InvalidKeyUsageException,
  InvalidMarkerException: () => InvalidMarkerException,
  KMS: () => KMS,
  KMSClient: () => KMSClient,
  KMSInternalException: () => KMSInternalException,
  KMSInvalidMacException: () => KMSInvalidMacException,
  KMSInvalidSignatureException: () => KMSInvalidSignatureException,
  KMSInvalidStateException: () => KMSInvalidStateException,
  KMSServiceException: () => KMSServiceException,
  KeyAgreementAlgorithmSpec: () => KeyAgreementAlgorithmSpec,
  KeyEncryptionMechanism: () => KeyEncryptionMechanism,
  KeyManagerType: () => KeyManagerType,
  KeyMaterialState: () => KeyMaterialState,
  KeySpec: () => KeySpec,
  KeyState: () => KeyState,
  KeyUnavailableException: () => KeyUnavailableException,
  KeyUsageType: () => KeyUsageType,
  LimitExceededException: () => LimitExceededException,
  ListAliasesCommand: () => ListAliasesCommand,
  ListGrantsCommand: () => ListGrantsCommand,
  ListKeyPoliciesCommand: () => ListKeyPoliciesCommand,
  ListKeyRotationsCommand: () => ListKeyRotationsCommand,
  ListKeysCommand: () => ListKeysCommand,
  ListResourceTagsCommand: () => ListResourceTagsCommand,
  ListRetirableGrantsCommand: () => ListRetirableGrantsCommand,
  MacAlgorithmSpec: () => MacAlgorithmSpec,
  MalformedPolicyDocumentException: () => MalformedPolicyDocumentException,
  MessageType: () => MessageType,
  MultiRegionKeyType: () => MultiRegionKeyType,
  NotFoundException: () => NotFoundException,
  OriginType: () => OriginType,
  PutKeyPolicyCommand: () => PutKeyPolicyCommand,
  ReEncryptCommand: () => ReEncryptCommand,
  ReplicateKeyCommand: () => ReplicateKeyCommand,
  RetireGrantCommand: () => RetireGrantCommand,
  RevokeGrantCommand: () => RevokeGrantCommand,
  RotateKeyOnDemandCommand: () => RotateKeyOnDemandCommand,
  RotationType: () => RotationType,
  ScheduleKeyDeletionCommand: () => ScheduleKeyDeletionCommand,
  SignCommand: () => SignCommand,
  SignRequestFilterSensitiveLog: () => SignRequestFilterSensitiveLog,
  SigningAlgorithmSpec: () => SigningAlgorithmSpec,
  TagException: () => TagException,
  TagResourceCommand: () => TagResourceCommand,
  UnsupportedOperationException: () => UnsupportedOperationException,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateAliasCommand: () => UpdateAliasCommand,
  UpdateCustomKeyStoreCommand: () => UpdateCustomKeyStoreCommand,
  UpdateCustomKeyStoreRequestFilterSensitiveLog: () => UpdateCustomKeyStoreRequestFilterSensitiveLog,
  UpdateKeyDescriptionCommand: () => UpdateKeyDescriptionCommand,
  UpdatePrimaryRegionCommand: () => UpdatePrimaryRegionCommand,
  VerifyCommand: () => VerifyCommand,
  VerifyMacCommand: () => VerifyMacCommand,
  VerifyMacRequestFilterSensitiveLog: () => VerifyMacRequestFilterSensitiveLog,
  VerifyRequestFilterSensitiveLog: () => VerifyRequestFilterSensitiveLog,
  WrappingKeySpec: () => WrappingKeySpec,
  XksKeyAlreadyInUseException: () => XksKeyAlreadyInUseException,
  XksKeyInvalidConfigurationException: () => XksKeyInvalidConfigurationException,
  XksKeyNotFoundException: () => XksKeyNotFoundException,
  XksProxyAuthenticationCredentialTypeFilterSensitiveLog: () => XksProxyAuthenticationCredentialTypeFilterSensitiveLog,
  XksProxyConfigurationTypeFilterSensitiveLog: () => XksProxyConfigurationTypeFilterSensitiveLog,
  XksProxyConnectivityType: () => XksProxyConnectivityType,
  XksProxyIncorrectAuthenticationCredentialException: () => XksProxyIncorrectAuthenticationCredentialException,
  XksProxyInvalidConfigurationException: () => XksProxyInvalidConfigurationException,
  XksProxyInvalidResponseException: () => XksProxyInvalidResponseException,
  XksProxyUriEndpointInUseException: () => XksProxyUriEndpointInUseException,
  XksProxyUriInUseException: () => XksProxyUriInUseException,
  XksProxyUriUnreachableException: () => XksProxyUriUnreachableException,
  XksProxyVpcEndpointServiceInUseException: () => XksProxyVpcEndpointServiceInUseException,
  XksProxyVpcEndpointServiceInvalidConfigurationException: () => XksProxyVpcEndpointServiceInvalidConfigurationException,
  XksProxyVpcEndpointServiceNotFoundException: () => XksProxyVpcEndpointServiceNotFoundException,
  __Client: () => import_smithy_client.Client,
  paginateDescribeCustomKeyStores: () => paginateDescribeCustomKeyStores,
  paginateListAliases: () => paginateListAliases,
  paginateListGrants: () => paginateListGrants,
  paginateListKeyPolicies: () => paginateListKeyPolicies,
  paginateListKeyRotations: () => paginateListKeyRotations,
  paginateListKeys: () => paginateListKeys,
  paginateListResourceTags: () => paginateListResourceTags,
  paginateListRetirableGrants: () => paginateListRetirableGrants
});
module.exports = __toCommonJS(index_exports);

// src/KMSClient.ts
var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
var import_middleware_logger = require("@aws-sdk/middleware-logger");
var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
var import_middleware_content_length = require("@smithy/middleware-content-length");
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_retry = require("@smithy/middleware-retry");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return Object.assign(options, {
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "kms"
  });
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/KMSClient.ts
var import_runtimeConfig = require("././runtimeConfig");

// src/runtimeExtensions.ts
var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
var import_protocol_http = require("@smithy/protocol-http");
var import_smithy_client = require("@smithy/smithy-client");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((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;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
  const extensionConfiguration = Object.assign(
    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
    getHttpAuthExtensionConfiguration(runtimeConfig)
  );
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return Object.assign(
    runtimeConfig,
    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
    resolveHttpAuthRuntimeConfig(extensionConfiguration)
  );
}, "resolveRuntimeExtensions");

// src/KMSClient.ts
var KMSClient = class extends import_smithy_client.Client {
  static {
    __name(this, "KMSClient");
  }
  /**
   * The resolved configuration of KMSClient class. This is resolved and normalized from the {@link KMSClientConfig | constructor configuration interface}.
   */
  config;
  constructor(...[configuration]) {
    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
    super(_config_0);
    this.initConfig = _config_0;
    const _config_1 = resolveClientEndpointParameters(_config_0);
    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
    this.config = _config_8;
    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultKMSHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials
        }), "identityProviderConfigProvider")
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
  }
  /**
   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
   */
  destroy() {
    super.destroy();
  }
};

// src/KMS.ts


// src/commands/CancelKeyDeletionCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");


// src/protocols/Aws_json1_1.ts
var import_core2 = require("@aws-sdk/core");



// src/models/KMSServiceException.ts

var KMSServiceException = class _KMSServiceException extends import_smithy_client.ServiceException {
  static {
    __name(this, "KMSServiceException");
  }
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _KMSServiceException.prototype);
  }
};

// src/models/models_0.ts

var 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"
};
var AlreadyExistsException = class _AlreadyExistsException extends KMSServiceException {
  static {
    __name(this, "AlreadyExistsException");
  }
  name = "AlreadyExistsException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "AlreadyExistsException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _AlreadyExistsException.prototype);
  }
};
var DependencyTimeoutException = class _DependencyTimeoutException extends KMSServiceException {
  static {
    __name(this, "DependencyTimeoutException");
  }
  name = "DependencyTimeoutException";
  $fault = "server";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DependencyTimeoutException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _DependencyTimeoutException.prototype);
  }
};
var InvalidArnException = class _InvalidArnException extends KMSServiceException {
  static {
    __name(this, "InvalidArnException");
  }
  name = "InvalidArnException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidArnException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidArnException.prototype);
  }
};
var KMSInternalException = class _KMSInternalException extends KMSServiceException {
  static {
    __name(this, "KMSInternalException");
  }
  name = "KMSInternalException";
  $fault = "server";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KMSInternalException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _KMSInternalException.prototype);
  }
};
var KMSInvalidStateException = class _KMSInvalidStateException extends KMSServiceException {
  static {
    __name(this, "KMSInvalidStateException");
  }
  name = "KMSInvalidStateException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KMSInvalidStateException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _KMSInvalidStateException.prototype);
  }
};
var NotFoundException = class _NotFoundException extends KMSServiceException {
  static {
    __name(this, "NotFoundException");
  }
  name = "NotFoundException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "NotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _NotFoundException.prototype);
  }
};
var CloudHsmClusterInUseException = class _CloudHsmClusterInUseException extends KMSServiceException {
  static {
    __name(this, "CloudHsmClusterInUseException");
  }
  name = "CloudHsmClusterInUseException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CloudHsmClusterInUseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CloudHsmClusterInUseException.prototype);
  }
};
var CloudHsmClusterInvalidConfigurationException = class _CloudHsmClusterInvalidConfigurationException extends KMSServiceException {
  static {
    __name(this, "CloudHsmClusterInvalidConfigurationException");
  }
  name = "CloudHsmClusterInvalidConfigurationException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CloudHsmClusterInvalidConfigurationException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CloudHsmClusterInvalidConfigurationException.prototype);
  }
};
var CloudHsmClusterNotActiveException = class _CloudHsmClusterNotActiveException extends KMSServiceException {
  static {
    __name(this, "CloudHsmClusterNotActiveException");
  }
  name = "CloudHsmClusterNotActiveException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CloudHsmClusterNotActiveException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CloudHsmClusterNotActiveException.prototype);
  }
};
var CloudHsmClusterNotFoundException = class _CloudHsmClusterNotFoundException extends KMSServiceException {
  static {
    __name(this, "CloudHsmClusterNotFoundException");
  }
  name = "CloudHsmClusterNotFoundException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CloudHsmClusterNotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CloudHsmClusterNotFoundException.prototype);
  }
};
var CloudHsmClusterNotRelatedException = class _CloudHsmClusterNotRelatedException extends KMSServiceException {
  static {
    __name(this, "CloudHsmClusterNotRelatedException");
  }
  name = "CloudHsmClusterNotRelatedException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CloudHsmClusterNotRelatedException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CloudHsmClusterNotRelatedException.prototype);
  }
};
var ConflictException = class _ConflictException extends KMSServiceException {
  static {
    __name(this, "ConflictException");
  }
  name = "ConflictException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ConflictException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ConflictException.prototype);
  }
};
var CustomKeyStoreInvalidStateException = class _CustomKeyStoreInvalidStateException extends KMSServiceException {
  static {
    __name(this, "CustomKeyStoreInvalidStateException");
  }
  name = "CustomKeyStoreInvalidStateException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CustomKeyStoreInvalidStateException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CustomKeyStoreInvalidStateException.prototype);
  }
};
var CustomKeyStoreNotFoundException = class _CustomKeyStoreNotFoundException extends KMSServiceException {
  static {
    __name(this, "CustomKeyStoreNotFoundException");
  }
  name = "CustomKeyStoreNotFoundException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CustomKeyStoreNotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CustomKeyStoreNotFoundException.prototype);
  }
};
var 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"
};
var ConnectionStateType = {
  CONNECTED: "CONNECTED",
  CONNECTING: "CONNECTING",
  DISCONNECTED: "DISCONNECTED",
  DISCONNECTING: "DISCONNECTING",
  FAILED: "FAILED"
};
var InvalidAliasNameException = class _InvalidAliasNameException extends KMSServiceException {
  static {
    __name(this, "InvalidAliasNameException");
  }
  name = "InvalidAliasNameException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidAliasNameException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidAliasNameException.prototype);
  }
};
var LimitExceededException = class _LimitExceededException extends KMSServiceException {
  static {
    __name(this, "LimitExceededException");
  }
  name = "LimitExceededException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _LimitExceededException.prototype);
  }
};
var CustomKeyStoreType = {
  AWS_CLOUDHSM: "AWS_CLOUDHSM",
  EXTERNAL_KEY_STORE: "EXTERNAL_KEY_STORE"
};
var XksProxyConnectivityType = {
  PUBLIC_ENDPOINT: "PUBLIC_ENDPOINT",
  VPC_ENDPOINT_SERVICE: "VPC_ENDPOINT_SERVICE"
};
var CustomKeyStoreNameInUseException = class _CustomKeyStoreNameInUseException extends KMSServiceException {
  static {
    __name(this, "CustomKeyStoreNameInUseException");
  }
  name = "CustomKeyStoreNameInUseException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CustomKeyStoreNameInUseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CustomKeyStoreNameInUseException.prototype);
  }
};
var IncorrectTrustAnchorException = class _IncorrectTrustAnchorException extends KMSServiceException {
  static {
    __name(this, "IncorrectTrustAnchorException");
  }
  name = "IncorrectTrustAnchorException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "IncorrectTrustAnchorException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _IncorrectTrustAnchorException.prototype);
  }
};
var XksProxyIncorrectAuthenticationCredentialException = class _XksProxyIncorrectAuthenticationCredentialException extends KMSServiceException {
  static {
    __name(this, "XksProxyIncorrectAuthenticationCredentialException");
  }
  name = "XksProxyIncorrectAuthenticationCredentialException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyIncorrectAuthenticationCredentialException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyIncorrectAuthenticationCredentialException.prototype);
  }
};
var XksProxyInvalidConfigurationException = class _XksProxyInvalidConfigurationException extends KMSServiceException {
  static {
    __name(this, "XksProxyInvalidConfigurationException");
  }
  name = "XksProxyInvalidConfigurationException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyInvalidConfigurationException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyInvalidConfigurationException.prototype);
  }
};
var XksProxyInvalidResponseException = class _XksProxyInvalidResponseException extends KMSServiceException {
  static {
    __name(this, "XksProxyInvalidResponseException");
  }
  name = "XksProxyInvalidResponseException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyInvalidResponseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyInvalidResponseException.prototype);
  }
};
var XksProxyUriEndpointInUseException = class _XksProxyUriEndpointInUseException extends KMSServiceException {
  static {
    __name(this, "XksProxyUriEndpointInUseException");
  }
  name = "XksProxyUriEndpointInUseException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyUriEndpointInUseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyUriEndpointInUseException.prototype);
  }
};
var XksProxyUriInUseException = class _XksProxyUriInUseException extends KMSServiceException {
  static {
    __name(this, "XksProxyUriInUseException");
  }
  name = "XksProxyUriInUseException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyUriInUseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyUriInUseException.prototype);
  }
};
var XksProxyUriUnreachableException = class _XksProxyUriUnreachableException extends KMSServiceException {
  static {
    __name(this, "XksProxyUriUnreachableException");
  }
  name = "XksProxyUriUnreachableException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyUriUnreachableException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyUriUnreachableException.prototype);
  }
};
var XksProxyVpcEndpointServiceInUseException = class _XksProxyVpcEndpointServiceInUseException extends KMSServiceException {
  static {
    __name(this, "XksProxyVpcEndpointServiceInUseException");
  }
  name = "XksProxyVpcEndpointServiceInUseException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyVpcEndpointServiceInUseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyVpcEndpointServiceInUseException.prototype);
  }
};
var XksProxyVpcEndpointServiceInvalidConfigurationException = class _XksProxyVpcEndpointServiceInvalidConfigurationException extends KMSServiceException {
  static {
    __name(this, "XksProxyVpcEndpointServiceInvalidConfigurationException");
  }
  name = "XksProxyVpcEndpointServiceInvalidConfigurationException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyVpcEndpointServiceInvalidConfigurationException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyVpcEndpointServiceInvalidConfigurationException.prototype);
  }
};
var XksProxyVpcEndpointServiceNotFoundException = class _XksProxyVpcEndpointServiceNotFoundException extends KMSServiceException {
  static {
    __name(this, "XksProxyVpcEndpointServiceNotFoundException");
  }
  name = "XksProxyVpcEndpointServiceNotFoundException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksProxyVpcEndpointServiceNotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksProxyVpcEndpointServiceNotFoundException.prototype);
  }
};
var 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"
};
var DisabledException = class _DisabledException extends KMSServiceException {
  static {
    __name(this, "DisabledException");
  }
  name = "DisabledException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DisabledException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _DisabledException.prototype);
  }
};
var DryRunOperationException = class _DryRunOperationException extends KMSServiceException {
  static {
    __name(this, "DryRunOperationException");
  }
  name = "DryRunOperationException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DryRunOperationException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _DryRunOperationException.prototype);
  }
};
var InvalidGrantTokenException = class _InvalidGrantTokenException extends KMSServiceException {
  static {
    __name(this, "InvalidGrantTokenException");
  }
  name = "InvalidGrantTokenException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidGrantTokenException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidGrantTokenException.prototype);
  }
};
var 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"
};
var KeySpec = {
  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"
};
var KeyUsageType = {
  ENCRYPT_DECRYPT: "ENCRYPT_DECRYPT",
  GENERATE_VERIFY_MAC: "GENERATE_VERIFY_MAC",
  KEY_AGREEMENT: "KEY_AGREEMENT",
  SIGN_VERIFY: "SIGN_VERIFY"
};
var OriginType = {
  AWS_CLOUDHSM: "AWS_CLOUDHSM",
  AWS_KMS: "AWS_KMS",
  EXTERNAL: "EXTERNAL",
  EXTERNAL_KEY_STORE: "EXTERNAL_KEY_STORE"
};
var EncryptionAlgorithmSpec = {
  RSAES_OAEP_SHA_1: "RSAES_OAEP_SHA_1",
  RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256",
  SM2PKE: "SM2PKE",
  SYMMETRIC_DEFAULT: "SYMMETRIC_DEFAULT"
};
var ExpirationModelType = {
  KEY_MATERIAL_DOES_NOT_EXPIRE: "KEY_MATERIAL_DOES_NOT_EXPIRE",
  KEY_MATERIAL_EXPIRES: "KEY_MATERIAL_EXPIRES"
};
var KeyAgreementAlgorithmSpec = {
  ECDH: "ECDH"
};
var KeyManagerType = {
  AWS: "AWS",
  CUSTOMER: "CUSTOMER"
};
var KeyState = {
  Creating: "Creating",
  Disabled: "Disabled",
  Enabled: "Enabled",
  PendingDeletion: "PendingDeletion",
  PendingImport: "PendingImport",
  PendingReplicaDeletion: "PendingReplicaDeletion",
  Unavailable: "Unavailable",
  Updating: "Updating"
};
var 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"
};
var MultiRegionKeyType = {
  PRIMARY: "PRIMARY",
  REPLICA: "REPLICA"
};
var SigningAlgorithmSpec = {
  ECDSA_SHA_256: "ECDSA_SHA_256",
  ECDSA_SHA_384: "ECDSA_SHA_384",
  ECDSA_SHA_512: "ECDSA_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"
};
var MalformedPolicyDocumentException = class _MalformedPolicyDocumentException extends KMSServiceException {
  static {
    __name(this, "MalformedPolicyDocumentException");
  }
  name = "MalformedPolicyDocumentException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "MalformedPolicyDocumentException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _MalformedPolicyDocumentException.prototype);
  }
};
var TagException = class _TagException extends KMSServiceException {
  static {
    __name(this, "TagException");
  }
  name = "TagException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TagException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _TagException.prototype);
  }
};
var UnsupportedOperationException = class _UnsupportedOperationException extends KMSServiceException {
  static {
    __name(this, "UnsupportedOperationException");
  }
  name = "UnsupportedOperationException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnsupportedOperationException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _UnsupportedOperationException.prototype);
  }
};
var XksKeyAlreadyInUseException = class _XksKeyAlreadyInUseException extends KMSServiceException {
  static {
    __name(this, "XksKeyAlreadyInUseException");
  }
  name = "XksKeyAlreadyInUseException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksKeyAlreadyInUseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksKeyAlreadyInUseException.prototype);
  }
};
var XksKeyInvalidConfigurationException = class _XksKeyInvalidConfigurationException extends KMSServiceException {
  static {
    __name(this, "XksKeyInvalidConfigurationException");
  }
  name = "XksKeyInvalidConfigurationException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksKeyInvalidConfigurationException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksKeyInvalidConfigurationException.prototype);
  }
};
var XksKeyNotFoundException = class _XksKeyNotFoundException extends KMSServiceException {
  static {
    __name(this, "XksKeyNotFoundException");
  }
  name = "XksKeyNotFoundException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "XksKeyNotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _XksKeyNotFoundException.prototype);
  }
};
var CustomKeyStoreHasCMKsException = class _CustomKeyStoreHasCMKsException extends KMSServiceException {
  static {
    __name(this, "CustomKeyStoreHasCMKsException");
  }
  name = "CustomKeyStoreHasCMKsException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CustomKeyStoreHasCMKsException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CustomKeyStoreHasCMKsException.prototype);
  }
};
var DataKeyPairSpec = {
  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"
};
var DataKeySpec = {
  AES_128: "AES_128",
  AES_256: "AES_256"
};
var KeyEncryptionMechanism = {
  RSAES_OAEP_SHA_256: "RSAES_OAEP_SHA_256"
};
var IncorrectKeyException = class _IncorrectKeyException extends KMSServiceException {
  static {
    __name(this, "IncorrectKeyException");
  }
  name = "IncorrectKeyException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "IncorrectKeyException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _IncorrectKeyException.prototype);
  }
};
var InvalidCiphertextException = class _InvalidCiphertextException extends KMSServiceException {
  static {
    __name(this, "InvalidCiphertextException");
  }
  name = "InvalidCiphertextException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidCiphertextException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidCiphertextException.prototype);
  }
};
var InvalidKeyUsageException = class _InvalidKeyUsageException extends KMSServiceException {
  static {
    __name(this, "InvalidKeyUsageException");
  }
  name = "InvalidKeyUsageException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidKeyUsageException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidKeyUsageException.prototype);
  }
};
var KeyUnavailableException = class _KeyUnavailableException extends KMSServiceException {
  static {
    __name(this, "KeyUnavailableException");
  }
  name = "KeyUnavailableException";
  $fault = "server";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KeyUnavailableException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _KeyUnavailableException.prototype);
  }
};
var InvalidMarkerException = class _InvalidMarkerException extends KMSServiceException {
  static {
    __name(this, "InvalidMarkerException");
  }
  name = "InvalidMarkerException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidMarkerException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidMarkerException.prototype);
  }
};
var ExpiredImportTokenException = class _ExpiredImportTokenException extends KMSServiceException {
  static {
    __name(this, "ExpiredImportTokenException");
  }
  name = "ExpiredImportTokenException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ExpiredImportTokenException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ExpiredImportTokenException.prototype);
  }
};
var WrappingKeySpec = {
  RSA_2048: "RSA_2048",
  RSA_3072: "RSA_3072",
  RSA_4096: "RSA_4096",
  SM2: "SM2"
};
var ImportType = {
  EXISTING_KEY_MATERIAL: "EXISTING_KEY_MATERIAL",
  NEW_KEY_MATERIAL: "NEW_KEY_MATERIAL"
};
var IncorrectKeyMaterialException = class _IncorrectKeyMaterialException extends KMSServiceException {
  static {
    __name(this, "IncorrectKeyMaterialException");
  }
  name = "IncorrectKeyMaterialException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "IncorrectKeyMaterialException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _IncorrectKeyMaterialException.prototype);
  }
};
var InvalidImportTokenException = class _InvalidImportTokenException extends KMSServiceException {
  static {
    __name(this, "InvalidImportTokenException");
  }
  name = "InvalidImportTokenException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidImportTokenException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidImportTokenException.prototype);
  }
};
var ImportState = {
  IMPORTED: "IMPORTED",
  PENDING_IMPORT: "PENDING_IMPORT"
};
var IncludeKeyMaterial = {
  ALL_KEY_MATERIAL: "ALL_KEY_MATERIAL",
  ROTATIONS_ONLY: "ROTATIONS_ONLY"
};
var InvalidGrantIdException = class _InvalidGrantIdException extends KMSServiceException {
  static {
    __name(this, "InvalidGrantIdException");
  }
  name = "InvalidGrantIdException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidGrantIdException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidGrantIdException.prototype);
  }
};
var KeyMaterialState = {
  CURRENT: "CURRENT",
  NON_CURRENT: "NON_CURRENT",
  PENDING_ROTATION: "PENDING_ROTATION"
};
var KMSInvalidMacException = class _KMSInvalidMacException extends KMSServiceException {
  static {
    __name(this, "KMSInvalidMacException");
  }
  name = "KMSInvalidMacException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KMSInvalidMacException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _KMSInvalidMacException.prototype);
  }
};
var KMSInvalidSignatureException = class _KMSInvalidSignatureException extends KMSServiceException {
  static {
    __name(this, "KMSInvalidSignatureException");
  }
  name = "KMSInvalidSignatureException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KMSInvalidSignatureException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _KMSInvalidSignatureException.prototype);
  }
};
var RotationType = {
  AUTOMATIC: "AUTOMATIC",
  ON_DEMAND: "ON_DEMAND"
};
var MessageType = {
  DIGEST: "DIGEST",
  EXTERNAL_MU: "EXTERNAL_MU",
  RAW: "RAW"
};
var XksProxyAuthenticationCredentialTypeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.AccessKeyId && { AccessKeyId: import_smithy_client.SENSITIVE_STRING },
  ...obj.RawSecretAccessKey && { RawSecretAccessKey: import_smithy_client.SENSITIVE_STRING }
}), "XksProxyAuthenticationCredentialTypeFilterSensitiveLog");
var CreateCustomKeyStoreRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.KeyStorePassword && { KeyStorePassword: import_smithy_client.SENSITIVE_STRING },
  ...obj.XksProxyAuthenticationCredential && {
    XksProxyAuthenticationCredential: XksProxyAuthenticationCredentialTypeFilterSensitiveLog(
      obj.XksProxyAuthenticationCredential
    )
  }
}), "CreateCustomKeyStoreRequestFilterSensitiveLog");
var XksProxyConfigurationTypeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.AccessKeyId && { AccessKeyId: import_smithy_client.SENSITIVE_STRING }
}), "XksProxyConfigurationTypeFilterSensitiveLog");
var CustomKeyStoresListEntryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.XksProxyConfiguration && {
    XksProxyConfiguration: XksProxyConfigurationTypeFilterSensitiveLog(obj.XksProxyConfiguration)
  }
}), "CustomKeyStoresListEntryFilterSensitiveLog");
var DecryptResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Plaintext && { Plaintext: import_smithy_client.SENSITIVE_STRING }
}), "DecryptResponseFilterSensitiveLog");
var DeriveSharedSecretResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.SharedSecret && { SharedSecret: import_smithy_client.SENSITIVE_STRING }
}), "DeriveSharedSecretResponseFilterSensitiveLog");
var DescribeCustomKeyStoresResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.CustomKeyStores && {
    CustomKeyStores: obj.CustomKeyStores.map((item) => CustomKeyStoresListEntryFilterSensitiveLog(item))
  }
}), "DescribeCustomKeyStoresResponseFilterSensitiveLog");
var EncryptRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Plaintext && { Plaintext: import_smithy_client.SENSITIVE_STRING }
}), "EncryptRequestFilterSensitiveLog");
var GenerateDataKeyResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Plaintext && { Plaintext: import_smithy_client.SENSITIVE_STRING }
}), "GenerateDataKeyResponseFilterSensitiveLog");
var GenerateDataKeyPairResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.PrivateKeyPlaintext && { PrivateKeyPlaintext: import_smithy_client.SENSITIVE_STRING }
}), "GenerateDataKeyPairResponseFilterSensitiveLog");
var GenerateMacRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Message && { Message: import_smithy_client.SENSITIVE_STRING }
}), "GenerateMacRequestFilterSensitiveLog");
var GenerateRandomResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Plaintext && { Plaintext: import_smithy_client.SENSITIVE_STRING }
}), "GenerateRandomResponseFilterSensitiveLog");
var GetParametersForImportResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.PublicKey && { PublicKey: import_smithy_client.SENSITIVE_STRING }
}), "GetParametersForImportResponseFilterSensitiveLog");
var SignRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Message && { Message: import_smithy_client.SENSITIVE_STRING }
}), "SignRequestFilterSensitiveLog");
var UpdateCustomKeyStoreRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.KeyStorePassword && { KeyStorePassword: import_smithy_client.SENSITIVE_STRING },
  ...obj.XksProxyAuthenticationCredential && {
    XksProxyAuthenticationCredential: XksProxyAuthenticationCredentialTypeFilterSensitiveLog(
      obj.