Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Attribute

type Attribute struct {

	// The attribute key.
	//
	// This member is required.
	Key *string

	// The value assigned to the attribute key.
	Value *string
}

    This data type is used in the ImageScanFinding data type.

    type AuthorizationData

    type AuthorizationData struct {
    
    	// A base64-encoded string that contains authorization data for the specified
    	// Amazon ECR registry. When the string is decoded, it is presented in the format
    	// user:password for private registry authentication using docker login.
    	AuthorizationToken *string
    
    	// The Unix time in seconds and milliseconds when the authorization token expires.
    	// Authorization tokens are valid for 12 hours.
    	ExpiresAt *time.Time
    
    	// The registry URL to use for this authorization token in a docker login command.
    	// The Amazon ECR registry URL format is
    	// https://aws_account_id.dkr.ecr.region.amazonaws.com. For example,
    	// https://012345678910.dkr.ecr.us-east-1.amazonaws.com..
    	ProxyEndpoint *string
    }

      An object representing authorization data for an Amazon ECR registry.

      type DescribeImagesFilter

      type DescribeImagesFilter struct {
      
      	// The tag status with which to filter your DescribeImages results. You can filter
      	// results based on whether they are TAGGED or UNTAGGED.
      	TagStatus TagStatus
      }

        An object representing a filter on a DescribeImages operation.

        type EmptyUploadException

        type EmptyUploadException struct {
        	Message *string
        }

          The specified layer upload does not contain any layer parts.

          func (*EmptyUploadException) Error

          func (e *EmptyUploadException) Error() string

          func (*EmptyUploadException) ErrorCode

          func (e *EmptyUploadException) ErrorCode() string

          func (*EmptyUploadException) ErrorFault

          func (e *EmptyUploadException) ErrorFault() smithy.ErrorFault

          func (*EmptyUploadException) ErrorMessage

          func (e *EmptyUploadException) ErrorMessage() string

          type EncryptionConfiguration

          type EncryptionConfiguration struct {
          
          	// The encryption type to use. If you use the KMS encryption type, the contents of
          	// the repository will be encrypted using server-side encryption with customer
          	// master keys (CMKs) stored in AWS KMS. When you use AWS KMS to encrypt your data,
          	// you can either use the default AWS managed CMK for Amazon ECR, or specify your
          	// own CMK, which you already created. For more information, see Protecting Data
          	// Using Server-Side Encryption with CMKs Stored in AWS Key Management Service
          	// (SSE-KMS)
          	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html) in the
          	// Amazon Simple Storage Service Console Developer Guide.. If you use the AES256
          	// encryption type, Amazon ECR uses server-side encryption with Amazon S3-managed
          	// encryption keys which encrypts the images in the repository using an AES-256
          	// encryption algorithm. For more information, see Protecting Data Using
          	// Server-Side Encryption with Amazon S3-Managed Encryption Keys (SSE-S3)
          	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html)
          	// in the Amazon Simple Storage Service Console Developer Guide..
          	//
          	// This member is required.
          	EncryptionType EncryptionType
          
          	// If you use the KMS encryption type, specify the CMK to use for encryption. The
          	// alias, key ID, or full ARN of the CMK can be specified. The key must exist in
          	// the same Region as the repository. If no key is specified, the default AWS
          	// managed CMK for Amazon ECR will be used.
          	KmsKey *string
          }

            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 AES-256 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 customer master keys (CMKs) stored in AWS Key Management Service (AWS KMS) to encrypt your images. For more information, see Amazon ECR encryption at rest (https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html) in the Amazon Elastic Container Registry User Guide.

            type EncryptionType

            type EncryptionType string
            const (
            	EncryptionTypeAes256 EncryptionType = "AES256"
            	EncryptionTypeKms    EncryptionType = "KMS"
            )

              Enum values for EncryptionType

              func (EncryptionType) Values

              func (EncryptionType) Values() []EncryptionType

                Values returns all known values for EncryptionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                type FindingSeverity

                type FindingSeverity string
                const (
                	FindingSeverityInformational FindingSeverity = "INFORMATIONAL"
                	FindingSeverityLow           FindingSeverity = "LOW"
                	FindingSeverityMedium        FindingSeverity = "MEDIUM"
                	FindingSeverityHigh          FindingSeverity = "HIGH"
                	FindingSeverityCritical      FindingSeverity = "CRITICAL"
                	FindingSeverityUndefined     FindingSeverity = "UNDEFINED"
                )

                  Enum values for FindingSeverity

                  func (FindingSeverity) Values

                  func (FindingSeverity) Values() []FindingSeverity

                    Values returns all known values for FindingSeverity. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                    type Image

                    type Image struct {
                    
                    	// An object containing the image tag and image digest associated with an image.
                    	ImageId *ImageIdentifier
                    
                    	// The image manifest associated with the image.
                    	ImageManifest *string
                    
                    	// The manifest media type of the image.
                    	ImageManifestMediaType *string
                    
                    	// The AWS account ID associated with the registry containing the image.
                    	RegistryId *string
                    
                    	// The name of the repository associated with the image.
                    	RepositoryName *string
                    }

                      An object representing an Amazon ECR image.

                      type ImageActionType

                      type ImageActionType string
                      const (
                      	ImageActionTypeExpire ImageActionType = "EXPIRE"
                      )

                        Enum values for ImageActionType

                        func (ImageActionType) Values

                        func (ImageActionType) Values() []ImageActionType

                          Values returns all known values for ImageActionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                          type ImageAlreadyExistsException

                          type ImageAlreadyExistsException struct {
                          	Message *string
                          }

                            The specified image has already been pushed, and there were no changes to the manifest or image tag after the last push.

                            func (*ImageAlreadyExistsException) Error

                            func (*ImageAlreadyExistsException) ErrorCode

                            func (e *ImageAlreadyExistsException) ErrorCode() string

                            func (*ImageAlreadyExistsException) ErrorFault

                            func (*ImageAlreadyExistsException) ErrorMessage

                            func (e *ImageAlreadyExistsException) ErrorMessage() string

                            type ImageDetail

                            type ImageDetail struct {
                            
                            	// The artifact media type of the image.
                            	ArtifactMediaType *string
                            
                            	// The sha256 digest of the image manifest.
                            	ImageDigest *string
                            
                            	// The media type of the image manifest.
                            	ImageManifestMediaType *string
                            
                            	// The date and time, expressed in standard JavaScript date format, at which the
                            	// current image was pushed to the repository.
                            	ImagePushedAt *time.Time
                            
                            	// A summary of the last completed image scan.
                            	ImageScanFindingsSummary *ImageScanFindingsSummary
                            
                            	// The current state of the scan.
                            	ImageScanStatus *ImageScanStatus
                            
                            	// The size, in bytes, of the image in the repository. If the image is a manifest
                            	// list, this will be the max size of all manifests in the list. Beginning with
                            	// Docker version 1.9, the Docker client compresses image layers before pushing
                            	// them to a V2 Docker registry. The output of the docker images command shows the
                            	// uncompressed image size, so it may return a larger image size than the image
                            	// sizes returned by DescribeImages.
                            	ImageSizeInBytes *int64
                            
                            	// The list of tags associated with this image.
                            	ImageTags []string
                            
                            	// The AWS account ID associated with the registry to which this image belongs.
                            	RegistryId *string
                            
                            	// The name of the repository to which this image belongs.
                            	RepositoryName *string
                            }

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

                              type ImageDigestDoesNotMatchException

                              type ImageDigestDoesNotMatchException struct {
                              	Message *string
                              }

                                The specified image digest does not match the digest that Amazon ECR calculated for the image.

                                func (*ImageDigestDoesNotMatchException) Error

                                func (*ImageDigestDoesNotMatchException) ErrorCode

                                func (*ImageDigestDoesNotMatchException) ErrorFault

                                func (*ImageDigestDoesNotMatchException) ErrorMessage

                                func (e *ImageDigestDoesNotMatchException) ErrorMessage() string

                                type ImageFailure

                                type ImageFailure struct {
                                
                                	// The code associated with the failure.
                                	FailureCode ImageFailureCode
                                
                                	// The reason for the failure.
                                	FailureReason *string
                                
                                	// The image ID associated with the failure.
                                	ImageId *ImageIdentifier
                                }

                                  An object representing an Amazon ECR image failure.

                                  type ImageFailureCode

                                  type ImageFailureCode string
                                  const (
                                  	ImageFailureCodeInvalidImageDigest            ImageFailureCode = "InvalidImageDigest"
                                  	ImageFailureCodeInvalidImageTag               ImageFailureCode = "InvalidImageTag"
                                  	ImageFailureCodeImageTagDoesNotMatchDigest    ImageFailureCode = "ImageTagDoesNotMatchDigest"
                                  	ImageFailureCodeImageNotFound                 ImageFailureCode = "ImageNotFound"
                                  	ImageFailureCodeMissingDigestAndTag           ImageFailureCode = "MissingDigestAndTag"
                                  	ImageFailureCodeImageReferencedByManifestList ImageFailureCode = "ImageReferencedByManifestList"
                                  	ImageFailureCodeKmsError                      ImageFailureCode = "KmsError"
                                  )

                                    Enum values for ImageFailureCode

                                    func (ImageFailureCode) Values

                                      Values returns all known values for ImageFailureCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                      type ImageIdentifier

                                      type ImageIdentifier struct {
                                      
                                      	// The sha256 digest of the image manifest.
                                      	ImageDigest *string
                                      
                                      	// The tag used for the image.
                                      	ImageTag *string
                                      }

                                        An object with identifying information for an Amazon ECR image.

                                        type ImageNotFoundException

                                        type ImageNotFoundException struct {
                                        	Message *string
                                        }

                                          The image requested does not exist in the specified repository.

                                          func (*ImageNotFoundException) Error

                                          func (e *ImageNotFoundException) Error() string

                                          func (*ImageNotFoundException) ErrorCode

                                          func (e *ImageNotFoundException) ErrorCode() string

                                          func (*ImageNotFoundException) ErrorFault

                                          func (e *ImageNotFoundException) ErrorFault() smithy.ErrorFault

                                          func (*ImageNotFoundException) ErrorMessage

                                          func (e *ImageNotFoundException) ErrorMessage() string

                                          type ImageScanFinding

                                          type ImageScanFinding struct {
                                          
                                          	// A collection of attributes of the host from which the finding is generated.
                                          	Attributes []Attribute
                                          
                                          	// The description of the finding.
                                          	Description *string
                                          
                                          	// The name associated with the finding, usually a CVE number.
                                          	Name *string
                                          
                                          	// The finding severity.
                                          	Severity FindingSeverity
                                          
                                          	// A link containing additional details about the security vulnerability.
                                          	Uri *string
                                          }

                                            Contains information about an image scan finding.

                                            type ImageScanFindings

                                            type ImageScanFindings struct {
                                            
                                            	// The image vulnerability counts, sorted by severity.
                                            	FindingSeverityCounts map[string]int32
                                            
                                            	// The findings from the image scan.
                                            	Findings []ImageScanFinding
                                            
                                            	// The time of the last completed image scan.
                                            	ImageScanCompletedAt *time.Time
                                            
                                            	// The time when the vulnerability data was last scanned.
                                            	VulnerabilitySourceUpdatedAt *time.Time
                                            }

                                              The details of an image scan.

                                              type ImageScanFindingsSummary

                                              type ImageScanFindingsSummary struct {
                                              
                                              	// The image vulnerability counts, sorted by severity.
                                              	FindingSeverityCounts map[string]int32
                                              
                                              	// The time of the last completed image scan.
                                              	ImageScanCompletedAt *time.Time
                                              
                                              	// The time when the vulnerability data was last scanned.
                                              	VulnerabilitySourceUpdatedAt *time.Time
                                              }

                                                A summary of the last completed image scan.

                                                type ImageScanStatus

                                                type ImageScanStatus struct {
                                                
                                                	// The description of the image scan status.
                                                	Description *string
                                                
                                                	// The current state of an image scan.
                                                	Status ScanStatus
                                                }

                                                  The current status of an image scan.

                                                  type ImageScanningConfiguration

                                                  type ImageScanningConfiguration struct {
                                                  
                                                  	// The setting that determines whether images are scanned after being pushed to a
                                                  	// repository. If set to true, images will be scanned after being pushed. If this
                                                  	// parameter is not specified, it will default to false and images will not be
                                                  	// scanned unless a scan is manually started with the StartImageScan API.
                                                  	ScanOnPush bool
                                                  }

                                                    The image scanning configuration for a repository.

                                                    type ImageTagAlreadyExistsException

                                                    type ImageTagAlreadyExistsException struct {
                                                    	Message *string
                                                    }

                                                      The specified image is tagged with a tag that already exists. The repository is configured for tag immutability.

                                                      func (*ImageTagAlreadyExistsException) Error

                                                      func (*ImageTagAlreadyExistsException) ErrorCode

                                                      func (e *ImageTagAlreadyExistsException) ErrorCode() string

                                                      func (*ImageTagAlreadyExistsException) ErrorFault

                                                      func (*ImageTagAlreadyExistsException) ErrorMessage

                                                      func (e *ImageTagAlreadyExistsException) ErrorMessage() string

                                                      type ImageTagMutability

                                                      type ImageTagMutability string
                                                      const (
                                                      	ImageTagMutabilityMutable   ImageTagMutability = "MUTABLE"
                                                      	ImageTagMutabilityImmutable ImageTagMutability = "IMMUTABLE"
                                                      )

                                                        Enum values for ImageTagMutability

                                                        func (ImageTagMutability) Values

                                                          Values returns all known values for ImageTagMutability. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                          type InvalidLayerException

                                                          type InvalidLayerException struct {
                                                          	Message *string
                                                          }

                                                            The layer digest calculation performed by Amazon ECR upon receipt of the image layer does not match the digest specified.

                                                            func (*InvalidLayerException) Error

                                                            func (e *InvalidLayerException) Error() string

                                                            func (*InvalidLayerException) ErrorCode

                                                            func (e *InvalidLayerException) ErrorCode() string

                                                            func (*InvalidLayerException) ErrorFault

                                                            func (e *InvalidLayerException) ErrorFault() smithy.ErrorFault

                                                            func (*InvalidLayerException) ErrorMessage

                                                            func (e *InvalidLayerException) ErrorMessage() string

                                                            type InvalidLayerPartException

                                                            type InvalidLayerPartException struct {
                                                            	Message *string
                                                            
                                                            	RegistryId            *string
                                                            	RepositoryName        *string
                                                            	UploadId              *string
                                                            	LastValidByteReceived *int64
                                                            }

                                                              The layer part size is not valid, or the first byte specified is not consecutive to the last byte of a previous layer part upload.

                                                              func (*InvalidLayerPartException) Error

                                                              func (e *InvalidLayerPartException) Error() string

                                                              func (*InvalidLayerPartException) ErrorCode

                                                              func (e *InvalidLayerPartException) ErrorCode() string

                                                              func (*InvalidLayerPartException) ErrorFault

                                                              func (*InvalidLayerPartException) ErrorMessage

                                                              func (e *InvalidLayerPartException) ErrorMessage() string

                                                              type InvalidParameterException

                                                              type InvalidParameterException struct {
                                                              	Message *string
                                                              }

                                                                The specified parameter is invalid. Review the available parameters for the API request.

                                                                func (*InvalidParameterException) Error

                                                                func (e *InvalidParameterException) Error() string

                                                                func (*InvalidParameterException) ErrorCode

                                                                func (e *InvalidParameterException) ErrorCode() string

                                                                func (*InvalidParameterException) ErrorFault

                                                                func (*InvalidParameterException) ErrorMessage

                                                                func (e *InvalidParameterException) ErrorMessage() string

                                                                type InvalidTagParameterException

                                                                type InvalidTagParameterException struct {
                                                                	Message *string
                                                                }

                                                                  An invalid parameter has been specified. Tag keys can have a maximum character length of 128 characters, and tag values can have a maximum length of 256 characters.

                                                                  func (*InvalidTagParameterException) Error

                                                                  func (*InvalidTagParameterException) ErrorCode

                                                                  func (e *InvalidTagParameterException) ErrorCode() string

                                                                  func (*InvalidTagParameterException) ErrorFault

                                                                  func (*InvalidTagParameterException) ErrorMessage

                                                                  func (e *InvalidTagParameterException) ErrorMessage() string

                                                                  type KmsException

                                                                  type KmsException struct {
                                                                  	Message *string
                                                                  
                                                                  	KmsError *string
                                                                  }

                                                                    The operation failed due to a KMS exception.

                                                                    func (*KmsException) Error

                                                                    func (e *KmsException) Error() string

                                                                    func (*KmsException) ErrorCode

                                                                    func (e *KmsException) ErrorCode() string

                                                                    func (*KmsException) ErrorFault

                                                                    func (e *KmsException) ErrorFault() smithy.ErrorFault

                                                                    func (*KmsException) ErrorMessage

                                                                    func (e *KmsException) ErrorMessage() string

                                                                    type Layer

                                                                    type Layer struct {
                                                                    
                                                                    	// The availability status of the image layer.
                                                                    	LayerAvailability LayerAvailability
                                                                    
                                                                    	// The sha256 digest of the image layer.
                                                                    	LayerDigest *string
                                                                    
                                                                    	// The size, in bytes, of the image layer.
                                                                    	LayerSize *int64
                                                                    
                                                                    	// The media type of the layer, such as
                                                                    	// application/vnd.docker.image.rootfs.diff.tar.gzip or
                                                                    	// application/vnd.oci.image.layer.v1.tar+gzip.
                                                                    	MediaType *string
                                                                    }

                                                                      An object representing an Amazon ECR image layer.

                                                                      type LayerAlreadyExistsException

                                                                      type LayerAlreadyExistsException struct {
                                                                      	Message *string
                                                                      }

                                                                        The image layer already exists in the associated repository.

                                                                        func (*LayerAlreadyExistsException) Error

                                                                        func (*LayerAlreadyExistsException) ErrorCode

                                                                        func (e *LayerAlreadyExistsException) ErrorCode() string

                                                                        func (*LayerAlreadyExistsException) ErrorFault

                                                                        func (*LayerAlreadyExistsException) ErrorMessage

                                                                        func (e *LayerAlreadyExistsException) ErrorMessage() string

                                                                        type LayerAvailability

                                                                        type LayerAvailability string
                                                                        const (
                                                                        	LayerAvailabilityAvailable   LayerAvailability = "AVAILABLE"
                                                                        	LayerAvailabilityUnavailable LayerAvailability = "UNAVAILABLE"
                                                                        )

                                                                          Enum values for LayerAvailability

                                                                          func (LayerAvailability) Values

                                                                            Values returns all known values for LayerAvailability. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                            type LayerFailure

                                                                            type LayerFailure struct {
                                                                            
                                                                            	// The failure code associated with the failure.
                                                                            	FailureCode LayerFailureCode
                                                                            
                                                                            	// The reason for the failure.
                                                                            	FailureReason *string
                                                                            
                                                                            	// The layer digest associated with the failure.
                                                                            	LayerDigest *string
                                                                            }

                                                                              An object representing an Amazon ECR image layer failure.

                                                                              type LayerFailureCode

                                                                              type LayerFailureCode string
                                                                              const (
                                                                              	LayerFailureCodeInvalidLayerDigest LayerFailureCode = "InvalidLayerDigest"
                                                                              	LayerFailureCodeMissingLayerDigest LayerFailureCode = "MissingLayerDigest"
                                                                              )

                                                                                Enum values for LayerFailureCode

                                                                                func (LayerFailureCode) Values

                                                                                  Values returns all known values for LayerFailureCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                  type LayerInaccessibleException

                                                                                  type LayerInaccessibleException struct {
                                                                                  	Message *string
                                                                                  }

                                                                                    The specified layer is not available because it is not associated with an image. Unassociated image layers may be cleaned up at any time.

                                                                                    func (*LayerInaccessibleException) Error

                                                                                    func (*LayerInaccessibleException) ErrorCode

                                                                                    func (e *LayerInaccessibleException) ErrorCode() string

                                                                                    func (*LayerInaccessibleException) ErrorFault

                                                                                    func (*LayerInaccessibleException) ErrorMessage

                                                                                    func (e *LayerInaccessibleException) ErrorMessage() string

                                                                                    type LayerPartTooSmallException

                                                                                    type LayerPartTooSmallException struct {
                                                                                    	Message *string
                                                                                    }

                                                                                      Layer parts must be at least 5 MiB in size.

                                                                                      func (*LayerPartTooSmallException) Error

                                                                                      func (*LayerPartTooSmallException) ErrorCode

                                                                                      func (e *LayerPartTooSmallException) ErrorCode() string

                                                                                      func (*LayerPartTooSmallException) ErrorFault

                                                                                      func (*LayerPartTooSmallException) ErrorMessage

                                                                                      func (e *LayerPartTooSmallException) ErrorMessage() string

                                                                                      type LayersNotFoundException

                                                                                      type LayersNotFoundException struct {
                                                                                      	Message *string
                                                                                      }

                                                                                        The specified layers could not be found, or the specified layer is not valid for this repository.

                                                                                        func (*LayersNotFoundException) Error

                                                                                        func (e *LayersNotFoundException) Error() string

                                                                                        func (*LayersNotFoundException) ErrorCode

                                                                                        func (e *LayersNotFoundException) ErrorCode() string

                                                                                        func (*LayersNotFoundException) ErrorFault

                                                                                        func (e *LayersNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                        func (*LayersNotFoundException) ErrorMessage

                                                                                        func (e *LayersNotFoundException) ErrorMessage() string

                                                                                        type LifecyclePolicyNotFoundException

                                                                                        type LifecyclePolicyNotFoundException struct {
                                                                                        	Message *string
                                                                                        }

                                                                                          The lifecycle policy could not be found, and no policy is set to the repository.

                                                                                          func (*LifecyclePolicyNotFoundException) Error

                                                                                          func (*LifecyclePolicyNotFoundException) ErrorCode

                                                                                          func (*LifecyclePolicyNotFoundException) ErrorFault

                                                                                          func (*LifecyclePolicyNotFoundException) ErrorMessage

                                                                                          func (e *LifecyclePolicyNotFoundException) ErrorMessage() string

                                                                                          type LifecyclePolicyPreviewFilter

                                                                                          type LifecyclePolicyPreviewFilter struct {
                                                                                          
                                                                                          	// The tag status of the image.
                                                                                          	TagStatus TagStatus
                                                                                          }

                                                                                            The filter for the lifecycle policy preview.

                                                                                            type LifecyclePolicyPreviewInProgressException

                                                                                            type LifecyclePolicyPreviewInProgressException struct {
                                                                                            	Message *string
                                                                                            }

                                                                                              The previous lifecycle policy preview request has not completed. Wait and try again.

                                                                                              func (*LifecyclePolicyPreviewInProgressException) Error

                                                                                              func (*LifecyclePolicyPreviewInProgressException) ErrorCode

                                                                                              func (*LifecyclePolicyPreviewInProgressException) ErrorFault

                                                                                              func (*LifecyclePolicyPreviewInProgressException) ErrorMessage

                                                                                              type LifecyclePolicyPreviewNotFoundException

                                                                                              type LifecyclePolicyPreviewNotFoundException struct {
                                                                                              	Message *string
                                                                                              }

                                                                                                There is no dry run for this repository.

                                                                                                func (*LifecyclePolicyPreviewNotFoundException) Error

                                                                                                func (*LifecyclePolicyPreviewNotFoundException) ErrorCode

                                                                                                func (*LifecyclePolicyPreviewNotFoundException) ErrorFault

                                                                                                func (*LifecyclePolicyPreviewNotFoundException) ErrorMessage

                                                                                                type LifecyclePolicyPreviewResult

                                                                                                type LifecyclePolicyPreviewResult struct {
                                                                                                
                                                                                                	// The type of action to be taken.
                                                                                                	Action *LifecyclePolicyRuleAction
                                                                                                
                                                                                                	// The priority of the applied rule.
                                                                                                	AppliedRulePriority *int32
                                                                                                
                                                                                                	// The sha256 digest of the image manifest.
                                                                                                	ImageDigest *string
                                                                                                
                                                                                                	// The date and time, expressed in standard JavaScript date format, at which the
                                                                                                	// current image was pushed to the repository.
                                                                                                	ImagePushedAt *time.Time
                                                                                                
                                                                                                	// The list of tags associated with this image.
                                                                                                	ImageTags []string
                                                                                                }

                                                                                                  The result of the lifecycle policy preview.

                                                                                                  type LifecyclePolicyPreviewStatus

                                                                                                  type LifecyclePolicyPreviewStatus string
                                                                                                  const (
                                                                                                  	LifecyclePolicyPreviewStatusInProgress LifecyclePolicyPreviewStatus = "IN_PROGRESS"
                                                                                                  	LifecyclePolicyPreviewStatusComplete   LifecyclePolicyPreviewStatus = "COMPLETE"
                                                                                                  	LifecyclePolicyPreviewStatusExpired    LifecyclePolicyPreviewStatus = "EXPIRED"
                                                                                                  	LifecyclePolicyPreviewStatusFailed     LifecyclePolicyPreviewStatus = "FAILED"
                                                                                                  )

                                                                                                    Enum values for LifecyclePolicyPreviewStatus

                                                                                                    func (LifecyclePolicyPreviewStatus) Values

                                                                                                      Values returns all known values for LifecyclePolicyPreviewStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                      type LifecyclePolicyPreviewSummary

                                                                                                      type LifecyclePolicyPreviewSummary struct {
                                                                                                      
                                                                                                      	// The number of expiring images.
                                                                                                      	ExpiringImageTotalCount *int32
                                                                                                      }

                                                                                                        The summary of the lifecycle policy preview request.

                                                                                                        type LifecyclePolicyRuleAction

                                                                                                        type LifecyclePolicyRuleAction struct {
                                                                                                        
                                                                                                        	// The type of action to be taken.
                                                                                                        	Type ImageActionType
                                                                                                        }

                                                                                                          The type of action to be taken.

                                                                                                          type LimitExceededException

                                                                                                          type LimitExceededException struct {
                                                                                                          	Message *string
                                                                                                          }

                                                                                                            The operation did not succeed because it would have exceeded a service limit for your account. For more information, see Amazon ECR Service Quotas (https://docs.aws.amazon.com/AmazonECR/latest/userguide/service-quotas.html) in the Amazon Elastic Container Registry User Guide.

                                                                                                            func (*LimitExceededException) Error

                                                                                                            func (e *LimitExceededException) Error() string

                                                                                                            func (*LimitExceededException) ErrorCode

                                                                                                            func (e *LimitExceededException) ErrorCode() string

                                                                                                            func (*LimitExceededException) ErrorFault

                                                                                                            func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                                                                            func (*LimitExceededException) ErrorMessage

                                                                                                            func (e *LimitExceededException) ErrorMessage() string

                                                                                                            type ListImagesFilter

                                                                                                            type ListImagesFilter struct {
                                                                                                            
                                                                                                            	// The tag status with which to filter your ListImages results. You can filter
                                                                                                            	// results based on whether they are TAGGED or UNTAGGED.
                                                                                                            	TagStatus TagStatus
                                                                                                            }

                                                                                                              An object representing a filter on a ListImages operation.

                                                                                                              type ReferencedImagesNotFoundException

                                                                                                              type ReferencedImagesNotFoundException struct {
                                                                                                              	Message *string
                                                                                                              }

                                                                                                                The manifest list is referencing an image that does not exist.

                                                                                                                func (*ReferencedImagesNotFoundException) Error

                                                                                                                func (*ReferencedImagesNotFoundException) ErrorCode

                                                                                                                func (*ReferencedImagesNotFoundException) ErrorFault

                                                                                                                func (*ReferencedImagesNotFoundException) ErrorMessage

                                                                                                                func (e *ReferencedImagesNotFoundException) ErrorMessage() string

                                                                                                                type RegistryPolicyNotFoundException

                                                                                                                type RegistryPolicyNotFoundException struct {
                                                                                                                	Message *string
                                                                                                                }

                                                                                                                  The registry doesn't have an associated registry policy.

                                                                                                                  func (*RegistryPolicyNotFoundException) Error

                                                                                                                  func (*RegistryPolicyNotFoundException) ErrorCode

                                                                                                                  func (e *RegistryPolicyNotFoundException) ErrorCode() string

                                                                                                                  func (*RegistryPolicyNotFoundException) ErrorFault

                                                                                                                  func (*RegistryPolicyNotFoundException) ErrorMessage

                                                                                                                  func (e *RegistryPolicyNotFoundException) ErrorMessage() string

                                                                                                                  type ReplicationConfiguration

                                                                                                                  type ReplicationConfiguration struct {
                                                                                                                  
                                                                                                                  	// An array of objects representing the replication rules for a replication
                                                                                                                  	// configuration. A replication configuration may contain only one replication rule
                                                                                                                  	// but the rule may contain one or more replication destinations.
                                                                                                                  	//
                                                                                                                  	// This member is required.
                                                                                                                  	Rules []ReplicationRule
                                                                                                                  }

                                                                                                                    The replication configuration for a registry.

                                                                                                                    type ReplicationDestination

                                                                                                                    type ReplicationDestination struct {
                                                                                                                    
                                                                                                                    	// A Region to replicate to.
                                                                                                                    	//
                                                                                                                    	// This member is required.
                                                                                                                    	Region *string
                                                                                                                    
                                                                                                                    	// The account ID of the destination registry to replicate to.
                                                                                                                    	//
                                                                                                                    	// This member is required.
                                                                                                                    	RegistryId *string
                                                                                                                    }

                                                                                                                      An array of objects representing the details of a replication destination.

                                                                                                                      type ReplicationRule

                                                                                                                      type ReplicationRule struct {
                                                                                                                      
                                                                                                                      	// An array of objects representing the details of a replication destination.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	Destinations []ReplicationDestination
                                                                                                                      }

                                                                                                                        An array of objects representing the replication destinations for a replication configuration. A replication configuration may contain only one replication rule but the rule may contain one or more replication destinations.

                                                                                                                        type Repository

                                                                                                                        type Repository struct {
                                                                                                                        
                                                                                                                        	// The date and time, in JavaScript date format, when the repository was created.
                                                                                                                        	CreatedAt *time.Time
                                                                                                                        
                                                                                                                        	// The encryption configuration for the repository. This determines how the
                                                                                                                        	// contents of your repository are encrypted at rest.
                                                                                                                        	EncryptionConfiguration *EncryptionConfiguration
                                                                                                                        
                                                                                                                        	// The image scanning configuration for a repository.
                                                                                                                        	ImageScanningConfiguration *ImageScanningConfiguration
                                                                                                                        
                                                                                                                        	// The tag mutability setting for the repository.
                                                                                                                        	ImageTagMutability ImageTagMutability
                                                                                                                        
                                                                                                                        	// The AWS account ID associated with the registry that contains the repository.
                                                                                                                        	RegistryId *string
                                                                                                                        
                                                                                                                        	// The Amazon Resource Name (ARN) that identifies the repository. The ARN contains
                                                                                                                        	// the arn:aws:ecr namespace, followed by the region of the repository, AWS account
                                                                                                                        	// ID of the repository owner, repository namespace, and repository name. For
                                                                                                                        	// example, arn:aws:ecr:region:012345678910:repository/test.
                                                                                                                        	RepositoryArn *string
                                                                                                                        
                                                                                                                        	// The name of the repository.
                                                                                                                        	RepositoryName *string
                                                                                                                        
                                                                                                                        	// The URI for the repository. You can use this URI for container image push and
                                                                                                                        	// pull operations.
                                                                                                                        	RepositoryUri *string
                                                                                                                        }

                                                                                                                          An object representing a repository.

                                                                                                                          type RepositoryAlreadyExistsException

                                                                                                                          type RepositoryAlreadyExistsException struct {
                                                                                                                          	Message *string
                                                                                                                          }

                                                                                                                            The specified repository already exists in the specified registry.

                                                                                                                            func (*RepositoryAlreadyExistsException) Error

                                                                                                                            func (*RepositoryAlreadyExistsException) ErrorCode

                                                                                                                            func (*RepositoryAlreadyExistsException) ErrorFault

                                                                                                                            func (*RepositoryAlreadyExistsException) ErrorMessage

                                                                                                                            func (e *RepositoryAlreadyExistsException) ErrorMessage() string

                                                                                                                            type RepositoryNotEmptyException

                                                                                                                            type RepositoryNotEmptyException struct {
                                                                                                                            	Message *string
                                                                                                                            }

                                                                                                                              The specified repository contains images. To delete a repository that contains images, you must force the deletion with the force parameter.

                                                                                                                              func (*RepositoryNotEmptyException) Error

                                                                                                                              func (*RepositoryNotEmptyException) ErrorCode

                                                                                                                              func (e *RepositoryNotEmptyException) ErrorCode() string

                                                                                                                              func (*RepositoryNotEmptyException) ErrorFault

                                                                                                                              func (*RepositoryNotEmptyException) ErrorMessage

                                                                                                                              func (e *RepositoryNotEmptyException) ErrorMessage() string

                                                                                                                              type RepositoryNotFoundException

                                                                                                                              type RepositoryNotFoundException struct {
                                                                                                                              	Message *string
                                                                                                                              }

                                                                                                                                The specified repository could not be found. Check the spelling of the specified repository and ensure that you are performing operations on the correct registry.

                                                                                                                                func (*RepositoryNotFoundException) Error

                                                                                                                                func (*RepositoryNotFoundException) ErrorCode

                                                                                                                                func (e *RepositoryNotFoundException) ErrorCode() string

                                                                                                                                func (*RepositoryNotFoundException) ErrorFault

                                                                                                                                func (*RepositoryNotFoundException) ErrorMessage

                                                                                                                                func (e *RepositoryNotFoundException) ErrorMessage() string

                                                                                                                                type RepositoryPolicyNotFoundException

                                                                                                                                type RepositoryPolicyNotFoundException struct {
                                                                                                                                	Message *string
                                                                                                                                }

                                                                                                                                  The specified repository and registry combination does not have an associated repository policy.

                                                                                                                                  func (*RepositoryPolicyNotFoundException) Error

                                                                                                                                  func (*RepositoryPolicyNotFoundException) ErrorCode

                                                                                                                                  func (*RepositoryPolicyNotFoundException) ErrorFault

                                                                                                                                  func (*RepositoryPolicyNotFoundException) ErrorMessage

                                                                                                                                  func (e *RepositoryPolicyNotFoundException) ErrorMessage() string

                                                                                                                                  type ScanNotFoundException

                                                                                                                                  type ScanNotFoundException struct {
                                                                                                                                  	Message *string
                                                                                                                                  }

                                                                                                                                    The specified image scan could not be found. Ensure that image scanning is enabled on the repository and try again.

                                                                                                                                    func (*ScanNotFoundException) Error

                                                                                                                                    func (e *ScanNotFoundException) Error() string

                                                                                                                                    func (*ScanNotFoundException) ErrorCode

                                                                                                                                    func (e *ScanNotFoundException) ErrorCode() string

                                                                                                                                    func (*ScanNotFoundException) ErrorFault

                                                                                                                                    func (e *ScanNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                                                                    func (*ScanNotFoundException) ErrorMessage

                                                                                                                                    func (e *ScanNotFoundException) ErrorMessage() string

                                                                                                                                    type ScanStatus

                                                                                                                                    type ScanStatus string
                                                                                                                                    const (
                                                                                                                                    	ScanStatusInProgress ScanStatus = "IN_PROGRESS"
                                                                                                                                    	ScanStatusComplete   ScanStatus = "COMPLETE"
                                                                                                                                    	ScanStatusFailed     ScanStatus = "FAILED"
                                                                                                                                    )

                                                                                                                                      Enum values for ScanStatus

                                                                                                                                      func (ScanStatus) Values

                                                                                                                                      func (ScanStatus) Values() []ScanStatus

                                                                                                                                        Values returns all known values for ScanStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                        type ServerException

                                                                                                                                        type ServerException struct {
                                                                                                                                        	Message *string
                                                                                                                                        }

                                                                                                                                          These errors are usually caused by a server-side issue.

                                                                                                                                          func (*ServerException) Error

                                                                                                                                          func (e *ServerException) Error() string

                                                                                                                                          func (*ServerException) ErrorCode

                                                                                                                                          func (e *ServerException) ErrorCode() string

                                                                                                                                          func (*ServerException) ErrorFault

                                                                                                                                          func (e *ServerException) ErrorFault() smithy.ErrorFault

                                                                                                                                          func (*ServerException) ErrorMessage

                                                                                                                                          func (e *ServerException) ErrorMessage() string

                                                                                                                                          type Tag

                                                                                                                                          type Tag struct {
                                                                                                                                          
                                                                                                                                          	// One part of a key-value pair that make up a tag. A key is a general label that
                                                                                                                                          	// acts like a category for more specific tag values.
                                                                                                                                          	Key *string
                                                                                                                                          
                                                                                                                                          	// The optional part of a key-value pair that make up a tag. A value acts as a
                                                                                                                                          	// descriptor within a tag category (key).
                                                                                                                                          	Value *string
                                                                                                                                          }

                                                                                                                                            The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional 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.

                                                                                                                                            type TagStatus

                                                                                                                                            type TagStatus string
                                                                                                                                            const (
                                                                                                                                            	TagStatusTagged   TagStatus = "TAGGED"
                                                                                                                                            	TagStatusUntagged TagStatus = "UNTAGGED"
                                                                                                                                            	TagStatusAny      TagStatus = "ANY"
                                                                                                                                            )

                                                                                                                                              Enum values for TagStatus

                                                                                                                                              func (TagStatus) Values

                                                                                                                                              func (TagStatus) Values() []TagStatus

                                                                                                                                                Values returns all known values for TagStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                type TooManyTagsException

                                                                                                                                                type TooManyTagsException struct {
                                                                                                                                                	Message *string
                                                                                                                                                }

                                                                                                                                                  The list of tags on the repository is over the limit. The maximum number of tags that can be applied to a repository is 50.

                                                                                                                                                  func (*TooManyTagsException) Error

                                                                                                                                                  func (e *TooManyTagsException) Error() string

                                                                                                                                                  func (*TooManyTagsException) ErrorCode

                                                                                                                                                  func (e *TooManyTagsException) ErrorCode() string

                                                                                                                                                  func (*TooManyTagsException) ErrorFault

                                                                                                                                                  func (e *TooManyTagsException) ErrorFault() smithy.ErrorFault

                                                                                                                                                  func (*TooManyTagsException) ErrorMessage

                                                                                                                                                  func (e *TooManyTagsException) ErrorMessage() string

                                                                                                                                                  type UnsupportedImageTypeException

                                                                                                                                                  type UnsupportedImageTypeException struct {
                                                                                                                                                  	Message *string
                                                                                                                                                  }

                                                                                                                                                    The image is of a type that cannot be scanned.

                                                                                                                                                    func (*UnsupportedImageTypeException) Error

                                                                                                                                                    func (*UnsupportedImageTypeException) ErrorCode

                                                                                                                                                    func (e *UnsupportedImageTypeException) ErrorCode() string

                                                                                                                                                    func (*UnsupportedImageTypeException) ErrorFault

                                                                                                                                                    func (*UnsupportedImageTypeException) ErrorMessage

                                                                                                                                                    func (e *UnsupportedImageTypeException) ErrorMessage() string

                                                                                                                                                    type UploadNotFoundException

                                                                                                                                                    type UploadNotFoundException struct {
                                                                                                                                                    	Message *string
                                                                                                                                                    }

                                                                                                                                                      The upload could not be found, or the specified upload ID is not valid for this repository.

                                                                                                                                                      func (*UploadNotFoundException) Error

                                                                                                                                                      func (e *UploadNotFoundException) Error() string

                                                                                                                                                      func (*UploadNotFoundException) ErrorCode

                                                                                                                                                      func (e *UploadNotFoundException) ErrorCode() string

                                                                                                                                                      func (*UploadNotFoundException) ErrorFault

                                                                                                                                                      func (e *UploadNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                                                                                      func (*UploadNotFoundException) ErrorMessage

                                                                                                                                                      func (e *UploadNotFoundException) ErrorMessage() string

                                                                                                                                                      type ValidationException

                                                                                                                                                      type ValidationException struct {
                                                                                                                                                      	Message *string
                                                                                                                                                      }

                                                                                                                                                        There was an exception validating this request.

                                                                                                                                                        func (*ValidationException) Error

                                                                                                                                                        func (e *ValidationException) Error() string

                                                                                                                                                        func (*ValidationException) ErrorCode

                                                                                                                                                        func (e *ValidationException) ErrorCode() string

                                                                                                                                                        func (*ValidationException) ErrorFault

                                                                                                                                                        func (e *ValidationException) ErrorFault() smithy.ErrorFault

                                                                                                                                                        func (*ValidationException) ErrorMessage

                                                                                                                                                        func (e *ValidationException) ErrorMessage() string