@aws-sdk/client-payment-cryptography-data 3.349.0

package/dist-es/commands/VerifyPinDataCommand.js

@@ -0,0 +1,43 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { VerifyPinDataInputFilterSensitiveLog } from "../models/models_0";
+import { de_VerifyPinDataCommand, se_VerifyPinDataCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class VerifyPinDataCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, VerifyPinDataCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "PaymentCryptographyDataClient";
+        const commandName = "VerifyPinDataCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: VerifyPinDataInputFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_VerifyPinDataCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_VerifyPinDataCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -0,0 +1,11 @@
+export * from "./DecryptDataCommand";
+export * from "./EncryptDataCommand";
+export * from "./GenerateCardValidationDataCommand";
+export * from "./GenerateMacCommand";
+export * from "./GeneratePinDataCommand";
+export * from "./ReEncryptDataCommand";
+export * from "./TranslatePinDataCommand";
+export * from "./VerifyAuthRequestCryptogramCommand";
+export * from "./VerifyCardValidationDataCommand";
+export * from "./VerifyMacCommand";
+export * from "./VerifyPinDataCommand";

package/dist-es/endpoint/EndpointParameters.js

@@ -0,0 +1,8 @@
+export const resolveClientEndpointParameters = (options) => {
+    return {
+        ...options,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "payment-cryptography",
+    };
+};

package/dist-es/endpoint/endpointResolver.js

@@ -0,0 +1,8 @@
+import { resolveEndpoint } from "@aws-sdk/util-endpoints";
+import { ruleSet } from "./ruleset";
+export const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return resolveEndpoint(ruleSet, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    });
+};

package/dist-es/endpoint/ruleset.js

@@ -0,0 +1,4 @@
+const q = "required", r = "fn", s = "argv", t = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://dataplane.payment-cryptography-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://dataplane.payment-cryptography-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://dataplane.payment-cryptography.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://dataplane.payment-cryptography.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
+export const ruleSet = _data;

package/dist-es/index.js

@@ -0,0 +1,5 @@
+export * from "./PaymentCryptographyDataClient";
+export * from "./PaymentCryptographyData";
+export * from "./commands";
+export * from "./models";
+export { PaymentCryptographyDataServiceException } from "./models/PaymentCryptographyDataServiceException";

package/dist-es/models/PaymentCryptographyDataServiceException.js

@@ -0,0 +1,8 @@
+import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
+export { __ServiceException };
+export class PaymentCryptographyDataServiceException extends __ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, PaymentCryptographyDataServiceException.prototype);
+    }
+}

package/dist-es/models/index.js

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-es/models/models_0.js

