@aws-sdk/client-chime 3.35.0 → 3.38.0

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

@@ -6,29 +6,11 @@ export interface PutVoiceConnectorTerminationCredentialsCommandInput extends Put
 }
 export interface PutVoiceConnectorTerminationCredentialsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Adds termination SIP credentials for the specified Amazon Chime Voice Connector.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutVoiceConnectorTerminationCredentialsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutVoiceConnectorTerminationCredentialsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutVoiceConnectorTerminationCredentialsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutVoiceConnectorTerminationCredentialsCommandInput} for command's `input` shape.
- * @see {@link PutVoiceConnectorTerminationCredentialsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutVoiceConnectorTerminationCredentialsCommand extends $Command<PutVoiceConnectorTerminationCredentialsCommandInput, PutVoiceConnectorTerminationCredentialsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutVoiceConnectorTerminationCredentialsCommandInput;
     constructor(input: PutVoiceConnectorTerminationCredentialsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutVoiceConnectorTerminationCredentialsCommandInput, PutVoiceConnectorTerminationCredentialsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface RedactChannelMessageCommandInput extends RedactChannelMessageRe
 }
 export interface RedactChannelMessageCommandOutput extends RedactChannelMessageResponse, __MetadataBearer {
 }
-/**
- * <p>Redacts message content, but not metadata. The message exists in the back end, but the
- *          action returns null content, and the state shows as redacted.</p>
- *
- *          <note>
- *             <p>The <code>x-amz-chime-bearer</code> request header is mandatory. Use the
- *                <code>AppInstanceUserArn</code> of the user that makes the API call as the value in
- *             the header.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, RedactChannelMessageCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, RedactChannelMessageCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new RedactChannelMessageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RedactChannelMessageCommandInput} for command's `input` shape.
- * @see {@link RedactChannelMessageCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RedactChannelMessageCommand extends $Command<RedactChannelMessageCommandInput, RedactChannelMessageCommandOutput, ChimeClientResolvedConfig> {
     readonly input: RedactChannelMessageCommandInput;
     constructor(input: RedactChannelMessageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RedactChannelMessageCommandInput, RedactChannelMessageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface RedactConversationMessageCommandInput extends RedactConversatio
 }
 export interface RedactConversationMessageCommandOutput extends RedactConversationMessageResponse, __MetadataBearer {
 }
-/**
- * <p>Redacts the specified message from the specified Amazon Chime conversation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, RedactConversationMessageCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, RedactConversationMessageCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new RedactConversationMessageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RedactConversationMessageCommandInput} for command's `input` shape.
- * @see {@link RedactConversationMessageCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RedactConversationMessageCommand extends $Command<RedactConversationMessageCommandInput, RedactConversationMessageCommandOutput, ChimeClientResolvedConfig> {
     readonly input: RedactConversationMessageCommandInput;
     constructor(input: RedactConversationMessageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RedactConversationMessageCommandInput, RedactConversationMessageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface RedactRoomMessageCommandInput extends RedactRoomMessageRequest
 }
 export interface RedactRoomMessageCommandOutput extends RedactRoomMessageResponse, __MetadataBearer {
 }
-/**
- * <p>Redacts the specified message from the specified Amazon Chime channel.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, RedactRoomMessageCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, RedactRoomMessageCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new RedactRoomMessageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RedactRoomMessageCommandInput} for command's `input` shape.
- * @see {@link RedactRoomMessageCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RedactRoomMessageCommand extends $Command<RedactRoomMessageCommandInput, RedactRoomMessageCommandOutput, ChimeClientResolvedConfig> {
     readonly input: RedactRoomMessageCommandInput;
     constructor(input: RedactRoomMessageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RedactRoomMessageCommandInput, RedactRoomMessageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface RegenerateSecurityTokenCommandInput extends RegenerateSecurityT
 }
 export interface RegenerateSecurityTokenCommandOutput extends RegenerateSecurityTokenResponse, __MetadataBearer {
 }
-/**
- * <p>Regenerates the security token for a bot.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, RegenerateSecurityTokenCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, RegenerateSecurityTokenCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new RegenerateSecurityTokenCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RegenerateSecurityTokenCommandInput} for command's `input` shape.
- * @see {@link RegenerateSecurityTokenCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RegenerateSecurityTokenCommand extends $Command<RegenerateSecurityTokenCommandInput, RegenerateSecurityTokenCommandOutput, ChimeClientResolvedConfig> {
     readonly input: RegenerateSecurityTokenCommandInput;
     constructor(input: RegenerateSecurityTokenCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegenerateSecurityTokenCommandInput, RegenerateSecurityTokenCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ResetPersonalPINCommandInput extends ResetPersonalPINRequest {
 }
 export interface ResetPersonalPINCommandOutput extends ResetPersonalPINResponse, __MetadataBearer {
 }
-/**
- * <p>Resets the personal meeting PIN for the specified user on an Amazon Chime account. Returns
- *             the <a>User</a> object with the updated personal meeting PIN.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, ResetPersonalPINCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, ResetPersonalPINCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new ResetPersonalPINCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResetPersonalPINCommandInput} for command's `input` shape.
- * @see {@link ResetPersonalPINCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ResetPersonalPINCommand extends $Command<ResetPersonalPINCommandInput, ResetPersonalPINCommandOutput, ChimeClientResolvedConfig> {
     readonly input: ResetPersonalPINCommandInput;
     constructor(input: ResetPersonalPINCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetPersonalPINCommandInput, ResetPersonalPINCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface RestorePhoneNumberCommandInput extends RestorePhoneNumberReques
 }
 export interface RestorePhoneNumberCommandOutput extends RestorePhoneNumberResponse, __MetadataBearer {
 }
-/**
- * <p>Moves a phone number from the <b>Deletion queue</b> back into the
- *             phone number <b>Inventory</b>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, RestorePhoneNumberCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, RestorePhoneNumberCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new RestorePhoneNumberCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RestorePhoneNumberCommandInput} for command's `input` shape.
- * @see {@link RestorePhoneNumberCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RestorePhoneNumberCommand extends $Command<RestorePhoneNumberCommandInput, RestorePhoneNumberCommandOutput, ChimeClientResolvedConfig> {
     readonly input: RestorePhoneNumberCommandInput;
     constructor(input: RestorePhoneNumberCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestorePhoneNumberCommandInput, RestorePhoneNumberCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface SearchAvailablePhoneNumbersCommandInput extends SearchAvailable
 }
 export interface SearchAvailablePhoneNumbersCommandOutput extends SearchAvailablePhoneNumbersResponse, __MetadataBearer {
 }
-/**
- * <p>Searches for phone numbers that can be ordered. For US numbers, provide at least one of
- *             the following search filters: <code>AreaCode</code>, <code>City</code>,
- *                 <code>State</code>, or <code>TollFreePrefix</code>. If you provide
- *             <code>City</code>, you must also provide <code>State</code>. Numbers outside the US only
- *             support the <code>PhoneNumberType</code> filter, which you must use.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, SearchAvailablePhoneNumbersCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, SearchAvailablePhoneNumbersCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new SearchAvailablePhoneNumbersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SearchAvailablePhoneNumbersCommandInput} for command's `input` shape.
- * @see {@link SearchAvailablePhoneNumbersCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SearchAvailablePhoneNumbersCommand extends $Command<SearchAvailablePhoneNumbersCommandInput, SearchAvailablePhoneNumbersCommandOutput, ChimeClientResolvedConfig> {
     readonly input: SearchAvailablePhoneNumbersCommandInput;
     constructor(input: SearchAvailablePhoneNumbersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchAvailablePhoneNumbersCommandInput, SearchAvailablePhoneNumbersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface SendChannelMessageCommandInput extends SendChannelMessageReques
 }
 export interface SendChannelMessageCommandOutput extends SendChannelMessageResponse, __MetadataBearer {
 }
-/**
- * <p>Sends a message to a particular channel that the member is a part of.</p>
- *
- *          <note>
- *             <p>The <code>x-amz-chime-bearer</code> request header is mandatory. Use the
- *                <code>AppInstanceUserArn</code> of the user that makes the API call as the value in
- *             the header.</p>
- *
- *             <p>Also, <code>STANDARD</code> messages can contain 4KB of data and the 1KB of metadata.
- *                <code>CONTROL</code> messages can contain 30 bytes of data and no metadata.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, SendChannelMessageCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, SendChannelMessageCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new SendChannelMessageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendChannelMessageCommandInput} for command's `input` shape.
- * @see {@link SendChannelMessageCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendChannelMessageCommand extends $Command<SendChannelMessageCommandInput, SendChannelMessageCommandOutput, ChimeClientResolvedConfig> {
     readonly input: SendChannelMessageCommandInput;
     constructor(input: SendChannelMessageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendChannelMessageCommandInput, SendChannelMessageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface StartMeetingTranscriptionCommandInput extends StartMeetingTrans
 }
 export interface StartMeetingTranscriptionCommandOutput extends StartMeetingTranscriptionResponse, __MetadataBearer {
 }
-/**
- * <p>Starts transcription for the specified <code>meetingId</code>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, StartMeetingTranscriptionCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, StartMeetingTranscriptionCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new StartMeetingTranscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartMeetingTranscriptionCommandInput} for command's `input` shape.
- * @see {@link StartMeetingTranscriptionCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartMeetingTranscriptionCommand extends $Command<StartMeetingTranscriptionCommandInput, StartMeetingTranscriptionCommandOutput, ChimeClientResolvedConfig> {
     readonly input: StartMeetingTranscriptionCommandInput;
     constructor(input: StartMeetingTranscriptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartMeetingTranscriptionCommandInput, StartMeetingTranscriptionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface StopMeetingTranscriptionCommandInput extends StopMeetingTranscr
 }
 export interface StopMeetingTranscriptionCommandOutput extends StopMeetingTranscriptionResponse, __MetadataBearer {
 }
-/**
- * <p>Stops transcription for the specified <code>meetingId</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, StopMeetingTranscriptionCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, StopMeetingTranscriptionCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new StopMeetingTranscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopMeetingTranscriptionCommandInput} for command's `input` shape.
- * @see {@link StopMeetingTranscriptionCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopMeetingTranscriptionCommand extends $Command<StopMeetingTranscriptionCommandInput, StopMeetingTranscriptionCommandOutput, ChimeClientResolvedConfig> {
     readonly input: StopMeetingTranscriptionCommandInput;
     constructor(input: StopMeetingTranscriptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopMeetingTranscriptionCommandInput, StopMeetingTranscriptionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TagAttendeeCommandInput extends TagAttendeeRequest {
 }
 export interface TagAttendeeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Applies the specified tags to the specified Amazon Chime SDK attendee.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, TagAttendeeCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, TagAttendeeCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new TagAttendeeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagAttendeeCommandInput} for command's `input` shape.
- * @see {@link TagAttendeeCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagAttendeeCommand extends $Command<TagAttendeeCommandInput, TagAttendeeCommandOutput, ChimeClientResolvedConfig> {
     readonly input: TagAttendeeCommandInput;
     constructor(input: TagAttendeeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagAttendeeCommandInput, TagAttendeeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TagMeetingCommandInput extends TagMeetingRequest {
 }
 export interface TagMeetingCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Applies the specified tags to the specified Amazon Chime SDK meeting.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, TagMeetingCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, TagMeetingCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new TagMeetingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagMeetingCommandInput} for command's `input` shape.
- * @see {@link TagMeetingCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagMeetingCommand extends $Command<TagMeetingCommandInput, TagMeetingCommandOutput, ChimeClientResolvedConfig> {
     readonly input: TagMeetingCommandInput;
     constructor(input: TagMeetingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagMeetingCommandInput, TagMeetingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Applies the specified tags to the specified Amazon Chime SDK meeting resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, TagResourceCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, TagResourceCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(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 ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ChimeClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UntagAttendeeCommandInput extends UntagAttendeeRequest {
 }
 export interface UntagAttendeeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Untags the specified tags from the specified Amazon Chime SDK attendee.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, UntagAttendeeCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UntagAttendeeCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UntagAttendeeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagAttendeeCommandInput} for command's `input` shape.
- * @see {@link UntagAttendeeCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagAttendeeCommand extends $Command<UntagAttendeeCommandInput, UntagAttendeeCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UntagAttendeeCommandInput;
     constructor(input: UntagAttendeeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagAttendeeCommandInput, UntagAttendeeCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface UpdateAccountCommandInput extends UpdateAccountRequest {
 }
 export interface UpdateAccountCommandOutput extends UpdateAccountResponse, __MetadataBearer {
 }
-/**
- * <p>Updates account details for the specified Amazon Chime account. Currently, only account name and default license updates are supported for this action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, UpdateAccountCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdateAccountCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdateAccountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAccountCommandInput} for command's `input` shape.
- * @see {@link UpdateAccountCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAccountCommand extends $Command<UpdateAccountCommandInput, UpdateAccountCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdateAccountCommandInput;
     constructor(input: UpdateAccountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAccountCommandInput, UpdateAccountCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface UpdateAccountSettingsCommandInput extends UpdateAccountSettings
 }
 export interface UpdateAccountSettingsCommandOutput extends UpdateAccountSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the settings for the specified Amazon Chime account. You can update settings for
- *             remote control of shared screens, or for the dial-out option. For more information about
- *             these settings, see <a href="https://docs.aws.amazon.com/chime/latest/ag/policies.html">Use
- *                 the Policies Page</a> in the <i>Amazon Chime Administration
- *                 Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, UpdateAccountSettingsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdateAccountSettingsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdateAccountSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAccountSettingsCommandInput} for command's `input` shape.
- * @see {@link UpdateAccountSettingsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAccountSettingsCommand extends $Command<UpdateAccountSettingsCommandInput, UpdateAccountSettingsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdateAccountSettingsCommandInput;
     constructor(input: UpdateAccountSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAccountSettingsCommandInput, UpdateAccountSettingsCommandOutput>;
     private serialize;
     private deserialize;