@aws-sdk/client-chime 3.35.0 → 3.38.0

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

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

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

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

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

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

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface UpdateChannelReadMarkerCommandInput extends UpdateChannelReadMa
 }
 export interface UpdateChannelReadMarkerCommandOutput extends UpdateChannelReadMarkerResponse, __MetadataBearer {
 }
-/**
- * <p>The details of the time when a user last read messages in 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, UpdateChannelReadMarkerCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdateChannelReadMarkerCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdateChannelReadMarkerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateChannelReadMarkerCommandInput} for command's `input` shape.
- * @see {@link UpdateChannelReadMarkerCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateChannelReadMarkerCommand extends $Command<UpdateChannelReadMarkerCommandInput, UpdateChannelReadMarkerCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdateChannelReadMarkerCommandInput;
     constructor(input: UpdateChannelReadMarkerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateChannelReadMarkerCommandInput, UpdateChannelReadMarkerCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface UpdatePhoneNumberCommandInput extends UpdatePhoneNumberRequest
 }
 export interface UpdatePhoneNumberCommandOutput extends UpdatePhoneNumberResponse, __MetadataBearer {
 }
-/**
- * <p>Updates phone number details, such as product type or calling name, for the specified phone number ID. You can update one phone number detail at a time. For example, you can update either the product type or the calling name in one action.</p>
- *          <p>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>
- *          <p>Updates to outbound calling names can take 72 hours to complete. Pending updates to outbound calling names must be complete before you can request another update.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, UpdatePhoneNumberCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdatePhoneNumberCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdatePhoneNumberCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdatePhoneNumberCommandInput} for command's `input` shape.
- * @see {@link UpdatePhoneNumberCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdatePhoneNumberCommand extends $Command<UpdatePhoneNumberCommandInput, UpdatePhoneNumberCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdatePhoneNumberCommandInput;
     constructor(input: UpdatePhoneNumberCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdatePhoneNumberCommandInput, UpdatePhoneNumberCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface UpdatePhoneNumberSettingsCommandInput extends UpdatePhoneNumber
 }
 export interface UpdatePhoneNumberSettingsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Updates the phone number settings for the administrator's AWS account, such as the default
- *             outbound calling name. You can update the default outbound calling name once every seven
- *             days. Outbound calling names can take up to 72 hours to update.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, UpdatePhoneNumberSettingsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdatePhoneNumberSettingsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdatePhoneNumberSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdatePhoneNumberSettingsCommandInput} for command's `input` shape.
- * @see {@link UpdatePhoneNumberSettingsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdatePhoneNumberSettingsCommand extends $Command<UpdatePhoneNumberSettingsCommandInput, UpdatePhoneNumberSettingsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdatePhoneNumberSettingsCommandInput;
     constructor(input: UpdatePhoneNumberSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdatePhoneNumberSettingsCommandInput, UpdatePhoneNumberSettingsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateProxySessionCommandInput extends UpdateProxySessionReques
 }
 export interface UpdateProxySessionCommandOutput extends UpdateProxySessionResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the specified proxy session details, such as voice or SMS capabilities.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, UpdateProxySessionCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdateProxySessionCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdateProxySessionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateProxySessionCommandInput} for command's `input` shape.
- * @see {@link UpdateProxySessionCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateProxySessionCommand extends $Command<UpdateProxySessionCommandInput, UpdateProxySessionCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdateProxySessionCommandInput;
     constructor(input: UpdateProxySessionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateProxySessionCommandInput, UpdateProxySessionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateRoomCommandInput extends UpdateRoomRequest {
 }
 export interface UpdateRoomCommandOutput extends UpdateRoomResponse, __MetadataBearer {
 }
-/**
- * <p>Updates room details, such as the room name, for a room in 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, UpdateRoomCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdateRoomCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdateRoomCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateRoomCommandInput} for command's `input` shape.
- * @see {@link UpdateRoomCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateRoomCommand extends $Command<UpdateRoomCommandInput, UpdateRoomCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdateRoomCommandInput;
     constructor(input: UpdateRoomCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRoomCommandInput, UpdateRoomCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface UpdateSipMediaApplicationCallCommandInput extends UpdateSipMedi
 }
 export interface UpdateSipMediaApplicationCallCommandOutput extends UpdateSipMediaApplicationCallResponse, __MetadataBearer {
 }
-/**
- * <p>Allows you to trigger a Lambda function at any time while a call is active, and replace the current actions with new actions returned by the invocation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, UpdateSipMediaApplicationCallCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdateSipMediaApplicationCallCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdateSipMediaApplicationCallCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateSipMediaApplicationCallCommandInput} for command's `input` shape.
- * @see {@link UpdateSipMediaApplicationCallCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateSipMediaApplicationCallCommand extends $Command<UpdateSipMediaApplicationCallCommandInput, UpdateSipMediaApplicationCallCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdateSipMediaApplicationCallCommandInput;
     constructor(input: UpdateSipMediaApplicationCallCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSipMediaApplicationCallCommandInput, UpdateSipMediaApplicationCallCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface UpdateVoiceConnectorGroupCommandInput extends UpdateVoiceConnec
 }
 export interface UpdateVoiceConnectorGroupCommandOutput extends UpdateVoiceConnectorGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Updates details of the specified Amazon Chime Voice Connector group, such as the name and
- *             Amazon Chime Voice Connector priority ranking.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, UpdateVoiceConnectorGroupCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, UpdateVoiceConnectorGroupCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new UpdateVoiceConnectorGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateVoiceConnectorGroupCommandInput} for command's `input` shape.
- * @see {@link UpdateVoiceConnectorGroupCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateVoiceConnectorGroupCommand extends $Command<UpdateVoiceConnectorGroupCommandInput, UpdateVoiceConnectorGroupCommandOutput, ChimeClientResolvedConfig> {
     readonly input: UpdateVoiceConnectorGroupCommandInput;
     constructor(input: UpdateVoiceConnectorGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateVoiceConnectorGroupCommandInput, UpdateVoiceConnectorGroupCommandOutput>;
     private serialize;
     private deserialize;