@aws-sdk/client-auditmanager 3.36.0 → 3.36.1

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

@@ -6,31 +6,11 @@ export interface DeleteControlCommandInput extends DeleteControlRequest {
 }
 export interface DeleteControlCommandOutput extends DeleteControlResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Deletes a custom control in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, DeleteControlCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, DeleteControlCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new DeleteControlCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteControlCommandInput} for command's `input` shape.
- * @see {@link DeleteControlCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteControlCommand extends $Command<DeleteControlCommandInput, DeleteControlCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: DeleteControlCommandInput;
     constructor(input: DeleteControlCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteControlCommandInput, DeleteControlCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeregisterAccountCommandInput extends DeregisterAccountRequest
 }
 export interface DeregisterAccountCommandOutput extends DeregisterAccountResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Deregisters an account in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, DeregisterAccountCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, DeregisterAccountCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new DeregisterAccountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterAccountCommandInput} for command's `input` shape.
- * @see {@link DeregisterAccountCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterAccountCommand extends $Command<DeregisterAccountCommandInput, DeregisterAccountCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: DeregisterAccountCommandInput;
     constructor(input: DeregisterAccountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterAccountCommandInput, DeregisterAccountCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DeregisterOrganizationAdminAccountCommandInput extends Deregist
 }
 export interface DeregisterOrganizationAdminAccountCommandOutput extends DeregisterOrganizationAdminAccountResponse, __MetadataBearer {
 }
-/**
- * <p>Removes the specified member account as a delegated administrator for Audit Manager. </p>
- *          <important>
- *             <p>When you remove a delegated administrator from your Audit Manager settings, or when you
- *         deregister a delegated administrator from Organizations, you continue to have access
- *       to the evidence that you previously collected under that account. However, Audit Manager
- *             will stop collecting and attaching evidence to that delegated administrator account
- *             moving forward.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, DeregisterOrganizationAdminAccountCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, DeregisterOrganizationAdminAccountCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new DeregisterOrganizationAdminAccountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterOrganizationAdminAccountCommandInput} for command's `input` shape.
- * @see {@link DeregisterOrganizationAdminAccountCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterOrganizationAdminAccountCommand extends $Command<DeregisterOrganizationAdminAccountCommandInput, DeregisterOrganizationAdminAccountCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: DeregisterOrganizationAdminAccountCommandInput;
     constructor(input: DeregisterOrganizationAdminAccountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterOrganizationAdminAccountCommandInput, DeregisterOrganizationAdminAccountCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DisassociateAssessmentReportEvidenceFolderCommandInput extends
 }
 export interface DisassociateAssessmentReportEvidenceFolderCommandOutput extends DisassociateAssessmentReportEvidenceFolderResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Disassociates an evidence folder from the specified assessment report in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, DisassociateAssessmentReportEvidenceFolderCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, DisassociateAssessmentReportEvidenceFolderCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new DisassociateAssessmentReportEvidenceFolderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateAssessmentReportEvidenceFolderCommandInput} for command's `input` shape.
- * @see {@link DisassociateAssessmentReportEvidenceFolderCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateAssessmentReportEvidenceFolderCommand extends $Command<DisassociateAssessmentReportEvidenceFolderCommandInput, DisassociateAssessmentReportEvidenceFolderCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: DisassociateAssessmentReportEvidenceFolderCommandInput;
     constructor(input: DisassociateAssessmentReportEvidenceFolderCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateAssessmentReportEvidenceFolderCommandInput, DisassociateAssessmentReportEvidenceFolderCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetAccountStatusCommandInput extends GetAccountStatusRequest {
 }
 export interface GetAccountStatusCommandOutput extends GetAccountStatusResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns the registration status of an account in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetAccountStatusCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetAccountStatusCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetAccountStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAccountStatusCommandInput} for command's `input` shape.
- * @see {@link GetAccountStatusCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAccountStatusCommand extends $Command<GetAccountStatusCommandInput, GetAccountStatusCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetAccountStatusCommandInput;
     constructor(input: GetAccountStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountStatusCommandInput, GetAccountStatusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetAssessmentCommandInput extends GetAssessmentRequest {
 }
 export interface GetAssessmentCommandOutput extends GetAssessmentResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns an assessment from Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetAssessmentCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetAssessmentCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetAssessmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAssessmentCommandInput} for command's `input` shape.
- * @see {@link GetAssessmentCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAssessmentCommand extends $Command<GetAssessmentCommandInput, GetAssessmentCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetAssessmentCommandInput;
     constructor(input: GetAssessmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAssessmentCommandInput, GetAssessmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetAssessmentFrameworkCommandInput extends GetAssessmentFramewo
 }
 export interface GetAssessmentFrameworkCommandOutput extends GetAssessmentFrameworkResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns a framework from Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetAssessmentFrameworkCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetAssessmentFrameworkCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetAssessmentFrameworkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAssessmentFrameworkCommandInput} for command's `input` shape.
- * @see {@link GetAssessmentFrameworkCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAssessmentFrameworkCommand extends $Command<GetAssessmentFrameworkCommandInput, GetAssessmentFrameworkCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetAssessmentFrameworkCommandInput;
     constructor(input: GetAssessmentFrameworkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAssessmentFrameworkCommandInput, GetAssessmentFrameworkCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetAssessmentReportUrlCommandInput extends GetAssessmentReportU
 }
 export interface GetAssessmentReportUrlCommandOutput extends GetAssessmentReportUrlResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns the URL of a specified assessment report in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetAssessmentReportUrlCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetAssessmentReportUrlCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetAssessmentReportUrlCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAssessmentReportUrlCommandInput} for command's `input` shape.
- * @see {@link GetAssessmentReportUrlCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAssessmentReportUrlCommand extends $Command<GetAssessmentReportUrlCommandInput, GetAssessmentReportUrlCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetAssessmentReportUrlCommandInput;
     constructor(input: GetAssessmentReportUrlCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAssessmentReportUrlCommandInput, GetAssessmentReportUrlCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetChangeLogsCommandInput extends GetChangeLogsRequest {
 }
 export interface GetChangeLogsCommandOutput extends GetChangeLogsResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns a list of changelogs from Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetChangeLogsCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetChangeLogsCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetChangeLogsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetChangeLogsCommandInput} for command's `input` shape.
- * @see {@link GetChangeLogsCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetChangeLogsCommand extends $Command<GetChangeLogsCommandInput, GetChangeLogsCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetChangeLogsCommandInput;
     constructor(input: GetChangeLogsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetChangeLogsCommandInput, GetChangeLogsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetControlCommandInput extends GetControlRequest {
 }
 export interface GetControlCommandOutput extends GetControlResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns a control from Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetControlCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetControlCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetControlCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetControlCommandInput} for command's `input` shape.
- * @see {@link GetControlCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetControlCommand extends $Command<GetControlCommandInput, GetControlCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetControlCommandInput;
     constructor(input: GetControlCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetControlCommandInput, GetControlCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetDelegationsCommandInput extends GetDelegationsRequest {
 }
 export interface GetDelegationsCommandOutput extends GetDelegationsResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns a list of delegations from an audit owner to a delegate.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetDelegationsCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetDelegationsCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetDelegationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDelegationsCommandInput} for command's `input` shape.
- * @see {@link GetDelegationsCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDelegationsCommand extends $Command<GetDelegationsCommandInput, GetDelegationsCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetDelegationsCommandInput;
     constructor(input: GetDelegationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDelegationsCommandInput, GetDelegationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetEvidenceByEvidenceFolderCommandInput extends GetEvidenceByEv
 }
 export interface GetEvidenceByEvidenceFolderCommandOutput extends GetEvidenceByEvidenceFolderResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns all evidence from a specified evidence folder in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetEvidenceByEvidenceFolderCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetEvidenceByEvidenceFolderCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetEvidenceByEvidenceFolderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEvidenceByEvidenceFolderCommandInput} for command's `input` shape.
- * @see {@link GetEvidenceByEvidenceFolderCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEvidenceByEvidenceFolderCommand extends $Command<GetEvidenceByEvidenceFolderCommandInput, GetEvidenceByEvidenceFolderCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetEvidenceByEvidenceFolderCommandInput;
     constructor(input: GetEvidenceByEvidenceFolderCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEvidenceByEvidenceFolderCommandInput, GetEvidenceByEvidenceFolderCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetEvidenceCommandInput extends GetEvidenceRequest {
 }
 export interface GetEvidenceCommandOutput extends GetEvidenceResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns evidence from Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetEvidenceCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetEvidenceCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetEvidenceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEvidenceCommandInput} for command's `input` shape.
- * @see {@link GetEvidenceCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEvidenceCommand extends $Command<GetEvidenceCommandInput, GetEvidenceCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetEvidenceCommandInput;
     constructor(input: GetEvidenceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEvidenceCommandInput, GetEvidenceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetEvidenceFolderCommandInput extends GetEvidenceFolderRequest
 }
 export interface GetEvidenceFolderCommandOutput extends GetEvidenceFolderResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns an evidence folder from the specified assessment in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetEvidenceFolderCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetEvidenceFolderCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetEvidenceFolderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEvidenceFolderCommandInput} for command's `input` shape.
- * @see {@link GetEvidenceFolderCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEvidenceFolderCommand extends $Command<GetEvidenceFolderCommandInput, GetEvidenceFolderCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetEvidenceFolderCommandInput;
     constructor(input: GetEvidenceFolderCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEvidenceFolderCommandInput, GetEvidenceFolderCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetEvidenceFoldersByAssessmentCommandInput extends GetEvidenceF
 }
 export interface GetEvidenceFoldersByAssessmentCommandOutput extends GetEvidenceFoldersByAssessmentResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns the evidence folders from a specified assessment in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetEvidenceFoldersByAssessmentCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetEvidenceFoldersByAssessmentCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetEvidenceFoldersByAssessmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEvidenceFoldersByAssessmentCommandInput} for command's `input` shape.
- * @see {@link GetEvidenceFoldersByAssessmentCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEvidenceFoldersByAssessmentCommand extends $Command<GetEvidenceFoldersByAssessmentCommandInput, GetEvidenceFoldersByAssessmentCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetEvidenceFoldersByAssessmentCommandInput;
     constructor(input: GetEvidenceFoldersByAssessmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEvidenceFoldersByAssessmentCommandInput, GetEvidenceFoldersByAssessmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetEvidenceFoldersByAssessmentControlCommandInput extends GetEv
 }
 export interface GetEvidenceFoldersByAssessmentControlCommandOutput extends GetEvidenceFoldersByAssessmentControlResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns a list of evidence folders associated with a specified control of an assessment in Audit Manager.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetEvidenceFoldersByAssessmentControlCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetEvidenceFoldersByAssessmentControlCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetEvidenceFoldersByAssessmentControlCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEvidenceFoldersByAssessmentControlCommandInput} for command's `input` shape.
- * @see {@link GetEvidenceFoldersByAssessmentControlCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEvidenceFoldersByAssessmentControlCommand extends $Command<GetEvidenceFoldersByAssessmentControlCommandInput, GetEvidenceFoldersByAssessmentControlCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetEvidenceFoldersByAssessmentControlCommandInput;
     constructor(input: GetEvidenceFoldersByAssessmentControlCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEvidenceFoldersByAssessmentControlCommandInput, GetEvidenceFoldersByAssessmentControlCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetOrganizationAdminAccountCommandInput extends GetOrganization
 }
 export interface GetOrganizationAdminAccountCommandOutput extends GetOrganizationAdminAccountResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns the name of the delegated Amazon Web Services administrator account for the organization.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetOrganizationAdminAccountCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetOrganizationAdminAccountCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetOrganizationAdminAccountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetOrganizationAdminAccountCommandInput} for command's `input` shape.
- * @see {@link GetOrganizationAdminAccountCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetOrganizationAdminAccountCommand extends $Command<GetOrganizationAdminAccountCommandInput, GetOrganizationAdminAccountCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetOrganizationAdminAccountCommandInput;
     constructor(input: GetOrganizationAdminAccountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetOrganizationAdminAccountCommandInput, GetOrganizationAdminAccountCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetServicesInScopeCommandInput extends GetServicesInScopeReques
 }
 export interface GetServicesInScopeCommandOutput extends GetServicesInScopeResponse, __MetadataBearer {
 }
-/**
- * <p>
- *    Returns a list of the in-scope Amazon Web Services services for the specified assessment.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AuditManagerClient, GetServicesInScopeCommand } from "@aws-sdk/client-auditmanager"; // ES Modules import
- * // const { AuditManagerClient, GetServicesInScopeCommand } = require("@aws-sdk/client-auditmanager"); // CommonJS import
- * const client = new AuditManagerClient(config);
- * const command = new GetServicesInScopeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetServicesInScopeCommandInput} for command's `input` shape.
- * @see {@link GetServicesInScopeCommandOutput} for command's `response` shape.
- * @see {@link AuditManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetServicesInScopeCommand extends $Command<GetServicesInScopeCommandInput, GetServicesInScopeCommandOutput, AuditManagerClientResolvedConfig> {
     readonly input: GetServicesInScopeCommandInput;
     constructor(input: GetServicesInScopeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AuditManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetServicesInScopeCommandInput, GetServicesInScopeCommandOutput>;
     private serialize;
     private deserialize;