@aws-sdk/client-ecr 3.34.0 → 3.37.0

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

@@ -1,37 +0,0 @@
-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 interface DeleteRepositoryCommandInput extends DeleteRepositoryRequest {
-}
-export interface DeleteRepositoryCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, DeleteRepositoryCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, DeleteRepositoryCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new DeleteRepositoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRepositoryCommandInput} for command's `input` shape.
- * @see {@link DeleteRepositoryCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/DescribeImagesCommand.d.ts

@@ -1,41 +0,0 @@
-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 interface DescribeImagesCommandInput extends DescribeImagesRequest {
-}
-export interface DescribeImagesCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, DescribeImagesCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, DescribeImagesCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new DescribeImagesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeImagesCommandInput} for command's `input` shape.
- * @see {@link DescribeImagesCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/DescribeRegistryCommand.d.ts

@@ -1,37 +0,0 @@
-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 interface DescribeRegistryCommandInput extends DescribeRegistryRequest {
-}
-export interface DescribeRegistryCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, DescribeRegistryCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, DescribeRegistryCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new DescribeRegistryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRegistryCommandInput} for command's `input` shape.
- * @see {@link DescribeRegistryCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/GetAuthorizationTokenCommand.d.ts

@@ -1,42 +0,0 @@
-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 interface GetAuthorizationTokenCommandInput extends GetAuthorizationTokenRequest {
-}
-export interface GetAuthorizationTokenCommandOutput extends 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 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, GetAuthorizationTokenCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, GetAuthorizationTokenCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new GetAuthorizationTokenCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAuthorizationTokenCommandInput} for command's `input` shape.
- * @see {@link GetAuthorizationTokenCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/GetDownloadUrlForLayerCommand.d.ts

@@ -1,42 +0,0 @@
-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 interface GetDownloadUrlForLayerCommandInput extends GetDownloadUrlForLayerRequest {
-}
-export interface GetDownloadUrlForLayerCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, GetDownloadUrlForLayerCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, GetDownloadUrlForLayerCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new GetDownloadUrlForLayerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDownloadUrlForLayerCommandInput} for command's `input` shape.
- * @see {@link GetDownloadUrlForLayerCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/InitiateLayerUploadCommand.d.ts

@@ -1,42 +0,0 @@
-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 interface InitiateLayerUploadCommandInput extends InitiateLayerUploadRequest {
-}
-export interface InitiateLayerUploadCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, InitiateLayerUploadCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, InitiateLayerUploadCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new InitiateLayerUploadCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link InitiateLayerUploadCommandInput} for command's `input` shape.
- * @see {@link InitiateLayerUploadCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/ListImagesCommand.d.ts

@@ -1,41 +0,0 @@
-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 interface ListImagesCommandInput extends ListImagesRequest {
-}
-export interface ListImagesCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, ListImagesCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, ListImagesCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new ListImagesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListImagesCommandInput} for command's `input` shape.
- * @see {@link ListImagesCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/PutImageCommand.d.ts

@@ -1,43 +0,0 @@
-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 interface PutImageCommandInput extends PutImageRequest {
-}
-export interface PutImageCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, PutImageCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, PutImageCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new PutImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutImageCommandInput} for command's `input` shape.
- * @see {@link PutImageCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/PutImageTagMutabilityCommand.d.ts

@@ -1,37 +0,0 @@
-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 interface PutImageTagMutabilityCommandInput extends PutImageTagMutabilityRequest {
-}
-export interface PutImageTagMutabilityCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, PutImageTagMutabilityCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, PutImageTagMutabilityCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new PutImageTagMutabilityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutImageTagMutabilityCommandInput} for command's `input` shape.
- * @see {@link PutImageTagMutabilityCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/PutLifecyclePolicyCommand.d.ts

@@ -1,37 +0,0 @@
-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 interface PutLifecyclePolicyCommandInput extends PutLifecyclePolicyRequest {
-}
-export interface PutLifecyclePolicyCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, PutLifecyclePolicyCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, PutLifecyclePolicyCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new PutLifecyclePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutLifecyclePolicyCommandInput} for command's `input` shape.
- * @see {@link PutLifecyclePolicyCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/PutRegistryPolicyCommand.d.ts

@@ -1,37 +0,0 @@
-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 interface PutRegistryPolicyCommandInput extends PutRegistryPolicyRequest {
-}
-export interface PutRegistryPolicyCommandOutput extends PutRegistryPolicyResponse, __MetadataBearer {
-}
-/**
- * <p>Creates or updates the permissions policy for your registry.</p>
- *         <p>A registry policy is used to specify permissions for another Amazon Web Services 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, PutRegistryPolicyCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, PutRegistryPolicyCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new PutRegistryPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRegistryPolicyCommandInput} for command's `input` shape.
- * @see {@link PutRegistryPolicyCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/PutReplicationConfigurationCommand.d.ts

@@ -1,45 +0,0 @@
-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 interface PutReplicationConfigurationCommandInput extends PutReplicationConfigurationRequest {
-}
-export interface PutReplicationConfigurationCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, PutReplicationConfigurationCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, PutReplicationConfigurationCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new PutReplicationConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutReplicationConfigurationCommandInput} for command's `input` shape.
- * @see {@link PutReplicationConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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/dist/types/ts3.4/commands/SetRepositoryPolicyCommand.d.ts

@@ -1,37 +0,0 @@
-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 interface SetRepositoryPolicyCommandInput extends SetRepositoryPolicyRequest {
-}
-export interface SetRepositoryPolicyCommandOutput extends 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, SetRepositoryPolicyCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, SetRepositoryPolicyCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new SetRepositoryPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetRepositoryPolicyCommandInput} for command's `input` shape.
- * @see {@link SetRepositoryPolicyCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-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;
-}

package/dist/types/ts3.4/commands/StartImageScanCommand.d.ts

@@ -1,38 +0,0 @@
-import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
-import { StartImageScanRequest, StartImageScanResponse } 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 interface StartImageScanCommandInput extends StartImageScanRequest {
-}
-export interface StartImageScanCommandOutput extends StartImageScanResponse, __MetadataBearer {
-}
-/**
- * <p>Starts an image vulnerability scan. An image scan can only be started once per 24
- *             hours on an individual image. This limit includes if an image was scanned on initial
- *             push. For more information, see <a href="https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html">Image scanning</a> in the
- *                 <i>Amazon Elastic Container Registry User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, StartImageScanCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, StartImageScanCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new StartImageScanCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartImageScanCommandInput} for command's `input` shape.
- * @see {@link StartImageScanCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartImageScanCommand extends $Command<StartImageScanCommandInput, StartImageScanCommandOutput, ECRClientResolvedConfig> {
-    readonly input: StartImageScanCommandInput;
-    constructor(input: StartImageScanCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartImageScanCommandInput, StartImageScanCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StartLifecyclePolicyPreviewCommand.d.ts

@@ -1,36 +0,0 @@
-import { ECRClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECRClient";
-import { StartLifecyclePolicyPreviewRequest, StartLifecyclePolicyPreviewResponse } 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 interface StartLifecyclePolicyPreviewCommandInput extends StartLifecyclePolicyPreviewRequest {
-}
-export interface StartLifecyclePolicyPreviewCommandOutput extends StartLifecyclePolicyPreviewResponse, __MetadataBearer {
-}
-/**
- * <p>Starts a preview of a lifecycle policy for the specified repository. This allows you
- *             to see the results before associating the lifecycle policy with the repository.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, StartLifecyclePolicyPreviewCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, StartLifecyclePolicyPreviewCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new StartLifecyclePolicyPreviewCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartLifecyclePolicyPreviewCommandInput} for command's `input` shape.
- * @see {@link StartLifecyclePolicyPreviewCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartLifecyclePolicyPreviewCommand extends $Command<StartLifecyclePolicyPreviewCommandInput, StartLifecyclePolicyPreviewCommandOutput, ECRClientResolvedConfig> {
-    readonly input: StartLifecyclePolicyPreviewCommandInput;
-    constructor(input: StartLifecyclePolicyPreviewCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartLifecyclePolicyPreviewCommandInput, StartLifecyclePolicyPreviewCommandOutput>;
-    private serialize;
-    private deserialize;
-}