Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuthorizationData

type AuthorizationData struct {

	// A base64-encoded string that contains authorization data for a public Amazon ECR
	// registry. When the string is decoded, it is presented in the format
	// user:password for public 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
}

    An authorization token data object that corresponds to a public registry.

    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 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 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
          
          	// 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 public 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 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 ImageTagDetail

                          type ImageTagDetail struct {
                          
                          	// The time stamp indicating when the image tag was created.
                          	CreatedAt *time.Time
                          
                          	// An object that describes the details of an image.
                          	ImageDetail *ReferencedImageDetail
                          
                          	// The tag associated with the image.
                          	ImageTag *string
                          }

                            An object representing the image tag details for an image.

                            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 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 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 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 ReferencedImageDetail

                                                      type ReferencedImageDetail 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 tag was pushed to the repository.
                                                      	ImagePushedAt *time.Time
                                                      
                                                      	// 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
                                                      }

                                                        An object that describes the image tag details returned by a DescribeImageTags action.

                                                        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 Registry

                                                          type Registry struct {
                                                          
                                                          	// An array of objects representing the aliases for a public registry.
                                                          	//
                                                          	// This member is required.
                                                          	Aliases []RegistryAlias
                                                          
                                                          	// The Amazon Resource Name (ARN) of the public registry.
                                                          	//
                                                          	// This member is required.
                                                          	RegistryArn *string
                                                          
                                                          	// The AWS account ID associated with the registry. If you do not specify a
                                                          	// registry, the default public registry is assumed.
                                                          	//
                                                          	// This member is required.
                                                          	RegistryId *string
                                                          
                                                          	// The URI of a public registry. The URI contains a universal prefix and the
                                                          	// registry alias.
                                                          	//
                                                          	// This member is required.
                                                          	RegistryUri *string
                                                          
                                                          	// Whether the account is verified. This indicates whether the account is an AWS
                                                          	// Marketplace vendor. If an account is verified, each public repository will
                                                          	// received a verified account badge on the Amazon ECR Public Gallery.
                                                          	//
                                                          	// This member is required.
                                                          	Verified *bool
                                                          }

                                                            The details of a public registry.

                                                            type RegistryAlias

                                                            type RegistryAlias struct {
                                                            
                                                            	// Whether or not the registry alias is the default alias for the registry. When
                                                            	// the first public repository is created, your public registry is assigned a
                                                            	// default registry alias.
                                                            	//
                                                            	// This member is required.
                                                            	DefaultRegistryAlias bool
                                                            
                                                            	// The name of the registry alias.
                                                            	//
                                                            	// This member is required.
                                                            	Name *string
                                                            
                                                            	// Whether or not the registry alias is the primary alias for the registry. If
                                                            	// true, the alias is the primary registry alias and is displayed in both the
                                                            	// repository URL and the image URI used in the docker pull commands on the Amazon
                                                            	// ECR Public Gallery. A registry alias that is not the primary registry alias can
                                                            	// be used in the repository URI in a docker pull command.
                                                            	//
                                                            	// This member is required.
                                                            	PrimaryRegistryAlias bool
                                                            
                                                            	// The status of the registry alias.
                                                            	//
                                                            	// This member is required.
                                                            	Status RegistryAliasStatus
                                                            }

                                                              An object representing the aliases for a public registry. A public registry is given an alias upon creation but a custom alias can be set using the Amazon ECR console. For more information, see Registries (https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html) in the Amazon Elastic Container Registry User Guide.

                                                              type RegistryAliasStatus

                                                              type RegistryAliasStatus string
                                                              const (
                                                              	RegistryAliasStatusActive   RegistryAliasStatus = "ACTIVE"
                                                              	RegistryAliasStatusPending  RegistryAliasStatus = "PENDING"
                                                              	RegistryAliasStatusRejected RegistryAliasStatus = "REJECTED"
                                                              )

                                                                Enum values for RegistryAliasStatus

                                                                func (RegistryAliasStatus) Values

                                                                  Values returns all known values for RegistryAliasStatus. 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 RegistryCatalogData

                                                                  type RegistryCatalogData struct {
                                                                  
                                                                  	// The display name for a public registry. This appears on the Amazon ECR Public
                                                                  	// Gallery. Only accounts that have the verified account badge can have a registry
                                                                  	// display name.
                                                                  	DisplayName *string
                                                                  }

                                                                    The metadata for a public registry.

                                                                    type RegistryNotFoundException

                                                                    type RegistryNotFoundException struct {
                                                                    	Message *string
                                                                    }

                                                                      The registry does not exist.

                                                                      func (*RegistryNotFoundException) Error

                                                                      func (e *RegistryNotFoundException) Error() string

                                                                      func (*RegistryNotFoundException) ErrorCode

                                                                      func (e *RegistryNotFoundException) ErrorCode() string

                                                                      func (*RegistryNotFoundException) ErrorFault

                                                                      func (*RegistryNotFoundException) ErrorMessage

                                                                      func (e *RegistryNotFoundException) ErrorMessage() string

                                                                      type Repository

                                                                      type Repository struct {
                                                                      
                                                                      	// The date and time, in JavaScript date format, when the repository was created.
                                                                      	CreatedAt *time.Time
                                                                      
                                                                      	// The AWS account ID associated with the public 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 RepositoryCatalogData

                                                                          type RepositoryCatalogData struct {
                                                                          
                                                                          	// The longform description of the contents of the repository. This text appears in
                                                                          	// the repository details on the Amazon ECR Public Gallery.
                                                                          	AboutText *string
                                                                          
                                                                          	// The architecture tags that are associated with the repository. Only supported
                                                                          	// operating system tags appear publicly in the Amazon ECR Public Gallery. For more
                                                                          	// information, see RepositoryCatalogDataInput.
                                                                          	Architectures []string
                                                                          
                                                                          	// The short description of the repository.
                                                                          	Description *string
                                                                          
                                                                          	// The URL containing the logo associated with the repository.
                                                                          	LogoUrl *string
                                                                          
                                                                          	// Whether or not the repository is certified by AWS Marketplace.
                                                                          	MarketplaceCertified *bool
                                                                          
                                                                          	// The operating system tags that are associated with the repository. Only
                                                                          	// supported operating system tags appear publicly in the Amazon ECR Public
                                                                          	// Gallery. For more information, see RepositoryCatalogDataInput.
                                                                          	OperatingSystems []string
                                                                          
                                                                          	// The longform usage details of the contents of the repository. The usage text
                                                                          	// provides context for users of the repository.
                                                                          	UsageText *string
                                                                          }

                                                                            The catalog data for a repository. This data is publicly visible in the Amazon ECR Public Gallery.

                                                                            type RepositoryCatalogDataInput

                                                                            type RepositoryCatalogDataInput struct {
                                                                            
                                                                            	// A detailed description of the contents of the repository. It is publicly visible
                                                                            	// in the Amazon ECR Public Gallery. The text must be in markdown format.
                                                                            	AboutText *string
                                                                            
                                                                            	// The system architecture that the images in the repository are compatible with.
                                                                            	// On the Amazon ECR Public Gallery, the following supported architectures will
                                                                            	// appear as badges on the repository and are used as search filters.
                                                                            	//
                                                                            	// * Linux
                                                                            	//
                                                                            	// *
                                                                            	// Windows
                                                                            	//
                                                                            	// If an unsupported tag is added to your repository catalog data, it will
                                                                            	// be associated with the repository and can be retrieved using the API but will
                                                                            	// not be discoverable in the Amazon ECR Public Gallery.
                                                                            	Architectures []string
                                                                            
                                                                            	// A short description of the contents of the repository. This text appears in both
                                                                            	// the image details and also when searching for repositories on the Amazon ECR
                                                                            	// Public Gallery.
                                                                            	Description *string
                                                                            
                                                                            	// The base64-encoded repository logo payload. The repository logo is only publicly
                                                                            	// visible in the Amazon ECR Public Gallery for verified accounts.
                                                                            	LogoImageBlob []byte
                                                                            
                                                                            	// The operating systems that the images in the repository are compatible with. On
                                                                            	// the Amazon ECR Public Gallery, the following supported operating systems will
                                                                            	// appear as badges on the repository and are used as search filters.
                                                                            	//
                                                                            	// * ARM
                                                                            	//
                                                                            	// * ARM
                                                                            	// 64
                                                                            	//
                                                                            	// * x86
                                                                            	//
                                                                            	// * x86-64
                                                                            	//
                                                                            	// If an unsupported tag is added to your repository catalog
                                                                            	// data, it will be associated with the repository and can be retrieved using the
                                                                            	// API but will not be discoverable in the Amazon ECR Public Gallery.
                                                                            	OperatingSystems []string
                                                                            
                                                                            	// Detailed information on how to use the contents of the repository. It is
                                                                            	// publicly visible in the Amazon ECR Public Gallery. The usage text provides
                                                                            	// context, support information, and additional usage details for users of the
                                                                            	// repository. The text must be in markdown format.
                                                                            	UsageText *string
                                                                            }

                                                                              An object containing the catalog data for a repository. This data is publicly visible in the Amazon ECR Public Gallery.

                                                                              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 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 UnsupportedCommandException

                                                                                      type UnsupportedCommandException struct {
                                                                                      	Message *string
                                                                                      }

                                                                                        The action is not supported in this Region.

                                                                                        func (*UnsupportedCommandException) Error

                                                                                        func (*UnsupportedCommandException) ErrorCode

                                                                                        func (e *UnsupportedCommandException) ErrorCode() string

                                                                                        func (*UnsupportedCommandException) ErrorFault

                                                                                        func (*UnsupportedCommandException) ErrorMessage

                                                                                        func (e *UnsupportedCommandException) 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