@aws-sdk/client-chime 3.31.0 → 3.35.0

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

@@ -0,0 +1,35 @@
+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 { GetEventsConfigurationRequest, GetEventsConfigurationResponse } from "../models/models_0";
+export interface GetEventsConfigurationCommandInput extends GetEventsConfigurationRequest {
+}
+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

@@ -0,0 +1,36 @@
+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 { GetGlobalSettingsResponse } from "../models/models_0";
+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

@@ -0,0 +1,35 @@
+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 { GetMediaCapturePipelineRequest, GetMediaCapturePipelineResponse } from "../models/models_0";
+export interface GetMediaCapturePipelineCommandInput extends GetMediaCapturePipelineRequest {
+}
+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

@@ -0,0 +1,41 @@
+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 { GetMeetingRequest, GetMeetingResponse } from "../models/models_0";
+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

@@ -0,0 +1,35 @@
+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 { GetMessagingSessionEndpointRequest, GetMessagingSessionEndpointResponse } from "../models/models_0";
+export interface GetMessagingSessionEndpointCommandInput extends GetMessagingSessionEndpointRequest {
+}
+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

@@ -0,0 +1,35 @@
+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 { GetPhoneNumberRequest, GetPhoneNumberResponse } from "../models/models_0";
+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

@@ -0,0 +1,36 @@
+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 { GetPhoneNumberOrderRequest, GetPhoneNumberOrderResponse } from "../models/models_0";
+export interface GetPhoneNumberOrderCommandInput extends GetPhoneNumberOrderRequest {
+}
+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

@@ -0,0 +1,35 @@
+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 { GetPhoneNumberSettingsResponse } from "../models/models_0";
+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

@@ -0,0 +1,35 @@
+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 { GetProxySessionRequest, GetProxySessionResponse } from "../models/models_0";
+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

@@ -0,0 +1,38 @@
+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 { GetRetentionSettingsRequest, GetRetentionSettingsResponse } from "../models/models_0";
+export interface GetRetentionSettingsCommandInput extends GetRetentionSettingsRequest {
+}
+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

@@ -0,0 +1,35 @@
+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 { GetRoomRequest, GetRoomResponse } from "../models/models_0";
+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

@@ -0,0 +1,35 @@
+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";
+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

@@ -0,0 +1,35 @@
+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";
+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

@@ -0,0 +1,35 @@
+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";
+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

@@ -0,0 +1,40 @@
+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";
+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;
+}

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

@@ -0,0 +1,36 @@
+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 { GetUserSettingsRequest } from "../models/models_0";
+import { GetUserSettingsResponse } from "../models/models_1";
+export interface GetUserSettingsCommandInput extends GetUserSettingsRequest {
+}
+export interface GetUserSettingsCommandOutput extends GetUserSettingsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves settings for the specified user ID, such as any associated phone number settings.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeClient, GetUserSettingsCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, GetUserSettingsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new GetUserSettingsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUserSettingsCommandInput} for command's `input` shape.
+ * @see {@link GetUserSettingsCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetUserSettingsCommand extends $Command<GetUserSettingsCommandInput, GetUserSettingsCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: GetUserSettingsCommandInput;
+    constructor(input: GetUserSettingsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUserSettingsCommandInput, GetUserSettingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+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 { GetVoiceConnectorRequest, GetVoiceConnectorResponse } from "../models/models_1";
+export interface GetVoiceConnectorCommandInput extends GetVoiceConnectorRequest {
+}
+export interface GetVoiceConnectorCommandOutput extends GetVoiceConnectorResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves details for the specified Amazon Chime Voice Connector, such as timestamps,name, outbound host, and encryption requirements.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeClient, GetVoiceConnectorCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, GetVoiceConnectorCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new GetVoiceConnectorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetVoiceConnectorCommandInput} for command's `input` shape.
+ * @see {@link GetVoiceConnectorCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetVoiceConnectorCommand extends $Command<GetVoiceConnectorCommandInput, GetVoiceConnectorCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: GetVoiceConnectorCommandInput;
+    constructor(input: GetVoiceConnectorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVoiceConnectorCommandInput, GetVoiceConnectorCommandOutput>;
+    private serialize;
+    private deserialize;
+}