/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace Chime { /** *

Most of these APIs are no longer supported and will not be * updated. We recommend using the latest versions in the Amazon * Chime SDK API reference, in the Amazon Chime SDK.

Using the latest * versions requires migrating to dedicated namespaces. For more information, refer * to Migrating * from the Amazon Chime namespace in the Amazon Chime SDK Developer * Guide.

The Amazon Chime application programming * interface (API) is designed so administrators can perform key tasks, such as * creating and managing Amazon Chime accounts, users, and Voice Connectors. This * guide provides detailed information about the Amazon Chime API, including * operations, types, inputs and outputs, and error codes.

You can use an * AWS SDK, the AWS Command Line Interface (AWS CLI), or the REST API to make API * calls for Amazon Chime. We recommend using an AWS SDK or the AWS CLI. The page * for each API action contains a See Also section that includes links to * information about using the action with a language-specific AWS SDK or the AWS * CLI.

Using an AWS SDK

You don't need to write code to * calculate a signature for request authentication. The SDK clients authenticate * your requests by using access keys that you provide. For more information about * AWS SDKs, see the AWS Developer * Center.

Using the AWS CLI

Use your access keys * with the AWS CLI to make API calls. For information about setting up the AWS * CLI, see Installing * the AWS Command Line Interface in the AWS Command Line Interface User * Guide. For a list of available Amazon Chime commands, see the Amazon * Chime commands in the AWS CLI Command Reference.

Using * REST APIs

If you use REST to make API calls, you must authenticate * your request by providing a signature. Amazon Chime supports Signature Version * 4. For more information, see Signature * Version 4 Signing Process in the Amazon Web Services General * Reference.

When making REST API calls, use the service name * chime and REST endpoint * https://service.chime.aws.amazon.com.

*

Administrative permissions are controlled using AWS Identity and Access * Management (IAM). For more information, see Identity * and Access Management for Amazon Chime in the Amazon Chime Administration * Guide.

*/ class AWS_CHIME_API ChimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef ChimeClientConfiguration ClientConfigurationType; typedef ChimeEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ChimeClient(const Aws::Chime::ChimeClientConfiguration& clientConfiguration = Aws::Chime::ChimeClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ChimeClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Chime::ChimeClientConfiguration& clientConfiguration = Aws::Chime::ChimeClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ChimeClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Chime::ChimeClientConfiguration& clientConfiguration = Aws::Chime::ChimeClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ChimeClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ChimeClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ChimeClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ChimeClient(); /** *

Associates a phone number with the specified Amazon Chime user.

See * Also:

AWS * API Reference

*/ virtual Model::AssociatePhoneNumberWithUserOutcome AssociatePhoneNumberWithUser(const Model::AssociatePhoneNumberWithUserRequest& request) const; /** * A Callable wrapper for AssociatePhoneNumberWithUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociatePhoneNumberWithUserOutcomeCallable AssociatePhoneNumberWithUserCallable(const AssociatePhoneNumberWithUserRequestT& request) const { return SubmitCallable(&ChimeClient::AssociatePhoneNumberWithUser, request); } /** * An Async wrapper for AssociatePhoneNumberWithUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociatePhoneNumberWithUserAsync(const AssociatePhoneNumberWithUserRequestT& request, const AssociatePhoneNumberWithUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::AssociatePhoneNumberWithUser, request, handler, context); } /** *

Associates the specified sign-in delegate groups with the specified Amazon * Chime account.

See Also:

AWS * API Reference

*/ virtual Model::AssociateSigninDelegateGroupsWithAccountOutcome AssociateSigninDelegateGroupsWithAccount(const Model::AssociateSigninDelegateGroupsWithAccountRequest& request) const; /** * A Callable wrapper for AssociateSigninDelegateGroupsWithAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateSigninDelegateGroupsWithAccountOutcomeCallable AssociateSigninDelegateGroupsWithAccountCallable(const AssociateSigninDelegateGroupsWithAccountRequestT& request) const { return SubmitCallable(&ChimeClient::AssociateSigninDelegateGroupsWithAccount, request); } /** * An Async wrapper for AssociateSigninDelegateGroupsWithAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateSigninDelegateGroupsWithAccountAsync(const AssociateSigninDelegateGroupsWithAccountRequestT& request, const AssociateSigninDelegateGroupsWithAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::AssociateSigninDelegateGroupsWithAccount, request, handler, context); } /** *

Adds up to 50 members to a chat room in an Amazon Chime Enterprise account. * Members can be users or bots. The member role designates whether the member is a * chat room administrator or a general chat room member.

See Also:

* AWS * API Reference

*/ virtual Model::BatchCreateRoomMembershipOutcome BatchCreateRoomMembership(const Model::BatchCreateRoomMembershipRequest& request) const; /** * A Callable wrapper for BatchCreateRoomMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchCreateRoomMembershipOutcomeCallable BatchCreateRoomMembershipCallable(const BatchCreateRoomMembershipRequestT& request) const { return SubmitCallable(&ChimeClient::BatchCreateRoomMembership, request); } /** * An Async wrapper for BatchCreateRoomMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchCreateRoomMembershipAsync(const BatchCreateRoomMembershipRequestT& request, const BatchCreateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::BatchCreateRoomMembership, request, handler, context); } /** *

Moves phone numbers into the Deletion queue. Phone numbers must be * disassociated from any users or Amazon Chime Voice Connectors before they can be * deleted.

Phone numbers remain in the Deletion queue for 7 days * before they are deleted permanently.

See Also:

AWS * API Reference

*/ virtual Model::BatchDeletePhoneNumberOutcome BatchDeletePhoneNumber(const Model::BatchDeletePhoneNumberRequest& request) const; /** * A Callable wrapper for BatchDeletePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDeletePhoneNumberOutcomeCallable BatchDeletePhoneNumberCallable(const BatchDeletePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeClient::BatchDeletePhoneNumber, request); } /** * An Async wrapper for BatchDeletePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDeletePhoneNumberAsync(const BatchDeletePhoneNumberRequestT& request, const BatchDeletePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::BatchDeletePhoneNumber, request, handler, context); } /** *

Suspends up to 50 users from a Team or * EnterpriseLWA Amazon Chime account. For more information about * different account types, see Managing * Your Amazon Chime Accounts in the Amazon Chime Administration * Guide.

Users suspended from a Team account are * disassociated from the account,but they can continue to use Amazon Chime as free * users. To remove the suspension from suspended Team account users, * invite them to the Team account again. You can use the * InviteUsers action to do so.

Users suspended from an * EnterpriseLWA account are immediately signed out of Amazon Chime * and can no longer sign in. To remove the suspension from suspended * EnterpriseLWA account users, use the BatchUnsuspendUser * action.

To sign out users without suspending them, use the * LogoutUser action.

See Also:

AWS * API Reference

*/ virtual Model::BatchSuspendUserOutcome BatchSuspendUser(const Model::BatchSuspendUserRequest& request) const; /** * A Callable wrapper for BatchSuspendUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchSuspendUserOutcomeCallable BatchSuspendUserCallable(const BatchSuspendUserRequestT& request) const { return SubmitCallable(&ChimeClient::BatchSuspendUser, request); } /** * An Async wrapper for BatchSuspendUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchSuspendUserAsync(const BatchSuspendUserRequestT& request, const BatchSuspendUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::BatchSuspendUser, request, handler, context); } /** *

Removes the suspension from up to 50 previously suspended users for the * specified Amazon Chime EnterpriseLWA account. Only users on * EnterpriseLWA accounts can be unsuspended using this action. For * more information about different account types, see * Managing Your Amazon Chime Accounts in the account types, in the Amazon * Chime Administration Guide.

Previously suspended users who are * unsuspended using this action are returned to Registered status. * Users who are not previously suspended are ignored.

See Also:

* AWS * API Reference

*/ virtual Model::BatchUnsuspendUserOutcome BatchUnsuspendUser(const Model::BatchUnsuspendUserRequest& request) const; /** * A Callable wrapper for BatchUnsuspendUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUnsuspendUserOutcomeCallable BatchUnsuspendUserCallable(const BatchUnsuspendUserRequestT& request) const { return SubmitCallable(&ChimeClient::BatchUnsuspendUser, request); } /** * An Async wrapper for BatchUnsuspendUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUnsuspendUserAsync(const BatchUnsuspendUserRequestT& request, const BatchUnsuspendUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::BatchUnsuspendUser, request, handler, context); } /** *

Updates phone number product types or calling names. You can update one * attribute at a time for each UpdatePhoneNumberRequestItem. For * example, you can update the product type or the calling name.

For * toll-free numbers, you cannot use the Amazon Chime Business Calling product * type. For numbers outside the U.S., you must use the Amazon Chime SIP Media * Application Dial-In product type.

Updates to outbound calling names can * take up to 72 hours to complete. Pending updates to outbound calling names must * be complete before you can request another update.

See Also:

AWS * API Reference

*/ virtual Model::BatchUpdatePhoneNumberOutcome BatchUpdatePhoneNumber(const Model::BatchUpdatePhoneNumberRequest& request) const; /** * A Callable wrapper for BatchUpdatePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUpdatePhoneNumberOutcomeCallable BatchUpdatePhoneNumberCallable(const BatchUpdatePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeClient::BatchUpdatePhoneNumber, request); } /** * An Async wrapper for BatchUpdatePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUpdatePhoneNumberAsync(const BatchUpdatePhoneNumberRequestT& request, const BatchUpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::BatchUpdatePhoneNumber, request, handler, context); } /** *

Updates user details within the UpdateUserRequestItem object for up to * 20 users for the specified Amazon Chime account. Currently, only * LicenseType updates are supported for this action.

See * Also:

AWS * API Reference

*/ virtual Model::BatchUpdateUserOutcome BatchUpdateUser(const Model::BatchUpdateUserRequest& request) const; /** * A Callable wrapper for BatchUpdateUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUpdateUserOutcomeCallable BatchUpdateUserCallable(const BatchUpdateUserRequestT& request) const { return SubmitCallable(&ChimeClient::BatchUpdateUser, request); } /** * An Async wrapper for BatchUpdateUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUpdateUserAsync(const BatchUpdateUserRequestT& request, const BatchUpdateUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::BatchUpdateUser, request, handler, context); } /** *

Creates an Amazon Chime account under the administrator's AWS account. Only * Team account types are currently supported for this action. For * more information about different account types, see Managing * Your Amazon Chime Accounts in the Amazon Chime Administration * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateAccountOutcome CreateAccount(const Model::CreateAccountRequest& request) const; /** * A Callable wrapper for CreateAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAccountOutcomeCallable CreateAccountCallable(const CreateAccountRequestT& request) const { return SubmitCallable(&ChimeClient::CreateAccount, request); } /** * An Async wrapper for CreateAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAccountAsync(const CreateAccountRequestT& request, const CreateAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::CreateAccount, request, handler, context); } /** *

Creates a bot for an Amazon Chime Enterprise account.

See * Also:

AWS API * Reference

*/ virtual Model::CreateBotOutcome CreateBot(const Model::CreateBotRequest& request) const; /** * A Callable wrapper for CreateBot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBotOutcomeCallable CreateBotCallable(const CreateBotRequestT& request) const { return SubmitCallable(&ChimeClient::CreateBot, request); } /** * An Async wrapper for CreateBot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBotAsync(const CreateBotRequestT& request, const CreateBotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::CreateBot, request, handler, context); } /** *

Uses the join token and call metadata in a meeting request (From number, To * number, and so forth) to initiate an outbound call to a public switched * telephone network (PSTN) and join them into a Chime meeting. Also ensures that * the From number belongs to the customer.

To play welcome audio or * implement an interactive voice response (IVR), use the * CreateSipMediaApplicationCall action with the corresponding SIP * media application ID.

This API is is not available in a * dedicated namespace.

See Also:

AWS * API Reference

*/ virtual Model::CreateMeetingDialOutOutcome CreateMeetingDialOut(const Model::CreateMeetingDialOutRequest& request) const; /** * A Callable wrapper for CreateMeetingDialOut that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMeetingDialOutOutcomeCallable CreateMeetingDialOutCallable(const CreateMeetingDialOutRequestT& request) const { return SubmitCallable(&ChimeClient::CreateMeetingDialOut, request); } /** * An Async wrapper for CreateMeetingDialOut that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMeetingDialOutAsync(const CreateMeetingDialOutRequestT& request, const CreateMeetingDialOutResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::CreateMeetingDialOut, request, handler, context); } /** *

Creates an order for phone numbers to be provisioned. For toll-free numbers, * you cannot use the Amazon Chime Business Calling product type. For numbers * outside the U.S., you must use the Amazon Chime SIP Media Application Dial-In * product type.

See Also:

AWS * API Reference

*/ virtual Model::CreatePhoneNumberOrderOutcome CreatePhoneNumberOrder(const Model::CreatePhoneNumberOrderRequest& request) const; /** * A Callable wrapper for CreatePhoneNumberOrder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePhoneNumberOrderOutcomeCallable CreatePhoneNumberOrderCallable(const CreatePhoneNumberOrderRequestT& request) const { return SubmitCallable(&ChimeClient::CreatePhoneNumberOrder, request); } /** * An Async wrapper for CreatePhoneNumberOrder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePhoneNumberOrderAsync(const CreatePhoneNumberOrderRequestT& request, const CreatePhoneNumberOrderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::CreatePhoneNumberOrder, request, handler, context); } /** *

Creates a chat room for the specified Amazon Chime Enterprise * account.

See Also:

AWS * API Reference

*/ virtual Model::CreateRoomOutcome CreateRoom(const Model::CreateRoomRequest& request) const; /** * A Callable wrapper for CreateRoom that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRoomOutcomeCallable CreateRoomCallable(const CreateRoomRequestT& request) const { return SubmitCallable(&ChimeClient::CreateRoom, request); } /** * An Async wrapper for CreateRoom that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRoomAsync(const CreateRoomRequestT& request, const CreateRoomResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::CreateRoom, request, handler, context); } /** *

Adds a member to a chat room in an Amazon Chime Enterprise account. A member * can be either a user or a bot. The member role designates whether the member is * a chat room administrator or a general chat room member.

See * Also:

AWS * API Reference

*/ virtual Model::CreateRoomMembershipOutcome CreateRoomMembership(const Model::CreateRoomMembershipRequest& request) const; /** * A Callable wrapper for CreateRoomMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRoomMembershipOutcomeCallable CreateRoomMembershipCallable(const CreateRoomMembershipRequestT& request) const { return SubmitCallable(&ChimeClient::CreateRoomMembership, request); } /** * An Async wrapper for CreateRoomMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRoomMembershipAsync(const CreateRoomMembershipRequestT& request, const CreateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::CreateRoomMembership, request, handler, context); } /** *

Creates a user under the specified Amazon Chime account.

See * Also:

AWS * API Reference

*/ virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const; /** * A Callable wrapper for CreateUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const { return SubmitCallable(&ChimeClient::CreateUser, request); } /** * An Async wrapper for CreateUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::CreateUser, request, handler, context); } /** *

Deletes the specified Amazon Chime account. You must suspend all users before * deleting Team account. You can use the BatchSuspendUser * action to dodo.

For EnterpriseLWA and * EnterpriseAD accounts, you must release the claimed domains for * your Amazon Chime account before deletion. As soon as you release the domain, * all users under that account are suspended.

Deleted accounts appear in * your Disabled accounts list for 90 days. To restore deleted account * from your Disabled accounts list, you must contact AWS Support.

*

After 90 days, deleted accounts are permanently removed from your * Disabled accounts list.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccountOutcome DeleteAccount(const Model::DeleteAccountRequest& request) const; /** * A Callable wrapper for DeleteAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccountOutcomeCallable DeleteAccountCallable(const DeleteAccountRequestT& request) const { return SubmitCallable(&ChimeClient::DeleteAccount, request); } /** * An Async wrapper for DeleteAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccountAsync(const DeleteAccountRequestT& request, const DeleteAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::DeleteAccount, request, handler, context); } /** *

Deletes the events configuration that allows a bot to receive outgoing * events.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEventsConfigurationOutcome DeleteEventsConfiguration(const Model::DeleteEventsConfigurationRequest& request) const; /** * A Callable wrapper for DeleteEventsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEventsConfigurationOutcomeCallable DeleteEventsConfigurationCallable(const DeleteEventsConfigurationRequestT& request) const { return SubmitCallable(&ChimeClient::DeleteEventsConfiguration, request); } /** * An Async wrapper for DeleteEventsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEventsConfigurationAsync(const DeleteEventsConfigurationRequestT& request, const DeleteEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::DeleteEventsConfiguration, request, handler, context); } /** *

Moves the specified phone number into the Deletion queue. A phone * number must be disassociated from any users or Amazon Chime Voice Connectors * before it can be deleted.

Deleted phone numbers remain in the Deletion * queue for 7 days before they are deleted permanently.

See * Also:

AWS * API Reference

*/ virtual Model::DeletePhoneNumberOutcome DeletePhoneNumber(const Model::DeletePhoneNumberRequest& request) const; /** * A Callable wrapper for DeletePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePhoneNumberOutcomeCallable DeletePhoneNumberCallable(const DeletePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeClient::DeletePhoneNumber, request); } /** * An Async wrapper for DeletePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePhoneNumberAsync(const DeletePhoneNumberRequestT& request, const DeletePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::DeletePhoneNumber, request, handler, context); } /** *

Deletes a chat room in an Amazon Chime Enterprise account.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteRoomOutcome DeleteRoom(const Model::DeleteRoomRequest& request) const; /** * A Callable wrapper for DeleteRoom that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRoomOutcomeCallable DeleteRoomCallable(const DeleteRoomRequestT& request) const { return SubmitCallable(&ChimeClient::DeleteRoom, request); } /** * An Async wrapper for DeleteRoom that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRoomAsync(const DeleteRoomRequestT& request, const DeleteRoomResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::DeleteRoom, request, handler, context); } /** *

Removes a member from a chat room in an Amazon Chime Enterprise * account.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRoomMembershipOutcome DeleteRoomMembership(const Model::DeleteRoomMembershipRequest& request) const; /** * A Callable wrapper for DeleteRoomMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRoomMembershipOutcomeCallable DeleteRoomMembershipCallable(const DeleteRoomMembershipRequestT& request) const { return SubmitCallable(&ChimeClient::DeleteRoomMembership, request); } /** * An Async wrapper for DeleteRoomMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRoomMembershipAsync(const DeleteRoomMembershipRequestT& request, const DeleteRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::DeleteRoomMembership, request, handler, context); } /** *

Disassociates the primary provisioned phone number from the specified Amazon * Chime user.

See Also:

AWS * API Reference

*/ virtual Model::DisassociatePhoneNumberFromUserOutcome DisassociatePhoneNumberFromUser(const Model::DisassociatePhoneNumberFromUserRequest& request) const; /** * A Callable wrapper for DisassociatePhoneNumberFromUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociatePhoneNumberFromUserOutcomeCallable DisassociatePhoneNumberFromUserCallable(const DisassociatePhoneNumberFromUserRequestT& request) const { return SubmitCallable(&ChimeClient::DisassociatePhoneNumberFromUser, request); } /** * An Async wrapper for DisassociatePhoneNumberFromUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociatePhoneNumberFromUserAsync(const DisassociatePhoneNumberFromUserRequestT& request, const DisassociatePhoneNumberFromUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::DisassociatePhoneNumberFromUser, request, handler, context); } /** *

Disassociates the specified sign-in delegate groups from the specified Amazon * Chime account.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateSigninDelegateGroupsFromAccountOutcome DisassociateSigninDelegateGroupsFromAccount(const Model::DisassociateSigninDelegateGroupsFromAccountRequest& request) const; /** * A Callable wrapper for DisassociateSigninDelegateGroupsFromAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateSigninDelegateGroupsFromAccountOutcomeCallable DisassociateSigninDelegateGroupsFromAccountCallable(const DisassociateSigninDelegateGroupsFromAccountRequestT& request) const { return SubmitCallable(&ChimeClient::DisassociateSigninDelegateGroupsFromAccount, request); } /** * An Async wrapper for DisassociateSigninDelegateGroupsFromAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateSigninDelegateGroupsFromAccountAsync(const DisassociateSigninDelegateGroupsFromAccountRequestT& request, const DisassociateSigninDelegateGroupsFromAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::DisassociateSigninDelegateGroupsFromAccount, request, handler, context); } /** *

Retrieves details for the specified Amazon Chime account, such as account * type and supported licenses.

See Also:

AWS * API Reference

*/ virtual Model::GetAccountOutcome GetAccount(const Model::GetAccountRequest& request) const; /** * A Callable wrapper for GetAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccountOutcomeCallable GetAccountCallable(const GetAccountRequestT& request) const { return SubmitCallable(&ChimeClient::GetAccount, request); } /** * An Async wrapper for GetAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccountAsync(const GetAccountRequestT& request, const GetAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetAccount, request, handler, context); } /** *

Retrieves account settings for the specified Amazon Chime account ID, such as * remote control and dialout settings. For more information about these settings, * see Use the * Policies Page in the Amazon Chime Administration Guide. *

See Also:

AWS * API Reference

*/ virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request) const; /** * A Callable wrapper for GetAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request) const { return SubmitCallable(&ChimeClient::GetAccountSettings, request); } /** * An Async wrapper for GetAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccountSettingsAsync(const GetAccountSettingsRequestT& request, const GetAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetAccountSettings, request, handler, context); } /** *

Retrieves details for the specified bot, such as bot email address, bot type, * status, and display name.

See Also:

AWS API * Reference

*/ virtual Model::GetBotOutcome GetBot(const Model::GetBotRequest& request) const; /** * A Callable wrapper for GetBot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBotOutcomeCallable GetBotCallable(const GetBotRequestT& request) const { return SubmitCallable(&ChimeClient::GetBot, request); } /** * An Async wrapper for GetBot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBotAsync(const GetBotRequestT& request, const GetBotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetBot, request, handler, context); } /** *

Gets details for an events configuration that allows a bot to receive * outgoing events, such as an HTTPS endpoint or Lambda function ARN.

See * Also:

AWS * API Reference

*/ virtual Model::GetEventsConfigurationOutcome GetEventsConfiguration(const Model::GetEventsConfigurationRequest& request) const; /** * A Callable wrapper for GetEventsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEventsConfigurationOutcomeCallable GetEventsConfigurationCallable(const GetEventsConfigurationRequestT& request) const { return SubmitCallable(&ChimeClient::GetEventsConfiguration, request); } /** * An Async wrapper for GetEventsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEventsConfigurationAsync(const GetEventsConfigurationRequestT& request, const GetEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetEventsConfiguration, request, handler, context); } /** *

Retrieves global settings for the administrator's AWS account, such as Amazon * Chime Business Calling and Amazon Chime Voice Connector settings.

See * Also:

AWS * API Reference

*/ virtual Model::GetGlobalSettingsOutcome GetGlobalSettings() const; /** * A Callable wrapper for GetGlobalSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetGlobalSettingsOutcomeCallable GetGlobalSettingsCallable() const { return SubmitCallable(&ChimeClient::GetGlobalSettings); } /** * An Async wrapper for GetGlobalSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetGlobalSettingsAsync(const GetGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetGlobalSettings, handler, context); } /** *

Retrieves details for the specified phone number ID, such as associations, * capabilities, and product type.

See Also:

AWS * API Reference

*/ virtual Model::GetPhoneNumberOutcome GetPhoneNumber(const Model::GetPhoneNumberRequest& request) const; /** * A Callable wrapper for GetPhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPhoneNumberOutcomeCallable GetPhoneNumberCallable(const GetPhoneNumberRequestT& request) const { return SubmitCallable(&ChimeClient::GetPhoneNumber, request); } /** * An Async wrapper for GetPhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPhoneNumberAsync(const GetPhoneNumberRequestT& request, const GetPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetPhoneNumber, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::GetPhoneNumberOrderOutcome GetPhoneNumberOrder(const Model::GetPhoneNumberOrderRequest& request) const; /** * A Callable wrapper for GetPhoneNumberOrder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPhoneNumberOrderOutcomeCallable GetPhoneNumberOrderCallable(const GetPhoneNumberOrderRequestT& request) const { return SubmitCallable(&ChimeClient::GetPhoneNumberOrder, request); } /** * An Async wrapper for GetPhoneNumberOrder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPhoneNumberOrderAsync(const GetPhoneNumberOrderRequestT& request, const GetPhoneNumberOrderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetPhoneNumberOrder, request, handler, context); } /** *

Retrieves the phone number settings for the administrator's AWS account, such * as the default outbound calling name.

See Also:

AWS * API Reference

*/ virtual Model::GetPhoneNumberSettingsOutcome GetPhoneNumberSettings() const; /** * A Callable wrapper for GetPhoneNumberSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPhoneNumberSettingsOutcomeCallable GetPhoneNumberSettingsCallable() const { return SubmitCallable(&ChimeClient::GetPhoneNumberSettings); } /** * An Async wrapper for GetPhoneNumberSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPhoneNumberSettingsAsync(const GetPhoneNumberSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetPhoneNumberSettings, handler, context); } /** *

Gets the retention settings for the specified Amazon Chime Enterprise * account. For more information about retention settings, see Managing * Chat Retention Policies in the Amazon Chime Administration Guide. *

See Also:

AWS * API Reference

*/ virtual Model::GetRetentionSettingsOutcome GetRetentionSettings(const Model::GetRetentionSettingsRequest& request) const; /** * A Callable wrapper for GetRetentionSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRetentionSettingsOutcomeCallable GetRetentionSettingsCallable(const GetRetentionSettingsRequestT& request) const { return SubmitCallable(&ChimeClient::GetRetentionSettings, request); } /** * An Async wrapper for GetRetentionSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRetentionSettingsAsync(const GetRetentionSettingsRequestT& request, const GetRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetRetentionSettings, request, handler, context); } /** *

Retrieves room details, such as the room name, for a room in an Amazon Chime * Enterprise account.

See Also:

AWS API * Reference

*/ virtual Model::GetRoomOutcome GetRoom(const Model::GetRoomRequest& request) const; /** * A Callable wrapper for GetRoom that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRoomOutcomeCallable GetRoomCallable(const GetRoomRequestT& request) const { return SubmitCallable(&ChimeClient::GetRoom, request); } /** * An Async wrapper for GetRoom that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRoomAsync(const GetRoomRequestT& request, const GetRoomResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetRoom, request, handler, context); } /** *

Retrieves details for the specified user ID, such as primary email address, * license type,and personal meeting PIN.

To retrieve user details with an * email address instead of a user ID, use the ListUsers action, and then * filter by email address.

See Also:

AWS API * Reference

*/ virtual Model::GetUserOutcome GetUser(const Model::GetUserRequest& request) const; /** * A Callable wrapper for GetUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetUserOutcomeCallable GetUserCallable(const GetUserRequestT& request) const { return SubmitCallable(&ChimeClient::GetUser, request); } /** * An Async wrapper for GetUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetUserAsync(const GetUserRequestT& request, const GetUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetUser, request, handler, context); } /** *

Retrieves settings for the specified user ID, such as any associated phone * number settings.

See Also:

AWS * API Reference

*/ virtual Model::GetUserSettingsOutcome GetUserSettings(const Model::GetUserSettingsRequest& request) const; /** * A Callable wrapper for GetUserSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetUserSettingsOutcomeCallable GetUserSettingsCallable(const GetUserSettingsRequestT& request) const { return SubmitCallable(&ChimeClient::GetUserSettings, request); } /** * An Async wrapper for GetUserSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetUserSettingsAsync(const GetUserSettingsRequestT& request, const GetUserSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::GetUserSettings, request, handler, context); } /** *

Sends email to a maximum of 50 users, inviting them to the specified Amazon * Chime Team account. Only Team account types are * currently supported for this action.

See Also:

AWS * API Reference

*/ virtual Model::InviteUsersOutcome InviteUsers(const Model::InviteUsersRequest& request) const; /** * A Callable wrapper for InviteUsers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::InviteUsersOutcomeCallable InviteUsersCallable(const InviteUsersRequestT& request) const { return SubmitCallable(&ChimeClient::InviteUsers, request); } /** * An Async wrapper for InviteUsers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void InviteUsersAsync(const InviteUsersRequestT& request, const InviteUsersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::InviteUsers, request, handler, context); } /** *

Lists the Amazon Chime accounts under the administrator's AWS account. You * can filter accounts by account name prefix. To find out which Amazon Chime * account a user belongs to, you can filter by the user's email address, which * returns one account result.

See Also:

AWS * API Reference

*/ virtual Model::ListAccountsOutcome ListAccounts(const Model::ListAccountsRequest& request) const; /** * A Callable wrapper for ListAccounts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAccountsOutcomeCallable ListAccountsCallable(const ListAccountsRequestT& request) const { return SubmitCallable(&ChimeClient::ListAccounts, request); } /** * An Async wrapper for ListAccounts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAccountsAsync(const ListAccountsRequestT& request, const ListAccountsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ListAccounts, request, handler, context); } /** *

Lists the bots associated with the administrator's Amazon Chime Enterprise * account ID.

See Also:

AWS API * Reference

*/ virtual Model::ListBotsOutcome ListBots(const Model::ListBotsRequest& request) const; /** * A Callable wrapper for ListBots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBotsOutcomeCallable ListBotsCallable(const ListBotsRequestT& request) const { return SubmitCallable(&ChimeClient::ListBots, request); } /** * An Async wrapper for ListBots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBotsAsync(const ListBotsRequestT& request, const ListBotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ListBots, request, handler, context); } /** *

Lists the phone number orders for the administrator's Amazon Chime * account.

See Also:

AWS * API Reference

*/ virtual Model::ListPhoneNumberOrdersOutcome ListPhoneNumberOrders(const Model::ListPhoneNumberOrdersRequest& request) const; /** * A Callable wrapper for ListPhoneNumberOrders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPhoneNumberOrdersOutcomeCallable ListPhoneNumberOrdersCallable(const ListPhoneNumberOrdersRequestT& request) const { return SubmitCallable(&ChimeClient::ListPhoneNumberOrders, request); } /** * An Async wrapper for ListPhoneNumberOrders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPhoneNumberOrdersAsync(const ListPhoneNumberOrdersRequestT& request, const ListPhoneNumberOrdersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ListPhoneNumberOrders, request, handler, context); } /** *

Lists the phone numbers for the specified Amazon Chime account, Amazon Chime * user, Amazon Chime Voice Connector, or Amazon Chime Voice Connector * group.

See Also:

AWS * API Reference

*/ virtual Model::ListPhoneNumbersOutcome ListPhoneNumbers(const Model::ListPhoneNumbersRequest& request) const; /** * A Callable wrapper for ListPhoneNumbers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPhoneNumbersOutcomeCallable ListPhoneNumbersCallable(const ListPhoneNumbersRequestT& request) const { return SubmitCallable(&ChimeClient::ListPhoneNumbers, request); } /** * An Async wrapper for ListPhoneNumbers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPhoneNumbersAsync(const ListPhoneNumbersRequestT& request, const ListPhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ListPhoneNumbers, request, handler, context); } /** *

Lists the membership details for the specified room in an Amazon Chime * Enterprise account, such as the members' IDs, email addresses, and * names.

See Also:

AWS * API Reference

*/ virtual Model::ListRoomMembershipsOutcome ListRoomMemberships(const Model::ListRoomMembershipsRequest& request) const; /** * A Callable wrapper for ListRoomMemberships that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRoomMembershipsOutcomeCallable ListRoomMembershipsCallable(const ListRoomMembershipsRequestT& request) const { return SubmitCallable(&ChimeClient::ListRoomMemberships, request); } /** * An Async wrapper for ListRoomMemberships that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRoomMembershipsAsync(const ListRoomMembershipsRequestT& request, const ListRoomMembershipsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ListRoomMemberships, request, handler, context); } /** *

Lists the room details for the specified Amazon Chime Enterprise account. * Optionally, filter the results by a member ID (user ID or bot ID) to see a list * of rooms that the member belongs to.

See Also:

AWS API * Reference

*/ virtual Model::ListRoomsOutcome ListRooms(const Model::ListRoomsRequest& request) const; /** * A Callable wrapper for ListRooms that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRoomsOutcomeCallable ListRoomsCallable(const ListRoomsRequestT& request) const { return SubmitCallable(&ChimeClient::ListRooms, request); } /** * An Async wrapper for ListRooms that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRoomsAsync(const ListRoomsRequestT& request, const ListRoomsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ListRooms, request, handler, context); } /** *

Lists supported phone number countries.

See Also:

AWS * API Reference

*/ virtual Model::ListSupportedPhoneNumberCountriesOutcome ListSupportedPhoneNumberCountries(const Model::ListSupportedPhoneNumberCountriesRequest& request) const; /** * A Callable wrapper for ListSupportedPhoneNumberCountries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSupportedPhoneNumberCountriesOutcomeCallable ListSupportedPhoneNumberCountriesCallable(const ListSupportedPhoneNumberCountriesRequestT& request) const { return SubmitCallable(&ChimeClient::ListSupportedPhoneNumberCountries, request); } /** * An Async wrapper for ListSupportedPhoneNumberCountries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSupportedPhoneNumberCountriesAsync(const ListSupportedPhoneNumberCountriesRequestT& request, const ListSupportedPhoneNumberCountriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ListSupportedPhoneNumberCountries, request, handler, context); } /** *

Lists the users that belong to the specified Amazon Chime account. You can * specify an email address to list only the user that the email address belongs * to.

See Also:

AWS API * Reference

*/ virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const; /** * A Callable wrapper for ListUsers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const { return SubmitCallable(&ChimeClient::ListUsers, request); } /** * An Async wrapper for ListUsers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ListUsers, request, handler, context); } /** *

Logs out the specified user from all of the devices they are currently logged * into.

See Also:

AWS * API Reference

*/ virtual Model::LogoutUserOutcome LogoutUser(const Model::LogoutUserRequest& request) const; /** * A Callable wrapper for LogoutUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::LogoutUserOutcomeCallable LogoutUserCallable(const LogoutUserRequestT& request) const { return SubmitCallable(&ChimeClient::LogoutUser, request); } /** * An Async wrapper for LogoutUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void LogoutUserAsync(const LogoutUserRequestT& request, const LogoutUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::LogoutUser, request, handler, context); } /** *

Creates an events configuration that allows a bot to receive outgoing events * sent by Amazon Chime. Choose either an HTTPS endpoint or a Lambda function ARN. * For more information, see Bot.

See Also:

AWS * API Reference

*/ virtual Model::PutEventsConfigurationOutcome PutEventsConfiguration(const Model::PutEventsConfigurationRequest& request) const; /** * A Callable wrapper for PutEventsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutEventsConfigurationOutcomeCallable PutEventsConfigurationCallable(const PutEventsConfigurationRequestT& request) const { return SubmitCallable(&ChimeClient::PutEventsConfiguration, request); } /** * An Async wrapper for PutEventsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutEventsConfigurationAsync(const PutEventsConfigurationRequestT& request, const PutEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::PutEventsConfiguration, request, handler, context); } /** *

Puts retention settings for the specified Amazon Chime Enterprise account. * We recommend using AWS CloudTrail to monitor usage of this API for your account. * For more information, see Logging * Amazon Chime API Calls with AWS CloudTrail in the Amazon Chime * Administration Guide.

To turn off existing retention settings, * remove the number of days from the corresponding RetentionDays field in * the RetentionSettings object. For more information about retention * settings, see Managing * Chat Retention Policies in the Amazon Chime Administration * Guide.

See Also:

AWS * API Reference

*/ virtual Model::PutRetentionSettingsOutcome PutRetentionSettings(const Model::PutRetentionSettingsRequest& request) const; /** * A Callable wrapper for PutRetentionSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutRetentionSettingsOutcomeCallable PutRetentionSettingsCallable(const PutRetentionSettingsRequestT& request) const { return SubmitCallable(&ChimeClient::PutRetentionSettings, request); } /** * An Async wrapper for PutRetentionSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutRetentionSettingsAsync(const PutRetentionSettingsRequestT& request, const PutRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::PutRetentionSettings, request, handler, context); } /** *

Redacts the specified message from the specified Amazon Chime * conversation.

See Also:

AWS * API Reference

*/ virtual Model::RedactConversationMessageOutcome RedactConversationMessage(const Model::RedactConversationMessageRequest& request) const; /** * A Callable wrapper for RedactConversationMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RedactConversationMessageOutcomeCallable RedactConversationMessageCallable(const RedactConversationMessageRequestT& request) const { return SubmitCallable(&ChimeClient::RedactConversationMessage, request); } /** * An Async wrapper for RedactConversationMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RedactConversationMessageAsync(const RedactConversationMessageRequestT& request, const RedactConversationMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::RedactConversationMessage, request, handler, context); } /** *

Redacts the specified message from the specified Amazon Chime * channel.

See Also:

AWS * API Reference

*/ virtual Model::RedactRoomMessageOutcome RedactRoomMessage(const Model::RedactRoomMessageRequest& request) const; /** * A Callable wrapper for RedactRoomMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RedactRoomMessageOutcomeCallable RedactRoomMessageCallable(const RedactRoomMessageRequestT& request) const { return SubmitCallable(&ChimeClient::RedactRoomMessage, request); } /** * An Async wrapper for RedactRoomMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RedactRoomMessageAsync(const RedactRoomMessageRequestT& request, const RedactRoomMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::RedactRoomMessage, request, handler, context); } /** *

Regenerates the security token for a bot.

See Also:

AWS * API Reference

*/ virtual Model::RegenerateSecurityTokenOutcome RegenerateSecurityToken(const Model::RegenerateSecurityTokenRequest& request) const; /** * A Callable wrapper for RegenerateSecurityToken that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegenerateSecurityTokenOutcomeCallable RegenerateSecurityTokenCallable(const RegenerateSecurityTokenRequestT& request) const { return SubmitCallable(&ChimeClient::RegenerateSecurityToken, request); } /** * An Async wrapper for RegenerateSecurityToken that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegenerateSecurityTokenAsync(const RegenerateSecurityTokenRequestT& request, const RegenerateSecurityTokenResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::RegenerateSecurityToken, request, handler, context); } /** *

Resets the personal meeting PIN for the specified user on an Amazon Chime * account. Returns the User object with the updated personal meeting * PIN.

See Also:

AWS * API Reference

*/ virtual Model::ResetPersonalPINOutcome ResetPersonalPIN(const Model::ResetPersonalPINRequest& request) const; /** * A Callable wrapper for ResetPersonalPIN that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetPersonalPINOutcomeCallable ResetPersonalPINCallable(const ResetPersonalPINRequestT& request) const { return SubmitCallable(&ChimeClient::ResetPersonalPIN, request); } /** * An Async wrapper for ResetPersonalPIN that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetPersonalPINAsync(const ResetPersonalPINRequestT& request, const ResetPersonalPINResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::ResetPersonalPIN, request, handler, context); } /** *

Moves a phone number from the Deletion queue back into the phone * number Inventory.

See Also:

AWS * API Reference

*/ virtual Model::RestorePhoneNumberOutcome RestorePhoneNumber(const Model::RestorePhoneNumberRequest& request) const; /** * A Callable wrapper for RestorePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestorePhoneNumberOutcomeCallable RestorePhoneNumberCallable(const RestorePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeClient::RestorePhoneNumber, request); } /** * An Async wrapper for RestorePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestorePhoneNumberAsync(const RestorePhoneNumberRequestT& request, const RestorePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::RestorePhoneNumber, request, handler, context); } /** *

Searches for phone numbers that can be ordered. For US numbers, provide at * least one of the following search filters: AreaCode, * City, State, or TollFreePrefix. If you * provide City, you must also provide State. Numbers * outside the US only support the PhoneNumberType filter, which you * must use.

See Also:

AWS * API Reference

*/ virtual Model::SearchAvailablePhoneNumbersOutcome SearchAvailablePhoneNumbers(const Model::SearchAvailablePhoneNumbersRequest& request) const; /** * A Callable wrapper for SearchAvailablePhoneNumbers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchAvailablePhoneNumbersOutcomeCallable SearchAvailablePhoneNumbersCallable(const SearchAvailablePhoneNumbersRequestT& request) const { return SubmitCallable(&ChimeClient::SearchAvailablePhoneNumbers, request); } /** * An Async wrapper for SearchAvailablePhoneNumbers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchAvailablePhoneNumbersAsync(const SearchAvailablePhoneNumbersRequestT& request, const SearchAvailablePhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::SearchAvailablePhoneNumbers, request, handler, context); } /** *

Updates account details for the specified Amazon Chime account. Currently, * only account name and default license updates are supported for this * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAccountOutcome UpdateAccount(const Model::UpdateAccountRequest& request) const; /** * A Callable wrapper for UpdateAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAccountOutcomeCallable UpdateAccountCallable(const UpdateAccountRequestT& request) const { return SubmitCallable(&ChimeClient::UpdateAccount, request); } /** * An Async wrapper for UpdateAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAccountAsync(const UpdateAccountRequestT& request, const UpdateAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdateAccount, request, handler, context); } /** *

Updates the settings for the specified Amazon Chime account. You can update * settings for remote control of shared screens, or for the dial-out option. For * more information about these settings, see Use the * Policies Page in the Amazon Chime Administration Guide.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request) const; /** * A Callable wrapper for UpdateAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request) const { return SubmitCallable(&ChimeClient::UpdateAccountSettings, request); } /** * An Async wrapper for UpdateAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAccountSettingsAsync(const UpdateAccountSettingsRequestT& request, const UpdateAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdateAccountSettings, request, handler, context); } /** *

Updates the status of the specified bot, such as starting or stopping the bot * from running in your Amazon Chime Enterprise account.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateBotOutcome UpdateBot(const Model::UpdateBotRequest& request) const; /** * A Callable wrapper for UpdateBot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateBotOutcomeCallable UpdateBotCallable(const UpdateBotRequestT& request) const { return SubmitCallable(&ChimeClient::UpdateBot, request); } /** * An Async wrapper for UpdateBot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateBotAsync(const UpdateBotRequestT& request, const UpdateBotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdateBot, request, handler, context); } /** *

Updates global settings for the administrator's AWS account, such as Amazon * Chime Business Calling and Amazon Chime Voice Connector settings.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateGlobalSettingsOutcome UpdateGlobalSettings(const Model::UpdateGlobalSettingsRequest& request) const; /** * A Callable wrapper for UpdateGlobalSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGlobalSettingsOutcomeCallable UpdateGlobalSettingsCallable(const UpdateGlobalSettingsRequestT& request) const { return SubmitCallable(&ChimeClient::UpdateGlobalSettings, request); } /** * An Async wrapper for UpdateGlobalSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGlobalSettingsAsync(const UpdateGlobalSettingsRequestT& request, const UpdateGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdateGlobalSettings, request, handler, context); } /** *

Updates phone number details, such as product type or calling name, for the * specified phone number ID. You can update one phone number detail at a time. For * example, you can update either the product type or the calling name in one * action.

For toll-free numbers, you cannot use the Amazon Chime Business * Calling product type. For numbers outside the U.S., you must use the Amazon * Chime SIP Media Application Dial-In product type.

Updates to outbound * calling names can take 72 hours to complete. Pending updates to outbound calling * names must be complete before you can request another update.

See * Also:

AWS * API Reference

*/ virtual Model::UpdatePhoneNumberOutcome UpdatePhoneNumber(const Model::UpdatePhoneNumberRequest& request) const; /** * A Callable wrapper for UpdatePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePhoneNumberOutcomeCallable UpdatePhoneNumberCallable(const UpdatePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeClient::UpdatePhoneNumber, request); } /** * An Async wrapper for UpdatePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePhoneNumberAsync(const UpdatePhoneNumberRequestT& request, const UpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdatePhoneNumber, request, handler, context); } /** *

Updates the phone number settings for the administrator's AWS account, such * as the default outbound calling name. You can update the default outbound * calling name once every seven days. Outbound calling names can take up to 72 * hours to update.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePhoneNumberSettingsOutcome UpdatePhoneNumberSettings(const Model::UpdatePhoneNumberSettingsRequest& request) const; /** * A Callable wrapper for UpdatePhoneNumberSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePhoneNumberSettingsOutcomeCallable UpdatePhoneNumberSettingsCallable(const UpdatePhoneNumberSettingsRequestT& request) const { return SubmitCallable(&ChimeClient::UpdatePhoneNumberSettings, request); } /** * An Async wrapper for UpdatePhoneNumberSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePhoneNumberSettingsAsync(const UpdatePhoneNumberSettingsRequestT& request, const UpdatePhoneNumberSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdatePhoneNumberSettings, request, handler, context); } /** *

Updates room details, such as the room name, for a room in an Amazon Chime * Enterprise account.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRoomOutcome UpdateRoom(const Model::UpdateRoomRequest& request) const; /** * A Callable wrapper for UpdateRoom that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRoomOutcomeCallable UpdateRoomCallable(const UpdateRoomRequestT& request) const { return SubmitCallable(&ChimeClient::UpdateRoom, request); } /** * An Async wrapper for UpdateRoom that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRoomAsync(const UpdateRoomRequestT& request, const UpdateRoomResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdateRoom, request, handler, context); } /** *

Updates room membership details, such as the member role, for a room in an * Amazon Chime Enterprise account. The member role designates whether the member * is a chat room administrator or a general chat room member. The member role can * be updated only for user IDs.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRoomMembershipOutcome UpdateRoomMembership(const Model::UpdateRoomMembershipRequest& request) const; /** * A Callable wrapper for UpdateRoomMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRoomMembershipOutcomeCallable UpdateRoomMembershipCallable(const UpdateRoomMembershipRequestT& request) const { return SubmitCallable(&ChimeClient::UpdateRoomMembership, request); } /** * An Async wrapper for UpdateRoomMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRoomMembershipAsync(const UpdateRoomMembershipRequestT& request, const UpdateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdateRoomMembership, request, handler, context); } /** *

Updates user details for a specified user ID. Currently, only * LicenseType updates are supported for this action.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const; /** * A Callable wrapper for UpdateUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const { return SubmitCallable(&ChimeClient::UpdateUser, request); } /** * An Async wrapper for UpdateUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdateUser, request, handler, context); } /** *

Updates the settings for the specified user, such as phone number * settings.

See Also:

AWS * API Reference

*/ virtual Model::UpdateUserSettingsOutcome UpdateUserSettings(const Model::UpdateUserSettingsRequest& request) const; /** * A Callable wrapper for UpdateUserSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateUserSettingsOutcomeCallable UpdateUserSettingsCallable(const UpdateUserSettingsRequestT& request) const { return SubmitCallable(&ChimeClient::UpdateUserSettings, request); } /** * An Async wrapper for UpdateUserSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateUserSettingsAsync(const UpdateUserSettingsRequestT& request, const UpdateUserSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeClient::UpdateUserSettings, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const ChimeClientConfiguration& clientConfiguration); ChimeClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Chime } // namespace Aws