@aws-sdk/client-ecr 3.36.0 → 3.39.0

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

@@ -6,32 +6,11 @@ export interface BatchGetImageCommandInput extends BatchGetImageRequest {
 }
 export interface BatchGetImageCommandOutput extends BatchGetImageResponse, __MetadataBearer {
 }
-/**
- * <p>Gets detailed information for an image. Images are specified with either an
- *                 <code>imageTag</code> or <code>imageDigest</code>.</p>
- *         <p>When an image is pulled, the BatchGetImage API is called once to retrieve the image
- *             manifest.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, BatchGetImageCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, BatchGetImageCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new BatchGetImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link BatchGetImageCommandInput} for command's `input` shape.
- * @see {@link BatchGetImageCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class BatchGetImageCommand extends $Command<BatchGetImageCommandInput, BatchGetImageCommandOutput, ECRClientResolvedConfig> {
     readonly input: BatchGetImageCommandInput;
     constructor(input: BatchGetImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchGetImageCommandInput, BatchGetImageCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface DeleteLifecyclePolicyCommandInput extends DeleteLifecyclePolicy
 }
 export interface DeleteLifecyclePolicyCommandOutput extends DeleteLifecyclePolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the lifecycle policy associated with the specified repository.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, DeleteLifecyclePolicyCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, DeleteLifecyclePolicyCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new DeleteLifecyclePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLifecyclePolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteLifecyclePolicyCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 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/dist-types/ts3.4/commands/DeleteRegistryPolicyCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteRegistryPolicyCommandInput extends DeleteRegistryPolicyRe
 }
 export interface DeleteRegistryPolicyCommandOutput extends DeleteRegistryPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the registry permissions policy.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, DeleteRegistryPolicyCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, DeleteRegistryPolicyCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new DeleteRegistryPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRegistryPolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteRegistryPolicyCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 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/dist-types/ts3.4/commands/DeleteRepositoryCommand.d.ts

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DescribeRepositoriesCommandInput extends DescribeRepositoriesRe
 }
 export interface DescribeRepositoriesCommandOutput extends DescribeRepositoriesResponse, __MetadataBearer {
 }
-/**
- * <p>Describes image repositories in a registry.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, DescribeRepositoriesCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, DescribeRepositoriesCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new DescribeRepositoriesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRepositoriesCommandInput} for command's `input` shape.
- * @see {@link DescribeRepositoriesCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 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/dist-types/ts3.4/commands/GetAuthorizationTokenCommand.d.ts

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

@@ -6,36 +6,11 @@ export interface GetDownloadUrlForLayerCommandInput extends GetDownloadUrlForLay
 }
 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/GetLifecyclePolicyCommand.d.ts

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

@@ -6,30 +6,11 @@ export interface GetLifecyclePolicyPreviewCommandInput extends GetLifecyclePolic
 }
 export interface GetLifecyclePolicyPreviewCommandOutput extends GetLifecyclePolicyPreviewResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the results of the lifecycle policy preview request for the specified
- *             repository.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, GetLifecyclePolicyPreviewCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, GetLifecyclePolicyPreviewCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new GetLifecyclePolicyPreviewCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLifecyclePolicyPreviewCommandInput} for command's `input` shape.
- * @see {@link GetLifecyclePolicyPreviewCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 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/dist-types/ts3.4/commands/GetRegistryPolicyCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetRegistryPolicyCommandInput extends GetRegistryPolicyRequest
 }
 export interface GetRegistryPolicyCommandOutput extends GetRegistryPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the permissions policy for a registry.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, GetRegistryPolicyCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, GetRegistryPolicyCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new GetRegistryPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRegistryPolicyCommandInput} for command's `input` shape.
- * @see {@link GetRegistryPolicyCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 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/dist-types/ts3.4/commands/GetRepositoryPolicyCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetRepositoryPolicyCommandInput extends GetRepositoryPolicyRequ
 }
 export interface GetRepositoryPolicyCommandOutput extends GetRepositoryPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the repository policy for the specified repository.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRClient, GetRepositoryPolicyCommand } from "@aws-sdk/client-ecr"; // ES Modules import
- * // const { ECRClient, GetRepositoryPolicyCommand } = require("@aws-sdk/client-ecr"); // CommonJS import
- * const client = new ECRClient(config);
- * const command = new GetRepositoryPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRepositoryPolicyCommandInput} for command's `input` shape.
- * @see {@link GetRepositoryPolicyCommandOutput} for command's `response` shape.
- * @see {@link ECRClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 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;