@aws-sdk/client-ecr 3.36.0 → 3.39.0

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

@@ -6,36 +6,11 @@ export interface InitiateLayerUploadCommandInput extends InitiateLayerUploadRequ
 }
 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

@@ -6,35 +6,11 @@ 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/ListTagsForResourceCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>List the tags for an Amazon ECR resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, ListTagsForResourceCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, ListTagsForResourceCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 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/dist-types/ts3.4/commands/PutImageCommand.d.ts

@@ -6,37 +6,11 @@ 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/PutImageScanningConfigurationCommand.d.ts

@@ -6,29 +6,11 @@ export interface PutImageScanningConfigurationCommandInput extends PutImageScann
 }
 export interface PutImageScanningConfigurationCommandOutput extends PutImageScanningConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the image scanning configuration for the specified repository.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, PutImageScanningConfigurationCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, PutImageScanningConfigurationCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new PutImageScanningConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutImageScanningConfigurationCommandInput} for command's `input` shape.
- * @see {@link PutImageScanningConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 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/dist-types/ts3.4/commands/PutImageTagMutabilityCommand.d.ts

@@ -6,31 +6,11 @@ export interface PutImageTagMutabilityCommandInput extends PutImageTagMutability
 }
 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

@@ -6,31 +6,11 @@ export interface PutLifecyclePolicyCommandInput extends PutLifecyclePolicyReques
 }
 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

@@ -6,31 +6,11 @@ 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

@@ -6,39 +6,11 @@ export interface PutReplicationConfigurationCommandInput extends PutReplicationC
 }
 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

@@ -6,31 +6,11 @@ export interface SetRepositoryPolicyCommandInput extends SetRepositoryPolicyRequ
 }
 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

@@ -6,32 +6,11 @@ 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

@@ -6,30 +6,11 @@ export interface StartLifecyclePolicyPreviewCommandInput extends StartLifecycleP
 }
 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;

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -6,30 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Adds specified tags to a resource with the specified ARN. Existing tags on a resource
- *             are not changed if they are not specified in the request parameters.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, TagResourceCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, TagResourceCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ECRClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -6,29 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes specified tags from a resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, UntagResourceCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, UntagResourceCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, ECRClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UploadLayerPartCommand.d.ts

@@ -6,36 +6,11 @@ export interface UploadLayerPartCommandInput extends UploadLayerPartRequest {
 }
 export interface UploadLayerPartCommandOutput extends UploadLayerPartResponse, __MetadataBearer {
 }
-/**
- * <p>Uploads an image layer part to Amazon ECR.</p>
- *         <p>When an image is pushed, each new image layer is uploaded in parts. The maximum size
- *             of each image layer part can be 20971520 bytes (or about 20MB). The UploadLayerPart API
- *             is called once per each new image layer part.</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, UploadLayerPartCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, UploadLayerPartCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new UploadLayerPartCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UploadLayerPartCommandInput} for command's `input` shape.
- * @see {@link UploadLayerPartCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UploadLayerPartCommand extends $Command<UploadLayerPartCommandInput, UploadLayerPartCommandOutput, ECRClientResolvedConfig> {
     readonly input: UploadLayerPartCommandInput;
     constructor(input: UploadLayerPartCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UploadLayerPartCommandInput, UploadLayerPartCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/index.d.ts

@@ -0,0 +1,35 @@
+export * from "./BatchCheckLayerAvailabilityCommand";
+export * from "./BatchDeleteImageCommand";
+export * from "./BatchGetImageCommand";
+export * from "./CompleteLayerUploadCommand";
+export * from "./CreateRepositoryCommand";
+export * from "./DeleteLifecyclePolicyCommand";
+export * from "./DeleteRegistryPolicyCommand";
+export * from "./DeleteRepositoryCommand";
+export * from "./DeleteRepositoryPolicyCommand";
+export * from "./DescribeImageReplicationStatusCommand";
+export * from "./DescribeImageScanFindingsCommand";
+export * from "./DescribeImagesCommand";
+export * from "./DescribeRegistryCommand";
+export * from "./DescribeRepositoriesCommand";
+export * from "./GetAuthorizationTokenCommand";
+export * from "./GetDownloadUrlForLayerCommand";
+export * from "./GetLifecyclePolicyCommand";
+export * from "./GetLifecyclePolicyPreviewCommand";
+export * from "./GetRegistryPolicyCommand";
+export * from "./GetRepositoryPolicyCommand";
+export * from "./InitiateLayerUploadCommand";
+export * from "./ListImagesCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./PutImageCommand";
+export * from "./PutImageScanningConfigurationCommand";
+export * from "./PutImageTagMutabilityCommand";
+export * from "./PutLifecyclePolicyCommand";
+export * from "./PutRegistryPolicyCommand";
+export * from "./PutReplicationConfigurationCommand";
+export * from "./SetRepositoryPolicyCommand";
+export * from "./StartImageScanCommand";
+export * from "./StartLifecyclePolicyPreviewCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UploadLayerPartCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,46 +1,6 @@
-export * from "./ECRClient";
 export * from "./ECR";
-export * from "./commands/BatchCheckLayerAvailabilityCommand";
-export * from "./commands/BatchDeleteImageCommand";
-export * from "./commands/BatchGetImageCommand";
-export * from "./commands/CompleteLayerUploadCommand";
-export * from "./commands/CreateRepositoryCommand";
-export * from "./commands/DeleteLifecyclePolicyCommand";
-export * from "./commands/DeleteRegistryPolicyCommand";
-export * from "./commands/DeleteRepositoryCommand";
-export * from "./commands/DeleteRepositoryPolicyCommand";
-export * from "./commands/DescribeImageReplicationStatusCommand";
-export * from "./commands/DescribeImagesCommand";
-export * from "./pagination/DescribeImagesPaginator";
-export * from "./commands/DescribeImageScanFindingsCommand";
-export * from "./pagination/DescribeImageScanFindingsPaginator";
-export * from "./waiters/waitForImageScanComplete";
-export * from "./commands/DescribeRegistryCommand";
-export * from "./commands/DescribeRepositoriesCommand";
-export * from "./pagination/DescribeRepositoriesPaginator";
-export * from "./commands/GetAuthorizationTokenCommand";
-export * from "./commands/GetDownloadUrlForLayerCommand";
-export * from "./commands/GetLifecyclePolicyCommand";
-export * from "./commands/GetLifecyclePolicyPreviewCommand";
-export * from "./pagination/GetLifecyclePolicyPreviewPaginator";
-export * from "./waiters/waitForLifecyclePolicyPreviewComplete";
-export * from "./commands/GetRegistryPolicyCommand";
-export * from "./commands/GetRepositoryPolicyCommand";
-export * from "./commands/InitiateLayerUploadCommand";
-export * from "./commands/ListImagesCommand";
-export * from "./pagination/ListImagesPaginator";
-export * from "./commands/ListTagsForResourceCommand";
-export * from "./commands/PutImageCommand";
-export * from "./commands/PutImageScanningConfigurationCommand";
-export * from "./commands/PutImageTagMutabilityCommand";
-export * from "./commands/PutLifecyclePolicyCommand";
-export * from "./commands/PutRegistryPolicyCommand";
-export * from "./commands/PutReplicationConfigurationCommand";
-export * from "./commands/SetRepositoryPolicyCommand";
-export * from "./commands/StartImageScanCommand";
-export * from "./commands/StartLifecyclePolicyPreviewCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./commands/UploadLayerPartCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./ECRClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export * from "./waiters";