@aws-sdk/client-ecr 3.2.0 → 3.5.0

package/types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2301 @@
+import { SmithyException as __SmithyException } from "@aws-sdk/smithy-client";
+import { MetadataBearer as $MetadataBearer } from "@aws-sdk/types";
+export interface BatchCheckLayerAvailabilityRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the image layers to
+     *             check. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository that is associated with the image layers to check.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The digests of the image layers to check.</p>
+     */
+    layerDigests: string[] | undefined;
+}
+export declare namespace BatchCheckLayerAvailabilityRequest {
+    const filterSensitiveLog: (obj: BatchCheckLayerAvailabilityRequest) => any;
+}
+export declare enum LayerFailureCode {
+    InvalidLayerDigest = "InvalidLayerDigest",
+    MissingLayerDigest = "MissingLayerDigest"
+}
+/**
+ * <p>An object representing an Amazon ECR image layer failure.</p>
+ */
+export interface LayerFailure {
+    /**
+     * <p>The layer digest associated with the failure.</p>
+     */
+    layerDigest?: string;
+    /**
+     * <p>The failure code associated with the failure.</p>
+     */
+    failureCode?: LayerFailureCode | string;
+    /**
+     * <p>The reason for the failure.</p>
+     */
+    failureReason?: string;
+}
+export declare namespace LayerFailure {
+    const filterSensitiveLog: (obj: LayerFailure) => any;
+}
+export declare enum LayerAvailability {
+    AVAILABLE = "AVAILABLE",
+    UNAVAILABLE = "UNAVAILABLE"
+}
+/**
+ * <p>An object representing an Amazon ECR image layer.</p>
+ */
+export interface Layer {
+    /**
+     * <p>The <code>sha256</code> digest of the image layer.</p>
+     */
+    layerDigest?: string;
+    /**
+     * <p>The availability status of the image layer.</p>
+     */
+    layerAvailability?: LayerAvailability | string;
+    /**
+     * <p>The size, in bytes, of the image layer.</p>
+     */
+    layerSize?: number;
+    /**
+     * <p>The media type of the layer, such as
+     *                 <code>application/vnd.docker.image.rootfs.diff.tar.gzip</code> or
+     *                 <code>application/vnd.oci.image.layer.v1.tar+gzip</code>.</p>
+     */
+    mediaType?: string;
+}
+export declare namespace Layer {
+    const filterSensitiveLog: (obj: Layer) => any;
+}
+export interface BatchCheckLayerAvailabilityResponse {
+    /**
+     * <p>A list of image layer objects corresponding to the image layer references in the
+     *             request.</p>
+     */
+    layers?: Layer[];
+    /**
+     * <p>Any failures associated with the call.</p>
+     */
+    failures?: LayerFailure[];
+}
+export declare namespace BatchCheckLayerAvailabilityResponse {
+    const filterSensitiveLog: (obj: BatchCheckLayerAvailabilityResponse) => any;
+}
+/**
+ * <p>The specified parameter is invalid. Review the available parameters for the API
+ *             request.</p>
+ */
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace InvalidParameterException {
+    const filterSensitiveLog: (obj: InvalidParameterException) => any;
+}
+/**
+ * <p>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.</p>
+ */
+export interface RepositoryNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "RepositoryNotFoundException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace RepositoryNotFoundException {
+    const filterSensitiveLog: (obj: RepositoryNotFoundException) => any;
+}
+/**
+ * <p>These errors are usually caused by a server-side issue.</p>
+ */
+export interface ServerException extends __SmithyException, $MetadataBearer {
+    name: "ServerException";
+    $fault: "server";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace ServerException {
+    const filterSensitiveLog: (obj: ServerException) => any;
+}
+/**
+ * <p>An object with identifying information for an Amazon ECR image.</p>
+ */
+export interface ImageIdentifier {
+    /**
+     * <p>The <code>sha256</code> digest of the image manifest.</p>
+     */
+    imageDigest?: string;
+    /**
+     * <p>The tag used for the image.</p>
+     */
+    imageTag?: string;
+}
+export declare namespace ImageIdentifier {
+    const filterSensitiveLog: (obj: ImageIdentifier) => any;
+}
+/**
+ * <p>Deletes specified images within a specified repository. Images are specified with
+ *             either the <code>imageTag</code> or <code>imageDigest</code>.</p>
+ */
+export interface BatchDeleteImageRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the image to delete.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository that contains the image to delete.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>A list of image ID references that correspond to images to delete. The format of the
+     *                 <code>imageIds</code> reference is <code>imageTag=tag</code> or
+     *                 <code>imageDigest=digest</code>.</p>
+     */
+    imageIds: ImageIdentifier[] | undefined;
+}
+export declare namespace BatchDeleteImageRequest {
+    const filterSensitiveLog: (obj: BatchDeleteImageRequest) => any;
+}
+export declare enum ImageFailureCode {
+    ImageNotFound = "ImageNotFound",
+    ImageReferencedByManifestList = "ImageReferencedByManifestList",
+    ImageTagDoesNotMatchDigest = "ImageTagDoesNotMatchDigest",
+    InvalidImageDigest = "InvalidImageDigest",
+    InvalidImageTag = "InvalidImageTag",
+    KmsError = "KmsError",
+    MissingDigestAndTag = "MissingDigestAndTag"
+}
+/**
+ * <p>An object representing an Amazon ECR image failure.</p>
+ */
+export interface ImageFailure {
+    /**
+     * <p>The image ID associated with the failure.</p>
+     */
+    imageId?: ImageIdentifier;
+    /**
+     * <p>The code associated with the failure.</p>
+     */
+    failureCode?: ImageFailureCode | string;
+    /**
+     * <p>The reason for the failure.</p>
+     */
+    failureReason?: string;
+}
+export declare namespace ImageFailure {
+    const filterSensitiveLog: (obj: ImageFailure) => any;
+}
+export interface BatchDeleteImageResponse {
+    /**
+     * <p>The image IDs of the deleted images.</p>
+     */
+    imageIds?: ImageIdentifier[];
+    /**
+     * <p>Any failures associated with the call.</p>
+     */
+    failures?: ImageFailure[];
+}
+export declare namespace BatchDeleteImageResponse {
+    const filterSensitiveLog: (obj: BatchDeleteImageResponse) => any;
+}
+export interface BatchGetImageRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the images to describe.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository that contains the images to describe.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>A list of image ID references that correspond to images to describe. The format of the
+     *                 <code>imageIds</code> reference is <code>imageTag=tag</code> or
+     *                 <code>imageDigest=digest</code>.</p>
+     */
+    imageIds: ImageIdentifier[] | undefined;
+    /**
+     * <p>The accepted media types for the request.</p>
+     *         <p>Valid values: <code>application/vnd.docker.distribution.manifest.v1+json</code> |
+     *                 <code>application/vnd.docker.distribution.manifest.v2+json</code> |
+     *                 <code>application/vnd.oci.image.manifest.v1+json</code>
+     *          </p>
+     */
+    acceptedMediaTypes?: string[];
+}
+export declare namespace BatchGetImageRequest {
+    const filterSensitiveLog: (obj: BatchGetImageRequest) => any;
+}
+/**
+ * <p>An object representing an Amazon ECR image.</p>
+ */
+export interface Image {
+    /**
+     * <p>The AWS account ID associated with the registry containing the image.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository associated with the image.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>An object containing the image tag and image digest associated with an image.</p>
+     */
+    imageId?: ImageIdentifier;
+    /**
+     * <p>The image manifest associated with the image.</p>
+     */
+    imageManifest?: string;
+    /**
+     * <p>The manifest media type of the image.</p>
+     */
+    imageManifestMediaType?: string;
+}
+export declare namespace Image {
+    const filterSensitiveLog: (obj: Image) => any;
+}
+export interface BatchGetImageResponse {
+    /**
+     * <p>A list of image objects corresponding to the image references in the request.</p>
+     */
+    images?: Image[];
+    /**
+     * <p>Any failures associated with the call.</p>
+     */
+    failures?: ImageFailure[];
+}
+export declare namespace BatchGetImageResponse {
+    const filterSensitiveLog: (obj: BatchGetImageResponse) => any;
+}
+export interface CompleteLayerUploadRequest {
+    /**
+     * <p>The AWS account ID associated with the registry to which to upload layers.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository to associate with the image layer.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The upload ID from a previous <a>InitiateLayerUpload</a> operation to
+     *             associate with the image layer.</p>
+     */
+    uploadId: string | undefined;
+    /**
+     * <p>The <code>sha256</code> digest of the image layer.</p>
+     */
+    layerDigests: string[] | undefined;
+}
+export declare namespace CompleteLayerUploadRequest {
+    const filterSensitiveLog: (obj: CompleteLayerUploadRequest) => any;
+}
+export interface CompleteLayerUploadResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The upload ID associated with the layer.</p>
+     */
+    uploadId?: string;
+    /**
+     * <p>The <code>sha256</code> digest of the image layer.</p>
+     */
+    layerDigest?: string;
+}
+export declare namespace CompleteLayerUploadResponse {
+    const filterSensitiveLog: (obj: CompleteLayerUploadResponse) => any;
+}
+/**
+ * <p>The specified layer upload does not contain any layer parts.</p>
+ */
+export interface EmptyUploadException extends __SmithyException, $MetadataBearer {
+    name: "EmptyUploadException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace EmptyUploadException {
+    const filterSensitiveLog: (obj: EmptyUploadException) => any;
+}
+/**
+ * <p>The layer digest calculation performed by Amazon ECR upon receipt of the image layer does
+ *             not match the digest specified.</p>
+ */
+export interface InvalidLayerException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLayerException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace InvalidLayerException {
+    const filterSensitiveLog: (obj: InvalidLayerException) => any;
+}
+/**
+ * <p>The operation failed due to a KMS exception.</p>
+ */
+export interface KmsException extends __SmithyException, $MetadataBearer {
+    name: "KmsException";
+    $fault: "client";
+    message?: string;
+    /**
+     * <p>The error code returned by AWS KMS.</p>
+     */
+    kmsError?: string;
+}
+export declare namespace KmsException {
+    const filterSensitiveLog: (obj: KmsException) => any;
+}
+/**
+ * <p>The image layer already exists in the associated repository.</p>
+ */
+export interface LayerAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "LayerAlreadyExistsException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace LayerAlreadyExistsException {
+    const filterSensitiveLog: (obj: LayerAlreadyExistsException) => any;
+}
+/**
+ * <p>Layer parts must be at least 5 MiB in size.</p>
+ */
+export interface LayerPartTooSmallException extends __SmithyException, $MetadataBearer {
+    name: "LayerPartTooSmallException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace LayerPartTooSmallException {
+    const filterSensitiveLog: (obj: LayerPartTooSmallException) => any;
+}
+/**
+ * <p>The upload could not be found, or the specified upload ID is not valid for this
+ *             repository.</p>
+ */
+export interface UploadNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "UploadNotFoundException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace UploadNotFoundException {
+    const filterSensitiveLog: (obj: UploadNotFoundException) => any;
+}
+export declare enum EncryptionType {
+    AES256 = "AES256",
+    KMS = "KMS"
+}
+/**
+ * <p>The encryption configuration for the repository. This determines how the contents of
+ *             your repository are encrypted at rest.</p>
+ *         <p>By default, when no encryption configuration is set or the <code>AES256</code>
+ *             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.</p>
+ *         <p>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 <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html">Amazon ECR encryption at
+ *                 rest</a> in the <i>Amazon Elastic Container Registry User Guide</i>.</p>
+ */
+export interface EncryptionConfiguration {
+    /**
+     * <p>The encryption type to use.</p>
+     *         <p>If you use the <code>KMS</code> 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 <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html">Protecting Data Using Server-Side
+     *                 Encryption with CMKs Stored in AWS Key Management Service (SSE-KMS)</a> in the
+     *                 <i>Amazon Simple Storage Service Console Developer Guide.</i>.</p>
+     *         <p>If you use the <code>AES256</code> 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 <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html">Protecting Data Using
+     *                 Server-Side Encryption with Amazon S3-Managed Encryption Keys (SSE-S3)</a> in
+     *             the <i>Amazon Simple Storage Service Console Developer Guide.</i>.</p>
+     */
+    encryptionType: EncryptionType | string | undefined;
+    /**
+     * <p>If you use the <code>KMS</code> 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.</p>
+     */
+    kmsKey?: string;
+}
+export declare namespace EncryptionConfiguration {
+    const filterSensitiveLog: (obj: EncryptionConfiguration) => any;
+}
+/**
+ * <p>The image scanning configuration for a repository.</p>
+ */
+export interface ImageScanningConfiguration {
+    /**
+     * <p>The setting that determines whether images are scanned after being pushed to a
+     *             repository. If set to <code>true</code>, images will be scanned after being pushed. If
+     *             this parameter is not specified, it will default to <code>false</code> and images will
+     *             not be scanned unless a scan is manually started with the <a>StartImageScan</a> API.</p>
+     */
+    scanOnPush?: boolean;
+}
+export declare namespace ImageScanningConfiguration {
+    const filterSensitiveLog: (obj: ImageScanningConfiguration) => any;
+}
+export declare enum ImageTagMutability {
+    IMMUTABLE = "IMMUTABLE",
+    MUTABLE = "MUTABLE"
+}
+/**
+ * <p>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.</p>
+ */
+export interface Tag {
+    /**
+     * <p>One part of a key-value pair that make up a tag. A <code>key</code> is a general label
+     *             that acts like a category for more specific tag values.</p>
+     */
+    Key?: string;
+    /**
+     * <p>The optional part of a key-value pair that make up a tag. A <code>value</code> acts as
+     *             a descriptor within a tag category (key).</p>
+     */
+    Value?: string;
+}
+export declare namespace Tag {
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateRepositoryRequest {
+    /**
+     * <p>The name to use for the repository. The repository name may be specified on its own
+     *             (such as <code>nginx-web-app</code>) or it can be prepended with a namespace to group
+     *             the repository into a category (such as <code>project-a/nginx-web-app</code>).</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The metadata that you apply to the repository 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.</p>
+     */
+    tags?: Tag[];
+    /**
+     * <p>The tag mutability setting for the repository. If this parameter is omitted, the
+     *             default setting of <code>MUTABLE</code> will be used which will allow image tags to be
+     *             overwritten. If <code>IMMUTABLE</code> is specified, all image tags within the
+     *             repository will be immutable which will prevent them from being overwritten.</p>
+     */
+    imageTagMutability?: ImageTagMutability | string;
+    /**
+     * <p>The image scanning configuration for the repository. This determines whether images
+     *             are scanned for known vulnerabilities after being pushed to the repository.</p>
+     */
+    imageScanningConfiguration?: ImageScanningConfiguration;
+    /**
+     * <p>The encryption configuration for the repository. This determines how the contents of
+     *             your repository are encrypted at rest.</p>
+     */
+    encryptionConfiguration?: EncryptionConfiguration;
+}
+export declare namespace CreateRepositoryRequest {
+    const filterSensitiveLog: (obj: CreateRepositoryRequest) => any;
+}
+/**
+ * <p>An object representing a repository.</p>
+ */
+export interface Repository {
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the repository. The ARN contains the <code>arn:aws:ecr</code> namespace, followed by the region of the
+     *     repository, AWS account ID of the repository owner, repository namespace, and repository name.
+     *     For example, <code>arn:aws:ecr:region:012345678910:repository/test</code>.</p>
+     */
+    repositoryArn?: string;
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The URI for the repository. You can use this URI for container image <code>push</code>
+     *             and <code>pull</code> operations.</p>
+     */
+    repositoryUri?: string;
+    /**
+     * <p>The date and time, in JavaScript date format, when the repository was created.</p>
+     */
+    createdAt?: Date;
+    /**
+     * <p>The tag mutability setting for the repository.</p>
+     */
+    imageTagMutability?: ImageTagMutability | string;
+    /**
+     * <p>The image scanning configuration for a repository.</p>
+     */
+    imageScanningConfiguration?: ImageScanningConfiguration;
+    /**
+     * <p>The encryption configuration for the repository. This determines how the contents of
+     *             your repository are encrypted at rest.</p>
+     */
+    encryptionConfiguration?: EncryptionConfiguration;
+}
+export declare namespace Repository {
+    const filterSensitiveLog: (obj: Repository) => any;
+}
+export interface CreateRepositoryResponse {
+    /**
+     * <p>The repository that was created.</p>
+     */
+    repository?: Repository;
+}
+export declare namespace CreateRepositoryResponse {
+    const filterSensitiveLog: (obj: CreateRepositoryResponse) => any;
+}
+/**
+ * <p>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.</p>
+ */
+export interface InvalidTagParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagParameterException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidTagParameterException {
+    const filterSensitiveLog: (obj: InvalidTagParameterException) => any;
+}
+/**
+ * <p>The operation did not succeed because it would have exceeded a service limit for your
+ *             account. For more information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/service-quotas.html">Amazon ECR Service Quotas</a> in
+ *             the Amazon Elastic Container Registry User Guide.</p>
+ */
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace LimitExceededException {
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+/**
+ * <p>The specified repository already exists in the specified registry.</p>
+ */
+export interface RepositoryAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "RepositoryAlreadyExistsException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace RepositoryAlreadyExistsException {
+    const filterSensitiveLog: (obj: RepositoryAlreadyExistsException) => any;
+}
+/**
+ * <p>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.</p>
+ */
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TooManyTagsException {
+    const filterSensitiveLog: (obj: TooManyTagsException) => any;
+}
+export interface DeleteLifecyclePolicyRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository.</p>
+     */
+    repositoryName: string | undefined;
+}
+export declare namespace DeleteLifecyclePolicyRequest {
+    const filterSensitiveLog: (obj: DeleteLifecyclePolicyRequest) => any;
+}
+export interface DeleteLifecyclePolicyResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The JSON lifecycle policy text.</p>
+     */
+    lifecyclePolicyText?: string;
+    /**
+     * <p>The time stamp of the last time that the lifecycle policy was run.</p>
+     */
+    lastEvaluatedAt?: Date;
+}
+export declare namespace DeleteLifecyclePolicyResponse {
+    const filterSensitiveLog: (obj: DeleteLifecyclePolicyResponse) => any;
+}
+/**
+ * <p>The lifecycle policy could not be found, and no policy is set to the
+ *             repository.</p>
+ */
+export interface LifecyclePolicyNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "LifecyclePolicyNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace LifecyclePolicyNotFoundException {
+    const filterSensitiveLog: (obj: LifecyclePolicyNotFoundException) => any;
+}
+export interface DeleteRegistryPolicyRequest {
+}
+export declare namespace DeleteRegistryPolicyRequest {
+    const filterSensitiveLog: (obj: DeleteRegistryPolicyRequest) => any;
+}
+export interface DeleteRegistryPolicyResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The contents of the registry permissions policy that was deleted.</p>
+     */
+    policyText?: string;
+}
+export declare namespace DeleteRegistryPolicyResponse {
+    const filterSensitiveLog: (obj: DeleteRegistryPolicyResponse) => any;
+}
+/**
+ * <p>The registry doesn't have an associated registry policy.</p>
+ */
+export interface RegistryPolicyNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "RegistryPolicyNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace RegistryPolicyNotFoundException {
+    const filterSensitiveLog: (obj: RegistryPolicyNotFoundException) => any;
+}
+export interface DeleteRepositoryRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository to
+     *             delete. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository to delete.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p> If a repository contains images, forces the deletion.</p>
+     */
+    force?: boolean;
+}
+export declare namespace DeleteRepositoryRequest {
+    const filterSensitiveLog: (obj: DeleteRepositoryRequest) => any;
+}
+export interface DeleteRepositoryResponse {
+    /**
+     * <p>The repository that was deleted.</p>
+     */
+    repository?: Repository;
+}
+export declare namespace DeleteRepositoryResponse {
+    const filterSensitiveLog: (obj: DeleteRepositoryResponse) => any;
+}
+/**
+ * <p>The specified repository contains images. To delete a repository that contains images,
+ *             you must force the deletion with the <code>force</code> parameter.</p>
+ */
+export interface RepositoryNotEmptyException extends __SmithyException, $MetadataBearer {
+    name: "RepositoryNotEmptyException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace RepositoryNotEmptyException {
+    const filterSensitiveLog: (obj: RepositoryNotEmptyException) => any;
+}
+export interface DeleteRepositoryPolicyRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository policy to
+     *             delete. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository that is associated with the repository policy to
+     *             delete.</p>
+     */
+    repositoryName: string | undefined;
+}
+export declare namespace DeleteRepositoryPolicyRequest {
+    const filterSensitiveLog: (obj: DeleteRepositoryPolicyRequest) => any;
+}
+export interface DeleteRepositoryPolicyResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The JSON repository policy that was deleted from the repository.</p>
+     */
+    policyText?: string;
+}
+export declare namespace DeleteRepositoryPolicyResponse {
+    const filterSensitiveLog: (obj: DeleteRepositoryPolicyResponse) => any;
+}
+/**
+ * <p>The specified repository and registry combination does not have an associated
+ *             repository policy.</p>
+ */
+export interface RepositoryPolicyNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "RepositoryPolicyNotFoundException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace RepositoryPolicyNotFoundException {
+    const filterSensitiveLog: (obj: RepositoryPolicyNotFoundException) => any;
+}
+export declare enum TagStatus {
+    ANY = "ANY",
+    TAGGED = "TAGGED",
+    UNTAGGED = "UNTAGGED"
+}
+/**
+ * <p>An object representing a filter on a <a>DescribeImages</a>
+ *             operation.</p>
+ */
+export interface DescribeImagesFilter {
+    /**
+     * <p>The tag status with which to filter your <a>DescribeImages</a> results. You
+     *             can filter results based on whether they are <code>TAGGED</code> or
+     *                 <code>UNTAGGED</code>.</p>
+     */
+    tagStatus?: TagStatus | string;
+}
+export declare namespace DescribeImagesFilter {
+    const filterSensitiveLog: (obj: DescribeImagesFilter) => any;
+}
+export interface DescribeImagesRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository in which
+     *             to describe images. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository that contains the images to describe.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The list of image IDs for the requested repository.</p>
+     */
+    imageIds?: ImageIdentifier[];
+    /**
+     * <p>The <code>nextToken</code> value returned from a previous paginated
+     *                 <code>DescribeImages</code> request where <code>maxResults</code> was used and the
+     *             results exceeded the value of that parameter. Pagination continues from the end of the
+     *             previous results that returned the <code>nextToken</code> value. This value is
+     *                 <code>null</code> when there are no more results to return. This option cannot be
+     *             used when you specify images with <code>imageIds</code>.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of repository results returned by <code>DescribeImages</code> in
+     *             paginated output. When this parameter is used, <code>DescribeImages</code> only returns
+     *                 <code>maxResults</code> results in a single page along with a <code>nextToken</code>
+     *             response element. The remaining results of the initial request can be seen by sending
+     *             another <code>DescribeImages</code> request with the returned <code>nextToken</code>
+     *             value. This value can be between 1 and 1000. If this
+     *             parameter is not used, then <code>DescribeImages</code> returns up to
+     *             100 results and a <code>nextToken</code> value, if applicable. This
+     *             option cannot be used when you specify images with <code>imageIds</code>.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>The filter key and value with which to filter your <code>DescribeImages</code>
+     *             results.</p>
+     */
+    filter?: DescribeImagesFilter;
+}
+export declare namespace DescribeImagesRequest {
+    const filterSensitiveLog: (obj: DescribeImagesRequest) => any;
+}
+export declare enum FindingSeverity {
+    CRITICAL = "CRITICAL",
+    HIGH = "HIGH",
+    INFORMATIONAL = "INFORMATIONAL",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    UNDEFINED = "UNDEFINED"
+}
+/**
+ * <p>A summary of the last completed image scan.</p>
+ */
+export interface ImageScanFindingsSummary {
+    /**
+     * <p>The time of the last completed image scan.</p>
+     */
+    imageScanCompletedAt?: Date;
+    /**
+     * <p>The time when the vulnerability data was last scanned.</p>
+     */
+    vulnerabilitySourceUpdatedAt?: Date;
+    /**
+     * <p>The image vulnerability counts, sorted by severity.</p>
+     */
+    findingSeverityCounts?: {
+        [key: string]: number;
+    };
+}
+export declare namespace ImageScanFindingsSummary {
+    const filterSensitiveLog: (obj: ImageScanFindingsSummary) => any;
+}
+export declare enum ScanStatus {
+    COMPLETE = "COMPLETE",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+/**
+ * <p>The current status of an image scan.</p>
+ */
+export interface ImageScanStatus {
+    /**
+     * <p>The current state of an image scan.</p>
+     */
+    status?: ScanStatus | string;
+    /**
+     * <p>The description of the image scan status.</p>
+     */
+    description?: string;
+}
+export declare namespace ImageScanStatus {
+    const filterSensitiveLog: (obj: ImageScanStatus) => any;
+}
+/**
+ * <p>An object that describes an image returned by a <a>DescribeImages</a>
+ *             operation.</p>
+ */
+export interface ImageDetail {
+    /**
+     * <p>The AWS account ID associated with the registry to which this image belongs.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository to which this image belongs.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The <code>sha256</code> digest of the image manifest.</p>
+     */
+    imageDigest?: string;
+    /**
+     * <p>The list of tags associated with this image.</p>
+     */
+    imageTags?: string[];
+    /**
+     * <p>The size, in bytes, of the image in the repository.</p>
+     *         <p>If the image is a manifest list, this will be the max size of all manifests in the
+     *             list.</p>
+     *         <note>
+     *             <p>Beginning with Docker version 1.9, the Docker client compresses image layers
+     *                 before pushing them to a V2 Docker registry. The output of the <code>docker
+     *                     images</code> command shows the uncompressed image size, so it may return a
+     *                 larger image size than the image sizes returned by <a>DescribeImages</a>.</p>
+     *         </note>
+     */
+    imageSizeInBytes?: number;
+    /**
+     * <p>The date and time, expressed in standard JavaScript date format, at which the current
+     *             image was pushed to the repository. </p>
+     */
+    imagePushedAt?: Date;
+    /**
+     * <p>The current state of the scan.</p>
+     */
+    imageScanStatus?: ImageScanStatus;
+    /**
+     * <p>A summary of the last completed image scan.</p>
+     */
+    imageScanFindingsSummary?: ImageScanFindingsSummary;
+    /**
+     * <p>The media type of the image manifest.</p>
+     */
+    imageManifestMediaType?: string;
+    /**
+     * <p>The artifact media type of the image.</p>
+     */
+    artifactMediaType?: string;
+}
+export declare namespace ImageDetail {
+    const filterSensitiveLog: (obj: ImageDetail) => any;
+}
+export interface DescribeImagesResponse {
+    /**
+     * <p>A list of <a>ImageDetail</a> objects that contain data about the
+     *             image.</p>
+     */
+    imageDetails?: ImageDetail[];
+    /**
+     * <p>The <code>nextToken</code> value to include in a future <code>DescribeImages</code>
+     *             request. When the results of a <code>DescribeImages</code> request exceed
+     *                 <code>maxResults</code>, this value can be used to retrieve the next page of
+     *             results. This value is <code>null</code> when there are no more results to
+     *             return.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace DescribeImagesResponse {
+    const filterSensitiveLog: (obj: DescribeImagesResponse) => any;
+}
+/**
+ * <p>The image requested does not exist in the specified repository.</p>
+ */
+export interface ImageNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ImageNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ImageNotFoundException {
+    const filterSensitiveLog: (obj: ImageNotFoundException) => any;
+}
+export interface DescribeImageScanFindingsRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository in
+     *             which to describe the image scan findings for. If you do not specify a registry, the
+     *             default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository for the image for which to describe the scan findings.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>An object with identifying information for an Amazon ECR image.</p>
+     */
+    imageId: ImageIdentifier | undefined;
+    /**
+     * <p>The <code>nextToken</code> value returned from a previous paginated
+     *                 <code>DescribeImageScanFindings</code> request where <code>maxResults</code> was
+     *             used and the results exceeded the value of that parameter. Pagination continues from the
+     *             end of the previous results that returned the <code>nextToken</code> value. This value
+     *             is null when there are no more results to return.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of image scan results returned by
+     *                 <code>DescribeImageScanFindings</code> in paginated output. When this parameter is
+     *             used, <code>DescribeImageScanFindings</code> only returns <code>maxResults</code>
+     *             results in a single page along with a <code>nextToken</code> response element. The
+     *             remaining results of the initial request can be seen by sending another
+     *                 <code>DescribeImageScanFindings</code> request with the returned
+     *                 <code>nextToken</code> value. This value can be between 1 and 1000. If this
+     *             parameter is not used, then <code>DescribeImageScanFindings</code> returns up to 100
+     *             results and a <code>nextToken</code> value, if applicable.</p>
+     */
+    maxResults?: number;
+}
+export declare namespace DescribeImageScanFindingsRequest {
+    const filterSensitiveLog: (obj: DescribeImageScanFindingsRequest) => any;
+}
+/**
+ * <p>This data type is used in the <a>ImageScanFinding</a> data type.</p>
+ */
+export interface Attribute {
+    /**
+     * <p>The attribute key.</p>
+     */
+    key: string | undefined;
+    /**
+     * <p>The value assigned to the attribute key.</p>
+     */
+    value?: string;
+}
+export declare namespace Attribute {
+    const filterSensitiveLog: (obj: Attribute) => any;
+}
+/**
+ * <p>Contains information about an image scan finding.</p>
+ */
+export interface ImageScanFinding {
+    /**
+     * <p>The name associated with the finding, usually a CVE number.</p>
+     */
+    name?: string;
+    /**
+     * <p>The description of the finding.</p>
+     */
+    description?: string;
+    /**
+     * <p>A link containing additional details about the security vulnerability.</p>
+     */
+    uri?: string;
+    /**
+     * <p>The finding severity.</p>
+     */
+    severity?: FindingSeverity | string;
+    /**
+     * <p>A collection of attributes of the host from which the finding is generated.</p>
+     */
+    attributes?: Attribute[];
+}
+export declare namespace ImageScanFinding {
+    const filterSensitiveLog: (obj: ImageScanFinding) => any;
+}
+/**
+ * <p>The details of an image scan.</p>
+ */
+export interface ImageScanFindings {
+    /**
+     * <p>The time of the last completed image scan.</p>
+     */
+    imageScanCompletedAt?: Date;
+    /**
+     * <p>The time when the vulnerability data was last scanned.</p>
+     */
+    vulnerabilitySourceUpdatedAt?: Date;
+    /**
+     * <p>The findings from the image scan.</p>
+     */
+    findings?: ImageScanFinding[];
+    /**
+     * <p>The image vulnerability counts, sorted by severity.</p>
+     */
+    findingSeverityCounts?: {
+        [key: string]: number;
+    };
+}
+export declare namespace ImageScanFindings {
+    const filterSensitiveLog: (obj: ImageScanFindings) => any;
+}
+export interface DescribeImageScanFindingsResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>An object with identifying information for an Amazon ECR image.</p>
+     */
+    imageId?: ImageIdentifier;
+    /**
+     * <p>The current state of the scan.</p>
+     */
+    imageScanStatus?: ImageScanStatus;
+    /**
+     * <p>The information contained in the image scan findings.</p>
+     */
+    imageScanFindings?: ImageScanFindings;
+    /**
+     * <p>The <code>nextToken</code> value to include in a future
+     *                 <code>DescribeImageScanFindings</code> request. When the results of a
+     *                 <code>DescribeImageScanFindings</code> request exceed <code>maxResults</code>, this
+     *             value can be used to retrieve the next page of results. This value is null when there
+     *             are no more results to return.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace DescribeImageScanFindingsResponse {
+    const filterSensitiveLog: (obj: DescribeImageScanFindingsResponse) => any;
+}
+/**
+ * <p>The specified image scan could not be found. Ensure that image scanning is enabled on
+ *             the repository and try again.</p>
+ */
+export interface ScanNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ScanNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ScanNotFoundException {
+    const filterSensitiveLog: (obj: ScanNotFoundException) => any;
+}
+export interface DescribeRegistryRequest {
+}
+export declare namespace DescribeRegistryRequest {
+    const filterSensitiveLog: (obj: DescribeRegistryRequest) => any;
+}
+/**
+ * <p>An array of objects representing the details of a replication destination.</p>
+ */
+export interface ReplicationDestination {
+    /**
+     * <p>A Region to replicate to.</p>
+     */
+    region: string | undefined;
+    /**
+     * <p>The account ID of the destination registry to replicate to.</p>
+     */
+    registryId: string | undefined;
+}
+export declare namespace ReplicationDestination {
+    const filterSensitiveLog: (obj: ReplicationDestination) => any;
+}
+/**
+ * <p>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.</p>
+ */
+export interface ReplicationRule {
+    /**
+     * <p>An array of objects representing the details of a replication destination.</p>
+     */
+    destinations: ReplicationDestination[] | undefined;
+}
+export declare namespace ReplicationRule {
+    const filterSensitiveLog: (obj: ReplicationRule) => any;
+}
+/**
+ * <p>The replication configuration for a registry.</p>
+ */
+export interface ReplicationConfiguration {
+    /**
+     * <p>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.</p>
+     */
+    rules: ReplicationRule[] | undefined;
+}
+export declare namespace ReplicationConfiguration {
+    const filterSensitiveLog: (obj: ReplicationConfiguration) => any;
+}
+export interface DescribeRegistryResponse {
+    /**
+     * <p>The ID of the registry.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The replication configuration for the registry.</p>
+     */
+    replicationConfiguration?: ReplicationConfiguration;
+}
+export declare namespace DescribeRegistryResponse {
+    const filterSensitiveLog: (obj: DescribeRegistryResponse) => any;
+}
+/**
+ * <p>There was an exception validating this request.</p>
+ */
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ValidationException {
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+export interface DescribeRepositoriesRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repositories to be
+     *             described. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>A list of repositories to describe. If this parameter is omitted, then all
+     *             repositories in a registry are described.</p>
+     */
+    repositoryNames?: string[];
+    /**
+     * <p>The <code>nextToken</code> value returned from a previous paginated
+     *                 <code>DescribeRepositories</code> request where <code>maxResults</code> was used and
+     *             the results exceeded the value of that parameter. Pagination continues from the end of
+     *             the previous results that returned the <code>nextToken</code> value. This value is
+     *                 <code>null</code> when there are no more results to return. This option cannot be
+     *             used when you specify repositories with <code>repositoryNames</code>.</p>
+     *         <note>
+     *             <p>This token should be treated as an opaque identifier that is only used to
+     *                 retrieve the next items in a list and not for other programmatic purposes.</p>
+     *         </note>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of repository results returned by <code>DescribeRepositories</code>
+     *             in paginated output. When this parameter is used, <code>DescribeRepositories</code> only
+     *             returns <code>maxResults</code> results in a single page along with a
+     *                 <code>nextToken</code> response element. The remaining results of the initial
+     *             request can be seen by sending another <code>DescribeRepositories</code> request with
+     *             the returned <code>nextToken</code> value. This value can be between 1
+     *             and 1000. If this parameter is not used, then
+     *                 <code>DescribeRepositories</code> returns up to 100 results and a
+     *                 <code>nextToken</code> value, if applicable. This option cannot be used when you
+     *             specify repositories with <code>repositoryNames</code>.</p>
+     */
+    maxResults?: number;
+}
+export declare namespace DescribeRepositoriesRequest {
+    const filterSensitiveLog: (obj: DescribeRepositoriesRequest) => any;
+}
+export interface DescribeRepositoriesResponse {
+    /**
+     * <p>A list of repository objects corresponding to valid repositories.</p>
+     */
+    repositories?: Repository[];
+    /**
+     * <p>The <code>nextToken</code> value to include in a future
+     *                 <code>DescribeRepositories</code> request. When the results of a
+     *                 <code>DescribeRepositories</code> request exceed <code>maxResults</code>, this value
+     *             can be used to retrieve the next page of results. This value is <code>null</code> when
+     *             there are no more results to return.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace DescribeRepositoriesResponse {
+    const filterSensitiveLog: (obj: DescribeRepositoriesResponse) => any;
+}
+export interface GetAuthorizationTokenRequest {
+    /**
+     * @deprecated
+     *
+     * <p>A list of AWS account IDs that are associated with the registries for which to get
+     *             AuthorizationData objects. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryIds?: string[];
+}
+export declare namespace GetAuthorizationTokenRequest {
+    const filterSensitiveLog: (obj: GetAuthorizationTokenRequest) => any;
+}
+/**
+ * <p>An object representing authorization data for an Amazon ECR registry.</p>
+ */
+export interface AuthorizationData {
+    /**
+     * <p>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
+     *                 <code>user:password</code> for private registry authentication using <code>docker
+     *                 login</code>.</p>
+     */
+    authorizationToken?: string;
+    /**
+     * <p>The Unix time in seconds and milliseconds when the authorization token expires.
+     *             Authorization tokens are valid for 12 hours.</p>
+     */
+    expiresAt?: Date;
+    /**
+     * <p>The registry URL to use for this authorization token in a <code>docker login</code>
+     *             command. The Amazon ECR registry URL format is
+     *         <code>https://aws_account_id.dkr.ecr.region.amazonaws.com</code>. For example,
+     *         <code>https://012345678910.dkr.ecr.us-east-1.amazonaws.com</code>.. </p>
+     */
+    proxyEndpoint?: string;
+}
+export declare namespace AuthorizationData {
+    const filterSensitiveLog: (obj: AuthorizationData) => any;
+}
+export interface GetAuthorizationTokenResponse {
+    /**
+     * <p>A list of authorization token data objects that correspond to the
+     *                 <code>registryIds</code> values in the request.</p>
+     */
+    authorizationData?: AuthorizationData[];
+}
+export declare namespace GetAuthorizationTokenResponse {
+    const filterSensitiveLog: (obj: GetAuthorizationTokenResponse) => any;
+}
+export interface GetDownloadUrlForLayerRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the image layer to
+     *             download. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository that is associated with the image layer to download.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The digest of the image layer to download.</p>
+     */
+    layerDigest: string | undefined;
+}
+export declare namespace GetDownloadUrlForLayerRequest {
+    const filterSensitiveLog: (obj: GetDownloadUrlForLayerRequest) => any;
+}
+export interface GetDownloadUrlForLayerResponse {
+    /**
+     * <p>The pre-signed Amazon S3 download URL for the requested layer.</p>
+     */
+    downloadUrl?: string;
+    /**
+     * <p>The digest of the image layer to download.</p>
+     */
+    layerDigest?: string;
+}
+export declare namespace GetDownloadUrlForLayerResponse {
+    const filterSensitiveLog: (obj: GetDownloadUrlForLayerResponse) => any;
+}
+/**
+ * <p>The specified layer is not available because it is not associated with an image.
+ *             Unassociated image layers may be cleaned up at any time.</p>
+ */
+export interface LayerInaccessibleException extends __SmithyException, $MetadataBearer {
+    name: "LayerInaccessibleException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace LayerInaccessibleException {
+    const filterSensitiveLog: (obj: LayerInaccessibleException) => any;
+}
+/**
+ * <p>The specified layers could not be found, or the specified layer is not valid for this
+ *             repository.</p>
+ */
+export interface LayersNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "LayersNotFoundException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace LayersNotFoundException {
+    const filterSensitiveLog: (obj: LayersNotFoundException) => any;
+}
+export interface GetLifecyclePolicyRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository.</p>
+     */
+    repositoryName: string | undefined;
+}
+export declare namespace GetLifecyclePolicyRequest {
+    const filterSensitiveLog: (obj: GetLifecyclePolicyRequest) => any;
+}
+export interface GetLifecyclePolicyResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The JSON lifecycle policy text.</p>
+     */
+    lifecyclePolicyText?: string;
+    /**
+     * <p>The time stamp of the last time that the lifecycle policy was run.</p>
+     */
+    lastEvaluatedAt?: Date;
+}
+export declare namespace GetLifecyclePolicyResponse {
+    const filterSensitiveLog: (obj: GetLifecyclePolicyResponse) => any;
+}
+/**
+ * <p>The filter for the lifecycle policy preview.</p>
+ */
+export interface LifecyclePolicyPreviewFilter {
+    /**
+     * <p>The tag status of the image.</p>
+     */
+    tagStatus?: TagStatus | string;
+}
+export declare namespace LifecyclePolicyPreviewFilter {
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewFilter) => any;
+}
+export interface GetLifecyclePolicyPreviewRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The list of imageIDs to be included.</p>
+     */
+    imageIds?: ImageIdentifier[];
+    /**
+     * <p>The <code>nextToken</code> value returned from a previous paginated
+     *                 <code>GetLifecyclePolicyPreviewRequest</code> request where <code>maxResults</code>
+     *             was used and the
+   results exceeded the value of that parameter. Pagination continues
+     *             from the end of the
+   previous results that returned the <code>nextToken</code> value.
+     *             This value is
+   <code>null</code> when there are no more results to return. This option
+     *             cannot be used when you specify images with <code>imageIds</code>.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of repository results returned by
+     *                 <code>GetLifecyclePolicyPreviewRequest</code> in
+   paginated output. When this
+     *             parameter is used, <code>GetLifecyclePolicyPreviewRequest</code> only returns
+     *                 <code>maxResults</code> results in a single page along with a
+     *             <code>nextToken</code>
+   response element. The remaining results of the initial request
+     *             can be seen by sending
+   another <code>GetLifecyclePolicyPreviewRequest</code> request
+     *             with the returned <code>nextToken</code>
+   value. This value can be between
+     *             1 and 1000. If this
+   parameter is not used, then
+     *                 <code>GetLifecyclePolicyPreviewRequest</code> returns up to
+   100
+     *             results and a <code>nextToken</code> value, if
+   applicable. This option cannot be used
+     *             when you specify images with <code>imageIds</code>.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>An optional parameter that filters results based on image tag status and all tags, if
+     *             tagged.</p>
+     */
+    filter?: LifecyclePolicyPreviewFilter;
+}
+export declare namespace GetLifecyclePolicyPreviewRequest {
+    const filterSensitiveLog: (obj: GetLifecyclePolicyPreviewRequest) => any;
+}
+export declare enum ImageActionType {
+    EXPIRE = "EXPIRE"
+}
+/**
+ * <p>The type of action to be taken.</p>
+ */
+export interface LifecyclePolicyRuleAction {
+    /**
+     * <p>The type of action to be taken.</p>
+     */
+    type?: ImageActionType | string;
+}
+export declare namespace LifecyclePolicyRuleAction {
+    const filterSensitiveLog: (obj: LifecyclePolicyRuleAction) => any;
+}
+/**
+ * <p>The result of the lifecycle policy preview.</p>
+ */
+export interface LifecyclePolicyPreviewResult {
+    /**
+     * <p>The list of tags associated with this image.</p>
+     */
+    imageTags?: string[];
+    /**
+     * <p>The <code>sha256</code> digest of the image manifest.</p>
+     */
+    imageDigest?: string;
+    /**
+     * <p>The date and time, expressed in standard JavaScript date format, at which the current
+     *             image was pushed to the repository.</p>
+     */
+    imagePushedAt?: Date;
+    /**
+     * <p>The type of action to be taken.</p>
+     */
+    action?: LifecyclePolicyRuleAction;
+    /**
+     * <p>The priority of the applied rule.</p>
+     */
+    appliedRulePriority?: number;
+}
+export declare namespace LifecyclePolicyPreviewResult {
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewResult) => any;
+}
+export declare enum LifecyclePolicyPreviewStatus {
+    COMPLETE = "COMPLETE",
+    EXPIRED = "EXPIRED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+/**
+ * <p>The summary of the lifecycle policy preview request.</p>
+ */
+export interface LifecyclePolicyPreviewSummary {
+    /**
+     * <p>The number of expiring images.</p>
+     */
+    expiringImageTotalCount?: number;
+}
+export declare namespace LifecyclePolicyPreviewSummary {
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewSummary) => any;
+}
+export interface GetLifecyclePolicyPreviewResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The JSON lifecycle policy text.</p>
+     */
+    lifecyclePolicyText?: string;
+    /**
+     * <p>The status of the lifecycle policy preview request.</p>
+     */
+    status?: LifecyclePolicyPreviewStatus | string;
+    /**
+     * <p>The <code>nextToken</code> value to include in a future
+     *                 <code>GetLifecyclePolicyPreview</code> request. When the results of a
+     *                 <code>GetLifecyclePolicyPreview</code> request exceed <code>maxResults</code>, this
+     *             value can be used to retrieve the next page of results. This value is <code>null</code>
+     *             when there are no more results to return.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>The results of the lifecycle policy preview request.</p>
+     */
+    previewResults?: LifecyclePolicyPreviewResult[];
+    /**
+     * <p>The list of images that is returned as a result of the action.</p>
+     */
+    summary?: LifecyclePolicyPreviewSummary;
+}
+export declare namespace GetLifecyclePolicyPreviewResponse {
+    const filterSensitiveLog: (obj: GetLifecyclePolicyPreviewResponse) => any;
+}
+/**
+ * <p>There is no dry run for this repository.</p>
+ */
+export interface LifecyclePolicyPreviewNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "LifecyclePolicyPreviewNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace LifecyclePolicyPreviewNotFoundException {
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewNotFoundException) => any;
+}
+export interface GetRegistryPolicyRequest {
+}
+export declare namespace GetRegistryPolicyRequest {
+    const filterSensitiveLog: (obj: GetRegistryPolicyRequest) => any;
+}
+export interface GetRegistryPolicyResponse {
+    /**
+     * <p>The ID of the registry.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The JSON text of the permissions policy for a registry.</p>
+     */
+    policyText?: string;
+}
+export declare namespace GetRegistryPolicyResponse {
+    const filterSensitiveLog: (obj: GetRegistryPolicyResponse) => any;
+}
+export interface GetRepositoryPolicyRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository with the policy to retrieve.</p>
+     */
+    repositoryName: string | undefined;
+}
+export declare namespace GetRepositoryPolicyRequest {
+    const filterSensitiveLog: (obj: GetRepositoryPolicyRequest) => any;
+}
+export interface GetRepositoryPolicyResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The JSON repository policy text associated with the repository.</p>
+     */
+    policyText?: string;
+}
+export declare namespace GetRepositoryPolicyResponse {
+    const filterSensitiveLog: (obj: GetRepositoryPolicyResponse) => any;
+}
+export interface InitiateLayerUploadRequest {
+    /**
+     * <p>The AWS account ID associated with the registry to which you intend to upload layers.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository to which you intend to upload layers.</p>
+     */
+    repositoryName: string | undefined;
+}
+export declare namespace InitiateLayerUploadRequest {
+    const filterSensitiveLog: (obj: InitiateLayerUploadRequest) => any;
+}
+export interface InitiateLayerUploadResponse {
+    /**
+     * <p>The upload ID for the layer upload. This parameter is passed to further <a>UploadLayerPart</a> and <a>CompleteLayerUpload</a>
+     *             operations.</p>
+     */
+    uploadId?: string;
+    /**
+     * <p>The size, in bytes, that Amazon ECR expects future layer part uploads to be.</p>
+     */
+    partSize?: number;
+}
+export declare namespace InitiateLayerUploadResponse {
+    const filterSensitiveLog: (obj: InitiateLayerUploadResponse) => any;
+}
+/**
+ * <p>An object representing a filter on a <a>ListImages</a> operation.</p>
+ */
+export interface ListImagesFilter {
+    /**
+     * <p>The tag status with which to filter your <a>ListImages</a> results. You can
+     *             filter results based on whether they are <code>TAGGED</code> or
+     *             <code>UNTAGGED</code>.</p>
+     */
+    tagStatus?: TagStatus | string;
+}
+export declare namespace ListImagesFilter {
+    const filterSensitiveLog: (obj: ListImagesFilter) => any;
+}
+export interface ListImagesRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository in which
+     *             to list images. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository with image IDs to be listed.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The <code>nextToken</code> value returned from a previous paginated
+     *                 <code>ListImages</code> request where <code>maxResults</code> was used and the
+     *             results exceeded the value of that parameter. Pagination continues from the end of the
+     *             previous results that returned the <code>nextToken</code> value. This value is
+     *                 <code>null</code> when there are no more results to return.</p>
+     *         <note>
+     *             <p>This token should be treated as an opaque identifier that is only used to
+     *                 retrieve the next items in a list and not for other programmatic purposes.</p>
+     *         </note>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of image results returned by <code>ListImages</code> in paginated
+     *             output. When this parameter is used, <code>ListImages</code> only returns
+     *                 <code>maxResults</code> results in a single page along with a <code>nextToken</code>
+     *             response element. The remaining results of the initial request can be seen by sending
+     *             another <code>ListImages</code> request with the returned <code>nextToken</code> value.
+     *             This value can be between 1 and 1000. If this parameter is
+     *             not used, then <code>ListImages</code> returns up to 100 results and a
+     *                 <code>nextToken</code> value, if applicable.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>The filter key and value with which to filter your <code>ListImages</code>
+     *             results.</p>
+     */
+    filter?: ListImagesFilter;
+}
+export declare namespace ListImagesRequest {
+    const filterSensitiveLog: (obj: ListImagesRequest) => any;
+}
+export interface ListImagesResponse {
+    /**
+     * <p>The list of image IDs for the requested repository.</p>
+     */
+    imageIds?: ImageIdentifier[];
+    /**
+     * <p>The <code>nextToken</code> value to include in a future <code>ListImages</code>
+     *             request. When the results of a <code>ListImages</code> request exceed
+     *                 <code>maxResults</code>, this value can be used to retrieve the next page of
+     *             results. This value is <code>null</code> when there are no more results to
+     *             return.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListImagesResponse {
+    const filterSensitiveLog: (obj: ListImagesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. Currently, the
+     *             only supported resource is an Amazon ECR repository.</p>
+     */
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    /**
+     * <p>The tags for the resource.</p>
+     */
+    tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+/**
+ * <p>The specified image has already been pushed, and there were no changes to the manifest
+ *             or image tag after the last push.</p>
+ */
+export interface ImageAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ImageAlreadyExistsException";
+    $fault: "client";
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace ImageAlreadyExistsException {
+    const filterSensitiveLog: (obj: ImageAlreadyExistsException) => any;
+}
+/**
+ * <p>The specified image digest does not match the digest that Amazon ECR calculated for the
+ *             image.</p>
+ */
+export interface ImageDigestDoesNotMatchException extends __SmithyException, $MetadataBearer {
+    name: "ImageDigestDoesNotMatchException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ImageDigestDoesNotMatchException {
+    const filterSensitiveLog: (obj: ImageDigestDoesNotMatchException) => any;
+}
+/**
+ * <p>The specified image is tagged with a tag that already exists. The repository is
+ *             configured for tag immutability.</p>
+ */
+export interface ImageTagAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ImageTagAlreadyExistsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ImageTagAlreadyExistsException {
+    const filterSensitiveLog: (obj: ImageTagAlreadyExistsException) => any;
+}
+export interface PutImageRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository in which
+     *             to put the image. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository in which to put the image.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The image manifest corresponding to the image to be uploaded.</p>
+     */
+    imageManifest: string | undefined;
+    /**
+     * <p>The media type of the image manifest. If you push an image manifest that does not
+     *             contain the <code>mediaType</code> field, you must specify the
+     *                 <code>imageManifestMediaType</code> in the request.</p>
+     */
+    imageManifestMediaType?: string;
+    /**
+     * <p>The tag to associate with the image. This parameter is required for images that use
+     *             the Docker Image Manifest V2 Schema 2 or Open Container Initiative (OCI) formats.</p>
+     */
+    imageTag?: string;
+    /**
+     * <p>The image digest of the image manifest corresponding to the image.</p>
+     */
+    imageDigest?: string;
+}
+export declare namespace PutImageRequest {
+    const filterSensitiveLog: (obj: PutImageRequest) => any;
+}
+export interface PutImageResponse {
+    /**
+     * <p>Details of the image uploaded.</p>
+     */
+    image?: Image;
+}
+export declare namespace PutImageResponse {
+    const filterSensitiveLog: (obj: PutImageResponse) => any;
+}
+/**
+ * <p>The manifest list is referencing an image that does not exist.</p>
+ */
+export interface ReferencedImagesNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ReferencedImagesNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReferencedImagesNotFoundException {
+    const filterSensitiveLog: (obj: ReferencedImagesNotFoundException) => any;
+}
+export interface PutImageScanningConfigurationRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository in
+     *             which to update the image scanning configuration setting.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository in which to update the image scanning configuration
+     *             setting.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The image scanning configuration for the repository. This setting determines whether
+     *             images are scanned for known vulnerabilities after being pushed to the
+     *             repository.</p>
+     */
+    imageScanningConfiguration: ImageScanningConfiguration | undefined;
+}
+export declare namespace PutImageScanningConfigurationRequest {
+    const filterSensitiveLog: (obj: PutImageScanningConfigurationRequest) => any;
+}
+export interface PutImageScanningConfigurationResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The image scanning configuration setting for the repository.</p>
+     */
+    imageScanningConfiguration?: ImageScanningConfiguration;
+}
+export declare namespace PutImageScanningConfigurationResponse {
+    const filterSensitiveLog: (obj: PutImageScanningConfigurationResponse) => any;
+}
+export interface PutImageTagMutabilityRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository in which
+     *             to update the image tag mutability settings. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository in which to update the image tag mutability
+     *             settings.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The tag mutability setting for the repository. If <code>MUTABLE</code> is specified,
+     *             image tags can be overwritten. If <code>IMMUTABLE</code> is specified, all image tags
+     *             within the repository will be immutable which will prevent them from being
+     *             overwritten.</p>
+     */
+    imageTagMutability: ImageTagMutability | string | undefined;
+}
+export declare namespace PutImageTagMutabilityRequest {
+    const filterSensitiveLog: (obj: PutImageTagMutabilityRequest) => any;
+}
+export interface PutImageTagMutabilityResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The image tag mutability setting for the repository.</p>
+     */
+    imageTagMutability?: ImageTagMutability | string;
+}
+export declare namespace PutImageTagMutabilityResponse {
+    const filterSensitiveLog: (obj: PutImageTagMutabilityResponse) => any;
+}
+export interface PutLifecyclePolicyRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository. If you
+     *             do
+   not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository to receive the policy.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The JSON repository policy text to apply to the repository.</p>
+     */
+    lifecyclePolicyText: string | undefined;
+}
+export declare namespace PutLifecyclePolicyRequest {
+    const filterSensitiveLog: (obj: PutLifecyclePolicyRequest) => any;
+}
+export interface PutLifecyclePolicyResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The JSON repository policy text.</p>
+     */
+    lifecyclePolicyText?: string;
+}
+export declare namespace PutLifecyclePolicyResponse {
+    const filterSensitiveLog: (obj: PutLifecyclePolicyResponse) => any;
+}
+export interface PutRegistryPolicyRequest {
+    /**
+     * <p>The JSON policy text to apply to your registry. The policy text follows the same
+     *             format as IAM policy text. For more information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/registry-permissions.html">Registry
+     *                 permissions</a> in the <i>Amazon Elastic Container Registry User Guide</i>.</p>
+     */
+    policyText: string | undefined;
+}
+export declare namespace PutRegistryPolicyRequest {
+    const filterSensitiveLog: (obj: PutRegistryPolicyRequest) => any;
+}
+export interface PutRegistryPolicyResponse {
+    /**
+     * <p>The registry ID.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The JSON policy text for your registry.</p>
+     */
+    policyText?: string;
+}
+export declare namespace PutRegistryPolicyResponse {
+    const filterSensitiveLog: (obj: PutRegistryPolicyResponse) => any;
+}
+export interface PutReplicationConfigurationRequest {
+    /**
+     * <p>An object representing the replication configuration for a registry.</p>
+     */
+    replicationConfiguration: ReplicationConfiguration | undefined;
+}
+export declare namespace PutReplicationConfigurationRequest {
+    const filterSensitiveLog: (obj: PutReplicationConfigurationRequest) => any;
+}
+export interface PutReplicationConfigurationResponse {
+    /**
+     * <p>The contents of the replication configuration for the registry.</p>
+     */
+    replicationConfiguration?: ReplicationConfiguration;
+}
+export declare namespace PutReplicationConfigurationResponse {
+    const filterSensitiveLog: (obj: PutReplicationConfigurationResponse) => any;
+}
+export interface SetRepositoryPolicyRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository to receive the policy.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The JSON repository policy text to apply to the repository. For more information, see
+     *                 <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html">Amazon ECR Repository
+     *                 Policies</a> in the <i>Amazon Elastic Container Registry User Guide</i>.</p>
+     */
+    policyText: string | undefined;
+    /**
+     * <p>If the policy you are attempting to set on a repository policy would prevent you from
+     *             setting another policy in the future, you must force the <a>SetRepositoryPolicy</a> operation. This is intended to prevent accidental
+     *             repository lock outs.</p>
+     */
+    force?: boolean;
+}
+export declare namespace SetRepositoryPolicyRequest {
+    const filterSensitiveLog: (obj: SetRepositoryPolicyRequest) => any;
+}
+export interface SetRepositoryPolicyResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The JSON repository policy text applied to the repository.</p>
+     */
+    policyText?: string;
+}
+export declare namespace SetRepositoryPolicyResponse {
+    const filterSensitiveLog: (obj: SetRepositoryPolicyResponse) => any;
+}
+export interface StartImageScanRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository in
+     *             which to start an image scan request. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository that contains the images to scan.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>An object with identifying information for an Amazon ECR image.</p>
+     */
+    imageId: ImageIdentifier | undefined;
+}
+export declare namespace StartImageScanRequest {
+    const filterSensitiveLog: (obj: StartImageScanRequest) => any;
+}
+export interface StartImageScanResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>An object with identifying information for an Amazon ECR image.</p>
+     */
+    imageId?: ImageIdentifier;
+    /**
+     * <p>The current state of the scan.</p>
+     */
+    imageScanStatus?: ImageScanStatus;
+}
+export declare namespace StartImageScanResponse {
+    const filterSensitiveLog: (obj: StartImageScanResponse) => any;
+}
+/**
+ * <p>The image is of a type that cannot be scanned.</p>
+ */
+export interface UnsupportedImageTypeException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedImageTypeException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace UnsupportedImageTypeException {
+    const filterSensitiveLog: (obj: UnsupportedImageTypeException) => any;
+}
+/**
+ * <p>The previous lifecycle policy preview request has not completed. Wait and try
+ *             again.</p>
+ */
+export interface LifecyclePolicyPreviewInProgressException extends __SmithyException, $MetadataBearer {
+    name: "LifecyclePolicyPreviewInProgressException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace LifecyclePolicyPreviewInProgressException {
+    const filterSensitiveLog: (obj: LifecyclePolicyPreviewInProgressException) => any;
+}
+export interface StartLifecyclePolicyPreviewRequest {
+    /**
+     * <p>The AWS account ID associated with the registry that contains the repository.
+     *             If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository to be evaluated.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The policy to be evaluated against. If you do not specify a policy, the current policy
+     *             for the repository is used.</p>
+     */
+    lifecyclePolicyText?: string;
+}
+export declare namespace StartLifecyclePolicyPreviewRequest {
+    const filterSensitiveLog: (obj: StartLifecyclePolicyPreviewRequest) => any;
+}
+export interface StartLifecyclePolicyPreviewResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The JSON repository policy text.</p>
+     */
+    lifecyclePolicyText?: string;
+    /**
+     * <p>The status of the lifecycle policy preview request.</p>
+     */
+    status?: LifecyclePolicyPreviewStatus | string;
+}
+export declare namespace StartLifecyclePolicyPreviewResponse {
+    const filterSensitiveLog: (obj: StartLifecyclePolicyPreviewResponse) => any;
+}
+export interface TagResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) of the the resource to which to add tags. Currently, the only supported
+     *             resource is an Amazon ECR repository.</p>
+     */
+    resourceArn: string | undefined;
+    /**
+     * <p>The tags to add to the resource. A tag is an array of key-value pairs.
+     *             Tag keys can have a maximum character length of 128 characters, and tag values can have
+     *             a maximum length of 256 characters.</p>
+     */
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource from which to remove tags. Currently, the only supported
+     *             resource is an Amazon ECR repository.</p>
+     */
+    resourceArn: string | undefined;
+    /**
+     * <p>The keys of the tags to be removed.</p>
+     */
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+/**
+ * <p>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.</p>
+ */
+export interface InvalidLayerPartException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLayerPartException";
+    $fault: "client";
+    /**
+     * <p>The registry ID associated with the exception.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the exception.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The upload ID associated with the exception.</p>
+     */
+    uploadId?: string;
+    /**
+     * <p>The last valid byte received from the layer part upload that is associated with the
+     *             exception.</p>
+     */
+    lastValidByteReceived?: number;
+    /**
+     * <p>The error message associated with the exception.</p>
+     */
+    message?: string;
+}
+export declare namespace InvalidLayerPartException {
+    const filterSensitiveLog: (obj: InvalidLayerPartException) => any;
+}
+export interface UploadLayerPartRequest {
+    /**
+     * <p>The AWS account ID associated with the registry to which you are uploading layer
+     *             parts. If you do not specify a registry, the default registry is assumed.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The name of the repository to which you are uploading layer parts.</p>
+     */
+    repositoryName: string | undefined;
+    /**
+     * <p>The upload ID from a previous <a>InitiateLayerUpload</a> operation to
+     *             associate with the layer part upload.</p>
+     */
+    uploadId: string | undefined;
+    /**
+     * <p>The position of the first byte of the layer part witin the overall image layer.</p>
+     */
+    partFirstByte: number | undefined;
+    /**
+     * <p>The position of the last byte of the layer part within the overall image layer.</p>
+     */
+    partLastByte: number | undefined;
+    /**
+     * <p>The base64-encoded layer part payload.</p>
+     */
+    layerPartBlob: Uint8Array | undefined;
+}
+export declare namespace UploadLayerPartRequest {
+    const filterSensitiveLog: (obj: UploadLayerPartRequest) => any;
+}
+export interface UploadLayerPartResponse {
+    /**
+     * <p>The registry ID associated with the request.</p>
+     */
+    registryId?: string;
+    /**
+     * <p>The repository name associated with the request.</p>
+     */
+    repositoryName?: string;
+    /**
+     * <p>The upload ID associated with the request.</p>
+     */
+    uploadId?: string;
+    /**
+     * <p>The integer value of the last byte received in the request.</p>
+     */
+    lastByteReceived?: number;
+}
+export declare namespace UploadLayerPartResponse {
+    const filterSensitiveLog: (obj: UploadLayerPartResponse) => any;
+}