@aws-sdk/client-chime 3.35.0 → 3.38.0

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface CreateRoomMembershipCommandInput extends CreateRoomMembershipRe
 }
 export interface CreateRoomMembershipCommandOutput extends CreateRoomMembershipResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a member to a chat room in an Amazon Chime Enterprise account. A member can be either a user or a bot. The member role designates whether the member is a chat room administrator or a general chat room member.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateRoomMembershipCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateRoomMembershipCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateRoomMembershipCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRoomMembershipCommandInput} for command's `input` shape.
- * @see {@link CreateRoomMembershipCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateRoomMembershipCommand extends $Command<CreateRoomMembershipCommandInput, CreateRoomMembershipCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateRoomMembershipCommandInput;
     constructor(input: CreateRoomMembershipCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRoomMembershipCommandInput, CreateRoomMembershipCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateSipMediaApplicationCallCommandInput extends CreateSipMedi
 }
 export interface CreateSipMediaApplicationCallCommandOutput extends CreateSipMediaApplicationCallResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an outbound call to a phone number from the phone number specified in the request, and it invokes the endpoint of the specified
- * <code>sipMediaApplicationId</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateSipMediaApplicationCallCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateSipMediaApplicationCallCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateSipMediaApplicationCallCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSipMediaApplicationCallCommandInput} for command's `input` shape.
- * @see {@link CreateSipMediaApplicationCallCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSipMediaApplicationCallCommand extends $Command<CreateSipMediaApplicationCallCommandInput, CreateSipMediaApplicationCallCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateSipMediaApplicationCallCommandInput;
     constructor(input: CreateSipMediaApplicationCallCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSipMediaApplicationCallCommandInput, CreateSipMediaApplicationCallCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface CreateSipRuleCommandInput extends CreateSipRuleRequest {
 }
 export interface CreateSipRuleCommandOutput extends CreateSipRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a SIP rule which can be used to run a SIP media application as a target for a specific trigger type.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateSipRuleCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateSipRuleCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateSipRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSipRuleCommandInput} for command's `input` shape.
- * @see {@link CreateSipRuleCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSipRuleCommand extends $Command<CreateSipRuleCommandInput, CreateSipRuleCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateSipRuleCommandInput;
     constructor(input: CreateSipRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSipRuleCommandInput, CreateSipRuleCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,35 +6,11 @@ export interface CreateVoiceConnectorCommandInput extends CreateVoiceConnectorRe
 }
 export interface CreateVoiceConnectorCommandOutput extends CreateVoiceConnectorResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon Chime Voice Connector under the administrator's AWS account. You can choose to create an Amazon Chime Voice Connector in a specific AWS Region.</p>
- *
- *          <p>
- * Enabling
- * <a>CreateVoiceConnectorRequest$RequireEncryption</a>
- * configures your Amazon Chime Voice Connector to use TLS transport for SIP signaling and Secure RTP (SRTP) for media. Inbound calls use TLS transport, and unencrypted outbound calls are blocked.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateVoiceConnectorCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateVoiceConnectorCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateVoiceConnectorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVoiceConnectorCommandInput} for command's `input` shape.
- * @see {@link CreateVoiceConnectorCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVoiceConnectorCommand extends $Command<CreateVoiceConnectorCommandInput, CreateVoiceConnectorCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateVoiceConnectorCommandInput;
     constructor(input: CreateVoiceConnectorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVoiceConnectorCommandInput, CreateVoiceConnectorCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateVoiceConnectorGroupCommandInput extends CreateVoiceConnec
 }
 export interface CreateVoiceConnectorGroupCommandOutput extends CreateVoiceConnectorGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon Chime Voice Connector group under the administrator's AWS account. You can
- *             associate Amazon Chime Voice Connectors with the Amazon Chime Voice Connector group by
- *             including <code>VoiceConnectorItems</code> in the request.</p>
- *          <p>You can include Amazon Chime Voice Connectors from different AWS Regions in your group. This
- *             creates a fault tolerant mechanism for fallback in case of availability events.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, CreateVoiceConnectorGroupCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, CreateVoiceConnectorGroupCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new CreateVoiceConnectorGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVoiceConnectorGroupCommandInput} for command's `input` shape.
- * @see {@link CreateVoiceConnectorGroupCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVoiceConnectorGroupCommand extends $Command<CreateVoiceConnectorGroupCommandInput, CreateVoiceConnectorGroupCommandOutput, ChimeClientResolvedConfig> {
     readonly input: CreateVoiceConnectorGroupCommandInput;
     constructor(input: CreateVoiceConnectorGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVoiceConnectorGroupCommandInput, CreateVoiceConnectorGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface DeleteAccountCommandInput extends DeleteAccountRequest {
 }
 export interface DeleteAccountCommandOutput extends DeleteAccountResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified Amazon Chime account. You must suspend all users before deleting
- *                 <code>Team</code> account. You can use the <a>BatchSuspendUser</a> action
- *             to dodo.</p>
- *
- *          <p>For <code>EnterpriseLWA</code> and <code>EnterpriseAD</code> accounts, you must release the
- *             claimed domains for your Amazon Chime account before deletion. As soon as you release
- *             the domain, all users under that account are suspended.</p>
- *
- *          <p>Deleted accounts appear in your <code>Disabled</code> accounts list for 90 days. To restore
- *             deleted account from your <code>Disabled</code> accounts list, you must contact AWS
- *             Support.</p>
- *
- *          <p>After 90 days, deleted accounts are permanently removed from your
- * <code>Disabled</code> accounts list.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, DeleteAccountCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, DeleteAccountCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new DeleteAccountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAccountCommandInput} for command's `input` shape.
- * @see {@link DeleteAccountCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAccountCommand extends $Command<DeleteAccountCommandInput, DeleteAccountCommandOutput, ChimeClientResolvedConfig> {
     readonly input: DeleteAccountCommandInput;
     constructor(input: DeleteAccountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAccountCommandInput, DeleteAccountCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface DeleteAttendeeCommandInput extends DeleteAttendeeRequest {
 }
 export interface DeleteAttendeeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes an attendee from the specified Amazon Chime SDK meeting and deletes their
- * <code>JoinToken</code>. Attendees are automatically deleted when a Amazon Chime SDK meeting is deleted. 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, DeleteAttendeeCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, DeleteAttendeeCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new DeleteAttendeeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAttendeeCommandInput} for command's `input` shape.
- * @see {@link DeleteAttendeeCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAttendeeCommand extends $Command<DeleteAttendeeCommandInput, DeleteAttendeeCommandOutput, ChimeClientResolvedConfig> {
     readonly input: DeleteAttendeeCommandInput;
     constructor(input: DeleteAttendeeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAttendeeCommandInput, DeleteAttendeeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DeleteChannelBanCommandInput extends DeleteChannelBanRequest {
 }
 export interface DeleteChannelBanCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Removes a user from a channel's ban list.</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, DeleteChannelBanCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, DeleteChannelBanCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new DeleteChannelBanCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteChannelBanCommandInput} for command's `input` shape.
- * @see {@link DeleteChannelBanCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteChannelBanCommand extends $Command<DeleteChannelBanCommandInput, DeleteChannelBanCommandOutput, ChimeClientResolvedConfig> {
     readonly input: DeleteChannelBanCommandInput;
     constructor(input: DeleteChannelBanCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteChannelBanCommandInput, DeleteChannelBanCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DeleteChannelCommandInput extends DeleteChannelRequest {
 }
 export interface DeleteChannelCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Immediately makes a channel and its memberships inaccessible and marks them for
- *          deletion. This is an irreversible process.</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, DeleteChannelCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, DeleteChannelCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new DeleteChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteChannelCommandInput} for command's `input` shape.
- * @see {@link DeleteChannelCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteChannelCommand extends $Command<DeleteChannelCommandInput, DeleteChannelCommandOutput, ChimeClientResolvedConfig> {
     readonly input: DeleteChannelCommandInput;
     constructor(input: DeleteChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteChannelCommandInput, DeleteChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DeleteChannelMembershipCommandInput extends DeleteChannelMember
 }
 export interface DeleteChannelMembershipCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Removes a member from a 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, DeleteChannelMembershipCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, DeleteChannelMembershipCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new DeleteChannelMembershipCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteChannelMembershipCommandInput} for command's `input` shape.
- * @see {@link DeleteChannelMembershipCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteChannelMembershipCommand extends $Command<DeleteChannelMembershipCommandInput, DeleteChannelMembershipCommandOutput, ChimeClientResolvedConfig> {
     readonly input: DeleteChannelMembershipCommandInput;
     constructor(input: DeleteChannelMembershipCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteChannelMembershipCommandInput, DeleteChannelMembershipCommandOutput>;
     private serialize;
     private deserialize;