@aws-sdk/client-chime 3.35.0 → 3.38.0

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

@@ -6,35 +6,11 @@ export interface GetAttendeeCommandInput extends GetAttendeeRequest {
 }
 export interface GetAttendeeCommandOutput extends GetAttendeeResponse, __MetadataBearer {
 }
-/**
- * <p>
- * Gets the Amazon Chime SDK attendee details for a specified meeting ID and attendee ID. 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, GetAttendeeCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetAttendeeCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetAttendeeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAttendeeCommandInput} for command's `input` shape.
- * @see {@link GetAttendeeCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAttendeeCommand extends $Command<GetAttendeeCommandInput, GetAttendeeCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetAttendeeCommandInput;
     constructor(input: GetAttendeeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAttendeeCommandInput, GetAttendeeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetBotCommandInput extends GetBotRequest {
 }
 export interface GetBotCommandOutput extends GetBotResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves details for the specified bot, such as bot email address, bot type, status, and display name.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, GetBotCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetBotCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetBotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBotCommandInput} for command's `input` shape.
- * @see {@link GetBotCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBotCommand extends $Command<GetBotCommandInput, GetBotCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetBotCommandInput;
     constructor(input: GetBotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBotCommandInput, GetBotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface GetChannelMessageCommandInput extends GetChannelMessageRequest
 }
 export interface GetChannelMessageCommandOutput extends GetChannelMessageResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the full details of a channel message.</p>
- *
- *          <note>
- *             <p>The x-amz-chime-bearer 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, GetChannelMessageCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetChannelMessageCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetChannelMessageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetChannelMessageCommandInput} for command's `input` shape.
- * @see {@link GetChannelMessageCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetChannelMessageCommand extends $Command<GetChannelMessageCommandInput, GetChannelMessageCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetChannelMessageCommandInput;
     constructor(input: GetChannelMessageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetChannelMessageCommandInput, GetChannelMessageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetEventsConfigurationCommandInput extends GetEventsConfigurati
 }
 export interface GetEventsConfigurationCommandOutput extends GetEventsConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Gets details for an events configuration that allows a bot to receive outgoing events, such as an HTTPS endpoint or Lambda function ARN.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, GetEventsConfigurationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetEventsConfigurationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetEventsConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEventsConfigurationCommandInput} for command's `input` shape.
- * @see {@link GetEventsConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEventsConfigurationCommand extends $Command<GetEventsConfigurationCommandInput, GetEventsConfigurationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetEventsConfigurationCommandInput;
     constructor(input: GetEventsConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEventsConfigurationCommandInput, GetEventsConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface GetMeetingCommandInput extends GetMeetingRequest {
 }
 export interface GetMeetingCommandOutput extends GetMeetingResponse, __MetadataBearer {
 }
-/**
- * <p>
- * Gets the Amazon Chime SDK meeting details for the specified meeting ID. 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, GetMeetingCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetMeetingCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetMeetingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMeetingCommandInput} for command's `input` shape.
- * @see {@link GetMeetingCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetMeetingCommand extends $Command<GetMeetingCommandInput, GetMeetingCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetMeetingCommandInput;
     constructor(input: GetMeetingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMeetingCommandInput, GetMeetingCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface GetPhoneNumberOrderCommandInput extends GetPhoneNumberOrderRequ
 }
 export interface GetPhoneNumberOrderCommandOutput extends GetPhoneNumberOrderResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves details for the specified phone number order, such as the order creation timestamp, phone
- *             numbers in E.164 format, product type, and order status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, GetPhoneNumberOrderCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetPhoneNumberOrderCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetPhoneNumberOrderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetPhoneNumberOrderCommandInput} for command's `input` shape.
- * @see {@link GetPhoneNumberOrderCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetPhoneNumberOrderCommand extends $Command<GetPhoneNumberOrderCommandInput, GetPhoneNumberOrderCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetPhoneNumberOrderCommandInput;
     constructor(input: GetPhoneNumberOrderCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPhoneNumberOrderCommandInput, GetPhoneNumberOrderCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface GetRetentionSettingsCommandInput extends GetRetentionSettingsRe
 }
 export interface GetRetentionSettingsCommandOutput extends GetRetentionSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>
- * Gets the retention settings for the specified Amazon Chime Enterprise account. For more information about retention settings, see
- * <a href="https://docs.aws.amazon.com/chime/latest/ag/chat-retention.html">Managing Chat Retention Policies</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, GetRetentionSettingsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetRetentionSettingsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetRetentionSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRetentionSettingsCommandInput} for command's `input` shape.
- * @see {@link GetRetentionSettingsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRetentionSettingsCommand extends $Command<GetRetentionSettingsCommandInput, GetRetentionSettingsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetRetentionSettingsCommandInput;
     constructor(input: GetRetentionSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRetentionSettingsCommandInput, GetRetentionSettingsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -1,34 +1,17 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { ChimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ChimeClient";
-import { GetSipMediaApplicationRequest, GetSipMediaApplicationResponse } from "../models/models_0";
+import { GetSipMediaApplicationRequest } from "../models/models_0";
+import { GetSipMediaApplicationResponse } from "../models/models_1";
 export interface GetSipMediaApplicationCommandInput extends GetSipMediaApplicationRequest {
 }
 export interface GetSipMediaApplicationCommandOutput extends GetSipMediaApplicationResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the information for a SIP media application, including name, AWS Region, and endpoints.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, GetSipMediaApplicationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetSipMediaApplicationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetSipMediaApplicationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSipMediaApplicationCommandInput} for command's `input` shape.
- * @see {@link GetSipMediaApplicationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSipMediaApplicationCommand extends $Command<GetSipMediaApplicationCommandInput, GetSipMediaApplicationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetSipMediaApplicationCommandInput;
     constructor(input: GetSipMediaApplicationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSipMediaApplicationCommandInput, GetSipMediaApplicationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { ChimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ChimeClient";
-import { GetSipMediaApplicationLoggingConfigurationRequest, GetSipMediaApplicationLoggingConfigurationResponse } from "../models/models_0";
+import { GetSipMediaApplicationLoggingConfigurationRequest, GetSipMediaApplicationLoggingConfigurationResponse } from "../models/models_1";
 export interface GetSipMediaApplicationLoggingConfigurationCommandInput extends GetSipMediaApplicationLoggingConfigurationRequest {
 }
 export interface GetSipMediaApplicationLoggingConfigurationCommandOutput extends GetSipMediaApplicationLoggingConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the logging configuration for 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, GetSipMediaApplicationLoggingConfigurationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetSipMediaApplicationLoggingConfigurationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetSipMediaApplicationLoggingConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSipMediaApplicationLoggingConfigurationCommandInput} for command's `input` shape.
- * @see {@link GetSipMediaApplicationLoggingConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSipMediaApplicationLoggingConfigurationCommand extends $Command<GetSipMediaApplicationLoggingConfigurationCommandInput, GetSipMediaApplicationLoggingConfigurationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetSipMediaApplicationLoggingConfigurationCommandInput;
     constructor(input: GetSipMediaApplicationLoggingConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSipMediaApplicationLoggingConfigurationCommandInput, GetSipMediaApplicationLoggingConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { ChimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ChimeClient";
-import { GetSipRuleRequest, GetSipRuleResponse } from "../models/models_0";
+import { GetSipRuleRequest, GetSipRuleResponse } from "../models/models_1";
 export interface GetSipRuleCommandInput extends GetSipRuleRequest {
 }
 export interface GetSipRuleCommandOutput extends GetSipRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the details of a SIP rule, such as the rule ID, name, triggers, and target endpoints.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, GetSipRuleCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetSipRuleCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetSipRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSipRuleCommandInput} for command's `input` shape.
- * @see {@link GetSipRuleCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSipRuleCommand extends $Command<GetSipRuleCommandInput, GetSipRuleCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetSipRuleCommandInput;
     constructor(input: GetSipRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSipRuleCommandInput, GetSipRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,39 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { ChimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ChimeClient";
-import { GetUserRequest, GetUserResponse } from "../models/models_0";
+import { GetUserRequest, GetUserResponse } from "../models/models_1";
 export interface GetUserCommandInput extends GetUserRequest {
 }
 export interface GetUserCommandOutput extends GetUserResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves details for the specified user ID, such as primary email address, license type,and personal meeting PIN.</p>
- *
- *          <p>
- * To retrieve user details with an email address instead of a user ID, use the
- * <a>ListUsers</a> action, and then filter by email address.
- * </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, GetUserCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, GetUserCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new GetUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetUserCommandInput} for command's `input` shape.
- * @see {@link GetUserCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetUserCommand extends $Command<GetUserCommandInput, GetUserCommandOutput, ChimeClientResolvedConfig> {
     readonly input: GetUserCommandInput;
     constructor(input: GetUserCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUserCommandInput, GetUserCommandOutput>;
     private serialize;
     private deserialize;