@aws-sdk/client-payment-cryptography-data 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,1882 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaymentCryptographyDataServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./PaymentCryptographyDataClient"), exports);
-tslib_1.__exportStar(require("./PaymentCryptographyData"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var PaymentCryptographyDataServiceException_1 = require("./models/PaymentCryptographyDataServiceException");
-Object.defineProperty(exports, "PaymentCryptographyDataServiceException", { enumerable: true, get: function () { return PaymentCryptographyDataServiceException_1.PaymentCryptographyDataServiceException; } });
+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 src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  CardGenerationAttributes: () => CardGenerationAttributes,
+  CardVerificationAttributes: () => CardVerificationAttributes,
+  CryptogramAuthResponse: () => CryptogramAuthResponse,
+  DecryptDataCommand: () => DecryptDataCommand,
+  DecryptDataInputFilterSensitiveLog: () => DecryptDataInputFilterSensitiveLog,
+  DecryptDataOutputFilterSensitiveLog: () => DecryptDataOutputFilterSensitiveLog,
+  DukptDerivationType: () => DukptDerivationType,
+  DukptEncryptionAttributesFilterSensitiveLog: () => DukptEncryptionAttributesFilterSensitiveLog,
+  DukptEncryptionMode: () => DukptEncryptionMode,
+  DukptKeyVariant: () => DukptKeyVariant,
+  EncryptDataCommand: () => EncryptDataCommand,
+  EncryptDataInputFilterSensitiveLog: () => EncryptDataInputFilterSensitiveLog,
+  EncryptDataOutputFilterSensitiveLog: () => EncryptDataOutputFilterSensitiveLog,
+  EncryptionDecryptionAttributes: () => EncryptionDecryptionAttributes,
+  EncryptionDecryptionAttributesFilterSensitiveLog: () => EncryptionDecryptionAttributesFilterSensitiveLog,
+  EncryptionMode: () => EncryptionMode,
+  GenerateCardValidationDataCommand: () => GenerateCardValidationDataCommand,
+  GenerateCardValidationDataInputFilterSensitiveLog: () => GenerateCardValidationDataInputFilterSensitiveLog,
+  GenerateMacCommand: () => GenerateMacCommand,
+  GenerateMacInputFilterSensitiveLog: () => GenerateMacInputFilterSensitiveLog,
+  GeneratePinDataCommand: () => GeneratePinDataCommand,
+  GeneratePinDataInputFilterSensitiveLog: () => GeneratePinDataInputFilterSensitiveLog,
+  InternalServerException: () => InternalServerException,
+  MacAlgorithm: () => MacAlgorithm,
+  MacAlgorithmEmvFilterSensitiveLog: () => MacAlgorithmEmvFilterSensitiveLog,
+  MacAttributes: () => MacAttributes,
+  MacAttributesFilterSensitiveLog: () => MacAttributesFilterSensitiveLog,
+  MajorKeyDerivationMode: () => MajorKeyDerivationMode,
+  PaddingType: () => PaddingType,
+  PaymentCryptographyData: () => PaymentCryptographyData,
+  PaymentCryptographyDataClient: () => PaymentCryptographyDataClient,
+  PaymentCryptographyDataServiceException: () => PaymentCryptographyDataServiceException,
+  PinBlockFormatForPinData: () => PinBlockFormatForPinData,
+  PinData: () => PinData,
+  PinGenerationAttributes: () => PinGenerationAttributes,
+  PinVerificationAttributes: () => PinVerificationAttributes,
+  ReEncryptDataCommand: () => ReEncryptDataCommand,
+  ReEncryptDataInputFilterSensitiveLog: () => ReEncryptDataInputFilterSensitiveLog,
+  ReEncryptDataOutputFilterSensitiveLog: () => ReEncryptDataOutputFilterSensitiveLog,
+  ReEncryptionAttributes: () => ReEncryptionAttributes,
+  ReEncryptionAttributesFilterSensitiveLog: () => ReEncryptionAttributesFilterSensitiveLog,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SessionKeyAmexFilterSensitiveLog: () => SessionKeyAmexFilterSensitiveLog,
+  SessionKeyDerivation: () => SessionKeyDerivation,
+  SessionKeyDerivationFilterSensitiveLog: () => SessionKeyDerivationFilterSensitiveLog,
+  SessionKeyDerivationMode: () => SessionKeyDerivationMode,
+  SessionKeyDerivationValue: () => SessionKeyDerivationValue,
+  SessionKeyEmv2000FilterSensitiveLog: () => SessionKeyEmv2000FilterSensitiveLog,
+  SessionKeyEmvCommonFilterSensitiveLog: () => SessionKeyEmvCommonFilterSensitiveLog,
+  SessionKeyMastercardFilterSensitiveLog: () => SessionKeyMastercardFilterSensitiveLog,
+  SessionKeyVisaFilterSensitiveLog: () => SessionKeyVisaFilterSensitiveLog,
+  SymmetricEncryptionAttributesFilterSensitiveLog: () => SymmetricEncryptionAttributesFilterSensitiveLog,
+  ThrottlingException: () => ThrottlingException,
+  TranslatePinDataCommand: () => TranslatePinDataCommand,
+  TranslatePinDataInputFilterSensitiveLog: () => TranslatePinDataInputFilterSensitiveLog,
+  TranslationIsoFormats: () => TranslationIsoFormats,
+  TranslationIsoFormatsFilterSensitiveLog: () => TranslationIsoFormatsFilterSensitiveLog,
+  TranslationPinDataIsoFormat034FilterSensitiveLog: () => TranslationPinDataIsoFormat034FilterSensitiveLog,
+  ValidationException: () => ValidationException,
+  VerificationFailedException: () => VerificationFailedException,
+  VerificationFailedReason: () => VerificationFailedReason,
+  VerifyAuthRequestCryptogramCommand: () => VerifyAuthRequestCryptogramCommand,
+  VerifyAuthRequestCryptogramInputFilterSensitiveLog: () => VerifyAuthRequestCryptogramInputFilterSensitiveLog,
+  VerifyCardValidationDataCommand: () => VerifyCardValidationDataCommand,
+  VerifyCardValidationDataInputFilterSensitiveLog: () => VerifyCardValidationDataInputFilterSensitiveLog,
+  VerifyMacCommand: () => VerifyMacCommand,
+  VerifyMacInputFilterSensitiveLog: () => VerifyMacInputFilterSensitiveLog,
+  VerifyPinDataCommand: () => VerifyPinDataCommand,
+  VerifyPinDataInputFilterSensitiveLog: () => VerifyPinDataInputFilterSensitiveLog,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/PaymentCryptographyDataClient.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_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+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");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "payment-cryptography"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/PaymentCryptographyDataClient.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");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/PaymentCryptographyDataClient.ts
+var _PaymentCryptographyDataClient = class _PaymentCryptographyDataClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    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_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(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();
+  }
+};
+__name(_PaymentCryptographyDataClient, "PaymentCryptographyDataClient");
+var PaymentCryptographyDataClient = _PaymentCryptographyDataClient;
+
+// src/PaymentCryptographyData.ts
+
+
+// src/commands/DecryptDataCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/models/models_0.ts
+
+
+// src/models/PaymentCryptographyDataServiceException.ts
+
+var _PaymentCryptographyDataServiceException = class _PaymentCryptographyDataServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _PaymentCryptographyDataServiceException.prototype);
+  }
+};
+__name(_PaymentCryptographyDataServiceException, "PaymentCryptographyDataServiceException");
+var PaymentCryptographyDataServiceException = _PaymentCryptographyDataServiceException;
+
+// src/models/models_0.ts
+var _AccessDeniedException = class _AccessDeniedException extends PaymentCryptographyDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var PaddingType = {
+  OAEP_SHA1: "OAEP_SHA1",
+  OAEP_SHA256: "OAEP_SHA256",
+  OAEP_SHA512: "OAEP_SHA512",
+  PKCS1: "PKCS1"
+};
+var CardGenerationAttributes;
+((CardGenerationAttributes3) => {
+  CardGenerationAttributes3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.AmexCardSecurityCodeVersion1 !== void 0)
+      return visitor.AmexCardSecurityCodeVersion1(value.AmexCardSecurityCodeVersion1);
+    if (value.AmexCardSecurityCodeVersion2 !== void 0)
+      return visitor.AmexCardSecurityCodeVersion2(value.AmexCardSecurityCodeVersion2);
+    if (value.CardVerificationValue1 !== void 0)
+      return visitor.CardVerificationValue1(value.CardVerificationValue1);
+    if (value.CardVerificationValue2 !== void 0)
+      return visitor.CardVerificationValue2(value.CardVerificationValue2);
+    if (value.CardHolderVerificationValue !== void 0)
+      return visitor.CardHolderVerificationValue(value.CardHolderVerificationValue);
+    if (value.DynamicCardVerificationCode !== void 0)
+      return visitor.DynamicCardVerificationCode(value.DynamicCardVerificationCode);
+    if (value.DynamicCardVerificationValue !== void 0)
+      return visitor.DynamicCardVerificationValue(value.DynamicCardVerificationValue);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(CardGenerationAttributes || (CardGenerationAttributes = {}));
+var CardVerificationAttributes;
+((CardVerificationAttributes3) => {
+  CardVerificationAttributes3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.AmexCardSecurityCodeVersion1 !== void 0)
+      return visitor.AmexCardSecurityCodeVersion1(value.AmexCardSecurityCodeVersion1);
+    if (value.AmexCardSecurityCodeVersion2 !== void 0)
+      return visitor.AmexCardSecurityCodeVersion2(value.AmexCardSecurityCodeVersion2);
+    if (value.CardVerificationValue1 !== void 0)
+      return visitor.CardVerificationValue1(value.CardVerificationValue1);
+    if (value.CardVerificationValue2 !== void 0)
+      return visitor.CardVerificationValue2(value.CardVerificationValue2);
+    if (value.CardHolderVerificationValue !== void 0)
+      return visitor.CardHolderVerificationValue(value.CardHolderVerificationValue);
+    if (value.DynamicCardVerificationCode !== void 0)
+      return visitor.DynamicCardVerificationCode(value.DynamicCardVerificationCode);
+    if (value.DynamicCardVerificationValue !== void 0)
+      return visitor.DynamicCardVerificationValue(value.DynamicCardVerificationValue);
+    if (value.DiscoverDynamicCardVerificationCode !== void 0)
+      return visitor.DiscoverDynamicCardVerificationCode(value.DiscoverDynamicCardVerificationCode);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(CardVerificationAttributes || (CardVerificationAttributes = {}));
+var CryptogramAuthResponse;
+((CryptogramAuthResponse3) => {
+  CryptogramAuthResponse3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.ArpcMethod1 !== void 0)
+      return visitor.ArpcMethod1(value.ArpcMethod1);
+    if (value.ArpcMethod2 !== void 0)
+      return visitor.ArpcMethod2(value.ArpcMethod2);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(CryptogramAuthResponse || (CryptogramAuthResponse = {}));
+var DukptDerivationType = {
+  AES_128: "AES_128",
+  AES_192: "AES_192",
+  AES_256: "AES_256",
+  TDES_2KEY: "TDES_2KEY",
+  TDES_3KEY: "TDES_3KEY"
+};
+var DukptKeyVariant = {
+  BIDIRECTIONAL: "BIDIRECTIONAL",
+  REQUEST: "REQUEST",
+  RESPONSE: "RESPONSE"
+};
+var DukptEncryptionMode = {
+  CBC: "CBC",
+  ECB: "ECB"
+};
+var EncryptionMode = {
+  CBC: "CBC",
+  CFB: "CFB",
+  CFB1: "CFB1",
+  CFB128: "CFB128",
+  CFB64: "CFB64",
+  CFB8: "CFB8",
+  ECB: "ECB",
+  OFB: "OFB"
+};
+var EncryptionDecryptionAttributes;
+((EncryptionDecryptionAttributes3) => {
+  EncryptionDecryptionAttributes3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.Symmetric !== void 0)
+      return visitor.Symmetric(value.Symmetric);
+    if (value.Asymmetric !== void 0)
+      return visitor.Asymmetric(value.Asymmetric);
+    if (value.Dukpt !== void 0)
+      return visitor.Dukpt(value.Dukpt);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(EncryptionDecryptionAttributes || (EncryptionDecryptionAttributes = {}));
+var _InternalServerException = class _InternalServerException extends PaymentCryptographyDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends PaymentCryptographyDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.ResourceId = opts.ResourceId;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ThrottlingException = class _ThrottlingException extends PaymentCryptographyDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends PaymentCryptographyDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.fieldList = opts.fieldList;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var MacAlgorithm = {
+  CMAC: "CMAC",
+  HMAC_SHA224: "HMAC_SHA224",
+  HMAC_SHA256: "HMAC_SHA256",
+  HMAC_SHA384: "HMAC_SHA384",
+  HMAC_SHA512: "HMAC_SHA512",
+  ISO9797_ALGORITHM1: "ISO9797_ALGORITHM1",
+  ISO9797_ALGORITHM3: "ISO9797_ALGORITHM3"
+};
+var MajorKeyDerivationMode = {
+  EMV_OPTION_A: "EMV_OPTION_A",
+  EMV_OPTION_B: "EMV_OPTION_B"
+};
+var SessionKeyDerivationMode = {
+  AMEX: "AMEX",
+  EMV2000: "EMV2000",
+  EMV_COMMON_SESSION_KEY: "EMV_COMMON_SESSION_KEY",
+  MASTERCARD_SESSION_KEY: "MASTERCARD_SESSION_KEY",
+  VISA: "VISA"
+};
+var SessionKeyDerivationValue;
+((SessionKeyDerivationValue3) => {
+  SessionKeyDerivationValue3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.ApplicationCryptogram !== void 0)
+      return visitor.ApplicationCryptogram(value.ApplicationCryptogram);
+    if (value.ApplicationTransactionCounter !== void 0)
+      return visitor.ApplicationTransactionCounter(value.ApplicationTransactionCounter);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(SessionKeyDerivationValue || (SessionKeyDerivationValue = {}));
+var MacAttributes;
+((MacAttributes3) => {
+  MacAttributes3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.Algorithm !== void 0)
+      return visitor.Algorithm(value.Algorithm);
+    if (value.EmvMac !== void 0)
+      return visitor.EmvMac(value.EmvMac);
+    if (value.DukptIso9797Algorithm1 !== void 0)
+      return visitor.DukptIso9797Algorithm1(value.DukptIso9797Algorithm1);
+    if (value.DukptIso9797Algorithm3 !== void 0)
+      return visitor.DukptIso9797Algorithm3(value.DukptIso9797Algorithm3);
+    if (value.DukptCmac !== void 0)
+      return visitor.DukptCmac(value.DukptCmac);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(MacAttributes || (MacAttributes = {}));
+var PinGenerationAttributes;
+((PinGenerationAttributes3) => {
+  PinGenerationAttributes3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.VisaPin !== void 0)
+      return visitor.VisaPin(value.VisaPin);
+    if (value.VisaPinVerificationValue !== void 0)
+      return visitor.VisaPinVerificationValue(value.VisaPinVerificationValue);
+    if (value.Ibm3624PinOffset !== void 0)
+      return visitor.Ibm3624PinOffset(value.Ibm3624PinOffset);
+    if (value.Ibm3624NaturalPin !== void 0)
+      return visitor.Ibm3624NaturalPin(value.Ibm3624NaturalPin);
+    if (value.Ibm3624RandomPin !== void 0)
+      return visitor.Ibm3624RandomPin(value.Ibm3624RandomPin);
+    if (value.Ibm3624PinFromOffset !== void 0)
+      return visitor.Ibm3624PinFromOffset(value.Ibm3624PinFromOffset);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(PinGenerationAttributes || (PinGenerationAttributes = {}));
+var PinBlockFormatForPinData = {
+  ISO_FORMAT_0: "ISO_FORMAT_0",
+  ISO_FORMAT_3: "ISO_FORMAT_3"
+};
+var PinData;
+((PinData2) => {
+  PinData2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.PinOffset !== void 0)
+      return visitor.PinOffset(value.PinOffset);
+    if (value.VerificationValue !== void 0)
+      return visitor.VerificationValue(value.VerificationValue);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(PinData || (PinData = {}));
+var ReEncryptionAttributes;
+((ReEncryptionAttributes3) => {
+  ReEncryptionAttributes3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.Symmetric !== void 0)
+      return visitor.Symmetric(value.Symmetric);
+    if (value.Dukpt !== void 0)
+      return visitor.Dukpt(value.Dukpt);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ReEncryptionAttributes || (ReEncryptionAttributes = {}));
+var TranslationIsoFormats;
+((TranslationIsoFormats3) => {
+  TranslationIsoFormats3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.IsoFormat0 !== void 0)
+      return visitor.IsoFormat0(value.IsoFormat0);
+    if (value.IsoFormat1 !== void 0)
+      return visitor.IsoFormat1(value.IsoFormat1);
+    if (value.IsoFormat3 !== void 0)
+      return visitor.IsoFormat3(value.IsoFormat3);
+    if (value.IsoFormat4 !== void 0)
+      return visitor.IsoFormat4(value.IsoFormat4);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(TranslationIsoFormats || (TranslationIsoFormats = {}));
+var VerificationFailedReason = {
+  INVALID_AUTH_REQUEST_CRYPTOGRAM: "INVALID_AUTH_REQUEST_CRYPTOGRAM",
+  INVALID_MAC: "INVALID_MAC",
+  INVALID_PIN: "INVALID_PIN",
+  INVALID_VALIDATION_DATA: "INVALID_VALIDATION_DATA"
+};
+var _VerificationFailedException = class _VerificationFailedException extends PaymentCryptographyDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "VerificationFailedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "VerificationFailedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _VerificationFailedException.prototype);
+    this.Reason = opts.Reason;
+    this.Message = opts.Message;
+  }
+};
+__name(_VerificationFailedException, "VerificationFailedException");
+var VerificationFailedException = _VerificationFailedException;
+var SessionKeyDerivation;
+((SessionKeyDerivation3) => {
+  SessionKeyDerivation3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.EmvCommon !== void 0)
+      return visitor.EmvCommon(value.EmvCommon);
+    if (value.Mastercard !== void 0)
+      return visitor.Mastercard(value.Mastercard);
+    if (value.Emv2000 !== void 0)
+      return visitor.Emv2000(value.Emv2000);
+    if (value.Amex !== void 0)
+      return visitor.Amex(value.Amex);
+    if (value.Visa !== void 0)
+      return visitor.Visa(value.Visa);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(SessionKeyDerivation || (SessionKeyDerivation = {}));
+var PinVerificationAttributes;
+((PinVerificationAttributes3) => {
+  PinVerificationAttributes3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.VisaPin !== void 0)
+      return visitor.VisaPin(value.VisaPin);
+    if (value.Ibm3624Pin !== void 0)
+      return visitor.Ibm3624Pin(value.Ibm3624Pin);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(PinVerificationAttributes || (PinVerificationAttributes = {}));
+var DukptEncryptionAttributesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.InitializationVector && { InitializationVector: import_smithy_client.SENSITIVE_STRING }
+}), "DukptEncryptionAttributesFilterSensitiveLog");
+var SymmetricEncryptionAttributesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.InitializationVector && { InitializationVector: import_smithy_client.SENSITIVE_STRING }
+}), "SymmetricEncryptionAttributesFilterSensitiveLog");
+var EncryptionDecryptionAttributesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.Symmetric !== void 0)
+    return { Symmetric: SymmetricEncryptionAttributesFilterSensitiveLog(obj.Symmetric) };
+  if (obj.Asymmetric !== void 0)
+    return { Asymmetric: obj.Asymmetric };
+  if (obj.Dukpt !== void 0)
+    return { Dukpt: DukptEncryptionAttributesFilterSensitiveLog(obj.Dukpt) };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "EncryptionDecryptionAttributesFilterSensitiveLog");
+var DecryptDataInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.CipherText && { CipherText: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DecryptionAttributes && {
+    DecryptionAttributes: EncryptionDecryptionAttributesFilterSensitiveLog(obj.DecryptionAttributes)
+  }
+}), "DecryptDataInputFilterSensitiveLog");
+var DecryptDataOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PlainText && { PlainText: import_smithy_client.SENSITIVE_STRING }
+}), "DecryptDataOutputFilterSensitiveLog");
+var EncryptDataInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PlainText && { PlainText: import_smithy_client.SENSITIVE_STRING },
+  ...obj.EncryptionAttributes && {
+    EncryptionAttributes: EncryptionDecryptionAttributesFilterSensitiveLog(obj.EncryptionAttributes)
+  }
+}), "EncryptDataInputFilterSensitiveLog");
+var EncryptDataOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.CipherText && { CipherText: import_smithy_client.SENSITIVE_STRING }
+}), "EncryptDataOutputFilterSensitiveLog");
+var GenerateCardValidationDataInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING },
+  ...obj.GenerationAttributes && { GenerationAttributes: obj.GenerationAttributes }
+}), "GenerateCardValidationDataInputFilterSensitiveLog");
+var MacAlgorithmEmvFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SessionKeyDerivationValue && { SessionKeyDerivationValue: obj.SessionKeyDerivationValue }
+}), "MacAlgorithmEmvFilterSensitiveLog");
+var MacAttributesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.Algorithm !== void 0)
+    return { Algorithm: obj.Algorithm };
+  if (obj.EmvMac !== void 0)
+    return { EmvMac: MacAlgorithmEmvFilterSensitiveLog(obj.EmvMac) };
+  if (obj.DukptIso9797Algorithm1 !== void 0)
+    return { DukptIso9797Algorithm1: obj.DukptIso9797Algorithm1 };
+  if (obj.DukptIso9797Algorithm3 !== void 0)
+    return { DukptIso9797Algorithm3: obj.DukptIso9797Algorithm3 };
+  if (obj.DukptCmac !== void 0)
+    return { DukptCmac: obj.DukptCmac };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "MacAttributesFilterSensitiveLog");
+var GenerateMacInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.MessageData && { MessageData: import_smithy_client.SENSITIVE_STRING },
+  ...obj.GenerationAttributes && { GenerationAttributes: MacAttributesFilterSensitiveLog(obj.GenerationAttributes) }
+}), "GenerateMacInputFilterSensitiveLog");
+var GeneratePinDataInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.GenerationAttributes && { GenerationAttributes: obj.GenerationAttributes },
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING }
+}), "GeneratePinDataInputFilterSensitiveLog");
+var ReEncryptionAttributesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.Symmetric !== void 0)
+    return { Symmetric: SymmetricEncryptionAttributesFilterSensitiveLog(obj.Symmetric) };
+  if (obj.Dukpt !== void 0)
+    return { Dukpt: DukptEncryptionAttributesFilterSensitiveLog(obj.Dukpt) };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "ReEncryptionAttributesFilterSensitiveLog");
+var ReEncryptDataInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.CipherText && { CipherText: import_smithy_client.SENSITIVE_STRING },
+  ...obj.IncomingEncryptionAttributes && {
+    IncomingEncryptionAttributes: ReEncryptionAttributesFilterSensitiveLog(obj.IncomingEncryptionAttributes)
+  },
+  ...obj.OutgoingEncryptionAttributes && {
+    OutgoingEncryptionAttributes: ReEncryptionAttributesFilterSensitiveLog(obj.OutgoingEncryptionAttributes)
+  }
+}), "ReEncryptDataInputFilterSensitiveLog");
+var ReEncryptDataOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.CipherText && { CipherText: import_smithy_client.SENSITIVE_STRING }
+}), "ReEncryptDataOutputFilterSensitiveLog");
+var TranslationPinDataIsoFormat034FilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING }
+}), "TranslationPinDataIsoFormat034FilterSensitiveLog");
+var TranslationIsoFormatsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.IsoFormat0 !== void 0)
+    return { IsoFormat0: TranslationPinDataIsoFormat034FilterSensitiveLog(obj.IsoFormat0) };
+  if (obj.IsoFormat1 !== void 0)
+    return { IsoFormat1: obj.IsoFormat1 };
+  if (obj.IsoFormat3 !== void 0)
+    return { IsoFormat3: TranslationPinDataIsoFormat034FilterSensitiveLog(obj.IsoFormat3) };
+  if (obj.IsoFormat4 !== void 0)
+    return { IsoFormat4: TranslationPinDataIsoFormat034FilterSensitiveLog(obj.IsoFormat4) };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "TranslationIsoFormatsFilterSensitiveLog");
+var TranslatePinDataInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.IncomingTranslationAttributes && {
+    IncomingTranslationAttributes: TranslationIsoFormatsFilterSensitiveLog(obj.IncomingTranslationAttributes)
+  },
+  ...obj.OutgoingTranslationAttributes && {
+    OutgoingTranslationAttributes: TranslationIsoFormatsFilterSensitiveLog(obj.OutgoingTranslationAttributes)
+  },
+  ...obj.EncryptedPinBlock && { EncryptedPinBlock: import_smithy_client.SENSITIVE_STRING }
+}), "TranslatePinDataInputFilterSensitiveLog");
+var SessionKeyAmexFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING }
+}), "SessionKeyAmexFilterSensitiveLog");
+var SessionKeyEmv2000FilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING }
+}), "SessionKeyEmv2000FilterSensitiveLog");
+var SessionKeyEmvCommonFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING }
+}), "SessionKeyEmvCommonFilterSensitiveLog");
+var SessionKeyMastercardFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING }
+}), "SessionKeyMastercardFilterSensitiveLog");
+var SessionKeyVisaFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING }
+}), "SessionKeyVisaFilterSensitiveLog");
+var SessionKeyDerivationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.EmvCommon !== void 0)
+    return { EmvCommon: SessionKeyEmvCommonFilterSensitiveLog(obj.EmvCommon) };
+  if (obj.Mastercard !== void 0)
+    return { Mastercard: SessionKeyMastercardFilterSensitiveLog(obj.Mastercard) };
+  if (obj.Emv2000 !== void 0)
+    return { Emv2000: SessionKeyEmv2000FilterSensitiveLog(obj.Emv2000) };
+  if (obj.Amex !== void 0)
+    return { Amex: SessionKeyAmexFilterSensitiveLog(obj.Amex) };
+  if (obj.Visa !== void 0)
+    return { Visa: SessionKeyVisaFilterSensitiveLog(obj.Visa) };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "SessionKeyDerivationFilterSensitiveLog");
+var VerifyAuthRequestCryptogramInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.SessionKeyDerivationAttributes && {
+    SessionKeyDerivationAttributes: SessionKeyDerivationFilterSensitiveLog(obj.SessionKeyDerivationAttributes)
+  },
+  ...obj.AuthResponseAttributes && { AuthResponseAttributes: obj.AuthResponseAttributes }
+}), "VerifyAuthRequestCryptogramInputFilterSensitiveLog");
+var VerifyCardValidationDataInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING },
+  ...obj.VerificationAttributes && { VerificationAttributes: obj.VerificationAttributes }
+}), "VerifyCardValidationDataInputFilterSensitiveLog");
+var VerifyMacInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.MessageData && { MessageData: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Mac && { Mac: import_smithy_client.SENSITIVE_STRING },
+  ...obj.VerificationAttributes && {
+    VerificationAttributes: MacAttributesFilterSensitiveLog(obj.VerificationAttributes)
+  }
+}), "VerifyMacInputFilterSensitiveLog");
+var VerifyPinDataInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.VerificationAttributes && { VerificationAttributes: obj.VerificationAttributes },
+  ...obj.PrimaryAccountNumber && { PrimaryAccountNumber: import_smithy_client.SENSITIVE_STRING }
+}), "VerifyPinDataInputFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@aws-sdk/core");
+var import_core2 = require("@smithy/core");
+
+var se_DecryptDataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/keys/{KeyIdentifier}/decrypt");
+  b.p("KeyIdentifier", () => input.KeyIdentifier, "{KeyIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      CipherText: [],
+      DecryptionAttributes: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DecryptDataCommand");
+var se_EncryptDataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/keys/{KeyIdentifier}/encrypt");
+  b.p("KeyIdentifier", () => input.KeyIdentifier, "{KeyIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EncryptionAttributes: (_) => (0, import_smithy_client._json)(_),
+      PlainText: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_EncryptDataCommand");
+var se_GenerateCardValidationDataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/cardvalidationdata/generate");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      GenerationAttributes: (_) => (0, import_smithy_client._json)(_),
+      KeyIdentifier: [],
+      PrimaryAccountNumber: [],
+      ValidationDataLength: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GenerateCardValidationDataCommand");
+var se_GenerateMacCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/mac/generate");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      GenerationAttributes: (_) => (0, import_smithy_client._json)(_),
+      KeyIdentifier: [],
+      MacLength: [],
+      MessageData: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GenerateMacCommand");
+var se_GeneratePinDataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/pindata/generate");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EncryptionKeyIdentifier: [],
+      GenerationAttributes: (_) => (0, import_smithy_client._json)(_),
+      GenerationKeyIdentifier: [],
+      PinBlockFormat: [],
+      PinDataLength: [],
+      PrimaryAccountNumber: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GeneratePinDataCommand");
+var se_ReEncryptDataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/keys/{IncomingKeyIdentifier}/reencrypt");
+  b.p("IncomingKeyIdentifier", () => input.IncomingKeyIdentifier, "{IncomingKeyIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      CipherText: [],
+      IncomingEncryptionAttributes: (_) => (0, import_smithy_client._json)(_),
+      OutgoingEncryptionAttributes: (_) => (0, import_smithy_client._json)(_),
+      OutgoingKeyIdentifier: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ReEncryptDataCommand");
+var se_TranslatePinDataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/pindata/translate");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EncryptedPinBlock: [],
+      IncomingDukptAttributes: (_) => (0, import_smithy_client._json)(_),
+      IncomingKeyIdentifier: [],
+      IncomingTranslationAttributes: (_) => (0, import_smithy_client._json)(_),
+      OutgoingDukptAttributes: (_) => (0, import_smithy_client._json)(_),
+      OutgoingKeyIdentifier: [],
+      OutgoingTranslationAttributes: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TranslatePinDataCommand");
+var se_VerifyAuthRequestCryptogramCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/cryptogram/verify");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      AuthRequestCryptogram: [],
+      AuthResponseAttributes: (_) => (0, import_smithy_client._json)(_),
+      KeyIdentifier: [],
+      MajorKeyDerivationMode: [],
+      SessionKeyDerivationAttributes: (_) => (0, import_smithy_client._json)(_),
+      TransactionData: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_VerifyAuthRequestCryptogramCommand");
+var se_VerifyCardValidationDataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/cardvalidationdata/verify");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      KeyIdentifier: [],
+      PrimaryAccountNumber: [],
+      ValidationData: [],
+      VerificationAttributes: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_VerifyCardValidationDataCommand");
+var se_VerifyMacCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/mac/verify");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      KeyIdentifier: [],
+      Mac: [],
+      MacLength: [],
+      MessageData: [],
+      VerificationAttributes: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_VerifyMacCommand");
+var se_VerifyPinDataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/pindata/verify");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      DukptAttributes: (_) => (0, import_smithy_client._json)(_),
+      EncryptedPinBlock: [],
+      EncryptionKeyIdentifier: [],
+      PinBlockFormat: [],
+      PinDataLength: [],
+      PrimaryAccountNumber: [],
+      VerificationAttributes: (_) => (0, import_smithy_client._json)(_),
+      VerificationKeyIdentifier: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_VerifyPinDataCommand");
+var de_DecryptDataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DecryptDataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString,
+    PlainText: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DecryptDataCommand");
+var de_DecryptDataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DecryptDataCommandError");
+var de_EncryptDataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_EncryptDataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CipherText: import_smithy_client.expectString,
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_EncryptDataCommand");
+var de_EncryptDataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_EncryptDataCommandError");
+var de_GenerateCardValidationDataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GenerateCardValidationDataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString,
+    ValidationData: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GenerateCardValidationDataCommand");
+var de_GenerateCardValidationDataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GenerateCardValidationDataCommandError");
+var de_GenerateMacCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GenerateMacCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString,
+    Mac: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GenerateMacCommand");
+var de_GenerateMacCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GenerateMacCommandError");
+var de_GeneratePinDataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GeneratePinDataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    EncryptedPinBlock: import_smithy_client.expectString,
+    EncryptionKeyArn: import_smithy_client.expectString,
+    EncryptionKeyCheckValue: import_smithy_client.expectString,
+    GenerationKeyArn: import_smithy_client.expectString,
+    GenerationKeyCheckValue: import_smithy_client.expectString,
+    PinData: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GeneratePinDataCommand");
+var de_GeneratePinDataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GeneratePinDataCommandError");
+var de_ReEncryptDataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ReEncryptDataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CipherText: import_smithy_client.expectString,
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ReEncryptDataCommand");
+var de_ReEncryptDataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ReEncryptDataCommandError");
+var de_TranslatePinDataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TranslatePinDataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString,
+    PinBlock: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_TranslatePinDataCommand");
+var de_TranslatePinDataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TranslatePinDataCommandError");
+var de_VerifyAuthRequestCryptogramCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_VerifyAuthRequestCryptogramCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    AuthResponseValue: import_smithy_client.expectString,
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_VerifyAuthRequestCryptogramCommand");
+var de_VerifyAuthRequestCryptogramCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    case "VerificationFailedException":
+    case "com.amazonaws.paymentcryptographydata#VerificationFailedException":
+      throw await de_VerificationFailedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_VerifyAuthRequestCryptogramCommandError");
+var de_VerifyCardValidationDataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_VerifyCardValidationDataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_VerifyCardValidationDataCommand");
+var de_VerifyCardValidationDataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    case "VerificationFailedException":
+    case "com.amazonaws.paymentcryptographydata#VerificationFailedException":
+      throw await de_VerificationFailedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_VerifyCardValidationDataCommandError");
+var de_VerifyMacCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_VerifyMacCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    KeyArn: import_smithy_client.expectString,
+    KeyCheckValue: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_VerifyMacCommand");
+var de_VerifyMacCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    case "VerificationFailedException":
+    case "com.amazonaws.paymentcryptographydata#VerificationFailedException":
+      throw await de_VerificationFailedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_VerifyMacCommandError");
+var de_VerifyPinDataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_VerifyPinDataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    EncryptionKeyArn: import_smithy_client.expectString,
+    EncryptionKeyCheckValue: import_smithy_client.expectString,
+    VerificationKeyArn: import_smithy_client.expectString,
+    VerificationKeyCheckValue: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_VerifyPinDataCommand");
+var de_VerifyPinDataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.paymentcryptographydata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.paymentcryptographydata#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.paymentcryptographydata#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.paymentcryptographydata#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.paymentcryptographydata#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    case "VerificationFailedException":
+    case "com.amazonaws.paymentcryptographydata#VerificationFailedException":
+      throw await de_VerificationFailedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_VerifyPinDataCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(PaymentCryptographyDataServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    ResourceId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    fieldList: import_smithy_client._json,
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var de_VerificationFailedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    Reason: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new VerificationFailedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_VerificationFailedExceptionRes");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/DecryptDataCommand.ts
+var _DecryptDataCommand = class _DecryptDataCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "DecryptData", {}).n("PaymentCryptographyDataClient", "DecryptDataCommand").f(DecryptDataInputFilterSensitiveLog, DecryptDataOutputFilterSensitiveLog).ser(se_DecryptDataCommand).de(de_DecryptDataCommand).build() {
+};
+__name(_DecryptDataCommand, "DecryptDataCommand");
+var DecryptDataCommand = _DecryptDataCommand;
+
+// src/commands/EncryptDataCommand.ts
+
+
+
+
+var _EncryptDataCommand = class _EncryptDataCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "EncryptData", {}).n("PaymentCryptographyDataClient", "EncryptDataCommand").f(EncryptDataInputFilterSensitiveLog, EncryptDataOutputFilterSensitiveLog).ser(se_EncryptDataCommand).de(de_EncryptDataCommand).build() {
+};
+__name(_EncryptDataCommand, "EncryptDataCommand");
+var EncryptDataCommand = _EncryptDataCommand;
+
+// src/commands/GenerateCardValidationDataCommand.ts
+
+
+
+
+var _GenerateCardValidationDataCommand = class _GenerateCardValidationDataCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "GenerateCardValidationData", {}).n("PaymentCryptographyDataClient", "GenerateCardValidationDataCommand").f(GenerateCardValidationDataInputFilterSensitiveLog, void 0).ser(se_GenerateCardValidationDataCommand).de(de_GenerateCardValidationDataCommand).build() {
+};
+__name(_GenerateCardValidationDataCommand, "GenerateCardValidationDataCommand");
+var GenerateCardValidationDataCommand = _GenerateCardValidationDataCommand;
+
+// src/commands/GenerateMacCommand.ts
+
+
+
+
+var _GenerateMacCommand = class _GenerateMacCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "GenerateMac", {}).n("PaymentCryptographyDataClient", "GenerateMacCommand").f(GenerateMacInputFilterSensitiveLog, void 0).ser(se_GenerateMacCommand).de(de_GenerateMacCommand).build() {
+};
+__name(_GenerateMacCommand, "GenerateMacCommand");
+var GenerateMacCommand = _GenerateMacCommand;
+
+// src/commands/GeneratePinDataCommand.ts
+
+
+
+
+var _GeneratePinDataCommand = class _GeneratePinDataCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "GeneratePinData", {}).n("PaymentCryptographyDataClient", "GeneratePinDataCommand").f(GeneratePinDataInputFilterSensitiveLog, void 0).ser(se_GeneratePinDataCommand).de(de_GeneratePinDataCommand).build() {
+};
+__name(_GeneratePinDataCommand, "GeneratePinDataCommand");
+var GeneratePinDataCommand = _GeneratePinDataCommand;
+
+// src/commands/ReEncryptDataCommand.ts
+
+
+
+
+var _ReEncryptDataCommand = class _ReEncryptDataCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "ReEncryptData", {}).n("PaymentCryptographyDataClient", "ReEncryptDataCommand").f(ReEncryptDataInputFilterSensitiveLog, ReEncryptDataOutputFilterSensitiveLog).ser(se_ReEncryptDataCommand).de(de_ReEncryptDataCommand).build() {
+};
+__name(_ReEncryptDataCommand, "ReEncryptDataCommand");
+var ReEncryptDataCommand = _ReEncryptDataCommand;
+
+// src/commands/TranslatePinDataCommand.ts
+
+
+
+
+var _TranslatePinDataCommand = class _TranslatePinDataCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "TranslatePinData", {}).n("PaymentCryptographyDataClient", "TranslatePinDataCommand").f(TranslatePinDataInputFilterSensitiveLog, void 0).ser(se_TranslatePinDataCommand).de(de_TranslatePinDataCommand).build() {
+};
+__name(_TranslatePinDataCommand, "TranslatePinDataCommand");
+var TranslatePinDataCommand = _TranslatePinDataCommand;
+
+// src/commands/VerifyAuthRequestCryptogramCommand.ts
+
+
+
+
+var _VerifyAuthRequestCryptogramCommand = class _VerifyAuthRequestCryptogramCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "VerifyAuthRequestCryptogram", {}).n("PaymentCryptographyDataClient", "VerifyAuthRequestCryptogramCommand").f(VerifyAuthRequestCryptogramInputFilterSensitiveLog, void 0).ser(se_VerifyAuthRequestCryptogramCommand).de(de_VerifyAuthRequestCryptogramCommand).build() {
+};
+__name(_VerifyAuthRequestCryptogramCommand, "VerifyAuthRequestCryptogramCommand");
+var VerifyAuthRequestCryptogramCommand = _VerifyAuthRequestCryptogramCommand;
+
+// src/commands/VerifyCardValidationDataCommand.ts
+
+
+
+
+var _VerifyCardValidationDataCommand = class _VerifyCardValidationDataCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "VerifyCardValidationData", {}).n("PaymentCryptographyDataClient", "VerifyCardValidationDataCommand").f(VerifyCardValidationDataInputFilterSensitiveLog, void 0).ser(se_VerifyCardValidationDataCommand).de(de_VerifyCardValidationDataCommand).build() {
+};
+__name(_VerifyCardValidationDataCommand, "VerifyCardValidationDataCommand");
+var VerifyCardValidationDataCommand = _VerifyCardValidationDataCommand;
+
+// src/commands/VerifyMacCommand.ts
+
+
+
+
+var _VerifyMacCommand = class _VerifyMacCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "VerifyMac", {}).n("PaymentCryptographyDataClient", "VerifyMacCommand").f(VerifyMacInputFilterSensitiveLog, void 0).ser(se_VerifyMacCommand).de(de_VerifyMacCommand).build() {
+};
+__name(_VerifyMacCommand, "VerifyMacCommand");
+var VerifyMacCommand = _VerifyMacCommand;
+
+// src/commands/VerifyPinDataCommand.ts
+
+
+
+
+var _VerifyPinDataCommand = class _VerifyPinDataCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("PaymentCryptographyDataPlane", "VerifyPinData", {}).n("PaymentCryptographyDataClient", "VerifyPinDataCommand").f(VerifyPinDataInputFilterSensitiveLog, void 0).ser(se_VerifyPinDataCommand).de(de_VerifyPinDataCommand).build() {
+};
+__name(_VerifyPinDataCommand, "VerifyPinDataCommand");
+var VerifyPinDataCommand = _VerifyPinDataCommand;
+
+// src/PaymentCryptographyData.ts
+var commands = {
+  DecryptDataCommand,
+  EncryptDataCommand,
+  GenerateCardValidationDataCommand,
+  GenerateMacCommand,
+  GeneratePinDataCommand,
+  ReEncryptDataCommand,
+  TranslatePinDataCommand,
+  VerifyAuthRequestCryptogramCommand,
+  VerifyCardValidationDataCommand,
+  VerifyMacCommand,
+  VerifyPinDataCommand
+};
+var _PaymentCryptographyData = class _PaymentCryptographyData extends PaymentCryptographyDataClient {
+};
+__name(_PaymentCryptographyData, "PaymentCryptographyData");
+var PaymentCryptographyData = _PaymentCryptographyData;
+(0, import_smithy_client.createAggregatedClient)(commands, PaymentCryptographyData);
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessDeniedException,
+  CardGenerationAttributes,
+  CardVerificationAttributes,
+  CryptogramAuthResponse,
+  DecryptDataCommand,
+  DecryptDataInputFilterSensitiveLog,
+  DecryptDataOutputFilterSensitiveLog,
+  DukptDerivationType,
+  DukptEncryptionAttributesFilterSensitiveLog,
+  DukptEncryptionMode,
+  DukptKeyVariant,
+  EncryptDataCommand,
+  EncryptDataInputFilterSensitiveLog,
+  EncryptDataOutputFilterSensitiveLog,
+  EncryptionDecryptionAttributes,
+  EncryptionDecryptionAttributesFilterSensitiveLog,
+  EncryptionMode,
+  GenerateCardValidationDataCommand,
+  GenerateCardValidationDataInputFilterSensitiveLog,
+  GenerateMacCommand,
+  GenerateMacInputFilterSensitiveLog,
+  GeneratePinDataCommand,
+  GeneratePinDataInputFilterSensitiveLog,
+  InternalServerException,
+  MacAlgorithm,
+  MacAlgorithmEmvFilterSensitiveLog,
+  MacAttributes,
+  MacAttributesFilterSensitiveLog,
+  MajorKeyDerivationMode,
+  PaddingType,
+  PaymentCryptographyData,
+  PaymentCryptographyDataClient,
+  PaymentCryptographyDataServiceException,
+  PinBlockFormatForPinData,
+  PinData,
+  PinGenerationAttributes,
+  PinVerificationAttributes,
+  ReEncryptDataCommand,
+  ReEncryptDataInputFilterSensitiveLog,
+  ReEncryptDataOutputFilterSensitiveLog,
+  ReEncryptionAttributes,
+  ReEncryptionAttributesFilterSensitiveLog,
+  ResourceNotFoundException,
+  SessionKeyAmexFilterSensitiveLog,
+  SessionKeyDerivation,
+  SessionKeyDerivationFilterSensitiveLog,
+  SessionKeyDerivationMode,
+  SessionKeyDerivationValue,
+  SessionKeyEmv2000FilterSensitiveLog,
+  SessionKeyEmvCommonFilterSensitiveLog,
+  SessionKeyMastercardFilterSensitiveLog,
+  SessionKeyVisaFilterSensitiveLog,
+  SymmetricEncryptionAttributesFilterSensitiveLog,
+  ThrottlingException,
+  TranslatePinDataCommand,
+  TranslatePinDataInputFilterSensitiveLog,
+  TranslationIsoFormats,
+  TranslationIsoFormatsFilterSensitiveLog,
+  TranslationPinDataIsoFormat034FilterSensitiveLog,
+  ValidationException,
+  VerificationFailedException,
+  VerificationFailedReason,
+  VerifyAuthRequestCryptogramCommand,
+  VerifyAuthRequestCryptogramInputFilterSensitiveLog,
+  VerifyCardValidationDataCommand,
+  VerifyCardValidationDataInputFilterSensitiveLog,
+  VerifyMacCommand,
+  VerifyMacInputFilterSensitiveLog,
+  VerifyPinDataCommand,
+  VerifyPinDataInputFilterSensitiveLog,
+  __Client
+});