@aws-sdk/client-codeartifact 3.35.0 → 3.38.0

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

@@ -6,33 +6,11 @@ export interface DeletePackageVersionsCommandInput extends DeletePackageVersions
 }
 export interface DeletePackageVersionsCommandOutput extends DeletePackageVersionsResult, __MetadataBearer {
 }
-/**
- * <p> Deletes one or more versions of a package. A deleted package version cannot be restored
- *       in your repository. If you want to remove a package version from your repository and be able
- *       to restore it later, set its status to <code>Archived</code>. Archived packages cannot be
- *       downloaded from a repository and don't show up with list package APIs (for example,
- *           <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html">ListackageVersions</a>), but you can restore them using <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html">UpdatePackageVersionsStatus</a>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, DeletePackageVersionsCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, DeletePackageVersionsCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new DeletePackageVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeletePackageVersionsCommandInput} for command's `input` shape.
- * @see {@link DeletePackageVersionsCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeletePackageVersionsCommand extends $Command<DeletePackageVersionsCommandInput, DeletePackageVersionsCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: DeletePackageVersionsCommandInput;
     constructor(input: DeletePackageVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePackageVersionsCommandInput, DeletePackageVersionsCommandOutput>;
     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 DeleteRepositoryResult, __MetadataBearer {
 }
-/**
- * <p>
- *          Deletes a repository.
- *        </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, DeleteRepositoryCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, DeleteRepositoryCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(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 CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRepositoryCommand extends $Command<DeleteRepositoryCommandInput, DeleteRepositoryCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: DeleteRepositoryCommandInput;
     constructor(input: DeleteRepositoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRepositoryCommandInput, DeleteRepositoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface DeleteRepositoryPermissionsPolicyCommandInput extends DeleteRep
 }
 export interface DeleteRepositoryPermissionsPolicyCommandOutput extends DeleteRepositoryPermissionsPolicyResult, __MetadataBearer {
 }
-/**
- * <p>
- *         Deletes the resource policy that is set on a repository. After a resource policy is deleted, the
- *         permissions allowed and denied by the deleted policy are removed. The effect of deleting a resource policy might not be immediate.
- *       </p>
- *          <important>
- *             <p>
- *          Use <code>DeleteRepositoryPermissionsPolicy</code> with caution. After a policy is deleted, AWS users, roles, and accounts lose permissions to perform
- *          the repository actions granted by the deleted policy.
- *        </p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, DeleteRepositoryPermissionsPolicyCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, DeleteRepositoryPermissionsPolicyCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new DeleteRepositoryPermissionsPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRepositoryPermissionsPolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteRepositoryPermissionsPolicyCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRepositoryPermissionsPolicyCommand extends $Command<DeleteRepositoryPermissionsPolicyCommandInput, DeleteRepositoryPermissionsPolicyCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: DeleteRepositoryPermissionsPolicyCommandInput;
     constructor(input: DeleteRepositoryPermissionsPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRepositoryPermissionsPolicyCommandInput, DeleteRepositoryPermissionsPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeDomainCommandInput extends DescribeDomainRequest {
 }
 export interface DescribeDomainCommandOutput extends DescribeDomainResult, __MetadataBearer {
 }
-/**
- * <p>
- *          Returns a
- *       <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DomainDescription.html">DomainDescription</a>
- *       object that contains information about the requested domain.
- *      </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, DescribeDomainCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, DescribeDomainCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new DescribeDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDomainCommandInput} for command's `input` shape.
- * @see {@link DescribeDomainCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDomainCommand extends $Command<DescribeDomainCommandInput, DescribeDomainCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: DescribeDomainCommandInput;
     constructor(input: DescribeDomainCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDomainCommandInput, DescribeDomainCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribePackageVersionCommandInput extends DescribePackageVersi
 }
 export interface DescribePackageVersionCommandOutput extends DescribePackageVersionResult, __MetadataBearer {
 }
-/**
- * <p>
- *        Returns a
- *        <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageVersionDescription.html">PackageVersionDescription</a>
- *        object that contains information about the requested package version.
- *      </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, DescribePackageVersionCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, DescribePackageVersionCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new DescribePackageVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePackageVersionCommandInput} for command's `input` shape.
- * @see {@link DescribePackageVersionCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePackageVersionCommand extends $Command<DescribePackageVersionCommandInput, DescribePackageVersionCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: DescribePackageVersionCommandInput;
     constructor(input: DescribePackageVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePackageVersionCommandInput, DescribePackageVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeRepositoryCommandInput extends DescribeRepositoryReques
 }
 export interface DescribeRepositoryCommandOutput extends DescribeRepositoryResult, __MetadataBearer {
 }
-/**
- * <p>
- *          Returns a <code>RepositoryDescription</code> object that contains detailed information
- *         about the requested repository.
- *        </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, DescribeRepositoryCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, DescribeRepositoryCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new DescribeRepositoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRepositoryCommandInput} for command's `input` shape.
- * @see {@link DescribeRepositoryCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeRepositoryCommand extends $Command<DescribeRepositoryCommandInput, DescribeRepositoryCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: DescribeRepositoryCommandInput;
     constructor(input: DescribeRepositoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRepositoryCommandInput, DescribeRepositoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DisassociateExternalConnectionCommandInput extends Disassociate
 }
 export interface DisassociateExternalConnectionCommandOutput extends DisassociateExternalConnectionResult, __MetadataBearer {
 }
-/**
- * <p>
- *       Removes an existing external connection from a repository.
- *     </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, DisassociateExternalConnectionCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, DisassociateExternalConnectionCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new DisassociateExternalConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateExternalConnectionCommandInput} for command's `input` shape.
- * @see {@link DisassociateExternalConnectionCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateExternalConnectionCommand extends $Command<DisassociateExternalConnectionCommandInput, DisassociateExternalConnectionCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: DisassociateExternalConnectionCommandInput;
     constructor(input: DisassociateExternalConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateExternalConnectionCommandInput, DisassociateExternalConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface DisposePackageVersionsCommandInput extends DisposePackageVersio
 }
 export interface DisposePackageVersionsCommandOutput extends DisposePackageVersionsResult, __MetadataBearer {
 }
-/**
- * <p>
- *       Deletes the assets in package versions and sets the package versions' status to <code>Disposed</code>.
- *       A disposed package version cannot be restored in your repository because its assets are deleted.
- *     </p>
- *
- *          <p>
- *       To view all disposed package versions in a repository, use <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html">ListPackageVersions</a> and set the
- *       <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html#API_ListPackageVersions_RequestSyntax">status</a> parameter
- *       to <code>Disposed</code>.
- *     </p>
- *
- *          <p>
- *       To view information about a disposed package version, use <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DescribePackageVersion.html">DescribePackageVersion</a>.
- *     </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, DisposePackageVersionsCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, DisposePackageVersionsCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new DisposePackageVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisposePackageVersionsCommandInput} for command's `input` shape.
- * @see {@link DisposePackageVersionsCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisposePackageVersionsCommand extends $Command<DisposePackageVersionsCommandInput, DisposePackageVersionsCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: DisposePackageVersionsCommandInput;
     constructor(input: DisposePackageVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisposePackageVersionsCommandInput, DisposePackageVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,49 +6,11 @@ export interface GetAuthorizationTokenCommandInput extends GetAuthorizationToken
 }
 export interface GetAuthorizationTokenCommandOutput extends GetAuthorizationTokenResult, __MetadataBearer {
 }
-/**
- * <p>
- *         Generates a temporary authorization token for accessing repositories in the domain.
- *         This API requires the <code>codeartifact:GetAuthorizationToken</code> and <code>sts:GetServiceBearerToken</code> permissions.
- *         For more information about authorization tokens, see
- *         <a href="https://docs.aws.amazon.com/codeartifact/latest/ug/tokens-authentication.html">AWS CodeArtifact authentication and tokens</a>.
- *       </p>
- *          <note>
- *             <p>CodeArtifact authorization tokens are valid for a period of 12 hours when created with the <code>login</code> command.
- *          You can call <code>login</code> periodically to refresh the token. When
- *          you create an authorization token with the <code>GetAuthorizationToken</code> API, you can set a custom authorization period,
- *          up to a maximum of 12 hours, with the <code>durationSeconds</code> parameter.</p>
- *             <p>The authorization period begins after <code>login</code>
- *          or <code>GetAuthorizationToken</code> is called. If <code>login</code> or <code>GetAuthorizationToken</code> is called while
- *          assuming a role, the token lifetime is independent of the maximum session duration
- *          of the role. For example, if you call <code>sts assume-role</code> and specify a session duration of 15 minutes, then
- *          generate a CodeArtifact authorization token, the token will be valid for the full authorization period
- *          even though this is longer than the 15-minute session duration.</p>
- *             <p>See
- *          <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html">Using IAM Roles</a>
- *          for more information on controlling session duration. </p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, GetAuthorizationTokenCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, GetAuthorizationTokenCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(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 CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAuthorizationTokenCommand extends $Command<GetAuthorizationTokenCommandInput, GetAuthorizationTokenCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: GetAuthorizationTokenCommandInput;
     constructor(input: GetAuthorizationTokenCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAuthorizationTokenCommandInput, GetAuthorizationTokenCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface GetDomainPermissionsPolicyCommandInput extends GetDomainPermiss
 }
 export interface GetDomainPermissionsPolicyCommandOutput extends GetDomainPermissionsPolicyResult, __MetadataBearer {
 }
-/**
- * <p>
- *         Returns the resource policy attached to the specified domain.
- *       </p>
- *          <note>
- *             <p>
- *          The policy is a resource-based policy, not an identity-based policy. For more information, see
- *          <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html">Identity-based policies
- *            and resource-based policies </a> in the <i>AWS Identity and Access Management User Guide</i>.
- *        </p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, GetDomainPermissionsPolicyCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, GetDomainPermissionsPolicyCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new GetDomainPermissionsPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDomainPermissionsPolicyCommandInput} for command's `input` shape.
- * @see {@link GetDomainPermissionsPolicyCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDomainPermissionsPolicyCommand extends $Command<GetDomainPermissionsPolicyCommandInput, GetDomainPermissionsPolicyCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: GetDomainPermissionsPolicyCommandInput;
     constructor(input: GetDomainPermissionsPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDomainPermissionsPolicyCommandInput, GetDomainPermissionsPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetPackageVersionAssetCommandInput extends GetPackageVersionAss
 }
 export interface GetPackageVersionAssetCommandOutput extends GetPackageVersionAssetResult, __MetadataBearer {
 }
-/**
- * <p>
- *       Returns an asset (or file) that is in a package. For example, for a Maven package version, use
- *       <code>GetPackageVersionAsset</code> to download a <code>JAR</code> file, a <code>POM</code> file,
- *       or any other assets in the package version.
- *     </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, GetPackageVersionAssetCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, GetPackageVersionAssetCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new GetPackageVersionAssetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetPackageVersionAssetCommandInput} for command's `input` shape.
- * @see {@link GetPackageVersionAssetCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetPackageVersionAssetCommand extends $Command<GetPackageVersionAssetCommandInput, GetPackageVersionAssetCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: GetPackageVersionAssetCommandInput;
     constructor(input: GetPackageVersionAssetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPackageVersionAssetCommandInput, GetPackageVersionAssetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface GetPackageVersionReadmeCommandInput extends GetPackageVersionRe
 }
 export interface GetPackageVersionReadmeCommandOutput extends GetPackageVersionReadmeResult, __MetadataBearer {
 }
-/**
- * <p>
- *          Gets the readme file or descriptive text for a package version. For packages that do not contain a readme file, CodeArtifact
- *          extracts a description from a metadata file. For example, from the <code><description></code> element in the
- *         <code>pom.xml</code> file of a Maven package.
- *       </p>
- *          <p>
- *        The returned text might contain formatting. For example, it might contain formatting for Markdown or reStructuredText.
- *      </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, GetPackageVersionReadmeCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, GetPackageVersionReadmeCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new GetPackageVersionReadmeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetPackageVersionReadmeCommandInput} for command's `input` shape.
- * @see {@link GetPackageVersionReadmeCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetPackageVersionReadmeCommand extends $Command<GetPackageVersionReadmeCommandInput, GetPackageVersionReadmeCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: GetPackageVersionReadmeCommandInput;
     constructor(input: GetPackageVersionReadmeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPackageVersionReadmeCommandInput, GetPackageVersionReadmeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,49 +6,11 @@ export interface GetRepositoryEndpointCommandInput extends GetRepositoryEndpoint
 }
 export interface GetRepositoryEndpointCommandOutput extends GetRepositoryEndpointResult, __MetadataBearer {
 }
-/**
- * <p>
- *       Returns the endpoint of a repository for a specific package format. A repository has one endpoint for each
- *       package format:
- *     </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>npm</code>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>pypi</code>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>maven</code>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, GetRepositoryEndpointCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, GetRepositoryEndpointCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new GetRepositoryEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRepositoryEndpointCommandInput} for command's `input` shape.
- * @see {@link GetRepositoryEndpointCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRepositoryEndpointCommand extends $Command<GetRepositoryEndpointCommandInput, GetRepositoryEndpointCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: GetRepositoryEndpointCommandInput;
     constructor(input: GetRepositoryEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRepositoryEndpointCommandInput, GetRepositoryEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetRepositoryPermissionsPolicyCommandInput extends GetRepositor
 }
 export interface GetRepositoryPermissionsPolicyCommandOutput extends GetRepositoryPermissionsPolicyResult, __MetadataBearer {
 }
-/**
- * <p>
- *         Returns the resource policy that is set on a repository.
- *       </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, GetRepositoryPermissionsPolicyCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, GetRepositoryPermissionsPolicyCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new GetRepositoryPermissionsPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRepositoryPermissionsPolicyCommandInput} for command's `input` shape.
- * @see {@link GetRepositoryPermissionsPolicyCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRepositoryPermissionsPolicyCommand extends $Command<GetRepositoryPermissionsPolicyCommandInput, GetRepositoryPermissionsPolicyCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: GetRepositoryPermissionsPolicyCommandInput;
     constructor(input: GetRepositoryPermissionsPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRepositoryPermissionsPolicyCommandInput, GetRepositoryPermissionsPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ListDomainsCommandInput extends ListDomainsRequest {
 }
 export interface ListDomainsCommandOutput extends ListDomainsResult, __MetadataBearer {
 }
-/**
- * <p> Returns a list of <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageVersionDescription.html">DomainSummary</a> objects for all domains owned by the AWS account that makes
- *       this call. Each returned <code>DomainSummary</code> object contains information about a
- *       domain. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, ListDomainsCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, ListDomainsCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new ListDomainsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDomainsCommandInput} for command's `input` shape.
- * @see {@link ListDomainsCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDomainsCommand extends $Command<ListDomainsCommandInput, ListDomainsCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: ListDomainsCommandInput;
     constructor(input: ListDomainsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDomainsCommandInput, ListDomainsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ListPackageVersionAssetsCommandInput extends ListPackageVersion
 }
 export interface ListPackageVersionAssetsCommandOutput extends ListPackageVersionAssetsResult, __MetadataBearer {
 }
-/**
- * <p>
- *        Returns a list of
- *        <a href="https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_AssetSummary.html">AssetSummary</a>
- *        objects for assets in a package version.
- *      </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodeartifactClient, ListPackageVersionAssetsCommand } from "@aws-sdk/client-codeartifact"; // ES Modules import
- * // const { CodeartifactClient, ListPackageVersionAssetsCommand } = require("@aws-sdk/client-codeartifact"); // CommonJS import
- * const client = new CodeartifactClient(config);
- * const command = new ListPackageVersionAssetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPackageVersionAssetsCommandInput} for command's `input` shape.
- * @see {@link ListPackageVersionAssetsCommandOutput} for command's `response` shape.
- * @see {@link CodeartifactClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListPackageVersionAssetsCommand extends $Command<ListPackageVersionAssetsCommandInput, ListPackageVersionAssetsCommandOutput, CodeartifactClientResolvedConfig> {
     readonly input: ListPackageVersionAssetsCommandInput;
     constructor(input: ListPackageVersionAssetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeartifactClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPackageVersionAssetsCommandInput, ListPackageVersionAssetsCommandOutput>;
     private serialize;
     private deserialize;