ChimeClient.h

 
#pragma once
#include <aws/chime/ChimePaginationBase.h>
#include <aws/chime/ChimeServiceClientModel.h>
#include <aws/chime/ChimeWaiter.h>
#include <aws/chime/Chime_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace Chime {
class AWS_CHIME_API ChimeClient : public Aws::Client::AWSJsonClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<ChimeClient>,
                                  public ChimePaginationBase<ChimeClient>,
                                  public ChimeWaiter<ChimeClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ChimeClientConfiguration ClientConfigurationType;
  typedef ChimeEndpointProvider EndpointProviderType;
 
  ChimeClient(const Aws::Chime::ChimeClientConfiguration& clientConfiguration = Aws::Chime::ChimeClientConfiguration(),
              std::shared_ptr<ChimeEndpointProviderBase> endpointProvider = nullptr);
 
  ChimeClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<ChimeEndpointProviderBase> endpointProvider = nullptr,
              const Aws::Chime::ChimeClientConfiguration& clientConfiguration = Aws::Chime::ChimeClientConfiguration());
 
  ChimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              std::shared_ptr<ChimeEndpointProviderBase> endpointProvider = nullptr,
              const Aws::Chime::ChimeClientConfiguration& clientConfiguration = Aws::Chime::ChimeClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ChimeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ChimeClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ChimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ChimeClient();
 
  virtual Model::AssociatePhoneNumberWithUserOutcome AssociatePhoneNumberWithUser(
      const Model::AssociatePhoneNumberWithUserRequest& request) const;
 
  template <typename AssociatePhoneNumberWithUserRequestT = Model::AssociatePhoneNumberWithUserRequest>
  Model::AssociatePhoneNumberWithUserOutcomeCallable AssociatePhoneNumberWithUserCallable(
      const AssociatePhoneNumberWithUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::AssociatePhoneNumberWithUser, request);
  }
 
  template <typename AssociatePhoneNumberWithUserRequestT = Model::AssociatePhoneNumberWithUserRequest>
  void AssociatePhoneNumberWithUserAsync(const AssociatePhoneNumberWithUserRequestT& request,
                                         const AssociatePhoneNumberWithUserResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::AssociatePhoneNumberWithUser, request, handler, context);
  }
 
  virtual Model::AssociateSigninDelegateGroupsWithAccountOutcome AssociateSigninDelegateGroupsWithAccount(
      const Model::AssociateSigninDelegateGroupsWithAccountRequest& request) const;
 
  template <typename AssociateSigninDelegateGroupsWithAccountRequestT = Model::AssociateSigninDelegateGroupsWithAccountRequest>
  Model::AssociateSigninDelegateGroupsWithAccountOutcomeCallable AssociateSigninDelegateGroupsWithAccountCallable(
      const AssociateSigninDelegateGroupsWithAccountRequestT& request) const {
    return SubmitCallable(&ChimeClient::AssociateSigninDelegateGroupsWithAccount, request);
  }
 
  template <typename AssociateSigninDelegateGroupsWithAccountRequestT = Model::AssociateSigninDelegateGroupsWithAccountRequest>
  void AssociateSigninDelegateGroupsWithAccountAsync(
      const AssociateSigninDelegateGroupsWithAccountRequestT& request,
      const AssociateSigninDelegateGroupsWithAccountResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::AssociateSigninDelegateGroupsWithAccount, request, handler, context);
  }
 
  virtual Model::BatchCreateRoomMembershipOutcome BatchCreateRoomMembership(const Model::BatchCreateRoomMembershipRequest& request) const;
 
  template <typename BatchCreateRoomMembershipRequestT = Model::BatchCreateRoomMembershipRequest>
  Model::BatchCreateRoomMembershipOutcomeCallable BatchCreateRoomMembershipCallable(
      const BatchCreateRoomMembershipRequestT& request) const {
    return SubmitCallable(&ChimeClient::BatchCreateRoomMembership, request);
  }
 
  template <typename BatchCreateRoomMembershipRequestT = Model::BatchCreateRoomMembershipRequest>
  void BatchCreateRoomMembershipAsync(const BatchCreateRoomMembershipRequestT& request,
                                      const BatchCreateRoomMembershipResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::BatchCreateRoomMembership, request, handler, context);
  }
 
  virtual Model::BatchDeletePhoneNumberOutcome BatchDeletePhoneNumber(const Model::BatchDeletePhoneNumberRequest& request) const;
 
  template <typename BatchDeletePhoneNumberRequestT = Model::BatchDeletePhoneNumberRequest>
  Model::BatchDeletePhoneNumberOutcomeCallable BatchDeletePhoneNumberCallable(const BatchDeletePhoneNumberRequestT& request) const {
    return SubmitCallable(&ChimeClient::BatchDeletePhoneNumber, request);
  }
 
  template <typename BatchDeletePhoneNumberRequestT = Model::BatchDeletePhoneNumberRequest>
  void BatchDeletePhoneNumberAsync(const BatchDeletePhoneNumberRequestT& request,
                                   const BatchDeletePhoneNumberResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::BatchDeletePhoneNumber, request, handler, context);
  }
 
  virtual Model::BatchSuspendUserOutcome BatchSuspendUser(const Model::BatchSuspendUserRequest& request) const;
 
  template <typename BatchSuspendUserRequestT = Model::BatchSuspendUserRequest>
  Model::BatchSuspendUserOutcomeCallable BatchSuspendUserCallable(const BatchSuspendUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::BatchSuspendUser, request);
  }
 
  template <typename BatchSuspendUserRequestT = Model::BatchSuspendUserRequest>
  void BatchSuspendUserAsync(const BatchSuspendUserRequestT& request, const BatchSuspendUserResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::BatchSuspendUser, request, handler, context);
  }
 
  virtual Model::BatchUnsuspendUserOutcome BatchUnsuspendUser(const Model::BatchUnsuspendUserRequest& request) const;
 
  template <typename BatchUnsuspendUserRequestT = Model::BatchUnsuspendUserRequest>
  Model::BatchUnsuspendUserOutcomeCallable BatchUnsuspendUserCallable(const BatchUnsuspendUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::BatchUnsuspendUser, request);
  }
 
  template <typename BatchUnsuspendUserRequestT = Model::BatchUnsuspendUserRequest>
  void BatchUnsuspendUserAsync(const BatchUnsuspendUserRequestT& request, const BatchUnsuspendUserResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::BatchUnsuspendUser, request, handler, context);
  }
 
  virtual Model::BatchUpdatePhoneNumberOutcome BatchUpdatePhoneNumber(const Model::BatchUpdatePhoneNumberRequest& request) const;
 
  template <typename BatchUpdatePhoneNumberRequestT = Model::BatchUpdatePhoneNumberRequest>
  Model::BatchUpdatePhoneNumberOutcomeCallable BatchUpdatePhoneNumberCallable(const BatchUpdatePhoneNumberRequestT& request) const {
    return SubmitCallable(&ChimeClient::BatchUpdatePhoneNumber, request);
  }
 
  template <typename BatchUpdatePhoneNumberRequestT = Model::BatchUpdatePhoneNumberRequest>
  void BatchUpdatePhoneNumberAsync(const BatchUpdatePhoneNumberRequestT& request,
                                   const BatchUpdatePhoneNumberResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::BatchUpdatePhoneNumber, request, handler, context);
  }
 
  virtual Model::BatchUpdateUserOutcome BatchUpdateUser(const Model::BatchUpdateUserRequest& request) const;
 
  template <typename BatchUpdateUserRequestT = Model::BatchUpdateUserRequest>
  Model::BatchUpdateUserOutcomeCallable BatchUpdateUserCallable(const BatchUpdateUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::BatchUpdateUser, request);
  }
 
  template <typename BatchUpdateUserRequestT = Model::BatchUpdateUserRequest>
  void BatchUpdateUserAsync(const BatchUpdateUserRequestT& request, const BatchUpdateUserResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::BatchUpdateUser, request, handler, context);
  }
 
  virtual Model::CreateAccountOutcome CreateAccount(const Model::CreateAccountRequest& request) const;
 
  template <typename CreateAccountRequestT = Model::CreateAccountRequest>
  Model::CreateAccountOutcomeCallable CreateAccountCallable(const CreateAccountRequestT& request) const {
    return SubmitCallable(&ChimeClient::CreateAccount, request);
  }
 
  template <typename CreateAccountRequestT = Model::CreateAccountRequest>
  void CreateAccountAsync(const CreateAccountRequestT& request, const CreateAccountResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::CreateAccount, request, handler, context);
  }
 
  virtual Model::CreateBotOutcome CreateBot(const Model::CreateBotRequest& request) const;
 
  template <typename CreateBotRequestT = Model::CreateBotRequest>
  Model::CreateBotOutcomeCallable CreateBotCallable(const CreateBotRequestT& request) const {
    return SubmitCallable(&ChimeClient::CreateBot, request);
  }
 
  template <typename CreateBotRequestT = Model::CreateBotRequest>
  void CreateBotAsync(const CreateBotRequestT& request, const CreateBotResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::CreateBot, request, handler, context);
  }
 
  virtual Model::CreateMeetingDialOutOutcome CreateMeetingDialOut(const Model::CreateMeetingDialOutRequest& request) const;
 
  template <typename CreateMeetingDialOutRequestT = Model::CreateMeetingDialOutRequest>
  Model::CreateMeetingDialOutOutcomeCallable CreateMeetingDialOutCallable(const CreateMeetingDialOutRequestT& request) const {
    return SubmitCallable(&ChimeClient::CreateMeetingDialOut, request);
  }
 
  template <typename CreateMeetingDialOutRequestT = Model::CreateMeetingDialOutRequest>
  void CreateMeetingDialOutAsync(const CreateMeetingDialOutRequestT& request, const CreateMeetingDialOutResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::CreateMeetingDialOut, request, handler, context);
  }
 
  virtual Model::CreatePhoneNumberOrderOutcome CreatePhoneNumberOrder(const Model::CreatePhoneNumberOrderRequest& request) const;
 
  template <typename CreatePhoneNumberOrderRequestT = Model::CreatePhoneNumberOrderRequest>
  Model::CreatePhoneNumberOrderOutcomeCallable CreatePhoneNumberOrderCallable(const CreatePhoneNumberOrderRequestT& request) const {
    return SubmitCallable(&ChimeClient::CreatePhoneNumberOrder, request);
  }
 
  template <typename CreatePhoneNumberOrderRequestT = Model::CreatePhoneNumberOrderRequest>
  void CreatePhoneNumberOrderAsync(const CreatePhoneNumberOrderRequestT& request,
                                   const CreatePhoneNumberOrderResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::CreatePhoneNumberOrder, request, handler, context);
  }
 
  virtual Model::CreateRoomOutcome CreateRoom(const Model::CreateRoomRequest& request) const;
 
  template <typename CreateRoomRequestT = Model::CreateRoomRequest>
  Model::CreateRoomOutcomeCallable CreateRoomCallable(const CreateRoomRequestT& request) const {
    return SubmitCallable(&ChimeClient::CreateRoom, request);
  }
 
  template <typename CreateRoomRequestT = Model::CreateRoomRequest>
  void CreateRoomAsync(const CreateRoomRequestT& request, const CreateRoomResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::CreateRoom, request, handler, context);
  }
 
  virtual Model::CreateRoomMembershipOutcome CreateRoomMembership(const Model::CreateRoomMembershipRequest& request) const;
 
  template <typename CreateRoomMembershipRequestT = Model::CreateRoomMembershipRequest>
  Model::CreateRoomMembershipOutcomeCallable CreateRoomMembershipCallable(const CreateRoomMembershipRequestT& request) const {
    return SubmitCallable(&ChimeClient::CreateRoomMembership, request);
  }
 
  template <typename CreateRoomMembershipRequestT = Model::CreateRoomMembershipRequest>
  void CreateRoomMembershipAsync(const CreateRoomMembershipRequestT& request, const CreateRoomMembershipResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::CreateRoomMembership, request, handler, context);
  }
 
  virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::CreateUser, request);
  }
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::CreateUser, request, handler, context);
  }
 
  virtual Model::DeleteAccountOutcome DeleteAccount(const Model::DeleteAccountRequest& request) const;
 
  template <typename DeleteAccountRequestT = Model::DeleteAccountRequest>
  Model::DeleteAccountOutcomeCallable DeleteAccountCallable(const DeleteAccountRequestT& request) const {
    return SubmitCallable(&ChimeClient::DeleteAccount, request);
  }
 
  template <typename DeleteAccountRequestT = Model::DeleteAccountRequest>
  void DeleteAccountAsync(const DeleteAccountRequestT& request, const DeleteAccountResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::DeleteAccount, request, handler, context);
  }
 
  virtual Model::DeleteEventsConfigurationOutcome DeleteEventsConfiguration(const Model::DeleteEventsConfigurationRequest& request) const;
 
  template <typename DeleteEventsConfigurationRequestT = Model::DeleteEventsConfigurationRequest>
  Model::DeleteEventsConfigurationOutcomeCallable DeleteEventsConfigurationCallable(
      const DeleteEventsConfigurationRequestT& request) const {
    return SubmitCallable(&ChimeClient::DeleteEventsConfiguration, request);
  }
 
  template <typename DeleteEventsConfigurationRequestT = Model::DeleteEventsConfigurationRequest>
  void DeleteEventsConfigurationAsync(const DeleteEventsConfigurationRequestT& request,
                                      const DeleteEventsConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::DeleteEventsConfiguration, request, handler, context);
  }
 
  virtual Model::DeletePhoneNumberOutcome DeletePhoneNumber(const Model::DeletePhoneNumberRequest& request) const;
 
  template <typename DeletePhoneNumberRequestT = Model::DeletePhoneNumberRequest>
  Model::DeletePhoneNumberOutcomeCallable DeletePhoneNumberCallable(const DeletePhoneNumberRequestT& request) const {
    return SubmitCallable(&ChimeClient::DeletePhoneNumber, request);
  }
 
  template <typename DeletePhoneNumberRequestT = Model::DeletePhoneNumberRequest>
  void DeletePhoneNumberAsync(const DeletePhoneNumberRequestT& request, const DeletePhoneNumberResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::DeletePhoneNumber, request, handler, context);
  }
 
  virtual Model::DeleteRoomOutcome DeleteRoom(const Model::DeleteRoomRequest& request) const;
 
  template <typename DeleteRoomRequestT = Model::DeleteRoomRequest>
  Model::DeleteRoomOutcomeCallable DeleteRoomCallable(const DeleteRoomRequestT& request) const {
    return SubmitCallable(&ChimeClient::DeleteRoom, request);
  }
 
  template <typename DeleteRoomRequestT = Model::DeleteRoomRequest>
  void DeleteRoomAsync(const DeleteRoomRequestT& request, const DeleteRoomResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::DeleteRoom, request, handler, context);
  }
 
  virtual Model::DeleteRoomMembershipOutcome DeleteRoomMembership(const Model::DeleteRoomMembershipRequest& request) const;
 
  template <typename DeleteRoomMembershipRequestT = Model::DeleteRoomMembershipRequest>
  Model::DeleteRoomMembershipOutcomeCallable DeleteRoomMembershipCallable(const DeleteRoomMembershipRequestT& request) const {
    return SubmitCallable(&ChimeClient::DeleteRoomMembership, request);
  }
 
  template <typename DeleteRoomMembershipRequestT = Model::DeleteRoomMembershipRequest>
  void DeleteRoomMembershipAsync(const DeleteRoomMembershipRequestT& request, const DeleteRoomMembershipResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::DeleteRoomMembership, request, handler, context);
  }
 
  virtual Model::DisassociatePhoneNumberFromUserOutcome DisassociatePhoneNumberFromUser(
      const Model::DisassociatePhoneNumberFromUserRequest& request) const;
 
  template <typename DisassociatePhoneNumberFromUserRequestT = Model::DisassociatePhoneNumberFromUserRequest>
  Model::DisassociatePhoneNumberFromUserOutcomeCallable DisassociatePhoneNumberFromUserCallable(
      const DisassociatePhoneNumberFromUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::DisassociatePhoneNumberFromUser, request);
  }
 
  template <typename DisassociatePhoneNumberFromUserRequestT = Model::DisassociatePhoneNumberFromUserRequest>
  void DisassociatePhoneNumberFromUserAsync(const DisassociatePhoneNumberFromUserRequestT& request,
                                            const DisassociatePhoneNumberFromUserResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::DisassociatePhoneNumberFromUser, request, handler, context);
  }
 
  virtual Model::DisassociateSigninDelegateGroupsFromAccountOutcome DisassociateSigninDelegateGroupsFromAccount(
      const Model::DisassociateSigninDelegateGroupsFromAccountRequest& request) const;
 
  template <typename DisassociateSigninDelegateGroupsFromAccountRequestT = Model::DisassociateSigninDelegateGroupsFromAccountRequest>
  Model::DisassociateSigninDelegateGroupsFromAccountOutcomeCallable DisassociateSigninDelegateGroupsFromAccountCallable(
      const DisassociateSigninDelegateGroupsFromAccountRequestT& request) const {
    return SubmitCallable(&ChimeClient::DisassociateSigninDelegateGroupsFromAccount, request);
  }
 
  template <typename DisassociateSigninDelegateGroupsFromAccountRequestT = Model::DisassociateSigninDelegateGroupsFromAccountRequest>
  void DisassociateSigninDelegateGroupsFromAccountAsync(
      const DisassociateSigninDelegateGroupsFromAccountRequestT& request,
      const DisassociateSigninDelegateGroupsFromAccountResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::DisassociateSigninDelegateGroupsFromAccount, request, handler, context);
  }
 
  virtual Model::GetAccountOutcome GetAccount(const Model::GetAccountRequest& request) const;
 
  template <typename GetAccountRequestT = Model::GetAccountRequest>
  Model::GetAccountOutcomeCallable GetAccountCallable(const GetAccountRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetAccount, request);
  }
 
  template <typename GetAccountRequestT = Model::GetAccountRequest>
  void GetAccountAsync(const GetAccountRequestT& request, const GetAccountResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetAccount, request, handler, context);
  }
 
  virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request) const;
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetAccountSettings, request);
  }
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  void GetAccountSettingsAsync(const GetAccountSettingsRequestT& request, const GetAccountSettingsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetAccountSettings, request, handler, context);
  }
 
  virtual Model::GetBotOutcome GetBot(const Model::GetBotRequest& request) const;
 
  template <typename GetBotRequestT = Model::GetBotRequest>
  Model::GetBotOutcomeCallable GetBotCallable(const GetBotRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetBot, request);
  }
 
  template <typename GetBotRequestT = Model::GetBotRequest>
  void GetBotAsync(const GetBotRequestT& request, const GetBotResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetBot, request, handler, context);
  }
 
  virtual Model::GetEventsConfigurationOutcome GetEventsConfiguration(const Model::GetEventsConfigurationRequest& request) const;
 
  template <typename GetEventsConfigurationRequestT = Model::GetEventsConfigurationRequest>
  Model::GetEventsConfigurationOutcomeCallable GetEventsConfigurationCallable(const GetEventsConfigurationRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetEventsConfiguration, request);
  }
 
  template <typename GetEventsConfigurationRequestT = Model::GetEventsConfigurationRequest>
  void GetEventsConfigurationAsync(const GetEventsConfigurationRequestT& request,
                                   const GetEventsConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetEventsConfiguration, request, handler, context);
  }
 
  virtual Model::GetGlobalSettingsOutcome GetGlobalSettings(const Model::GetGlobalSettingsRequest& request = {}) const;
 
  template <typename GetGlobalSettingsRequestT = Model::GetGlobalSettingsRequest>
  Model::GetGlobalSettingsOutcomeCallable GetGlobalSettingsCallable(const GetGlobalSettingsRequestT& request = {}) const {
    return SubmitCallable(&ChimeClient::GetGlobalSettings, request);
  }
 
  template <typename GetGlobalSettingsRequestT = Model::GetGlobalSettingsRequest>
  void GetGlobalSettingsAsync(const GetGlobalSettingsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetGlobalSettingsRequestT& request = {}) const {
    return SubmitAsync(&ChimeClient::GetGlobalSettings, request, handler, context);
  }
 
  virtual Model::GetPhoneNumberOutcome GetPhoneNumber(const Model::GetPhoneNumberRequest& request) const;
 
  template <typename GetPhoneNumberRequestT = Model::GetPhoneNumberRequest>
  Model::GetPhoneNumberOutcomeCallable GetPhoneNumberCallable(const GetPhoneNumberRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetPhoneNumber, request);
  }
 
  template <typename GetPhoneNumberRequestT = Model::GetPhoneNumberRequest>
  void GetPhoneNumberAsync(const GetPhoneNumberRequestT& request, const GetPhoneNumberResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetPhoneNumber, request, handler, context);
  }
 
  virtual Model::GetPhoneNumberOrderOutcome GetPhoneNumberOrder(const Model::GetPhoneNumberOrderRequest& request) const;
 
  template <typename GetPhoneNumberOrderRequestT = Model::GetPhoneNumberOrderRequest>
  Model::GetPhoneNumberOrderOutcomeCallable GetPhoneNumberOrderCallable(const GetPhoneNumberOrderRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetPhoneNumberOrder, request);
  }
 
  template <typename GetPhoneNumberOrderRequestT = Model::GetPhoneNumberOrderRequest>
  void GetPhoneNumberOrderAsync(const GetPhoneNumberOrderRequestT& request, const GetPhoneNumberOrderResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetPhoneNumberOrder, request, handler, context);
  }
 
  virtual Model::GetPhoneNumberSettingsOutcome GetPhoneNumberSettings(const Model::GetPhoneNumberSettingsRequest& request = {}) const;
 
  template <typename GetPhoneNumberSettingsRequestT = Model::GetPhoneNumberSettingsRequest>
  Model::GetPhoneNumberSettingsOutcomeCallable GetPhoneNumberSettingsCallable(const GetPhoneNumberSettingsRequestT& request = {}) const {
    return SubmitCallable(&ChimeClient::GetPhoneNumberSettings, request);
  }
 
  template <typename GetPhoneNumberSettingsRequestT = Model::GetPhoneNumberSettingsRequest>
  void GetPhoneNumberSettingsAsync(const GetPhoneNumberSettingsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const GetPhoneNumberSettingsRequestT& request = {}) const {
    return SubmitAsync(&ChimeClient::GetPhoneNumberSettings, request, handler, context);
  }
 
  virtual Model::GetRetentionSettingsOutcome GetRetentionSettings(const Model::GetRetentionSettingsRequest& request) const;
 
  template <typename GetRetentionSettingsRequestT = Model::GetRetentionSettingsRequest>
  Model::GetRetentionSettingsOutcomeCallable GetRetentionSettingsCallable(const GetRetentionSettingsRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetRetentionSettings, request);
  }
 
  template <typename GetRetentionSettingsRequestT = Model::GetRetentionSettingsRequest>
  void GetRetentionSettingsAsync(const GetRetentionSettingsRequestT& request, const GetRetentionSettingsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetRetentionSettings, request, handler, context);
  }
 
  virtual Model::GetRoomOutcome GetRoom(const Model::GetRoomRequest& request) const;
 
  template <typename GetRoomRequestT = Model::GetRoomRequest>
  Model::GetRoomOutcomeCallable GetRoomCallable(const GetRoomRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetRoom, request);
  }
 
  template <typename GetRoomRequestT = Model::GetRoomRequest>
  void GetRoomAsync(const GetRoomRequestT& request, const GetRoomResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetRoom, request, handler, context);
  }
 
  virtual Model::GetUserOutcome GetUser(const Model::GetUserRequest& request) const;
 
  template <typename GetUserRequestT = Model::GetUserRequest>
  Model::GetUserOutcomeCallable GetUserCallable(const GetUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetUser, request);
  }
 
  template <typename GetUserRequestT = Model::GetUserRequest>
  void GetUserAsync(const GetUserRequestT& request, const GetUserResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetUser, request, handler, context);
  }
 
  virtual Model::GetUserSettingsOutcome GetUserSettings(const Model::GetUserSettingsRequest& request) const;
 
  template <typename GetUserSettingsRequestT = Model::GetUserSettingsRequest>
  Model::GetUserSettingsOutcomeCallable GetUserSettingsCallable(const GetUserSettingsRequestT& request) const {
    return SubmitCallable(&ChimeClient::GetUserSettings, request);
  }
 
  template <typename GetUserSettingsRequestT = Model::GetUserSettingsRequest>
  void GetUserSettingsAsync(const GetUserSettingsRequestT& request, const GetUserSettingsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::GetUserSettings, request, handler, context);
  }
 
  virtual Model::InviteUsersOutcome InviteUsers(const Model::InviteUsersRequest& request) const;
 
  template <typename InviteUsersRequestT = Model::InviteUsersRequest>
  Model::InviteUsersOutcomeCallable InviteUsersCallable(const InviteUsersRequestT& request) const {
    return SubmitCallable(&ChimeClient::InviteUsers, request);
  }
 
  template <typename InviteUsersRequestT = Model::InviteUsersRequest>
  void InviteUsersAsync(const InviteUsersRequestT& request, const InviteUsersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::InviteUsers, request, handler, context);
  }
 
  virtual Model::ListAccountsOutcome ListAccounts(const Model::ListAccountsRequest& request = {}) const;
 
  template <typename ListAccountsRequestT = Model::ListAccountsRequest>
  Model::ListAccountsOutcomeCallable ListAccountsCallable(const ListAccountsRequestT& request = {}) const {
    return SubmitCallable(&ChimeClient::ListAccounts, request);
  }
 
  template <typename ListAccountsRequestT = Model::ListAccountsRequest>
  void ListAccountsAsync(const ListAccountsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListAccountsRequestT& request = {}) const {
    return SubmitAsync(&ChimeClient::ListAccounts, request, handler, context);
  }
 
  virtual Model::ListBotsOutcome ListBots(const Model::ListBotsRequest& request) const;
 
  template <typename ListBotsRequestT = Model::ListBotsRequest>
  Model::ListBotsOutcomeCallable ListBotsCallable(const ListBotsRequestT& request) const {
    return SubmitCallable(&ChimeClient::ListBots, request);
  }
 
  template <typename ListBotsRequestT = Model::ListBotsRequest>
  void ListBotsAsync(const ListBotsRequestT& request, const ListBotsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::ListBots, request, handler, context);
  }
 
  virtual Model::ListPhoneNumberOrdersOutcome ListPhoneNumberOrders(const Model::ListPhoneNumberOrdersRequest& request = {}) const;
 
  template <typename ListPhoneNumberOrdersRequestT = Model::ListPhoneNumberOrdersRequest>
  Model::ListPhoneNumberOrdersOutcomeCallable ListPhoneNumberOrdersCallable(const ListPhoneNumberOrdersRequestT& request = {}) const {
    return SubmitCallable(&ChimeClient::ListPhoneNumberOrders, request);
  }
 
  template <typename ListPhoneNumberOrdersRequestT = Model::ListPhoneNumberOrdersRequest>
  void ListPhoneNumberOrdersAsync(const ListPhoneNumberOrdersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListPhoneNumberOrdersRequestT& request = {}) const {
    return SubmitAsync(&ChimeClient::ListPhoneNumberOrders, request, handler, context);
  }
 
  virtual Model::ListPhoneNumbersOutcome ListPhoneNumbers(const Model::ListPhoneNumbersRequest& request = {}) const;
 
  template <typename ListPhoneNumbersRequestT = Model::ListPhoneNumbersRequest>
  Model::ListPhoneNumbersOutcomeCallable ListPhoneNumbersCallable(const ListPhoneNumbersRequestT& request = {}) const {
    return SubmitCallable(&ChimeClient::ListPhoneNumbers, request);
  }
 
  template <typename ListPhoneNumbersRequestT = Model::ListPhoneNumbersRequest>
  void ListPhoneNumbersAsync(const ListPhoneNumbersResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListPhoneNumbersRequestT& request = {}) const {
    return SubmitAsync(&ChimeClient::ListPhoneNumbers, request, handler, context);
  }
 
  virtual Model::ListRoomMembershipsOutcome ListRoomMemberships(const Model::ListRoomMembershipsRequest& request) const;
 
  template <typename ListRoomMembershipsRequestT = Model::ListRoomMembershipsRequest>
  Model::ListRoomMembershipsOutcomeCallable ListRoomMembershipsCallable(const ListRoomMembershipsRequestT& request) const {
    return SubmitCallable(&ChimeClient::ListRoomMemberships, request);
  }
 
  template <typename ListRoomMembershipsRequestT = Model::ListRoomMembershipsRequest>
  void ListRoomMembershipsAsync(const ListRoomMembershipsRequestT& request, const ListRoomMembershipsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::ListRoomMemberships, request, handler, context);
  }
 
  virtual Model::ListRoomsOutcome ListRooms(const Model::ListRoomsRequest& request) const;
 
  template <typename ListRoomsRequestT = Model::ListRoomsRequest>
  Model::ListRoomsOutcomeCallable ListRoomsCallable(const ListRoomsRequestT& request) const {
    return SubmitCallable(&ChimeClient::ListRooms, request);
  }
 
  template <typename ListRoomsRequestT = Model::ListRoomsRequest>
  void ListRoomsAsync(const ListRoomsRequestT& request, const ListRoomsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::ListRooms, request, handler, context);
  }
 
  virtual Model::ListSupportedPhoneNumberCountriesOutcome ListSupportedPhoneNumberCountries(
      const Model::ListSupportedPhoneNumberCountriesRequest& request) const;
 
  template <typename ListSupportedPhoneNumberCountriesRequestT = Model::ListSupportedPhoneNumberCountriesRequest>
  Model::ListSupportedPhoneNumberCountriesOutcomeCallable ListSupportedPhoneNumberCountriesCallable(
      const ListSupportedPhoneNumberCountriesRequestT& request) const {
    return SubmitCallable(&ChimeClient::ListSupportedPhoneNumberCountries, request);
  }
 
  template <typename ListSupportedPhoneNumberCountriesRequestT = Model::ListSupportedPhoneNumberCountriesRequest>
  void ListSupportedPhoneNumberCountriesAsync(const ListSupportedPhoneNumberCountriesRequestT& request,
                                              const ListSupportedPhoneNumberCountriesResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::ListSupportedPhoneNumberCountries, request, handler, context);
  }
 
  virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const {
    return SubmitCallable(&ChimeClient::ListUsers, request);
  }
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::ListUsers, request, handler, context);
  }
 
  virtual Model::LogoutUserOutcome LogoutUser(const Model::LogoutUserRequest& request) const;
 
  template <typename LogoutUserRequestT = Model::LogoutUserRequest>
  Model::LogoutUserOutcomeCallable LogoutUserCallable(const LogoutUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::LogoutUser, request);
  }
 
  template <typename LogoutUserRequestT = Model::LogoutUserRequest>
  void LogoutUserAsync(const LogoutUserRequestT& request, const LogoutUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::LogoutUser, request, handler, context);
  }
 
  virtual Model::PutEventsConfigurationOutcome PutEventsConfiguration(const Model::PutEventsConfigurationRequest& request) const;
 
  template <typename PutEventsConfigurationRequestT = Model::PutEventsConfigurationRequest>
  Model::PutEventsConfigurationOutcomeCallable PutEventsConfigurationCallable(const PutEventsConfigurationRequestT& request) const {
    return SubmitCallable(&ChimeClient::PutEventsConfiguration, request);
  }
 
  template <typename PutEventsConfigurationRequestT = Model::PutEventsConfigurationRequest>
  void PutEventsConfigurationAsync(const PutEventsConfigurationRequestT& request,
                                   const PutEventsConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::PutEventsConfiguration, request, handler, context);
  }
 
  virtual Model::PutRetentionSettingsOutcome PutRetentionSettings(const Model::PutRetentionSettingsRequest& request) const;
 
  template <typename PutRetentionSettingsRequestT = Model::PutRetentionSettingsRequest>
  Model::PutRetentionSettingsOutcomeCallable PutRetentionSettingsCallable(const PutRetentionSettingsRequestT& request) const {
    return SubmitCallable(&ChimeClient::PutRetentionSettings, request);
  }
 
  template <typename PutRetentionSettingsRequestT = Model::PutRetentionSettingsRequest>
  void PutRetentionSettingsAsync(const PutRetentionSettingsRequestT& request, const PutRetentionSettingsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::PutRetentionSettings, request, handler, context);
  }
 
  virtual Model::RedactConversationMessageOutcome RedactConversationMessage(const Model::RedactConversationMessageRequest& request) const;
 
  template <typename RedactConversationMessageRequestT = Model::RedactConversationMessageRequest>
  Model::RedactConversationMessageOutcomeCallable RedactConversationMessageCallable(
      const RedactConversationMessageRequestT& request) const {
    return SubmitCallable(&ChimeClient::RedactConversationMessage, request);
  }
 
  template <typename RedactConversationMessageRequestT = Model::RedactConversationMessageRequest>
  void RedactConversationMessageAsync(const RedactConversationMessageRequestT& request,
                                      const RedactConversationMessageResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::RedactConversationMessage, request, handler, context);
  }
 
  virtual Model::RedactRoomMessageOutcome RedactRoomMessage(const Model::RedactRoomMessageRequest& request) const;
 
  template <typename RedactRoomMessageRequestT = Model::RedactRoomMessageRequest>
  Model::RedactRoomMessageOutcomeCallable RedactRoomMessageCallable(const RedactRoomMessageRequestT& request) const {
    return SubmitCallable(&ChimeClient::RedactRoomMessage, request);
  }
 
  template <typename RedactRoomMessageRequestT = Model::RedactRoomMessageRequest>
  void RedactRoomMessageAsync(const RedactRoomMessageRequestT& request, const RedactRoomMessageResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::RedactRoomMessage, request, handler, context);
  }
 
  virtual Model::RegenerateSecurityTokenOutcome RegenerateSecurityToken(const Model::RegenerateSecurityTokenRequest& request) const;
 
  template <typename RegenerateSecurityTokenRequestT = Model::RegenerateSecurityTokenRequest>
  Model::RegenerateSecurityTokenOutcomeCallable RegenerateSecurityTokenCallable(const RegenerateSecurityTokenRequestT& request) const {
    return SubmitCallable(&ChimeClient::RegenerateSecurityToken, request);
  }
 
  template <typename RegenerateSecurityTokenRequestT = Model::RegenerateSecurityTokenRequest>
  void RegenerateSecurityTokenAsync(const RegenerateSecurityTokenRequestT& request,
                                    const RegenerateSecurityTokenResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::RegenerateSecurityToken, request, handler, context);
  }
 
  virtual Model::ResetPersonalPINOutcome ResetPersonalPIN(const Model::ResetPersonalPINRequest& request) const;
 
  template <typename ResetPersonalPINRequestT = Model::ResetPersonalPINRequest>
  Model::ResetPersonalPINOutcomeCallable ResetPersonalPINCallable(const ResetPersonalPINRequestT& request) const {
    return SubmitCallable(&ChimeClient::ResetPersonalPIN, request);
  }
 
  template <typename ResetPersonalPINRequestT = Model::ResetPersonalPINRequest>
  void ResetPersonalPINAsync(const ResetPersonalPINRequestT& request, const ResetPersonalPINResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::ResetPersonalPIN, request, handler, context);
  }
 
  virtual Model::RestorePhoneNumberOutcome RestorePhoneNumber(const Model::RestorePhoneNumberRequest& request) const;
 
  template <typename RestorePhoneNumberRequestT = Model::RestorePhoneNumberRequest>
  Model::RestorePhoneNumberOutcomeCallable RestorePhoneNumberCallable(const RestorePhoneNumberRequestT& request) const {
    return SubmitCallable(&ChimeClient::RestorePhoneNumber, request);
  }
 
  template <typename RestorePhoneNumberRequestT = Model::RestorePhoneNumberRequest>
  void RestorePhoneNumberAsync(const RestorePhoneNumberRequestT& request, const RestorePhoneNumberResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::RestorePhoneNumber, request, handler, context);
  }
 
  virtual Model::SearchAvailablePhoneNumbersOutcome SearchAvailablePhoneNumbers(
      const Model::SearchAvailablePhoneNumbersRequest& request = {}) const;
 
  template <typename SearchAvailablePhoneNumbersRequestT = Model::SearchAvailablePhoneNumbersRequest>
  Model::SearchAvailablePhoneNumbersOutcomeCallable SearchAvailablePhoneNumbersCallable(
      const SearchAvailablePhoneNumbersRequestT& request = {}) const {
    return SubmitCallable(&ChimeClient::SearchAvailablePhoneNumbers, request);
  }
 
  template <typename SearchAvailablePhoneNumbersRequestT = Model::SearchAvailablePhoneNumbersRequest>
  void SearchAvailablePhoneNumbersAsync(const SearchAvailablePhoneNumbersResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const SearchAvailablePhoneNumbersRequestT& request = {}) const {
    return SubmitAsync(&ChimeClient::SearchAvailablePhoneNumbers, request, handler, context);
  }
 
  virtual Model::UpdateAccountOutcome UpdateAccount(const Model::UpdateAccountRequest& request) const;
 
  template <typename UpdateAccountRequestT = Model::UpdateAccountRequest>
  Model::UpdateAccountOutcomeCallable UpdateAccountCallable(const UpdateAccountRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdateAccount, request);
  }
 
  template <typename UpdateAccountRequestT = Model::UpdateAccountRequest>
  void UpdateAccountAsync(const UpdateAccountRequestT& request, const UpdateAccountResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdateAccount, request, handler, context);
  }
 
  virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request) const;
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdateAccountSettings, request);
  }
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  void UpdateAccountSettingsAsync(const UpdateAccountSettingsRequestT& request, const UpdateAccountSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdateAccountSettings, request, handler, context);
  }
 
  virtual Model::UpdateBotOutcome UpdateBot(const Model::UpdateBotRequest& request) const;
 
  template <typename UpdateBotRequestT = Model::UpdateBotRequest>
  Model::UpdateBotOutcomeCallable UpdateBotCallable(const UpdateBotRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdateBot, request);
  }
 
  template <typename UpdateBotRequestT = Model::UpdateBotRequest>
  void UpdateBotAsync(const UpdateBotRequestT& request, const UpdateBotResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdateBot, request, handler, context);
  }
 
  virtual Model::UpdateGlobalSettingsOutcome UpdateGlobalSettings(const Model::UpdateGlobalSettingsRequest& request = {}) const;
 
  template <typename UpdateGlobalSettingsRequestT = Model::UpdateGlobalSettingsRequest>
  Model::UpdateGlobalSettingsOutcomeCallable UpdateGlobalSettingsCallable(const UpdateGlobalSettingsRequestT& request = {}) const {
    return SubmitCallable(&ChimeClient::UpdateGlobalSettings, request);
  }
 
  template <typename UpdateGlobalSettingsRequestT = Model::UpdateGlobalSettingsRequest>
  void UpdateGlobalSettingsAsync(const UpdateGlobalSettingsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const UpdateGlobalSettingsRequestT& request = {}) const {
    return SubmitAsync(&ChimeClient::UpdateGlobalSettings, request, handler, context);
  }
 
  virtual Model::UpdatePhoneNumberOutcome UpdatePhoneNumber(const Model::UpdatePhoneNumberRequest& request) const;
 
  template <typename UpdatePhoneNumberRequestT = Model::UpdatePhoneNumberRequest>
  Model::UpdatePhoneNumberOutcomeCallable UpdatePhoneNumberCallable(const UpdatePhoneNumberRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdatePhoneNumber, request);
  }
 
  template <typename UpdatePhoneNumberRequestT = Model::UpdatePhoneNumberRequest>
  void UpdatePhoneNumberAsync(const UpdatePhoneNumberRequestT& request, const UpdatePhoneNumberResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdatePhoneNumber, request, handler, context);
  }
 
  virtual Model::UpdatePhoneNumberSettingsOutcome UpdatePhoneNumberSettings(const Model::UpdatePhoneNumberSettingsRequest& request) const;
 
  template <typename UpdatePhoneNumberSettingsRequestT = Model::UpdatePhoneNumberSettingsRequest>
  Model::UpdatePhoneNumberSettingsOutcomeCallable UpdatePhoneNumberSettingsCallable(
      const UpdatePhoneNumberSettingsRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdatePhoneNumberSettings, request);
  }
 
  template <typename UpdatePhoneNumberSettingsRequestT = Model::UpdatePhoneNumberSettingsRequest>
  void UpdatePhoneNumberSettingsAsync(const UpdatePhoneNumberSettingsRequestT& request,
                                      const UpdatePhoneNumberSettingsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdatePhoneNumberSettings, request, handler, context);
  }
 
  virtual Model::UpdateRoomOutcome UpdateRoom(const Model::UpdateRoomRequest& request) const;
 
  template <typename UpdateRoomRequestT = Model::UpdateRoomRequest>
  Model::UpdateRoomOutcomeCallable UpdateRoomCallable(const UpdateRoomRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdateRoom, request);
  }
 
  template <typename UpdateRoomRequestT = Model::UpdateRoomRequest>
  void UpdateRoomAsync(const UpdateRoomRequestT& request, const UpdateRoomResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdateRoom, request, handler, context);
  }
 
  virtual Model::UpdateRoomMembershipOutcome UpdateRoomMembership(const Model::UpdateRoomMembershipRequest& request) const;
 
  template <typename UpdateRoomMembershipRequestT = Model::UpdateRoomMembershipRequest>
  Model::UpdateRoomMembershipOutcomeCallable UpdateRoomMembershipCallable(const UpdateRoomMembershipRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdateRoomMembership, request);
  }
 
  template <typename UpdateRoomMembershipRequestT = Model::UpdateRoomMembershipRequest>
  void UpdateRoomMembershipAsync(const UpdateRoomMembershipRequestT& request, const UpdateRoomMembershipResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdateRoomMembership, request, handler, context);
  }
 
  virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const;
 
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdateUser, request);
  }
 
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdateUser, request, handler, context);
  }
 
  virtual Model::UpdateUserSettingsOutcome UpdateUserSettings(const Model::UpdateUserSettingsRequest& request) const;
 
  template <typename UpdateUserSettingsRequestT = Model::UpdateUserSettingsRequest>
  Model::UpdateUserSettingsOutcomeCallable UpdateUserSettingsCallable(const UpdateUserSettingsRequestT& request) const {
    return SubmitCallable(&ChimeClient::UpdateUserSettings, request);
  }
 
  template <typename UpdateUserSettingsRequestT = Model::UpdateUserSettingsRequest>
  void UpdateUserSettingsAsync(const UpdateUserSettingsRequestT& request, const UpdateUserSettingsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChimeClient::UpdateUserSettings, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ChimeEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ChimeClient>;
  void init(const ChimeClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ChimeError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ChimeClientConfiguration m_clientConfiguration;
  std::shared_ptr<ChimeEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Chime
}  // namespace Aws