Module aws_sdk_paymentcryptography::types

source ·
Expand description

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.

  • ExportTr31KeyBlock

    Parameter information for key material export using TR-31 standard.

  • ExportTr34KeyBlock

    Parameter information for key material export using TR-34 standard.

  • ImportTr31KeyBlock

    Parameter information for key material import using TR-31 standard.

  • ImportTr34KeyBlock

    Parameter information for key material import using TR-34 standard.

  • 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.

  • 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 wrapped key using TR-31 or TR-34 standard.

Enums

  • ExportKeyMaterial

    Parameter information for key material export from Amazon Web Services Payment Cryptography.

  • ImportKeyMaterial

    Parameter information for key material import.

  • 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.
  • 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.
  • 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.