@@ -0,0 +1,488 @@
+import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { PaymentCryptographyDataServiceException as __BaseException } from "./PaymentCryptographyDataServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export const PaddingType = {
+    OAEP_SHA1: "OAEP_SHA1",
+    OAEP_SHA256: "OAEP_SHA256",
+    OAEP_SHA512: "OAEP_SHA512",
+    PKCS1: "PKCS1",
+};
+export var CardGenerationAttributes;
+(function (CardGenerationAttributes) {
+    CardGenerationAttributes.visit = (value, visitor) => {
+        if (value.AmexCardSecurityCodeVersion1 !== undefined)
+            return visitor.AmexCardSecurityCodeVersion1(value.AmexCardSecurityCodeVersion1);
+        if (value.AmexCardSecurityCodeVersion2 !== undefined)
+            return visitor.AmexCardSecurityCodeVersion2(value.AmexCardSecurityCodeVersion2);
+        if (value.CardVerificationValue1 !== undefined)
+            return visitor.CardVerificationValue1(value.CardVerificationValue1);
+        if (value.CardVerificationValue2 !== undefined)
+            return visitor.CardVerificationValue2(value.CardVerificationValue2);
+        if (value.CardHolderVerificationValue !== undefined)
+            return visitor.CardHolderVerificationValue(value.CardHolderVerificationValue);
+        if (value.DynamicCardVerificationCode !== undefined)
+            return visitor.DynamicCardVerificationCode(value.DynamicCardVerificationCode);
+        if (value.DynamicCardVerificationValue !== undefined)
+            return visitor.DynamicCardVerificationValue(value.DynamicCardVerificationValue);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CardGenerationAttributes || (CardGenerationAttributes = {}));
+export var CardVerificationAttributes;
+(function (CardVerificationAttributes) {
+    CardVerificationAttributes.visit = (value, visitor) => {
+        if (value.AmexCardSecurityCodeVersion1 !== undefined)
+            return visitor.AmexCardSecurityCodeVersion1(value.AmexCardSecurityCodeVersion1);
+        if (value.AmexCardSecurityCodeVersion2 !== undefined)
+            return visitor.AmexCardSecurityCodeVersion2(value.AmexCardSecurityCodeVersion2);
+        if (value.CardVerificationValue1 !== undefined)
+            return visitor.CardVerificationValue1(value.CardVerificationValue1);
+        if (value.CardVerificationValue2 !== undefined)
+            return visitor.CardVerificationValue2(value.CardVerificationValue2);
+        if (value.CardHolderVerificationValue !== undefined)
+            return visitor.CardHolderVerificationValue(value.CardHolderVerificationValue);
+        if (value.DynamicCardVerificationCode !== undefined)
+            return visitor.DynamicCardVerificationCode(value.DynamicCardVerificationCode);
+        if (value.DynamicCardVerificationValue !== undefined)
+            return visitor.DynamicCardVerificationValue(value.DynamicCardVerificationValue);
+        if (value.DiscoverDynamicCardVerificationCode !== undefined)
+            return visitor.DiscoverDynamicCardVerificationCode(value.DiscoverDynamicCardVerificationCode);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CardVerificationAttributes || (CardVerificationAttributes = {}));
+export var CryptogramAuthResponse;
+(function (CryptogramAuthResponse) {
+    CryptogramAuthResponse.visit = (value, visitor) => {
+        if (value.ArpcMethod1 !== undefined)
+            return visitor.ArpcMethod1(value.ArpcMethod1);
+        if (value.ArpcMethod2 !== undefined)
+            return visitor.ArpcMethod2(value.ArpcMethod2);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CryptogramAuthResponse || (CryptogramAuthResponse = {}));
+export const DukptDerivationType = {
+    AES_128: "AES_128",
+    AES_192: "AES_192",
+    AES_256: "AES_256",
+    TDES_2KEY: "TDES_2KEY",
+    TDES_3KEY: "TDES_3KEY",
+};
+export const DukptKeyVariant = {
+    BIDIRECTIONAL: "BIDIRECTIONAL",
+    REQUEST: "REQUEST",
+    RESPONSE: "RESPONSE",
+};
+export const DukptEncryptionMode = {
+    CBC: "CBC",
+    ECB: "ECB",
+};
+export const EncryptionMode = {
+    CBC: "CBC",
+    CFB: "CFB",
+    CFB1: "CFB1",
+    CFB128: "CFB128",
+    CFB64: "CFB64",
+    CFB8: "CFB8",
+    ECB: "ECB",
+    OFB: "OFB",
+};
+export var EncryptionDecryptionAttributes;
+(function (EncryptionDecryptionAttributes) {
+    EncryptionDecryptionAttributes.visit = (value, visitor) => {
+        if (value.Symmetric !== undefined)
+            return visitor.Symmetric(value.Symmetric);
+        if (value.Asymmetric !== undefined)
+            return visitor.Asymmetric(value.Asymmetric);
+        if (value.Dukpt !== undefined)
+            return visitor.Dukpt(value.Dukpt);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(EncryptionDecryptionAttributes || (EncryptionDecryptionAttributes = {}));
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.ResourceId = opts.ResourceId;
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.fieldList = opts.fieldList;
+    }
+}
+export const 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",
+};
+export const MajorKeyDerivationMode = {
+    EMV_OPTION_A: "EMV_OPTION_A",
+    EMV_OPTION_B: "EMV_OPTION_B",
+};
+export const SessionKeyDerivationMode = {
+    AMEX: "AMEX",
+    EMV2000: "EMV2000",
+    EMV_COMMON_SESSION_KEY: "EMV_COMMON_SESSION_KEY",
+    MASTERCARD_SESSION_KEY: "MASTERCARD_SESSION_KEY",
+    VISA: "VISA",
+};
+export var SessionKeyDerivationValue;
+(function (SessionKeyDerivationValue) {
+    SessionKeyDerivationValue.visit = (value, visitor) => {
+        if (value.ApplicationCryptogram !== undefined)
+            return visitor.ApplicationCryptogram(value.ApplicationCryptogram);
+        if (value.ApplicationTransactionCounter !== undefined)
+            return visitor.ApplicationTransactionCounter(value.ApplicationTransactionCounter);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(SessionKeyDerivationValue || (SessionKeyDerivationValue = {}));
+export var MacAttributes;
+(function (MacAttributes) {
+    MacAttributes.visit = (value, visitor) => {
+        if (value.Algorithm !== undefined)
+            return visitor.Algorithm(value.Algorithm);
+        if (value.EmvMac !== undefined)
+            return visitor.EmvMac(value.EmvMac);
+        if (value.DukptIso9797Algorithm1 !== undefined)
+            return visitor.DukptIso9797Algorithm1(value.DukptIso9797Algorithm1);
+        if (value.DukptIso9797Algorithm3 !== undefined)
+            return visitor.DukptIso9797Algorithm3(value.DukptIso9797Algorithm3);
+        if (value.DukptCmac !== undefined)
+            return visitor.DukptCmac(value.DukptCmac);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(MacAttributes || (MacAttributes = {}));
+export var PinGenerationAttributes;
+(function (PinGenerationAttributes) {
+    PinGenerationAttributes.visit = (value, visitor) => {
+        if (value.VisaPin !== undefined)
+            return visitor.VisaPin(value.VisaPin);
+        if (value.VisaPinVerificationValue !== undefined)
+            return visitor.VisaPinVerificationValue(value.VisaPinVerificationValue);
+        if (value.Ibm3624PinOffset !== undefined)
+            return visitor.Ibm3624PinOffset(value.Ibm3624PinOffset);
+        if (value.Ibm3624NaturalPin !== undefined)
+            return visitor.Ibm3624NaturalPin(value.Ibm3624NaturalPin);
+        if (value.Ibm3624RandomPin !== undefined)
+            return visitor.Ibm3624RandomPin(value.Ibm3624RandomPin);
+        if (value.Ibm3624PinFromOffset !== undefined)
+            return visitor.Ibm3624PinFromOffset(value.Ibm3624PinFromOffset);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PinGenerationAttributes || (PinGenerationAttributes = {}));
+export const PinBlockFormatForPinData = {
+    ISO_FORMAT_0: "ISO_FORMAT_0",
+    ISO_FORMAT_3: "ISO_FORMAT_3",
+};
+export var PinData;
+(function (PinData) {
+    PinData.visit = (value, visitor) => {
+        if (value.PinOffset !== undefined)
+            return visitor.PinOffset(value.PinOffset);
+        if (value.VerificationValue !== undefined)
+            return visitor.VerificationValue(value.VerificationValue);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PinData || (PinData = {}));
+export var ReEncryptionAttributes;
+(function (ReEncryptionAttributes) {
+    ReEncryptionAttributes.visit = (value, visitor) => {
+        if (value.Symmetric !== undefined)
+            return visitor.Symmetric(value.Symmetric);
+        if (value.Dukpt !== undefined)
+            return visitor.Dukpt(value.Dukpt);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ReEncryptionAttributes || (ReEncryptionAttributes = {}));
+export var TranslationIsoFormats;
+(function (TranslationIsoFormats) {
+    TranslationIsoFormats.visit = (value, visitor) => {
+        if (value.IsoFormat0 !== undefined)
+            return visitor.IsoFormat0(value.IsoFormat0);
+        if (value.IsoFormat1 !== undefined)
+            return visitor.IsoFormat1(value.IsoFormat1);
+        if (value.IsoFormat3 !== undefined)
+            return visitor.IsoFormat3(value.IsoFormat3);
+        if (value.IsoFormat4 !== undefined)
+            return visitor.IsoFormat4(value.IsoFormat4);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(TranslationIsoFormats || (TranslationIsoFormats = {}));
+export const VerificationFailedReason = {
+    INVALID_AUTH_REQUEST_CRYPTOGRAM: "INVALID_AUTH_REQUEST_CRYPTOGRAM",
+    INVALID_MAC: "INVALID_MAC",
+    INVALID_PIN: "INVALID_PIN",
+    INVALID_VALIDATION_DATA: "INVALID_VALIDATION_DATA",
+};
+export class VerificationFailedException extends __BaseException {
+    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;
+    }
+}
+export var SessionKeyDerivation;
+(function (SessionKeyDerivation) {
+    SessionKeyDerivation.visit = (value, visitor) => {
+        if (value.EmvCommon !== undefined)
+            return visitor.EmvCommon(value.EmvCommon);
+        if (value.Mastercard !== undefined)
+            return visitor.Mastercard(value.Mastercard);
+        if (value.Emv2000 !== undefined)
+            return visitor.Emv2000(value.Emv2000);
+        if (value.Amex !== undefined)
+            return visitor.Amex(value.Amex);
+        if (value.Visa !== undefined)
+            return visitor.Visa(value.Visa);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(SessionKeyDerivation || (SessionKeyDerivation = {}));
+export var PinVerificationAttributes;
+(function (PinVerificationAttributes) {
+    PinVerificationAttributes.visit = (value, visitor) => {
+        if (value.VisaPin !== undefined)
+            return visitor.VisaPin(value.VisaPin);
+        if (value.Ibm3624Pin !== undefined)
+            return visitor.Ibm3624Pin(value.Ibm3624Pin);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PinVerificationAttributes || (PinVerificationAttributes = {}));
+export const DukptEncryptionAttributesFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InitializationVector && { InitializationVector: SENSITIVE_STRING }),
+});
+export const SymmetricEncryptionAttributesFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InitializationVector && { InitializationVector: SENSITIVE_STRING }),
+});
+export const EncryptionDecryptionAttributesFilterSensitiveLog = (obj) => {
+    if (obj.Symmetric !== undefined)
+        return { Symmetric: SymmetricEncryptionAttributesFilterSensitiveLog(obj.Symmetric) };
+    if (obj.Asymmetric !== undefined)
+        return { Asymmetric: obj.Asymmetric };
+    if (obj.Dukpt !== undefined)
+        return { Dukpt: DukptEncryptionAttributesFilterSensitiveLog(obj.Dukpt) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const DecryptDataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.CipherText && { CipherText: SENSITIVE_STRING }),
+    ...(obj.DecryptionAttributes && {
+        DecryptionAttributes: EncryptionDecryptionAttributesFilterSensitiveLog(obj.DecryptionAttributes),
+    }),
+});
+export const DecryptDataOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PlainText && { PlainText: SENSITIVE_STRING }),
+});
+export const EncryptDataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PlainText && { PlainText: SENSITIVE_STRING }),
+    ...(obj.EncryptionAttributes && {
+        EncryptionAttributes: EncryptionDecryptionAttributesFilterSensitiveLog(obj.EncryptionAttributes),
+    }),
+});
+export const EncryptDataOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.CipherText && { CipherText: SENSITIVE_STRING }),
+});
+export const GenerateCardValidationDataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+    ...(obj.GenerationAttributes && { GenerationAttributes: obj.GenerationAttributes }),
+});
+export const MacAlgorithmEmvFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+    ...(obj.SessionKeyDerivationValue && { SessionKeyDerivationValue: obj.SessionKeyDerivationValue }),
+});
+export const MacAttributesFilterSensitiveLog = (obj) => {
+    if (obj.Algorithm !== undefined)
+        return { Algorithm: obj.Algorithm };
+    if (obj.EmvMac !== undefined)
+        return { EmvMac: MacAlgorithmEmvFilterSensitiveLog(obj.EmvMac) };
+    if (obj.DukptIso9797Algorithm1 !== undefined)
+        return { DukptIso9797Algorithm1: obj.DukptIso9797Algorithm1 };
+    if (obj.DukptIso9797Algorithm3 !== undefined)
+        return { DukptIso9797Algorithm3: obj.DukptIso9797Algorithm3 };
+    if (obj.DukptCmac !== undefined)
+        return { DukptCmac: obj.DukptCmac };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const GenerateMacInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.GenerationAttributes && { GenerationAttributes: MacAttributesFilterSensitiveLog(obj.GenerationAttributes) }),
+});
+export const GeneratePinDataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.GenerationAttributes && { GenerationAttributes: obj.GenerationAttributes }),
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+});
+export const ReEncryptionAttributesFilterSensitiveLog = (obj) => {
+    if (obj.Symmetric !== undefined)
+        return { Symmetric: SymmetricEncryptionAttributesFilterSensitiveLog(obj.Symmetric) };
+    if (obj.Dukpt !== undefined)
+        return { Dukpt: DukptEncryptionAttributesFilterSensitiveLog(obj.Dukpt) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ReEncryptDataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.CipherText && { CipherText: SENSITIVE_STRING }),
+    ...(obj.IncomingEncryptionAttributes && {
+        IncomingEncryptionAttributes: ReEncryptionAttributesFilterSensitiveLog(obj.IncomingEncryptionAttributes),
+    }),
+    ...(obj.OutgoingEncryptionAttributes && {
+        OutgoingEncryptionAttributes: ReEncryptionAttributesFilterSensitiveLog(obj.OutgoingEncryptionAttributes),
+    }),
+});
+export const ReEncryptDataOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.CipherText && { CipherText: SENSITIVE_STRING }),
+});
+export const TranslationPinDataIsoFormat034FilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+});
+export const TranslationIsoFormatsFilterSensitiveLog = (obj) => {
+    if (obj.IsoFormat0 !== undefined)
+        return { IsoFormat0: TranslationPinDataIsoFormat034FilterSensitiveLog(obj.IsoFormat0) };
+    if (obj.IsoFormat1 !== undefined)
+        return { IsoFormat1: obj.IsoFormat1 };
+    if (obj.IsoFormat3 !== undefined)
+        return { IsoFormat3: TranslationPinDataIsoFormat034FilterSensitiveLog(obj.IsoFormat3) };
+    if (obj.IsoFormat4 !== undefined)
+        return { IsoFormat4: TranslationPinDataIsoFormat034FilterSensitiveLog(obj.IsoFormat4) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const TranslatePinDataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.IncomingTranslationAttributes && {
+        IncomingTranslationAttributes: TranslationIsoFormatsFilterSensitiveLog(obj.IncomingTranslationAttributes),
+    }),
+    ...(obj.OutgoingTranslationAttributes && {
+        OutgoingTranslationAttributes: TranslationIsoFormatsFilterSensitiveLog(obj.OutgoingTranslationAttributes),
+    }),
+});
+export const SessionKeyAmexFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+});
+export const SessionKeyEmv2000FilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+});
+export const SessionKeyEmvCommonFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+});
+export const SessionKeyMastercardFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+});
+export const SessionKeyVisaFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+});
+export const SessionKeyDerivationFilterSensitiveLog = (obj) => {
+    if (obj.EmvCommon !== undefined)
+        return { EmvCommon: SessionKeyEmvCommonFilterSensitiveLog(obj.EmvCommon) };
+    if (obj.Mastercard !== undefined)
+        return { Mastercard: SessionKeyMastercardFilterSensitiveLog(obj.Mastercard) };
+    if (obj.Emv2000 !== undefined)
+        return { Emv2000: SessionKeyEmv2000FilterSensitiveLog(obj.Emv2000) };
+    if (obj.Amex !== undefined)
+        return { Amex: SessionKeyAmexFilterSensitiveLog(obj.Amex) };
+    if (obj.Visa !== undefined)
+        return { Visa: SessionKeyVisaFilterSensitiveLog(obj.Visa) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const VerifyAuthRequestCryptogramInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SessionKeyDerivationAttributes && {
+        SessionKeyDerivationAttributes: SessionKeyDerivationFilterSensitiveLog(obj.SessionKeyDerivationAttributes),
+    }),
+    ...(obj.AuthResponseAttributes && { AuthResponseAttributes: obj.AuthResponseAttributes }),
+});
+export const VerifyCardValidationDataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+    ...(obj.VerificationAttributes && { VerificationAttributes: obj.VerificationAttributes }),
+});
+export const VerifyMacInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VerificationAttributes && {
+        VerificationAttributes: MacAttributesFilterSensitiveLog(obj.VerificationAttributes),
+    }),
+});
+export const VerifyPinDataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VerificationAttributes && { VerificationAttributes: obj.VerificationAttributes }),
+    ...(obj.PrimaryAccountNumber && { PrimaryAccountNumber: SENSITIVE_STRING }),
+});