Module aws_sdk_ecr::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Amazon EC2 Container Registry can respond with.

Structs

• Attribute

  This data type is used in the ImageScanFinding data type.

• AuthorizationData

  An object representing authorization data for an Amazon ECR registry.

• AwsEcrContainerImageDetails

  The image details of the Amazon ECR container image.

• CvssScore

  The CVSS score for a finding.

• CvssScoreAdjustment

  Details on adjustments Amazon Inspector made to the CVSS score for a finding.

• CvssScoreDetails

  Information about the CVSS score.

• DescribeImagesFilter

  An object representing a filter on a DescribeImages operation.

• EncryptionConfiguration

  The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest.

  By default, when no encryption configuration is set or the AES256 encryption type is used, Amazon ECR uses server-side encryption with Amazon S3-managed encryption keys which encrypts your data at rest using an AES256 encryption algorithm. This does not require any action on your part.

  For more control over the encryption of the contents of your repository, you can use server-side encryption with Key Management Service key stored in Key Management Service (KMS) to encrypt your images. For more information, see Amazon ECR encryption at rest in the Amazon Elastic Container Registry User Guide.

• EncryptionConfigurationForRepositoryCreationTemplate

  The encryption configuration to associate with the repository creation template.

• EnhancedImageScanFinding

  The details of an enhanced image scan. This is returned when enhanced scanning is enabled for your private registry.

• Image

  An object representing an Amazon ECR image.

• ImageDetail

  An object that describes an image returned by a DescribeImages operation.

• ImageFailure

  An object representing an Amazon ECR image failure.

• ImageIdentifier

  An object with identifying information for an image in an Amazon ECR repository.

• ImageReplicationStatus

  The status of the replication process for an image.

• ImageScanFinding

  Contains information about an image scan finding.

• ImageScanFindings

  The details of an image scan.

• ImageScanFindingsSummary

  A summary of the last completed image scan.

• ImageScanStatus

  The current status of an image scan.

• ImageScanningConfiguration

  The image scanning configuration for a repository.

• Layer

  An object representing an Amazon ECR image layer.

• LayerFailure

  An object representing an Amazon ECR image layer failure.

• LifecyclePolicyPreviewFilter

  The filter for the lifecycle policy preview.

• LifecyclePolicyPreviewResult

  The result of the lifecycle policy preview.

• LifecyclePolicyPreviewSummary

  The summary of the lifecycle policy preview request.

• LifecyclePolicyRuleAction

  The type of action to be taken.

• ListImagesFilter

  An object representing a filter on a ListImages operation.

• PackageVulnerabilityDetails

  Information about a package vulnerability finding.

• PullThroughCacheRule

  The details of a pull through cache rule.

• Recommendation

  Details about the recommended course of action to remediate the finding.

• RegistryScanningConfiguration

  The scanning configuration for a private registry.

• RegistryScanningRule

  The details of a scanning rule for a private registry.

• Remediation

  Information on how to remediate a finding.

• ReplicationConfiguration

  The replication configuration for a registry.

• ReplicationDestination

  An array of objects representing the destination for a replication rule.

• ReplicationRule

  An array of objects representing the replication destinations and repository filters for a replication configuration.

• Repository

  An object representing a repository.

• RepositoryCreationTemplate

  The details of the repository creation template associated with the request.

• RepositoryFilter

  The filter settings used with image replication. Specifying a repository filter to a replication rule provides a method for controlling which repositories in a private registry are replicated. If no filters are added, the contents of all repositories are replicated.

• RepositoryScanningConfiguration

  The details of the scanning configuration for a repository.

• RepositoryScanningConfigurationFailure

  The details about any failures associated with the scanning configuration of a repository.

• Resource

  Details about the resource involved in a finding.

• ResourceDetails

  Contains details about the resource involved in the finding.

• ScanningRepositoryFilter

  The details of a scanning repository filter. For more information on how to use filters, see Using filters in the Amazon Elastic Container Registry User Guide.

• ScoreDetails

  Information about the Amazon Inspector score given to a finding.

• Tag

  The metadata to apply to a resource to help you categorize and organize them. Each tag consists of a key and a value, both of which you define. Tag keys can have a maximum character length of 128 characters, and tag values can have a maximum length of 256 characters.

• VulnerablePackage

  Information on the vulnerable package identified by a finding.

Enums

• EncryptionType
  When writing a match expression against EncryptionType, 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.
• FindingSeverity
  When writing a match expression against FindingSeverity, 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.
• ImageActionType
  When writing a match expression against ImageActionType, 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.
• ImageFailureCode
  When writing a match expression against ImageFailureCode, 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.
• ImageTagMutability
  When writing a match expression against ImageTagMutability, 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.
• LayerAvailability
  When writing a match expression against LayerAvailability, 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.
• LayerFailureCode
  When writing a match expression against LayerFailureCode, 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.
• LifecyclePolicyPreviewStatus
  When writing a match expression against LifecyclePolicyPreviewStatus, 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.
• RctAppliedFor
  When writing a match expression against RctAppliedFor, 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.
• ReplicationStatus
  When writing a match expression against ReplicationStatus, 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.
• RepositoryFilterType
  When writing a match expression against RepositoryFilterType, 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.
• ScanFrequency
  When writing a match expression against ScanFrequency, 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.
• ScanStatus
  When writing a match expression against ScanStatus, 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.
• ScanType
  When writing a match expression against ScanType, 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.
• ScanningConfigurationFailureCode
  When writing a match expression against ScanningConfigurationFailureCode, 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.
• ScanningRepositoryFilterType
  When writing a match expression against ScanningRepositoryFilterType, 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.
• TagStatus
  When writing a match expression against TagStatus, 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.
• UpstreamRegistry
  When writing a match expression against UpstreamRegistry, 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.