func (c *ECR) DeleteRepository(input *DeleteRepositoryInput) (*DeleteRepositoryOutput, error) {
	req, out := c.DeleteRepositoryRequest(input)
	err := req.Send()
	return out, err
}
DeleteRepository API operation for Amazon EC2 Container Registry.

Deletes an existing image repository. If a repository contains images, you
must use the force option to delete it.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions
with awserr.Error's Code and Message methods to get detailed information about
the error.

See the AWS API reference guide for Amazon EC2 Container Registry's
API operation DeleteRepository for usage and error information.

Returned Error Codes:
* ServerException
These errors are usually caused by a server-side issue.

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

* RepositoryNotFoundException
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.

* RepositoryNotEmptyException
The specified repository contains images. To delete a repository that contains
images, you must force the deletion with the force parameter.
package ecr
import (
	"time"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
)
const opBatchCheckLayerAvailability = "BatchCheckLayerAvailability"
func (c *ECR) BatchCheckLayerAvailabilityRequest(input *BatchCheckLayerAvailabilityInput) (req *request.Request, output *BatchCheckLayerAvailabilityOutput) {
	op := &request.Operation{
		Name:       opBatchCheckLayerAvailability,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &BatchCheckLayerAvailabilityInput{}
	}
	req = c.newRequest(op, input, output)
	output = &BatchCheckLayerAvailabilityOutput{}
	req.Data = output
	return
}
func (c *ECR) BatchCheckLayerAvailability(input *BatchCheckLayerAvailabilityInput) (*BatchCheckLayerAvailabilityOutput, error) {
	req, out := c.BatchCheckLayerAvailabilityRequest(input)
	err := req.Send()
	return out, err
}
const opBatchDeleteImage = "BatchDeleteImage"
func (c *ECR) BatchDeleteImageRequest(input *BatchDeleteImageInput) (req *request.Request, output *BatchDeleteImageOutput) {
	op := &request.Operation{
		Name:       opBatchDeleteImage,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &BatchDeleteImageInput{}
	}
	req = c.newRequest(op, input, output)
	output = &BatchDeleteImageOutput{}
	req.Data = output
	return
}
func (c *ECR) BatchDeleteImage(input *BatchDeleteImageInput) (*BatchDeleteImageOutput, error) {
	req, out := c.BatchDeleteImageRequest(input)
	err := req.Send()
	return out, err
}
const opBatchGetImage = "BatchGetImage"
func (c *ECR) BatchGetImageRequest(input *BatchGetImageInput) (req *request.Request, output *BatchGetImageOutput) {
	op := &request.Operation{
		Name:       opBatchGetImage,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &BatchGetImageInput{}
	}
	req = c.newRequest(op, input, output)
	output = &BatchGetImageOutput{}
	req.Data = output
	return
}
func (c *ECR) BatchGetImage(input *BatchGetImageInput) (*BatchGetImageOutput, error) {
	req, out := c.BatchGetImageRequest(input)
	err := req.Send()
	return out, err
}
const opCompleteLayerUpload = "CompleteLayerUpload"
func (c *ECR) CompleteLayerUploadRequest(input *CompleteLayerUploadInput) (req *request.Request, output *CompleteLayerUploadOutput) {
	op := &request.Operation{
		Name:       opCompleteLayerUpload,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CompleteLayerUploadInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CompleteLayerUploadOutput{}
	req.Data = output
	return
}
func (c *ECR) CompleteLayerUpload(input *CompleteLayerUploadInput) (*CompleteLayerUploadOutput, error) {
	req, out := c.CompleteLayerUploadRequest(input)
	err := req.Send()
	return out, err
}
const opCreateRepository = "CreateRepository"
func (c *ECR) CreateRepositoryRequest(input *CreateRepositoryInput) (req *request.Request, output *CreateRepositoryOutput) {
	op := &request.Operation{
		Name:       opCreateRepository,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateRepositoryInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateRepositoryOutput{}
	req.Data = output
	return
}
func (c *ECR) CreateRepository(input *CreateRepositoryInput) (*CreateRepositoryOutput, error) {
	req, out := c.CreateRepositoryRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteRepository = "DeleteRepository"
func (c *ECR) DeleteRepositoryRequest(input *DeleteRepositoryInput) (req *request.Request, output *DeleteRepositoryOutput) {
	op := &request.Operation{
		Name:       opDeleteRepository,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteRepositoryInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteRepositoryOutput{}
	req.Data = output
	return
}