@aws-sdk/client-chime 3.35.0 → 3.38.0

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

@@ -6,29 +6,11 @@ export interface BatchUpdateUserCommandInput extends BatchUpdateUserRequest {
 }
 export interface BatchUpdateUserCommandOutput extends BatchUpdateUserResponse, __MetadataBearer {
 }
-/**
- * <p>Updates user details within the <a>UpdateUserRequestItem</a> object for up to 20 users for the specified Amazon Chime account. Currently, only <code>LicenseType</code> 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, BatchUpdateUserCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, BatchUpdateUserCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new BatchUpdateUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link BatchUpdateUserCommandInput} for command's `input` shape.
- * @see {@link BatchUpdateUserCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class BatchUpdateUserCommand extends $Command<BatchUpdateUserCommandInput, BatchUpdateUserCommandOutput, ChimeClientResolvedConfig> {
     readonly input: BatchUpdateUserCommandInput;
     constructor(input: BatchUpdateUserCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchUpdateUserCommandInput, BatchUpdateUserCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateAccountCommandInput extends CreateAccountRequest {
 }
 export interface CreateAccountCommandOutput extends CreateAccountResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon Chime account under the administrator's AWS account. Only <code>Team</code>
- *             account types are currently supported for this action. For more information about different account types, see
- *     <a href="https://docs.aws.amazon.com/chime/latest/ag/manage-chime-account.html">Managing Your Amazon Chime Accounts</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, CreateAccountCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateAccountCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateAccountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAccountCommandInput} for command's `input` shape.
- * @see {@link CreateAccountCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateAccountCommand extends $Command<CreateAccountCommandInput, CreateAccountCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateAccountCommandInput;
     constructor(input: CreateAccountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAccountCommandInput, CreateAccountCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,43 +6,11 @@ export interface CreateAppInstanceAdminCommandInput extends CreateAppInstanceAdm
 }
 export interface CreateAppInstanceAdminCommandOutput extends CreateAppInstanceAdminResponse, __MetadataBearer {
 }
-/**
- * <p>Promotes an <code>AppInstanceUser</code> to an <code>AppInstanceAdmin</code>. The promoted user can perform the following actions.
- * </p>
- *
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>ChannelModerator</code> actions across all channels in the <code>AppInstance</code>.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>DeleteChannelMessage</code> actions.</p>
- *             </li>
- *          </ul>
- *
- *          <p>Only an <code>AppInstanceUser</code> can be promoted to an <code>AppInstanceAdmin</code> role.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateAppInstanceAdminCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateAppInstanceAdminCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateAppInstanceAdminCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAppInstanceAdminCommandInput} for command's `input` shape.
- * @see {@link CreateAppInstanceAdminCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateAppInstanceAdminCommand extends $Command<CreateAppInstanceAdminCommandInput, CreateAppInstanceAdminCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateAppInstanceAdminCommandInput;
     constructor(input: CreateAppInstanceAdminCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAppInstanceAdminCommandInput, CreateAppInstanceAdminCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateAppInstanceCommandInput extends CreateAppInstanceRequest
 }
 export interface CreateAppInstanceCommandOutput extends CreateAppInstanceResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon Chime SDK messaging <code>AppInstance</code> under an AWS account. Only SDK messaging customers use this API.
- * <code>CreateAppInstance</code> supports idempotency behavior as described in the AWS API Standard.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateAppInstanceCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateAppInstanceCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateAppInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAppInstanceCommandInput} for command's `input` shape.
- * @see {@link CreateAppInstanceCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateAppInstanceCommand extends $Command<CreateAppInstanceCommandInput, CreateAppInstanceCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateAppInstanceCommandInput;
     constructor(input: CreateAppInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAppInstanceCommandInput, CreateAppInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateAppInstanceUserCommandInput extends CreateAppInstanceUser
 }
 export interface CreateAppInstanceUserCommandOutput extends CreateAppInstanceUserResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a user under an Amazon Chime <code>AppInstance</code>. The request consists of a unique <code>appInstanceUserId</code> and
- * <code>Name</code> for that user.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateAppInstanceUserCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateAppInstanceUserCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateAppInstanceUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAppInstanceUserCommandInput} for command's `input` shape.
- * @see {@link CreateAppInstanceUserCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateAppInstanceUserCommand extends $Command<CreateAppInstanceUserCommandInput, CreateAppInstanceUserCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateAppInstanceUserCommandInput;
     constructor(input: CreateAppInstanceUserCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAppInstanceUserCommandInput, CreateAppInstanceUserCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface CreateAttendeeCommandInput extends CreateAttendeeRequest {
 }
 export interface CreateAttendeeCommandOutput extends CreateAttendeeResponse, __MetadataBearer {
 }
-/**
- * <p>
- * Creates a new attendee for an active Amazon Chime SDK meeting. For more information about the Amazon Chime SDK, see
- * <a href="https://docs.aws.amazon.com/chime/latest/dg/meetings-sdk.html">Using the Amazon Chime SDK</a>
- * in the
- * <i>Amazon Chime Developer Guide</i>.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateAttendeeCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateAttendeeCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateAttendeeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAttendeeCommandInput} for command's `input` shape.
- * @see {@link CreateAttendeeCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateAttendeeCommand extends $Command<CreateAttendeeCommandInput, CreateAttendeeCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateAttendeeCommandInput;
     constructor(input: CreateAttendeeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAttendeeCommandInput, CreateAttendeeCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,40 +6,11 @@ export interface CreateChannelBanCommandInput extends CreateChannelBanRequest {
 }
 export interface CreateChannelBanCommandOutput extends CreateChannelBanResponse, __MetadataBearer {
 }
-/**
- * <p>Permanently bans a member from a channel. Moderators can't add banned members to a
- *          channel. To undo a ban, you first have to <code>DeleteChannelBan</code>, and then
- *             <code>CreateChannelMembership</code>. Bans are cleaned up when you delete users or
- *          channels.</p>
- *          <p>If you ban a user who is already part of a channel, that user is automatically kicked
- *          from the channel.</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, CreateChannelBanCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateChannelBanCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateChannelBanCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateChannelBanCommandInput} for command's `input` shape.
- * @see {@link CreateChannelBanCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateChannelBanCommand extends $Command<CreateChannelBanCommandInput, CreateChannelBanCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateChannelBanCommandInput;
     constructor(input: CreateChannelBanCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateChannelBanCommandInput, CreateChannelBanCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface CreateChannelCommandInput extends CreateChannelRequest {
 }
 export interface CreateChannelCommandOutput extends CreateChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a channel to which you can add users and send messages.</p>
- *
- *          <p>
- *             <b>Restriction</b>: You can't change a channel's
- *          privacy.</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, CreateChannelCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateChannelCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateChannelCommandInput} for command's `input` shape.
- * @see {@link CreateChannelCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateChannelCommand extends $Command<CreateChannelCommandInput, CreateChannelCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateChannelCommandInput;
     constructor(input: CreateChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateChannelCommandInput, CreateChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,66 +6,11 @@ export interface CreateChannelMembershipCommandInput extends CreateChannelMember
 }
 export interface CreateChannelMembershipCommandOutput extends CreateChannelMembershipResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a user to a channel. The <code>InvitedBy</code> response field is derived from the
- *          request header. A channel member can:</p>
- *
- *          <ul>
- *             <li>
- *                <p>List messages</p>
- *             </li>
- *             <li>
- *                <p>Send messages</p>
- *             </li>
- *             <li>
- *                <p>Receive messages</p>
- *             </li>
- *             <li>
- *                <p>Edit their own messages</p>
- *             </li>
- *             <li>
- *                <p>Leave the channel</p>
- *             </li>
- *          </ul>
- *
- *          <p>Privacy settings impact this action as follows:</p>
- *
- *          <ul>
- *             <li>
- *                <p>Public Channels: You do not need to be a member to list messages, but you must be
- *                a member to send messages.</p>
- *             </li>
- *             <li>
- *                <p>Private Channels: You must be a member to list or send messages.</p>
- *             </li>
- *          </ul>
- *
- *          <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, CreateChannelMembershipCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateChannelMembershipCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateChannelMembershipCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateChannelMembershipCommandInput} for command's `input` shape.
- * @see {@link CreateChannelMembershipCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateChannelMembershipCommand extends $Command<CreateChannelMembershipCommandInput, CreateChannelMembershipCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateChannelMembershipCommandInput;
     constructor(input: CreateChannelMembershipCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateChannelMembershipCommandInput, CreateChannelMembershipCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,53 +6,11 @@ export interface CreateChannelModeratorCommandInput extends CreateChannelModerat
 }
 export interface CreateChannelModeratorCommandOutput extends CreateChannelModeratorResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new <code>ChannelModerator</code>. A channel moderator can:</p>
- *
- *          <ul>
- *             <li>
- *                <p>Add and remove other members of the channel.</p>
- *             </li>
- *             <li>
- *                <p>Add and remove other moderators of the channel.</p>
- *             </li>
- *             <li>
- *                <p>Add and remove user bans for the channel.</p>
- *             </li>
- *             <li>
- *                <p>Redact messages in the channel.</p>
- *             </li>
- *             <li>
- *                <p>List messages in the channel.</p>
- *             </li>
- *          </ul>
- *
- *          <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, CreateChannelModeratorCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateChannelModeratorCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateChannelModeratorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateChannelModeratorCommandInput} for command's `input` shape.
- * @see {@link CreateChannelModeratorCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateChannelModeratorCommand extends $Command<CreateChannelModeratorCommandInput, CreateChannelModeratorCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateChannelModeratorCommandInput;
     constructor(input: CreateChannelModeratorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateChannelModeratorCommandInput, CreateChannelModeratorCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,39 +6,11 @@ export interface CreateMeetingCommandInput extends CreateMeetingRequest {
 }
 export interface CreateMeetingCommandOutput extends CreateMeetingResponse, __MetadataBearer {
 }
-/**
- * <p>
- * Creates a new Amazon Chime SDK meeting in the specified media Region with no initial attendees. For more information about specifying media Regions, see
- * <a href="https://docs.aws.amazon.com/chime/latest/dg/chime-sdk-meetings-regions.html">Amazon Chime SDK Media Regions</a>
- * in the
- * <i>Amazon Chime Developer Guide</i>
- * . For more information about the Amazon Chime SDK, see
- * <a href="https://docs.aws.amazon.com/chime/latest/dg/meetings-sdk.html">Using the Amazon Chime SDK</a>
- * in the
- * <i>Amazon Chime Developer Guide</i>
- * .
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateMeetingCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateMeetingCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateMeetingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateMeetingCommandInput} for command's `input` shape.
- * @see {@link CreateMeetingCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateMeetingCommand extends $Command<CreateMeetingCommandInput, CreateMeetingCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateMeetingCommandInput;
     constructor(input: CreateMeetingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMeetingCommandInput, CreateMeetingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateMeetingDialOutCommandInput extends CreateMeetingDialOutRe
 }
 export interface CreateMeetingDialOutCommandOutput extends CreateMeetingDialOutResponse, __MetadataBearer {
 }
-/**
- * <p>Uses the join token and call metadata in a meeting request (From number, To number, and so forth) to initiate an outbound call to a public
- *     switched telephone network (PSTN) and join them into a Chime meeting. Also ensures that the From number belongs to the customer.</p>
- *
- *          <p>To play welcome audio or implement an interactive voice response (IVR), use the
- * <code>CreateSipMediaApplicationCall</code> action with the corresponding SIP media application ID.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateMeetingDialOutCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateMeetingDialOutCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateMeetingDialOutCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateMeetingDialOutCommandInput} for command's `input` shape.
- * @see {@link CreateMeetingDialOutCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateMeetingDialOutCommand extends $Command<CreateMeetingDialOutCommandInput, CreateMeetingDialOutCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateMeetingDialOutCommandInput;
     constructor(input: CreateMeetingDialOutCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMeetingDialOutCommandInput, CreateMeetingDialOutCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface CreateMeetingWithAttendeesCommandInput extends CreateMeetingWit
 }
 export interface CreateMeetingWithAttendeesCommandOutput extends CreateMeetingWithAttendeesResponse, __MetadataBearer {
 }
-/**
- * <p>
- * Creates a new Amazon Chime SDK meeting in the specified media Region, with attendees. For more information about specifying media Regions, see
- * <a href="https://docs.aws.amazon.com/chime/latest/dg/chime-sdk-meetings-regions.html">Amazon Chime SDK Media Regions</a>
- * in the
- * <i>Amazon Chime Developer Guide</i>
- * . For more information about the Amazon Chime SDK, see
- * <a href="https://docs.aws.amazon.com/chime/latest/dg/meetings-sdk.html">Using the Amazon Chime SDK</a>
- * in the
- * <i>Amazon Chime Developer Guide</i>
- * .
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateMeetingWithAttendeesCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateMeetingWithAttendeesCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateMeetingWithAttendeesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateMeetingWithAttendeesCommandInput} for command's `input` shape.
- * @see {@link CreateMeetingWithAttendeesCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateMeetingWithAttendeesCommand extends $Command<CreateMeetingWithAttendeesCommandInput, CreateMeetingWithAttendeesCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateMeetingWithAttendeesCommandInput;
     constructor(input: CreateMeetingWithAttendeesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMeetingWithAttendeesCommandInput, CreateMeetingWithAttendeesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreatePhoneNumberOrderCommandInput extends CreatePhoneNumberOrd
 }
 export interface CreatePhoneNumberOrderCommandOutput extends CreatePhoneNumberOrderResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an order for phone numbers to be provisioned. For toll-free numbers, you cannot use the Amazon Chime Business Calling product type.
- *         For numbers outside the U.S., you must use the Amazon Chime SIP Media Application Dial-In product type.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreatePhoneNumberOrderCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreatePhoneNumberOrderCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreatePhoneNumberOrderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreatePhoneNumberOrderCommandInput} for command's `input` shape.
- * @see {@link CreatePhoneNumberOrderCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreatePhoneNumberOrderCommand extends $Command<CreatePhoneNumberOrderCommandInput, CreatePhoneNumberOrderCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreatePhoneNumberOrderCommandInput;
     constructor(input: CreatePhoneNumberOrderCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePhoneNumberOrderCommandInput, CreatePhoneNumberOrderCommandOutput>;
     private serialize;
     private deserialize;