@aws-sdk/client-ecr-public 3.35.0 → 3.38.0

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 in a public registry. If the repository contains images, you must
- *          either delete all images in the repository or use the <code>force</code> option which
- *          deletes all images on your behalf before deleting the repository.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, DeleteRepositoryCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, DeleteRepositoryCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRepositoryCommand extends $Command<DeleteRepositoryCommandInput, DeleteRepositoryCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: DeleteRepositoryCommandInput;
     constructor(input: DeleteRepositoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, 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 { ECRPUBLICClient, DeleteRepositoryPolicyCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, DeleteRepositoryPolicyCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRepositoryPolicyCommand extends $Command<DeleteRepositoryPolicyCommandInput, DeleteRepositoryPolicyCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: DeleteRepositoryPolicyCommandInput;
     constructor(input: DeleteRepositoryPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRepositoryPolicyCommandInput, DeleteRepositoryPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeImageTagsCommandInput extends DescribeImageTagsRequest
 }
 export interface DescribeImageTagsCommandOutput extends DescribeImageTagsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the image tag details for a repository in a public registry.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, DescribeImageTagsCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, DescribeImageTagsCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(config);
- * const command = new DescribeImageTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeImageTagsCommandInput} for command's `input` shape.
- * @see {@link DescribeImageTagsCommandOutput} for command's `response` shape.
- * @see {@link ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeImageTagsCommand extends $Command<DescribeImageTagsCommandInput, DescribeImageTagsCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: DescribeImageTagsCommandInput;
     constructor(input: DescribeImageTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeImageTagsCommandInput, DescribeImageTagsCommandOutput>;
     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 in a public registry.</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 { ECRPUBLICClient, DescribeImagesCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, DescribeImagesCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeImagesCommand extends $Command<DescribeImagesCommandInput, DescribeImagesCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: DescribeImagesCommandInput;
     constructor(input: DescribeImagesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeImagesCommandInput, DescribeImagesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeRegistriesCommandInput extends DescribeRegistriesReques
 }
 export interface DescribeRegistriesCommandOutput extends DescribeRegistriesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns details for a public registry.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, DescribeRegistriesCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, DescribeRegistriesCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(config);
- * const command = new DescribeRegistriesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRegistriesCommandInput} for command's `input` shape.
- * @see {@link DescribeRegistriesCommandOutput} for command's `response` shape.
- * @see {@link ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeRegistriesCommand extends $Command<DescribeRegistriesCommandInput, DescribeRegistriesCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: DescribeRegistriesCommandInput;
     constructor(input: DescribeRegistriesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRegistriesCommandInput, DescribeRegistriesCommandOutput>;
     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 repositories in a public registry.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, DescribeRepositoriesCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, DescribeRepositoriesCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeRepositoriesCommand extends $Command<DescribeRepositoriesCommandInput, DescribeRepositoriesCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: DescribeRepositoriesCommandInput;
     constructor(input: DescribeRepositoriesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRepositoriesCommandInput, DescribeRepositoriesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +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. This API requires
- *          the <code>ecr-public:GetAuthorizationToken</code> and
- *             <code>sts:GetServiceBearerToken</code> permissions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, GetAuthorizationTokenCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, GetAuthorizationTokenCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAuthorizationTokenCommand extends $Command<GetAuthorizationTokenCommandInput, GetAuthorizationTokenCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: GetAuthorizationTokenCommandInput;
     constructor(input: GetAuthorizationTokenCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAuthorizationTokenCommandInput, GetAuthorizationTokenCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetRegistryCatalogDataCommandInput extends GetRegistryCatalogDa
 }
 export interface GetRegistryCatalogDataCommandOutput extends GetRegistryCatalogDataResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves catalog metadata for a public registry.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, GetRegistryCatalogDataCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, GetRegistryCatalogDataCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(config);
- * const command = new GetRegistryCatalogDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRegistryCatalogDataCommandInput} for command's `input` shape.
- * @see {@link GetRegistryCatalogDataCommandOutput} for command's `response` shape.
- * @see {@link ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRegistryCatalogDataCommand extends $Command<GetRegistryCatalogDataCommandInput, GetRegistryCatalogDataCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: GetRegistryCatalogDataCommandInput;
     constructor(input: GetRegistryCatalogDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRegistryCatalogDataCommandInput, GetRegistryCatalogDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetRepositoryCatalogDataCommandInput extends GetRepositoryCatal
 }
 export interface GetRepositoryCatalogDataCommandOutput extends GetRepositoryCatalogDataResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieve catalog metadata for a repository in a public registry. This metadata is
- *          displayed publicly in the Amazon ECR Public Gallery.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, GetRepositoryCatalogDataCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, GetRepositoryCatalogDataCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(config);
- * const command = new GetRepositoryCatalogDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRepositoryCatalogDataCommandInput} for command's `input` shape.
- * @see {@link GetRepositoryCatalogDataCommandOutput} for command's `response` shape.
- * @see {@link ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRepositoryCatalogDataCommand extends $Command<GetRepositoryCatalogDataCommandInput, GetRepositoryCatalogDataCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: GetRepositoryCatalogDataCommandInput;
     constructor(input: GetRepositoryCatalogDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRepositoryCatalogDataCommandInput, GetRepositoryCatalogDataCommandOutput>;
     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 { ECRPUBLICClient, GetRepositoryPolicyCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, GetRepositoryPolicyCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRepositoryPolicyCommand extends $Command<GetRepositoryPolicyCommandInput, GetRepositoryPolicyCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: GetRepositoryPolicyCommandInput;
     constructor(input: GetRepositoryPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRepositoryPolicyCommandInput, GetRepositoryPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +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 { ECRPUBLICClient, InitiateLayerUploadCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, InitiateLayerUploadCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class InitiateLayerUploadCommand extends $Command<InitiateLayerUploadCommandInput, InitiateLayerUploadCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: InitiateLayerUploadCommandInput;
     constructor(input: InitiateLayerUploadCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InitiateLayerUploadCommandInput, InitiateLayerUploadCommandOutput>;
     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 Public resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, ListTagsForResourceCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, ListTagsForResourceCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +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 { ECRPUBLICClient, PutImageCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, PutImageCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutImageCommand extends $Command<PutImageCommandInput, PutImageCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: PutImageCommandInput;
     constructor(input: PutImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutImageCommandInput, PutImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutRegistryCatalogDataCommandInput extends PutRegistryCatalogDa
 }
 export interface PutRegistryCatalogDataCommandOutput extends PutRegistryCatalogDataResponse, __MetadataBearer {
 }
-/**
- * <p>Create or updates the catalog data for a public registry.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, PutRegistryCatalogDataCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, PutRegistryCatalogDataCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(config);
- * const command = new PutRegistryCatalogDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRegistryCatalogDataCommandInput} for command's `input` shape.
- * @see {@link PutRegistryCatalogDataCommandOutput} for command's `response` shape.
- * @see {@link ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutRegistryCatalogDataCommand extends $Command<PutRegistryCatalogDataCommandInput, PutRegistryCatalogDataCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: PutRegistryCatalogDataCommandInput;
     constructor(input: PutRegistryCatalogDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRegistryCatalogDataCommandInput, PutRegistryCatalogDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutRepositoryCatalogDataCommandInput extends PutRepositoryCatal
 }
 export interface PutRepositoryCatalogDataCommandOutput extends PutRepositoryCatalogDataResponse, __MetadataBearer {
 }
-/**
- * <p>Creates or updates the catalog data for a repository in a public registry.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, PutRepositoryCatalogDataCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, PutRepositoryCatalogDataCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(config);
- * const command = new PutRepositoryCatalogDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRepositoryCatalogDataCommandInput} for command's `input` shape.
- * @see {@link PutRepositoryCatalogDataCommandOutput} for command's `response` shape.
- * @see {@link ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutRepositoryCatalogDataCommand extends $Command<PutRepositoryCatalogDataCommandInput, PutRepositoryCatalogDataCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: PutRepositoryCatalogDataCommandInput;
     constructor(input: PutRepositoryCatalogDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRepositoryCatalogDataCommandInput, PutRepositoryCatalogDataCommandOutput>;
     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 public 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 { ECRPUBLICClient, SetRepositoryPolicyCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, SetRepositoryPolicyCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SetRepositoryPolicyCommand extends $Command<SetRepositoryPolicyCommandInput, SetRepositoryPolicyCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: SetRepositoryPolicyCommandInput;
     constructor(input: SetRepositoryPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetRepositoryPolicyCommandInput, SetRepositoryPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Associates the specified tags to a resource with the specified <code>resourceArn</code>.
- *          If existing tags on a resource are not specified in the request parameters, they are not
- *          changed. When a resource is deleted, the tags associated with that resource are deleted as
- *          well.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECRPUBLICClient, TagResourceCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, TagResourceCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, 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 { ECRPUBLICClient, UntagResourceCommand } from "@aws-sdk/client-ecr-public"; // ES Modules import
- * // const { ECRPUBLICClient, UntagResourceCommand } = require("@aws-sdk/client-ecr-public"); // CommonJS import
- * const client = new ECRPUBLICClient(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 ECRPUBLICClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, ECRPUBLICClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECRPUBLICClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;