@aws-sdk/client-chime 3.31.0 → 3.35.0

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

@@ -0,0 +1,43 @@
+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 { DescribeChannelRequest, DescribeChannelResponse } from "../models/models_0";
+export interface DescribeChannelCommandInput extends DescribeChannelRequest {
+}
+export interface DescribeChannelCommandOutput extends DescribeChannelResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the full details of a channel in an Amazon Chime
+ *          <code>AppInstance</code>.</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, DescribeChannelCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DescribeChannelCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DescribeChannelCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeChannelCommandInput} for command's `input` shape.
+ * @see {@link DescribeChannelCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeChannelCommand extends $Command<DescribeChannelCommandInput, DescribeChannelCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DescribeChannelCommandInput;
+    constructor(input: DescribeChannelCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeChannelCommandInput, DescribeChannelCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeChannelMembershipCommand.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 { DescribeChannelMembershipRequest, DescribeChannelMembershipResponse } from "../models/models_0";
+export interface DescribeChannelMembershipCommandInput extends DescribeChannelMembershipRequest {
+}
+export interface DescribeChannelMembershipCommandOutput extends DescribeChannelMembershipResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the full details of a user's channel membership.</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, DescribeChannelMembershipCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DescribeChannelMembershipCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DescribeChannelMembershipCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeChannelMembershipCommandInput} for command's `input` shape.
+ * @see {@link DescribeChannelMembershipCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeChannelMembershipCommand extends $Command<DescribeChannelMembershipCommandInput, DescribeChannelMembershipCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DescribeChannelMembershipCommandInput;
+    constructor(input: DescribeChannelMembershipCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeChannelMembershipCommandInput, DescribeChannelMembershipCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,42 @@
+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 { DescribeChannelMembershipForAppInstanceUserRequest, DescribeChannelMembershipForAppInstanceUserResponse } from "../models/models_0";
+export interface DescribeChannelMembershipForAppInstanceUserCommandInput extends DescribeChannelMembershipForAppInstanceUserRequest {
+}
+export interface DescribeChannelMembershipForAppInstanceUserCommandOutput extends DescribeChannelMembershipForAppInstanceUserResponse, __MetadataBearer {
+}
+/**
+ * <p> Returns the details of a channel based on the membership of the specified
+ *             <code>AppInstanceUser</code>.</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, DescribeChannelMembershipForAppInstanceUserCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DescribeChannelMembershipForAppInstanceUserCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DescribeChannelMembershipForAppInstanceUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeChannelMembershipForAppInstanceUserCommandInput} for command's `input` shape.
+ * @see {@link DescribeChannelMembershipForAppInstanceUserCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeChannelMembershipForAppInstanceUserCommand extends $Command<DescribeChannelMembershipForAppInstanceUserCommandInput, DescribeChannelMembershipForAppInstanceUserCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DescribeChannelMembershipForAppInstanceUserCommandInput;
+    constructor(input: DescribeChannelMembershipForAppInstanceUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeChannelMembershipForAppInstanceUserCommandInput, DescribeChannelMembershipForAppInstanceUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,42 @@
+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 { DescribeChannelModeratedByAppInstanceUserRequest, DescribeChannelModeratedByAppInstanceUserResponse } from "../models/models_0";
+export interface DescribeChannelModeratedByAppInstanceUserCommandInput extends DescribeChannelModeratedByAppInstanceUserRequest {
+}
+export interface DescribeChannelModeratedByAppInstanceUserCommandOutput extends DescribeChannelModeratedByAppInstanceUserResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the full details of a channel moderated by the specified
+ *             <code>AppInstanceUser</code>.</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, DescribeChannelModeratedByAppInstanceUserCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DescribeChannelModeratedByAppInstanceUserCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DescribeChannelModeratedByAppInstanceUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeChannelModeratedByAppInstanceUserCommandInput} for command's `input` shape.
+ * @see {@link DescribeChannelModeratedByAppInstanceUserCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeChannelModeratedByAppInstanceUserCommand extends $Command<DescribeChannelModeratedByAppInstanceUserCommandInput, DescribeChannelModeratedByAppInstanceUserCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DescribeChannelModeratedByAppInstanceUserCommandInput;
+    constructor(input: DescribeChannelModeratedByAppInstanceUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeChannelModeratedByAppInstanceUserCommandInput, DescribeChannelModeratedByAppInstanceUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeChannelModeratorCommand.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 { DescribeChannelModeratorRequest, DescribeChannelModeratorResponse } from "../models/models_0";
+export interface DescribeChannelModeratorCommandInput extends DescribeChannelModeratorRequest {
+}
+export interface DescribeChannelModeratorCommandOutput extends DescribeChannelModeratorResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the full details of a single ChannelModerator.</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, DescribeChannelModeratorCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DescribeChannelModeratorCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DescribeChannelModeratorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeChannelModeratorCommandInput} for command's `input` shape.
+ * @see {@link DescribeChannelModeratorCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeChannelModeratorCommand extends $Command<DescribeChannelModeratorCommandInput, DescribeChannelModeratorCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DescribeChannelModeratorCommandInput;
+    constructor(input: DescribeChannelModeratorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeChannelModeratorCommandInput, DescribeChannelModeratorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociatePhoneNumberFromUserCommand.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 { DisassociatePhoneNumberFromUserRequest, DisassociatePhoneNumberFromUserResponse } from "../models/models_0";
+export interface DisassociatePhoneNumberFromUserCommandInput extends DisassociatePhoneNumberFromUserRequest {
+}
+export interface DisassociatePhoneNumberFromUserCommandOutput extends DisassociatePhoneNumberFromUserResponse, __MetadataBearer {
+}
+/**
+ * <p>Disassociates the primary provisioned phone number from the specified Amazon Chime user.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeClient, DisassociatePhoneNumberFromUserCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DisassociatePhoneNumberFromUserCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DisassociatePhoneNumberFromUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociatePhoneNumberFromUserCommandInput} for command's `input` shape.
+ * @see {@link DisassociatePhoneNumberFromUserCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisassociatePhoneNumberFromUserCommand extends $Command<DisassociatePhoneNumberFromUserCommandInput, DisassociatePhoneNumberFromUserCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DisassociatePhoneNumberFromUserCommandInput;
+    constructor(input: DisassociatePhoneNumberFromUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociatePhoneNumberFromUserCommandInput, DisassociatePhoneNumberFromUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociatePhoneNumbersFromVoiceConnectorCommand.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 { DisassociatePhoneNumbersFromVoiceConnectorRequest, DisassociatePhoneNumbersFromVoiceConnectorResponse } from "../models/models_0";
+export interface DisassociatePhoneNumbersFromVoiceConnectorCommandInput extends DisassociatePhoneNumbersFromVoiceConnectorRequest {
+}
+export interface DisassociatePhoneNumbersFromVoiceConnectorCommandOutput extends DisassociatePhoneNumbersFromVoiceConnectorResponse, __MetadataBearer {
+}
+/**
+ * <p>Disassociates the specified phone numbers from 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, DisassociatePhoneNumbersFromVoiceConnectorCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DisassociatePhoneNumbersFromVoiceConnectorCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DisassociatePhoneNumbersFromVoiceConnectorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociatePhoneNumbersFromVoiceConnectorCommandInput} for command's `input` shape.
+ * @see {@link DisassociatePhoneNumbersFromVoiceConnectorCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisassociatePhoneNumbersFromVoiceConnectorCommand extends $Command<DisassociatePhoneNumbersFromVoiceConnectorCommandInput, DisassociatePhoneNumbersFromVoiceConnectorCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DisassociatePhoneNumbersFromVoiceConnectorCommandInput;
+    constructor(input: DisassociatePhoneNumbersFromVoiceConnectorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociatePhoneNumbersFromVoiceConnectorCommandInput, DisassociatePhoneNumbersFromVoiceConnectorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociatePhoneNumbersFromVoiceConnectorGroupCommand.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 { DisassociatePhoneNumbersFromVoiceConnectorGroupRequest, DisassociatePhoneNumbersFromVoiceConnectorGroupResponse } from "../models/models_0";
+export interface DisassociatePhoneNumbersFromVoiceConnectorGroupCommandInput extends DisassociatePhoneNumbersFromVoiceConnectorGroupRequest {
+}
+export interface DisassociatePhoneNumbersFromVoiceConnectorGroupCommandOutput extends DisassociatePhoneNumbersFromVoiceConnectorGroupResponse, __MetadataBearer {
+}
+/**
+ * <p>Disassociates the specified phone numbers from the specified Amazon Chime Voice Connector group.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeClient, DisassociatePhoneNumbersFromVoiceConnectorGroupCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DisassociatePhoneNumbersFromVoiceConnectorGroupCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DisassociatePhoneNumbersFromVoiceConnectorGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociatePhoneNumbersFromVoiceConnectorGroupCommandInput} for command's `input` shape.
+ * @see {@link DisassociatePhoneNumbersFromVoiceConnectorGroupCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisassociatePhoneNumbersFromVoiceConnectorGroupCommand extends $Command<DisassociatePhoneNumbersFromVoiceConnectorGroupCommandInput, DisassociatePhoneNumbersFromVoiceConnectorGroupCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DisassociatePhoneNumbersFromVoiceConnectorGroupCommandInput;
+    constructor(input: DisassociatePhoneNumbersFromVoiceConnectorGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociatePhoneNumbersFromVoiceConnectorGroupCommandInput, DisassociatePhoneNumbersFromVoiceConnectorGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociateSigninDelegateGroupsFromAccountCommand.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 { DisassociateSigninDelegateGroupsFromAccountRequest, DisassociateSigninDelegateGroupsFromAccountResponse } from "../models/models_0";
+export interface DisassociateSigninDelegateGroupsFromAccountCommandInput extends DisassociateSigninDelegateGroupsFromAccountRequest {
+}
+export interface DisassociateSigninDelegateGroupsFromAccountCommandOutput extends DisassociateSigninDelegateGroupsFromAccountResponse, __MetadataBearer {
+}
+/**
+ * <p>Disassociates the specified sign-in delegate groups from the specified Amazon Chime account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeClient, DisassociateSigninDelegateGroupsFromAccountCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, DisassociateSigninDelegateGroupsFromAccountCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new DisassociateSigninDelegateGroupsFromAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociateSigninDelegateGroupsFromAccountCommandInput} for command's `input` shape.
+ * @see {@link DisassociateSigninDelegateGroupsFromAccountCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisassociateSigninDelegateGroupsFromAccountCommand extends $Command<DisassociateSigninDelegateGroupsFromAccountCommandInput, DisassociateSigninDelegateGroupsFromAccountCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: DisassociateSigninDelegateGroupsFromAccountCommandInput;
+    constructor(input: DisassociateSigninDelegateGroupsFromAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateSigninDelegateGroupsFromAccountCommandInput, DisassociateSigninDelegateGroupsFromAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetAccountCommand.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 { GetAccountRequest, GetAccountResponse } from "../models/models_0";
+export interface GetAccountCommandInput extends GetAccountRequest {
+}
+export interface GetAccountCommandOutput extends GetAccountResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves details for the specified Amazon Chime account, such as account type and supported
+ *             licenses.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeClient, GetAccountCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, GetAccountCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new GetAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetAccountCommandInput} for command's `input` shape.
+ * @see {@link GetAccountCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetAccountCommand extends $Command<GetAccountCommandInput, GetAccountCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: GetAccountCommandInput;
+    constructor(input: GetAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountCommandInput, GetAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetAccountSettingsCommand.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 { GetAccountSettingsRequest, GetAccountSettingsResponse } from "../models/models_0";
+export interface GetAccountSettingsCommandInput extends GetAccountSettingsRequest {
+}
+export interface GetAccountSettingsCommandOutput extends GetAccountSettingsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves account settings for the specified Amazon Chime account ID, such as remote control
+ *             and dialout settings. For more information about these settings, see
+ *     <a href="https://docs.aws.amazon.com/chime/latest/ag/policies.html">Use the Policies Page</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, GetAccountSettingsCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, GetAccountSettingsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new GetAccountSettingsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetAccountSettingsCommandInput} for command's `input` shape.
+ * @see {@link GetAccountSettingsCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetAccountSettingsCommand extends $Command<GetAccountSettingsCommandInput, GetAccountSettingsCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: GetAccountSettingsCommandInput;
+    constructor(input: GetAccountSettingsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountSettingsCommandInput, GetAccountSettingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetAppInstanceRetentionSettingsCommand.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 { GetAppInstanceRetentionSettingsRequest, GetAppInstanceRetentionSettingsResponse } from "../models/models_0";
+export interface GetAppInstanceRetentionSettingsCommandInput extends GetAppInstanceRetentionSettingsRequest {
+}
+export interface GetAppInstanceRetentionSettingsCommandOutput extends GetAppInstanceRetentionSettingsResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the retention settings for an <code>AppInstance</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeClient, GetAppInstanceRetentionSettingsCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, GetAppInstanceRetentionSettingsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new GetAppInstanceRetentionSettingsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetAppInstanceRetentionSettingsCommandInput} for command's `input` shape.
+ * @see {@link GetAppInstanceRetentionSettingsCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetAppInstanceRetentionSettingsCommand extends $Command<GetAppInstanceRetentionSettingsCommandInput, GetAppInstanceRetentionSettingsCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: GetAppInstanceRetentionSettingsCommandInput;
+    constructor(input: GetAppInstanceRetentionSettingsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAppInstanceRetentionSettingsCommandInput, GetAppInstanceRetentionSettingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetAppInstanceStreamingConfigurationsCommand.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 { GetAppInstanceStreamingConfigurationsRequest, GetAppInstanceStreamingConfigurationsResponse } from "../models/models_0";
+export interface GetAppInstanceStreamingConfigurationsCommandInput extends GetAppInstanceStreamingConfigurationsRequest {
+}
+export interface GetAppInstanceStreamingConfigurationsCommandOutput extends GetAppInstanceStreamingConfigurationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the streaming settings for an <code>AppInstance</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeClient, GetAppInstanceStreamingConfigurationsCommand } from "@aws-sdk/client-chime"; // ES Modules import
+ * // const { ChimeClient, GetAppInstanceStreamingConfigurationsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
+ * const client = new ChimeClient(config);
+ * const command = new GetAppInstanceStreamingConfigurationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetAppInstanceStreamingConfigurationsCommandInput} for command's `input` shape.
+ * @see {@link GetAppInstanceStreamingConfigurationsCommandOutput} for command's `response` shape.
+ * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetAppInstanceStreamingConfigurationsCommand extends $Command<GetAppInstanceStreamingConfigurationsCommandInput, GetAppInstanceStreamingConfigurationsCommandOutput, ChimeClientResolvedConfig> {
+    readonly input: GetAppInstanceStreamingConfigurationsCommandInput;
+    constructor(input: GetAppInstanceStreamingConfigurationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAppInstanceStreamingConfigurationsCommandInput, GetAppInstanceStreamingConfigurationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetAttendeeCommand.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 { GetAttendeeRequest, GetAttendeeResponse } from "../models/models_0";
+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

@@ -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 { GetBotRequest, GetBotResponse } from "../models/models_0";
+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

@@ -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 { GetChannelMessageRequest, GetChannelMessageResponse } from "../models/models_0";
+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;
+}