WickrClient.h

 
#pragma once
#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>
#include <aws/wickr/WickrPaginationBase.h>
#include <aws/wickr/WickrServiceClientModel.h>
#include <aws/wickr/WickrWaiter.h>
#include <aws/wickr/Wickr_EXPORTS.h>
 
namespace Aws {
namespace Wickr {
class AWS_WICKR_API WickrClient : public Aws::Client::AWSJsonClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<WickrClient>,
                                  public WickrPaginationBase<WickrClient>,
                                  public WickrWaiter<WickrClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef WickrClientConfiguration ClientConfigurationType;
  typedef WickrEndpointProvider EndpointProviderType;
 
  WickrClient(const Aws::Wickr::WickrClientConfiguration& clientConfiguration = Aws::Wickr::WickrClientConfiguration(),
              std::shared_ptr<WickrEndpointProviderBase> endpointProvider = nullptr);
 
  WickrClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<WickrEndpointProviderBase> endpointProvider = nullptr,
              const Aws::Wickr::WickrClientConfiguration& clientConfiguration = Aws::Wickr::WickrClientConfiguration());
 
  WickrClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              std::shared_ptr<WickrEndpointProviderBase> endpointProvider = nullptr,
              const Aws::Wickr::WickrClientConfiguration& clientConfiguration = Aws::Wickr::WickrClientConfiguration());
 
  /* Legacy constructors due deprecation */
  WickrClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  WickrClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  WickrClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~WickrClient();
 
  virtual Model::BatchCreateUserOutcome BatchCreateUser(const Model::BatchCreateUserRequest& request) const;
 
  template <typename BatchCreateUserRequestT = Model::BatchCreateUserRequest>
  Model::BatchCreateUserOutcomeCallable BatchCreateUserCallable(const BatchCreateUserRequestT& request) const {
    return SubmitCallable(&WickrClient::BatchCreateUser, request);
  }
 
  template <typename BatchCreateUserRequestT = Model::BatchCreateUserRequest>
  void BatchCreateUserAsync(const BatchCreateUserRequestT& request, const BatchCreateUserResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::BatchCreateUser, request, handler, context);
  }
 
  virtual Model::BatchDeleteUserOutcome BatchDeleteUser(const Model::BatchDeleteUserRequest& request) const;
 
  template <typename BatchDeleteUserRequestT = Model::BatchDeleteUserRequest>
  Model::BatchDeleteUserOutcomeCallable BatchDeleteUserCallable(const BatchDeleteUserRequestT& request) const {
    return SubmitCallable(&WickrClient::BatchDeleteUser, request);
  }
 
  template <typename BatchDeleteUserRequestT = Model::BatchDeleteUserRequest>
  void BatchDeleteUserAsync(const BatchDeleteUserRequestT& request, const BatchDeleteUserResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::BatchDeleteUser, request, handler, context);
  }
 
  virtual Model::BatchLookupUserUnameOutcome BatchLookupUserUname(const Model::BatchLookupUserUnameRequest& request) const;
 
  template <typename BatchLookupUserUnameRequestT = Model::BatchLookupUserUnameRequest>
  Model::BatchLookupUserUnameOutcomeCallable BatchLookupUserUnameCallable(const BatchLookupUserUnameRequestT& request) const {
    return SubmitCallable(&WickrClient::BatchLookupUserUname, request);
  }
 
  template <typename BatchLookupUserUnameRequestT = Model::BatchLookupUserUnameRequest>
  void BatchLookupUserUnameAsync(const BatchLookupUserUnameRequestT& request, const BatchLookupUserUnameResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::BatchLookupUserUname, request, handler, context);
  }
 
  virtual Model::BatchReinviteUserOutcome BatchReinviteUser(const Model::BatchReinviteUserRequest& request) const;
 
  template <typename BatchReinviteUserRequestT = Model::BatchReinviteUserRequest>
  Model::BatchReinviteUserOutcomeCallable BatchReinviteUserCallable(const BatchReinviteUserRequestT& request) const {
    return SubmitCallable(&WickrClient::BatchReinviteUser, request);
  }
 
  template <typename BatchReinviteUserRequestT = Model::BatchReinviteUserRequest>
  void BatchReinviteUserAsync(const BatchReinviteUserRequestT& request, const BatchReinviteUserResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::BatchReinviteUser, request, handler, context);
  }
 
  virtual Model::BatchResetDevicesForUserOutcome BatchResetDevicesForUser(const Model::BatchResetDevicesForUserRequest& request) const;
 
  template <typename BatchResetDevicesForUserRequestT = Model::BatchResetDevicesForUserRequest>
  Model::BatchResetDevicesForUserOutcomeCallable BatchResetDevicesForUserCallable(const BatchResetDevicesForUserRequestT& request) const {
    return SubmitCallable(&WickrClient::BatchResetDevicesForUser, request);
  }
 
  template <typename BatchResetDevicesForUserRequestT = Model::BatchResetDevicesForUserRequest>
  void BatchResetDevicesForUserAsync(const BatchResetDevicesForUserRequestT& request,
                                     const BatchResetDevicesForUserResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::BatchResetDevicesForUser, request, handler, context);
  }
 
  virtual Model::BatchToggleUserSuspendStatusOutcome BatchToggleUserSuspendStatus(
      const Model::BatchToggleUserSuspendStatusRequest& request) const;
 
  template <typename BatchToggleUserSuspendStatusRequestT = Model::BatchToggleUserSuspendStatusRequest>
  Model::BatchToggleUserSuspendStatusOutcomeCallable BatchToggleUserSuspendStatusCallable(
      const BatchToggleUserSuspendStatusRequestT& request) const {
    return SubmitCallable(&WickrClient::BatchToggleUserSuspendStatus, request);
  }
 
  template <typename BatchToggleUserSuspendStatusRequestT = Model::BatchToggleUserSuspendStatusRequest>
  void BatchToggleUserSuspendStatusAsync(const BatchToggleUserSuspendStatusRequestT& request,
                                         const BatchToggleUserSuspendStatusResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::BatchToggleUserSuspendStatus, 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(&WickrClient::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(&WickrClient::CreateBot, request, handler, context);
  }
 
  virtual Model::CreateDataRetentionBotOutcome CreateDataRetentionBot(const Model::CreateDataRetentionBotRequest& request) const;
 
  template <typename CreateDataRetentionBotRequestT = Model::CreateDataRetentionBotRequest>
  Model::CreateDataRetentionBotOutcomeCallable CreateDataRetentionBotCallable(const CreateDataRetentionBotRequestT& request) const {
    return SubmitCallable(&WickrClient::CreateDataRetentionBot, request);
  }
 
  template <typename CreateDataRetentionBotRequestT = Model::CreateDataRetentionBotRequest>
  void CreateDataRetentionBotAsync(const CreateDataRetentionBotRequestT& request,
                                   const CreateDataRetentionBotResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::CreateDataRetentionBot, request, handler, context);
  }
 
  virtual Model::CreateDataRetentionBotChallengeOutcome CreateDataRetentionBotChallenge(
      const Model::CreateDataRetentionBotChallengeRequest& request) const;
 
  template <typename CreateDataRetentionBotChallengeRequestT = Model::CreateDataRetentionBotChallengeRequest>
  Model::CreateDataRetentionBotChallengeOutcomeCallable CreateDataRetentionBotChallengeCallable(
      const CreateDataRetentionBotChallengeRequestT& request) const {
    return SubmitCallable(&WickrClient::CreateDataRetentionBotChallenge, request);
  }
 
  template <typename CreateDataRetentionBotChallengeRequestT = Model::CreateDataRetentionBotChallengeRequest>
  void CreateDataRetentionBotChallengeAsync(const CreateDataRetentionBotChallengeRequestT& request,
                                            const CreateDataRetentionBotChallengeResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::CreateDataRetentionBotChallenge, request, handler, context);
  }
 
  virtual Model::CreateNetworkOutcome CreateNetwork(const Model::CreateNetworkRequest& request) const;
 
  template <typename CreateNetworkRequestT = Model::CreateNetworkRequest>
  Model::CreateNetworkOutcomeCallable CreateNetworkCallable(const CreateNetworkRequestT& request) const {
    return SubmitCallable(&WickrClient::CreateNetwork, request);
  }
 
  template <typename CreateNetworkRequestT = Model::CreateNetworkRequest>
  void CreateNetworkAsync(const CreateNetworkRequestT& request, const CreateNetworkResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::CreateNetwork, request, handler, context);
  }
 
  virtual Model::CreateSecurityGroupOutcome CreateSecurityGroup(const Model::CreateSecurityGroupRequest& request) const;
 
  template <typename CreateSecurityGroupRequestT = Model::CreateSecurityGroupRequest>
  Model::CreateSecurityGroupOutcomeCallable CreateSecurityGroupCallable(const CreateSecurityGroupRequestT& request) const {
    return SubmitCallable(&WickrClient::CreateSecurityGroup, request);
  }
 
  template <typename CreateSecurityGroupRequestT = Model::CreateSecurityGroupRequest>
  void CreateSecurityGroupAsync(const CreateSecurityGroupRequestT& request, const CreateSecurityGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::CreateSecurityGroup, request, handler, context);
  }
 
  virtual Model::DeleteBotOutcome DeleteBot(const Model::DeleteBotRequest& request) const;
 
  template <typename DeleteBotRequestT = Model::DeleteBotRequest>
  Model::DeleteBotOutcomeCallable DeleteBotCallable(const DeleteBotRequestT& request) const {
    return SubmitCallable(&WickrClient::DeleteBot, request);
  }
 
  template <typename DeleteBotRequestT = Model::DeleteBotRequest>
  void DeleteBotAsync(const DeleteBotRequestT& request, const DeleteBotResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::DeleteBot, request, handler, context);
  }
 
  virtual Model::DeleteDataRetentionBotOutcome DeleteDataRetentionBot(const Model::DeleteDataRetentionBotRequest& request) const;
 
  template <typename DeleteDataRetentionBotRequestT = Model::DeleteDataRetentionBotRequest>
  Model::DeleteDataRetentionBotOutcomeCallable DeleteDataRetentionBotCallable(const DeleteDataRetentionBotRequestT& request) const {
    return SubmitCallable(&WickrClient::DeleteDataRetentionBot, request);
  }
 
  template <typename DeleteDataRetentionBotRequestT = Model::DeleteDataRetentionBotRequest>
  void DeleteDataRetentionBotAsync(const DeleteDataRetentionBotRequestT& request,
                                   const DeleteDataRetentionBotResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::DeleteDataRetentionBot, request, handler, context);
  }
 
  virtual Model::DeleteNetworkOutcome DeleteNetwork(const Model::DeleteNetworkRequest& request) const;
 
  template <typename DeleteNetworkRequestT = Model::DeleteNetworkRequest>
  Model::DeleteNetworkOutcomeCallable DeleteNetworkCallable(const DeleteNetworkRequestT& request) const {
    return SubmitCallable(&WickrClient::DeleteNetwork, request);
  }
 
  template <typename DeleteNetworkRequestT = Model::DeleteNetworkRequest>
  void DeleteNetworkAsync(const DeleteNetworkRequestT& request, const DeleteNetworkResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::DeleteNetwork, request, handler, context);
  }
 
  virtual Model::DeleteSecurityGroupOutcome DeleteSecurityGroup(const Model::DeleteSecurityGroupRequest& request) const;
 
  template <typename DeleteSecurityGroupRequestT = Model::DeleteSecurityGroupRequest>
  Model::DeleteSecurityGroupOutcomeCallable DeleteSecurityGroupCallable(const DeleteSecurityGroupRequestT& request) const {
    return SubmitCallable(&WickrClient::DeleteSecurityGroup, request);
  }
 
  template <typename DeleteSecurityGroupRequestT = Model::DeleteSecurityGroupRequest>
  void DeleteSecurityGroupAsync(const DeleteSecurityGroupRequestT& request, const DeleteSecurityGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::DeleteSecurityGroup, 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(&WickrClient::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(&WickrClient::GetBot, request, handler, context);
  }
 
  virtual Model::GetBotsCountOutcome GetBotsCount(const Model::GetBotsCountRequest& request) const;
 
  template <typename GetBotsCountRequestT = Model::GetBotsCountRequest>
  Model::GetBotsCountOutcomeCallable GetBotsCountCallable(const GetBotsCountRequestT& request) const {
    return SubmitCallable(&WickrClient::GetBotsCount, request);
  }
 
  template <typename GetBotsCountRequestT = Model::GetBotsCountRequest>
  void GetBotsCountAsync(const GetBotsCountRequestT& request, const GetBotsCountResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetBotsCount, request, handler, context);
  }
 
  virtual Model::GetDataRetentionBotOutcome GetDataRetentionBot(const Model::GetDataRetentionBotRequest& request) const;
 
  template <typename GetDataRetentionBotRequestT = Model::GetDataRetentionBotRequest>
  Model::GetDataRetentionBotOutcomeCallable GetDataRetentionBotCallable(const GetDataRetentionBotRequestT& request) const {
    return SubmitCallable(&WickrClient::GetDataRetentionBot, request);
  }
 
  template <typename GetDataRetentionBotRequestT = Model::GetDataRetentionBotRequest>
  void GetDataRetentionBotAsync(const GetDataRetentionBotRequestT& request, const GetDataRetentionBotResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetDataRetentionBot, request, handler, context);
  }
 
  virtual Model::GetGuestUserHistoryCountOutcome GetGuestUserHistoryCount(const Model::GetGuestUserHistoryCountRequest& request) const;
 
  template <typename GetGuestUserHistoryCountRequestT = Model::GetGuestUserHistoryCountRequest>
  Model::GetGuestUserHistoryCountOutcomeCallable GetGuestUserHistoryCountCallable(const GetGuestUserHistoryCountRequestT& request) const {
    return SubmitCallable(&WickrClient::GetGuestUserHistoryCount, request);
  }
 
  template <typename GetGuestUserHistoryCountRequestT = Model::GetGuestUserHistoryCountRequest>
  void GetGuestUserHistoryCountAsync(const GetGuestUserHistoryCountRequestT& request,
                                     const GetGuestUserHistoryCountResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetGuestUserHistoryCount, request, handler, context);
  }
 
  virtual Model::GetNetworkOutcome GetNetwork(const Model::GetNetworkRequest& request) const;
 
  template <typename GetNetworkRequestT = Model::GetNetworkRequest>
  Model::GetNetworkOutcomeCallable GetNetworkCallable(const GetNetworkRequestT& request) const {
    return SubmitCallable(&WickrClient::GetNetwork, request);
  }
 
  template <typename GetNetworkRequestT = Model::GetNetworkRequest>
  void GetNetworkAsync(const GetNetworkRequestT& request, const GetNetworkResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetNetwork, request, handler, context);
  }
 
  virtual Model::GetNetworkSettingsOutcome GetNetworkSettings(const Model::GetNetworkSettingsRequest& request) const;
 
  template <typename GetNetworkSettingsRequestT = Model::GetNetworkSettingsRequest>
  Model::GetNetworkSettingsOutcomeCallable GetNetworkSettingsCallable(const GetNetworkSettingsRequestT& request) const {
    return SubmitCallable(&WickrClient::GetNetworkSettings, request);
  }
 
  template <typename GetNetworkSettingsRequestT = Model::GetNetworkSettingsRequest>
  void GetNetworkSettingsAsync(const GetNetworkSettingsRequestT& request, const GetNetworkSettingsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetNetworkSettings, request, handler, context);
  }
 
  virtual Model::GetOidcInfoOutcome GetOidcInfo(const Model::GetOidcInfoRequest& request) const;
 
  template <typename GetOidcInfoRequestT = Model::GetOidcInfoRequest>
  Model::GetOidcInfoOutcomeCallable GetOidcInfoCallable(const GetOidcInfoRequestT& request) const {
    return SubmitCallable(&WickrClient::GetOidcInfo, request);
  }
 
  template <typename GetOidcInfoRequestT = Model::GetOidcInfoRequest>
  void GetOidcInfoAsync(const GetOidcInfoRequestT& request, const GetOidcInfoResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetOidcInfo, request, handler, context);
  }
 
  virtual Model::GetOpentdfConfigOutcome GetOpentdfConfig(const Model::GetOpentdfConfigRequest& request) const;
 
  template <typename GetOpentdfConfigRequestT = Model::GetOpentdfConfigRequest>
  Model::GetOpentdfConfigOutcomeCallable GetOpentdfConfigCallable(const GetOpentdfConfigRequestT& request) const {
    return SubmitCallable(&WickrClient::GetOpentdfConfig, request);
  }
 
  template <typename GetOpentdfConfigRequestT = Model::GetOpentdfConfigRequest>
  void GetOpentdfConfigAsync(const GetOpentdfConfigRequestT& request, const GetOpentdfConfigResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetOpentdfConfig, request, handler, context);
  }
 
  virtual Model::GetSecurityGroupOutcome GetSecurityGroup(const Model::GetSecurityGroupRequest& request) const;
 
  template <typename GetSecurityGroupRequestT = Model::GetSecurityGroupRequest>
  Model::GetSecurityGroupOutcomeCallable GetSecurityGroupCallable(const GetSecurityGroupRequestT& request) const {
    return SubmitCallable(&WickrClient::GetSecurityGroup, request);
  }
 
  template <typename GetSecurityGroupRequestT = Model::GetSecurityGroupRequest>
  void GetSecurityGroupAsync(const GetSecurityGroupRequestT& request, const GetSecurityGroupResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetSecurityGroup, 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(&WickrClient::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(&WickrClient::GetUser, request, handler, context);
  }
 
  virtual Model::GetUsersCountOutcome GetUsersCount(const Model::GetUsersCountRequest& request) const;
 
  template <typename GetUsersCountRequestT = Model::GetUsersCountRequest>
  Model::GetUsersCountOutcomeCallable GetUsersCountCallable(const GetUsersCountRequestT& request) const {
    return SubmitCallable(&WickrClient::GetUsersCount, request);
  }
 
  template <typename GetUsersCountRequestT = Model::GetUsersCountRequest>
  void GetUsersCountAsync(const GetUsersCountRequestT& request, const GetUsersCountResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::GetUsersCount, request, handler, context);
  }
 
  virtual Model::ListBlockedGuestUsersOutcome ListBlockedGuestUsers(const Model::ListBlockedGuestUsersRequest& request) const;
 
  template <typename ListBlockedGuestUsersRequestT = Model::ListBlockedGuestUsersRequest>
  Model::ListBlockedGuestUsersOutcomeCallable ListBlockedGuestUsersCallable(const ListBlockedGuestUsersRequestT& request) const {
    return SubmitCallable(&WickrClient::ListBlockedGuestUsers, request);
  }
 
  template <typename ListBlockedGuestUsersRequestT = Model::ListBlockedGuestUsersRequest>
  void ListBlockedGuestUsersAsync(const ListBlockedGuestUsersRequestT& request, const ListBlockedGuestUsersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::ListBlockedGuestUsers, 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(&WickrClient::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(&WickrClient::ListBots, request, handler, context);
  }
 
  virtual Model::ListDevicesForUserOutcome ListDevicesForUser(const Model::ListDevicesForUserRequest& request) const;
 
  template <typename ListDevicesForUserRequestT = Model::ListDevicesForUserRequest>
  Model::ListDevicesForUserOutcomeCallable ListDevicesForUserCallable(const ListDevicesForUserRequestT& request) const {
    return SubmitCallable(&WickrClient::ListDevicesForUser, request);
  }
 
  template <typename ListDevicesForUserRequestT = Model::ListDevicesForUserRequest>
  void ListDevicesForUserAsync(const ListDevicesForUserRequestT& request, const ListDevicesForUserResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::ListDevicesForUser, request, handler, context);
  }
 
  virtual Model::ListGuestUsersOutcome ListGuestUsers(const Model::ListGuestUsersRequest& request) const;
 
  template <typename ListGuestUsersRequestT = Model::ListGuestUsersRequest>
  Model::ListGuestUsersOutcomeCallable ListGuestUsersCallable(const ListGuestUsersRequestT& request) const {
    return SubmitCallable(&WickrClient::ListGuestUsers, request);
  }
 
  template <typename ListGuestUsersRequestT = Model::ListGuestUsersRequest>
  void ListGuestUsersAsync(const ListGuestUsersRequestT& request, const ListGuestUsersResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::ListGuestUsers, request, handler, context);
  }
 
  virtual Model::ListNetworksOutcome ListNetworks(const Model::ListNetworksRequest& request = {}) const;
 
  template <typename ListNetworksRequestT = Model::ListNetworksRequest>
  Model::ListNetworksOutcomeCallable ListNetworksCallable(const ListNetworksRequestT& request = {}) const {
    return SubmitCallable(&WickrClient::ListNetworks, request);
  }
 
  template <typename ListNetworksRequestT = Model::ListNetworksRequest>
  void ListNetworksAsync(const ListNetworksResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListNetworksRequestT& request = {}) const {
    return SubmitAsync(&WickrClient::ListNetworks, request, handler, context);
  }
 
  virtual Model::ListSecurityGroupUsersOutcome ListSecurityGroupUsers(const Model::ListSecurityGroupUsersRequest& request) const;
 
  template <typename ListSecurityGroupUsersRequestT = Model::ListSecurityGroupUsersRequest>
  Model::ListSecurityGroupUsersOutcomeCallable ListSecurityGroupUsersCallable(const ListSecurityGroupUsersRequestT& request) const {
    return SubmitCallable(&WickrClient::ListSecurityGroupUsers, request);
  }
 
  template <typename ListSecurityGroupUsersRequestT = Model::ListSecurityGroupUsersRequest>
  void ListSecurityGroupUsersAsync(const ListSecurityGroupUsersRequestT& request,
                                   const ListSecurityGroupUsersResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::ListSecurityGroupUsers, request, handler, context);
  }
 
  virtual Model::ListSecurityGroupsOutcome ListSecurityGroups(const Model::ListSecurityGroupsRequest& request) const;
 
  template <typename ListSecurityGroupsRequestT = Model::ListSecurityGroupsRequest>
  Model::ListSecurityGroupsOutcomeCallable ListSecurityGroupsCallable(const ListSecurityGroupsRequestT& request) const {
    return SubmitCallable(&WickrClient::ListSecurityGroups, request);
  }
 
  template <typename ListSecurityGroupsRequestT = Model::ListSecurityGroupsRequest>
  void ListSecurityGroupsAsync(const ListSecurityGroupsRequestT& request, const ListSecurityGroupsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::ListSecurityGroups, 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(&WickrClient::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(&WickrClient::ListUsers, request, handler, context);
  }
 
  virtual Model::RegisterOidcConfigOutcome RegisterOidcConfig(const Model::RegisterOidcConfigRequest& request) const;
 
  template <typename RegisterOidcConfigRequestT = Model::RegisterOidcConfigRequest>
  Model::RegisterOidcConfigOutcomeCallable RegisterOidcConfigCallable(const RegisterOidcConfigRequestT& request) const {
    return SubmitCallable(&WickrClient::RegisterOidcConfig, request);
  }
 
  template <typename RegisterOidcConfigRequestT = Model::RegisterOidcConfigRequest>
  void RegisterOidcConfigAsync(const RegisterOidcConfigRequestT& request, const RegisterOidcConfigResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::RegisterOidcConfig, request, handler, context);
  }
 
  virtual Model::RegisterOidcConfigTestOutcome RegisterOidcConfigTest(const Model::RegisterOidcConfigTestRequest& request) const;
 
  template <typename RegisterOidcConfigTestRequestT = Model::RegisterOidcConfigTestRequest>
  Model::RegisterOidcConfigTestOutcomeCallable RegisterOidcConfigTestCallable(const RegisterOidcConfigTestRequestT& request) const {
    return SubmitCallable(&WickrClient::RegisterOidcConfigTest, request);
  }
 
  template <typename RegisterOidcConfigTestRequestT = Model::RegisterOidcConfigTestRequest>
  void RegisterOidcConfigTestAsync(const RegisterOidcConfigTestRequestT& request,
                                   const RegisterOidcConfigTestResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::RegisterOidcConfigTest, request, handler, context);
  }
 
  virtual Model::RegisterOpentdfConfigOutcome RegisterOpentdfConfig(const Model::RegisterOpentdfConfigRequest& request) const;
 
  template <typename RegisterOpentdfConfigRequestT = Model::RegisterOpentdfConfigRequest>
  Model::RegisterOpentdfConfigOutcomeCallable RegisterOpentdfConfigCallable(const RegisterOpentdfConfigRequestT& request) const {
    return SubmitCallable(&WickrClient::RegisterOpentdfConfig, request);
  }
 
  template <typename RegisterOpentdfConfigRequestT = Model::RegisterOpentdfConfigRequest>
  void RegisterOpentdfConfigAsync(const RegisterOpentdfConfigRequestT& request, const RegisterOpentdfConfigResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::RegisterOpentdfConfig, 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(&WickrClient::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(&WickrClient::UpdateBot, request, handler, context);
  }
 
  virtual Model::UpdateDataRetentionOutcome UpdateDataRetention(const Model::UpdateDataRetentionRequest& request) const;
 
  template <typename UpdateDataRetentionRequestT = Model::UpdateDataRetentionRequest>
  Model::UpdateDataRetentionOutcomeCallable UpdateDataRetentionCallable(const UpdateDataRetentionRequestT& request) const {
    return SubmitCallable(&WickrClient::UpdateDataRetention, request);
  }
 
  template <typename UpdateDataRetentionRequestT = Model::UpdateDataRetentionRequest>
  void UpdateDataRetentionAsync(const UpdateDataRetentionRequestT& request, const UpdateDataRetentionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::UpdateDataRetention, request, handler, context);
  }
 
  virtual Model::UpdateGuestUserOutcome UpdateGuestUser(const Model::UpdateGuestUserRequest& request) const;
 
  template <typename UpdateGuestUserRequestT = Model::UpdateGuestUserRequest>
  Model::UpdateGuestUserOutcomeCallable UpdateGuestUserCallable(const UpdateGuestUserRequestT& request) const {
    return SubmitCallable(&WickrClient::UpdateGuestUser, request);
  }
 
  template <typename UpdateGuestUserRequestT = Model::UpdateGuestUserRequest>
  void UpdateGuestUserAsync(const UpdateGuestUserRequestT& request, const UpdateGuestUserResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::UpdateGuestUser, request, handler, context);
  }
 
  virtual Model::UpdateNetworkOutcome UpdateNetwork(const Model::UpdateNetworkRequest& request) const;
 
  template <typename UpdateNetworkRequestT = Model::UpdateNetworkRequest>
  Model::UpdateNetworkOutcomeCallable UpdateNetworkCallable(const UpdateNetworkRequestT& request) const {
    return SubmitCallable(&WickrClient::UpdateNetwork, request);
  }
 
  template <typename UpdateNetworkRequestT = Model::UpdateNetworkRequest>
  void UpdateNetworkAsync(const UpdateNetworkRequestT& request, const UpdateNetworkResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::UpdateNetwork, request, handler, context);
  }
 
  virtual Model::UpdateNetworkSettingsOutcome UpdateNetworkSettings(const Model::UpdateNetworkSettingsRequest& request) const;
 
  template <typename UpdateNetworkSettingsRequestT = Model::UpdateNetworkSettingsRequest>
  Model::UpdateNetworkSettingsOutcomeCallable UpdateNetworkSettingsCallable(const UpdateNetworkSettingsRequestT& request) const {
    return SubmitCallable(&WickrClient::UpdateNetworkSettings, request);
  }
 
  template <typename UpdateNetworkSettingsRequestT = Model::UpdateNetworkSettingsRequest>
  void UpdateNetworkSettingsAsync(const UpdateNetworkSettingsRequestT& request, const UpdateNetworkSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::UpdateNetworkSettings, request, handler, context);
  }
 
  virtual Model::UpdateSecurityGroupOutcome UpdateSecurityGroup(const Model::UpdateSecurityGroupRequest& request) const;
 
  template <typename UpdateSecurityGroupRequestT = Model::UpdateSecurityGroupRequest>
  Model::UpdateSecurityGroupOutcomeCallable UpdateSecurityGroupCallable(const UpdateSecurityGroupRequestT& request) const {
    return SubmitCallable(&WickrClient::UpdateSecurityGroup, request);
  }
 
  template <typename UpdateSecurityGroupRequestT = Model::UpdateSecurityGroupRequest>
  void UpdateSecurityGroupAsync(const UpdateSecurityGroupRequestT& request, const UpdateSecurityGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WickrClient::UpdateSecurityGroup, 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(&WickrClient::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(&WickrClient::UpdateUser, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<WickrEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<WickrClient>;
  void init(const WickrClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, WickrError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  WickrClientConfiguration m_clientConfiguration;
  std::shared_ptr<WickrEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Wickr
}  // namespace Aws