@aws-sdk/client-ecr 3.2.0 → 3.5.0

package/types/ts3.4/commands/CompleteLayerUploadCommand.d.ts

@@ -0,0 +1,27 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { CompleteLayerUploadRequest, CompleteLayerUploadResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type CompleteLayerUploadCommandInput = CompleteLayerUploadRequest;
+export declare type CompleteLayerUploadCommandOutput = CompleteLayerUploadResponse & __MetadataBearer;
+/**
+ * <p>Informs Amazon ECR that the image layer upload has completed for a specified registry,
+ *             repository name, and upload ID. You can optionally provide a <code>sha256</code> digest
+ *             of the image layer for data validation purposes.</p>
+ *         <p>When an image is pushed, the CompleteLayerUpload API is called once per each new image
+ *             layer to verify that the upload has completed.</p>
+ *          <note>
+ *             <p>This operation is used by the Amazon ECR proxy and is not generally used by
+ *         customers for pulling and pushing images. In most cases, you should use the <code>docker</code> CLI to pull, tag, and push images.</p>
+ *          </note>
+ */
+export declare class CompleteLayerUploadCommand extends $Command<CompleteLayerUploadCommandInput, CompleteLayerUploadCommandOutput, ECRClientResolvedConfig> {
+    readonly input: CompleteLayerUploadCommandInput;
+    constructor(input: CompleteLayerUploadCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CompleteLayerUploadCommandInput, CompleteLayerUploadCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/CreateRepositoryCommand.d.ts

@@ -0,0 +1,20 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { CreateRepositoryRequest, CreateRepositoryResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type CreateRepositoryCommandInput = CreateRepositoryRequest;
+export declare type CreateRepositoryCommandOutput = CreateRepositoryResponse & __MetadataBearer;
+/**
+ * <p>Creates a repository. For more information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html">Amazon ECR Repositories</a> in the
+ *                 <i>Amazon Elastic Container Registry User Guide</i>.</p>
+ */
+export declare class CreateRepositoryCommand extends $Command<CreateRepositoryCommandInput, CreateRepositoryCommandOutput, ECRClientResolvedConfig> {
+    readonly input: CreateRepositoryCommandInput;
+    constructor(input: CreateRepositoryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRepositoryCommandInput, CreateRepositoryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/DeleteLifecyclePolicyCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { DeleteLifecyclePolicyRequest, DeleteLifecyclePolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type DeleteLifecyclePolicyCommandInput = DeleteLifecyclePolicyRequest;
+export declare type DeleteLifecyclePolicyCommandOutput = DeleteLifecyclePolicyResponse & __MetadataBearer;
+/**
+ * <p>Deletes the lifecycle policy associated with the specified repository.</p>
+ */
+export declare class DeleteLifecyclePolicyCommand extends $Command<DeleteLifecyclePolicyCommandInput, DeleteLifecyclePolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: DeleteLifecyclePolicyCommandInput;
+    constructor(input: DeleteLifecyclePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLifecyclePolicyCommandInput, DeleteLifecyclePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/DeleteRegistryPolicyCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { DeleteRegistryPolicyRequest, DeleteRegistryPolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type DeleteRegistryPolicyCommandInput = DeleteRegistryPolicyRequest;
+export declare type DeleteRegistryPolicyCommandOutput = DeleteRegistryPolicyResponse & __MetadataBearer;
+/**
+ * <p>Deletes the registry permissions policy.</p>
+ */
+export declare class DeleteRegistryPolicyCommand extends $Command<DeleteRegistryPolicyCommandInput, DeleteRegistryPolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: DeleteRegistryPolicyCommandInput;
+    constructor(input: DeleteRegistryPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRegistryPolicyCommandInput, DeleteRegistryPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/DeleteRepositoryCommand.d.ts

@@ -0,0 +1,21 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { DeleteRepositoryRequest, DeleteRepositoryResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type DeleteRepositoryCommandInput = DeleteRepositoryRequest;
+export declare type DeleteRepositoryCommandOutput = DeleteRepositoryResponse & __MetadataBearer;
+/**
+ * <p>Deletes a repository. If the repository contains images, you must either delete all
+ *             images in the repository or use the <code>force</code> option to delete the
+ *             repository.</p>
+ */
+export declare class DeleteRepositoryCommand extends $Command<DeleteRepositoryCommandInput, DeleteRepositoryCommandOutput, ECRClientResolvedConfig> {
+    readonly input: DeleteRepositoryCommandInput;
+    constructor(input: DeleteRepositoryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRepositoryCommandInput, DeleteRepositoryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/DeleteRepositoryPolicyCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { DeleteRepositoryPolicyRequest, DeleteRepositoryPolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type DeleteRepositoryPolicyCommandInput = DeleteRepositoryPolicyRequest;
+export declare type DeleteRepositoryPolicyCommandOutput = DeleteRepositoryPolicyResponse & __MetadataBearer;
+/**
+ * <p>Deletes the repository policy associated with the specified repository.</p>
+ */
+export declare class DeleteRepositoryPolicyCommand extends $Command<DeleteRepositoryPolicyCommandInput, DeleteRepositoryPolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: DeleteRepositoryPolicyCommandInput;
+    constructor(input: DeleteRepositoryPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRepositoryPolicyCommandInput, DeleteRepositoryPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/DescribeImageScanFindingsCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { DescribeImageScanFindingsRequest, DescribeImageScanFindingsResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type DescribeImageScanFindingsCommandInput = DescribeImageScanFindingsRequest;
+export declare type DescribeImageScanFindingsCommandOutput = DescribeImageScanFindingsResponse & __MetadataBearer;
+/**
+ * <p>Returns the scan findings for the specified image.</p>
+ */
+export declare class DescribeImageScanFindingsCommand extends $Command<DescribeImageScanFindingsCommandInput, DescribeImageScanFindingsCommandOutput, ECRClientResolvedConfig> {
+    readonly input: DescribeImageScanFindingsCommandInput;
+    constructor(input: DescribeImageScanFindingsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeImageScanFindingsCommandInput, DescribeImageScanFindingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/DescribeImagesCommand.d.ts

@@ -0,0 +1,25 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { DescribeImagesRequest, DescribeImagesResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type DescribeImagesCommandInput = DescribeImagesRequest;
+export declare type DescribeImagesCommandOutput = DescribeImagesResponse & __MetadataBearer;
+/**
+ * <p>Returns metadata about the images in a repository.</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>
+ */
+export declare class DescribeImagesCommand extends $Command<DescribeImagesCommandInput, DescribeImagesCommandOutput, ECRClientResolvedConfig> {
+    readonly input: DescribeImagesCommandInput;
+    constructor(input: DescribeImagesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeImagesCommandInput, DescribeImagesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/DescribeRegistryCommand.d.ts

@@ -0,0 +1,21 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { DescribeRegistryRequest, DescribeRegistryResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type DescribeRegistryCommandInput = DescribeRegistryRequest;
+export declare type DescribeRegistryCommandOutput = DescribeRegistryResponse & __MetadataBearer;
+/**
+ * <p>Describes the settings for a registry. The replication configuration for a repository
+ *             can be created or updated with the <a>PutReplicationConfiguration</a> API
+ *             action.</p>
+ */
+export declare class DescribeRegistryCommand extends $Command<DescribeRegistryCommandInput, DescribeRegistryCommandOutput, ECRClientResolvedConfig> {
+    readonly input: DescribeRegistryCommandInput;
+    constructor(input: DescribeRegistryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRegistryCommandInput, DescribeRegistryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/DescribeRepositoriesCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { DescribeRepositoriesRequest, DescribeRepositoriesResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type DescribeRepositoriesCommandInput = DescribeRepositoriesRequest;
+export declare type DescribeRepositoriesCommandOutput = DescribeRepositoriesResponse & __MetadataBearer;
+/**
+ * <p>Describes image repositories in a registry.</p>
+ */
+export declare class DescribeRepositoriesCommand extends $Command<DescribeRepositoriesCommandInput, DescribeRepositoriesCommandOutput, ECRClientResolvedConfig> {
+    readonly input: DescribeRepositoriesCommandInput;
+    constructor(input: DescribeRepositoriesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRepositoriesCommandInput, DescribeRepositoriesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/GetAuthorizationTokenCommand.d.ts

@@ -0,0 +1,26 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { GetAuthorizationTokenRequest, GetAuthorizationTokenResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type GetAuthorizationTokenCommandInput = GetAuthorizationTokenRequest;
+export declare type GetAuthorizationTokenCommandOutput = GetAuthorizationTokenResponse & __MetadataBearer;
+/**
+ * <p>Retrieves an authorization token. An authorization token represents your IAM
+ *             authentication credentials and can be used to access any Amazon ECR registry that your IAM
+ *             principal has access to. The authorization token is valid for 12 hours.</p>
+ *         <p>The <code>authorizationToken</code> returned is a base64 encoded string that can be
+ *             decoded and used in a <code>docker login</code> command to authenticate to a registry.
+ *             The AWS CLI offers an <code>get-login-password</code> command that simplifies the login
+ *             process. For more information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth">Registry
+ *                 Authentication</a> in the <i>Amazon Elastic Container Registry User Guide</i>.</p>
+ */
+export declare class GetAuthorizationTokenCommand extends $Command<GetAuthorizationTokenCommandInput, GetAuthorizationTokenCommandOutput, ECRClientResolvedConfig> {
+    readonly input: GetAuthorizationTokenCommandInput;
+    constructor(input: GetAuthorizationTokenCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAuthorizationTokenCommandInput, GetAuthorizationTokenCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/GetDownloadUrlForLayerCommand.d.ts

@@ -0,0 +1,26 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { GetDownloadUrlForLayerRequest, GetDownloadUrlForLayerResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type GetDownloadUrlForLayerCommandInput = GetDownloadUrlForLayerRequest;
+export declare type GetDownloadUrlForLayerCommandOutput = GetDownloadUrlForLayerResponse & __MetadataBearer;
+/**
+ * <p>Retrieves the pre-signed Amazon S3 download URL corresponding to an image layer. You
+ *             can only get URLs for image layers that are referenced in an image.</p>
+ *         <p>When an image is pulled, the GetDownloadUrlForLayer API is called once per image layer
+ *             that is not already cached.</p>
+ *          <note>
+ *             <p>This operation is used by the Amazon ECR proxy and is not generally used by
+ *         customers for pulling and pushing images. In most cases, you should use the <code>docker</code> CLI to pull, tag, and push images.</p>
+ *          </note>
+ */
+export declare class GetDownloadUrlForLayerCommand extends $Command<GetDownloadUrlForLayerCommandInput, GetDownloadUrlForLayerCommandOutput, ECRClientResolvedConfig> {
+    readonly input: GetDownloadUrlForLayerCommandInput;
+    constructor(input: GetDownloadUrlForLayerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDownloadUrlForLayerCommandInput, GetDownloadUrlForLayerCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/GetLifecyclePolicyCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { GetLifecyclePolicyRequest, GetLifecyclePolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type GetLifecyclePolicyCommandInput = GetLifecyclePolicyRequest;
+export declare type GetLifecyclePolicyCommandOutput = GetLifecyclePolicyResponse & __MetadataBearer;
+/**
+ * <p>Retrieves the lifecycle policy for the specified repository.</p>
+ */
+export declare class GetLifecyclePolicyCommand extends $Command<GetLifecyclePolicyCommandInput, GetLifecyclePolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: GetLifecyclePolicyCommandInput;
+    constructor(input: GetLifecyclePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLifecyclePolicyCommandInput, GetLifecyclePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/GetLifecyclePolicyPreviewCommand.d.ts

@@ -0,0 +1,20 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { GetLifecyclePolicyPreviewRequest, GetLifecyclePolicyPreviewResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type GetLifecyclePolicyPreviewCommandInput = GetLifecyclePolicyPreviewRequest;
+export declare type GetLifecyclePolicyPreviewCommandOutput = GetLifecyclePolicyPreviewResponse & __MetadataBearer;
+/**
+ * <p>Retrieves the results of the lifecycle policy preview request for the specified
+ *             repository.</p>
+ */
+export declare class GetLifecyclePolicyPreviewCommand extends $Command<GetLifecyclePolicyPreviewCommandInput, GetLifecyclePolicyPreviewCommandOutput, ECRClientResolvedConfig> {
+    readonly input: GetLifecyclePolicyPreviewCommandInput;
+    constructor(input: GetLifecyclePolicyPreviewCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLifecyclePolicyPreviewCommandInput, GetLifecyclePolicyPreviewCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/GetRegistryPolicyCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { GetRegistryPolicyRequest, GetRegistryPolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type GetRegistryPolicyCommandInput = GetRegistryPolicyRequest;
+export declare type GetRegistryPolicyCommandOutput = GetRegistryPolicyResponse & __MetadataBearer;
+/**
+ * <p>Retrieves the permissions policy for a registry.</p>
+ */
+export declare class GetRegistryPolicyCommand extends $Command<GetRegistryPolicyCommandInput, GetRegistryPolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: GetRegistryPolicyCommandInput;
+    constructor(input: GetRegistryPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRegistryPolicyCommandInput, GetRegistryPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/GetRepositoryPolicyCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { GetRepositoryPolicyRequest, GetRepositoryPolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type GetRepositoryPolicyCommandInput = GetRepositoryPolicyRequest;
+export declare type GetRepositoryPolicyCommandOutput = GetRepositoryPolicyResponse & __MetadataBearer;
+/**
+ * <p>Retrieves the repository policy for the specified repository.</p>
+ */
+export declare class GetRepositoryPolicyCommand extends $Command<GetRepositoryPolicyCommandInput, GetRepositoryPolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: GetRepositoryPolicyCommandInput;
+    constructor(input: GetRepositoryPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRepositoryPolicyCommandInput, GetRepositoryPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/InitiateLayerUploadCommand.d.ts

@@ -0,0 +1,26 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { InitiateLayerUploadRequest, InitiateLayerUploadResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type InitiateLayerUploadCommandInput = InitiateLayerUploadRequest;
+export declare type InitiateLayerUploadCommandOutput = InitiateLayerUploadResponse & __MetadataBearer;
+/**
+ * <p>Notifies Amazon ECR that you intend to upload an image layer.</p>
+ *         <p>When an image is pushed, the InitiateLayerUpload API is called once per image layer
+ *             that has not already been uploaded. Whether or not an image layer has been uploaded is
+ *             determined by the BatchCheckLayerAvailability API action.</p>
+ *          <note>
+ *             <p>This operation is used by the Amazon ECR proxy and is not generally used by
+ *         customers for pulling and pushing images. In most cases, you should use the <code>docker</code> CLI to pull, tag, and push images.</p>
+ *          </note>
+ */
+export declare class InitiateLayerUploadCommand extends $Command<InitiateLayerUploadCommandInput, InitiateLayerUploadCommandOutput, ECRClientResolvedConfig> {
+    readonly input: InitiateLayerUploadCommandInput;
+    constructor(input: InitiateLayerUploadCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InitiateLayerUploadCommandInput, InitiateLayerUploadCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/ListImagesCommand.d.ts

@@ -0,0 +1,25 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { ListImagesRequest, ListImagesResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type ListImagesCommandInput = ListImagesRequest;
+export declare type ListImagesCommandOutput = ListImagesResponse & __MetadataBearer;
+/**
+ * <p>Lists all the image IDs for the specified repository.</p>
+ *         <p>You can filter images based on whether or not they are tagged by using the
+ *                 <code>tagStatus</code> filter and specifying either <code>TAGGED</code>,
+ *                 <code>UNTAGGED</code> or <code>ANY</code>. For example, you can filter your results
+ *             to return only <code>UNTAGGED</code> images and then pipe that result to a <a>BatchDeleteImage</a> operation to delete them. Or, you can filter your
+ *             results to return only <code>TAGGED</code> images to list all of the tags in your
+ *             repository.</p>
+ */
+export declare class ListImagesCommand extends $Command<ListImagesCommandInput, ListImagesCommandOutput, ECRClientResolvedConfig> {
+    readonly input: ListImagesCommandInput;
+    constructor(input: ListImagesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImagesCommandInput, ListImagesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type ListTagsForResourceCommandInput = ListTagsForResourceRequest;
+export declare type ListTagsForResourceCommandOutput = ListTagsForResourceResponse & __MetadataBearer;
+/**
+ * <p>List the tags for an Amazon ECR resource.</p>
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ECRClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/PutImageCommand.d.ts

@@ -0,0 +1,27 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { PutImageRequest, PutImageResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type PutImageCommandInput = PutImageRequest;
+export declare type PutImageCommandOutput = PutImageResponse & __MetadataBearer;
+/**
+ * <p>Creates or updates the image manifest and tags associated with an image.</p>
+ *         <p>When an image is pushed and all new image layers have been uploaded, the PutImage API
+ *             is called once to create or update the image manifest and the tags associated with the
+ *             image.</p>
+ *
+ *         <note>
+ *             <p>This operation is used by the Amazon ECR proxy and is not generally used by
+ *         customers for pulling and pushing images. In most cases, you should use the <code>docker</code> CLI to pull, tag, and push images.</p>
+ *          </note>
+ */
+export declare class PutImageCommand extends $Command<PutImageCommandInput, PutImageCommandOutput, ECRClientResolvedConfig> {
+    readonly input: PutImageCommandInput;
+    constructor(input: PutImageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutImageCommandInput, PutImageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/PutImageScanningConfigurationCommand.d.ts

@@ -0,0 +1,19 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { PutImageScanningConfigurationRequest, PutImageScanningConfigurationResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type PutImageScanningConfigurationCommandInput = PutImageScanningConfigurationRequest;
+export declare type PutImageScanningConfigurationCommandOutput = PutImageScanningConfigurationResponse & __MetadataBearer;
+/**
+ * <p>Updates the image scanning configuration for the specified repository.</p>
+ */
+export declare class PutImageScanningConfigurationCommand extends $Command<PutImageScanningConfigurationCommandInput, PutImageScanningConfigurationCommandOutput, ECRClientResolvedConfig> {
+    readonly input: PutImageScanningConfigurationCommandInput;
+    constructor(input: PutImageScanningConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutImageScanningConfigurationCommandInput, PutImageScanningConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/PutImageTagMutabilityCommand.d.ts

@@ -0,0 +1,21 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { PutImageTagMutabilityRequest, PutImageTagMutabilityResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type PutImageTagMutabilityCommandInput = PutImageTagMutabilityRequest;
+export declare type PutImageTagMutabilityCommandOutput = PutImageTagMutabilityResponse & __MetadataBearer;
+/**
+ * <p>Updates the image tag mutability settings for the specified repository. For more
+ *             information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-tag-mutability.html">Image Tag
+ *                 Mutability</a> in the <i>Amazon Elastic Container Registry User Guide</i>.</p>
+ */
+export declare class PutImageTagMutabilityCommand extends $Command<PutImageTagMutabilityCommandInput, PutImageTagMutabilityCommandOutput, ECRClientResolvedConfig> {
+    readonly input: PutImageTagMutabilityCommandInput;
+    constructor(input: PutImageTagMutabilityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutImageTagMutabilityCommandInput, PutImageTagMutabilityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/PutLifecyclePolicyCommand.d.ts

@@ -0,0 +1,21 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { PutLifecyclePolicyRequest, PutLifecyclePolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type PutLifecyclePolicyCommandInput = PutLifecyclePolicyRequest;
+export declare type PutLifecyclePolicyCommandOutput = PutLifecyclePolicyResponse & __MetadataBearer;
+/**
+ * <p>Creates or updates the lifecycle policy for the specified repository. For more
+ *             information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html">Lifecycle Policy
+ *                 Template</a>.</p>
+ */
+export declare class PutLifecyclePolicyCommand extends $Command<PutLifecyclePolicyCommandInput, PutLifecyclePolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: PutLifecyclePolicyCommandInput;
+    constructor(input: PutLifecyclePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutLifecyclePolicyCommandInput, PutLifecyclePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/PutRegistryPolicyCommand.d.ts

@@ -0,0 +1,21 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { PutRegistryPolicyRequest, PutRegistryPolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type PutRegistryPolicyCommandInput = PutRegistryPolicyRequest;
+export declare type PutRegistryPolicyCommandOutput = PutRegistryPolicyResponse & __MetadataBearer;
+/**
+ * <p>Creates or updates the permissions policy for your registry.</p>
+ *         <p>A registry policy is used to specify permissions for another AWS account and is used
+ *             when configuring cross-account replication. 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>
+ */
+export declare class PutRegistryPolicyCommand extends $Command<PutRegistryPolicyCommandInput, PutRegistryPolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: PutRegistryPolicyCommandInput;
+    constructor(input: PutRegistryPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRegistryPolicyCommandInput, PutRegistryPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/PutReplicationConfigurationCommand.d.ts

@@ -0,0 +1,29 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { PutReplicationConfigurationRequest, PutReplicationConfigurationResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type PutReplicationConfigurationCommandInput = PutReplicationConfigurationRequest;
+export declare type PutReplicationConfigurationCommandOutput = PutReplicationConfigurationResponse & __MetadataBearer;
+/**
+ * <p>Creates or updates the replication configuration for a registry. The existing
+ *             replication configuration for a repository can be retrieved with the <a>DescribeRegistry</a> API action. The first time the
+ *             PutReplicationConfiguration API is called, a service-linked IAM role is created in
+ *             your account for the replication process. For more information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/using-service-linked-roles.html">Using
+ *                 Service-Linked Roles for Amazon ECR</a> in the
+ *             <i>Amazon Elastic Container Registry User Guide</i>.</p>
+ *         <note>
+ *             <p>When configuring cross-account replication, the destination account must grant the
+ *                 source account permission to replicate. This permission is controlled using a
+ *                 registry permissions policy. For more information, see <a>PutRegistryPolicy</a>.</p>
+ *         </note>
+ */
+export declare class PutReplicationConfigurationCommand extends $Command<PutReplicationConfigurationCommandInput, PutReplicationConfigurationCommandOutput, ECRClientResolvedConfig> {
+    readonly input: PutReplicationConfigurationCommandInput;
+    constructor(input: PutReplicationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutReplicationConfigurationCommandInput, PutReplicationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/types/ts3.4/commands/SetRepositoryPolicyCommand.d.ts

@@ -0,0 +1,21 @@
+import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
+import { SetRepositoryPolicyRequest, SetRepositoryPolicyResponse } from "../models/models_0";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
+export declare type SetRepositoryPolicyCommandInput = SetRepositoryPolicyRequest;
+export declare type SetRepositoryPolicyCommandOutput = SetRepositoryPolicyResponse & __MetadataBearer;
+/**
+ * <p>Applies a repository policy to the specified repository to control access permissions.
+ *             For more information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html">Amazon ECR Repository
+ *                 Policies</a> in the <i>Amazon Elastic Container Registry User Guide</i>.</p>
+ */
+export declare class SetRepositoryPolicyCommand extends $Command<SetRepositoryPolicyCommandInput, SetRepositoryPolicyCommandOutput, ECRClientResolvedConfig> {
+    readonly input: SetRepositoryPolicyCommandInput;
+    constructor(input: SetRepositoryPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetRepositoryPolicyCommandInput, SetRepositoryPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}