Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Payment Cryptography Control Plane can respond with.

Structs

Alias

Contains information about an alias.

ExportAttributes

The attributes for IPEK generation during export.

ExportDiffieHellmanTr31KeyBlock

Key derivation parameter information for key material export using asymmetric ECDH key exchange method.

ExportDukptInitialKey

Parameter information for IPEK generation during export.

ExportKeyCryptogram

Parameter information for key material export using asymmetric RSA wrap and unwrap key exchange method.

ExportTr31KeyBlock

Parameter information for key material export using symmetric TR-31 key exchange method.

ExportTr34KeyBlock

Parameter information for key material export using the asymmetric TR-34 key exchange method.

ImportDiffieHellmanTr31KeyBlock

Key derivation parameter information for key material import using asymmetric ECDH key exchange method.

ImportKeyCryptogram

Parameter information for key material import using asymmetric RSA wrap and unwrap key exchange method.

ImportTr31KeyBlock

Parameter information for key material import using symmetric TR-31 key exchange method.

ImportTr34KeyBlock

Parameter information for key material import using the asymmetric TR-34 key exchange method.

Key

Metadata about an Amazon Web Services Payment Cryptography key.

KeyAttributes

The role of the key, the algorithm it supports, and the cryptographic operations allowed with the key. This data is immutable after the key is created.

KeyBlockHeaders

Optional metadata for export associated with the key material. This data is signed but transmitted in clear text.

KeyModesOfUse

The list of cryptographic operations that you can perform using the key. The modes of use are defined in section A.5.3 of the TR-31 spec.

KeySummary

Metadata about an Amazon Web Services Payment Cryptography key.

RootCertificatePublicKey

Parameter information for root public key certificate import.

Tag

A structure that contains information about a tag.

TrustedCertificatePublicKey

Parameter information for trusted public key certificate import.

WrappedKey

Parameter information for generating a WrappedKeyBlock for key exchange.

Enums

DeriveKeyUsage

When writing a match expression against DeriveKeyUsage, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DiffieHellmanDerivationData

The shared information used when deriving a key using ECDH.

ExportKeyMaterial

Parameter information for key material export from Amazon Web Services Payment Cryptography using TR-31 or TR-34 or RSA wrap and unwrap key exchange method.

ImportKeyMaterial

Parameter information for key material import into Amazon Web Services Payment Cryptography using TR-31 or TR-34 or RSA wrap and unwrap key exchange method.

KeyAlgorithm

When writing a match expression against KeyAlgorithm, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyCheckValueAlgorithm

When writing a match expression against KeyCheckValueAlgorithm, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyClass

When writing a match expression against KeyClass, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyDerivationFunction

When writing a match expression against KeyDerivationFunction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyDerivationHashAlgorithm

When writing a match expression against KeyDerivationHashAlgorithm, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyExportability

When writing a match expression against KeyExportability, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyMaterialType

When writing a match expression against KeyMaterialType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyOrigin

When writing a match expression against KeyOrigin, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyState

When writing a match expression against KeyState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KeyUsage

When writing a match expression against KeyUsage, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SymmetricKeyAlgorithm

When writing a match expression against SymmetricKeyAlgorithm, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Tr34KeyBlockFormat

When writing a match expression against Tr34KeyBlockFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WrappedKeyMaterialFormat

When writing a match expression against WrappedKeyMaterialFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WrappingKeySpec

When writing a match expression against WrappingKeySpec, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.