SocialMessagingClient.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/socialmessaging/SocialMessagingPaginationBase.h>
#include <aws/socialmessaging/SocialMessagingServiceClientModel.h>
#include <aws/socialmessaging/SocialMessagingWaiter.h>
#include <aws/socialmessaging/SocialMessaging_EXPORTS.h>
 
namespace Aws {
namespace SocialMessaging {
class AWS_SOCIALMESSAGING_API SocialMessagingClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<SocialMessagingClient>,
                                                      public SocialMessagingPaginationBase<SocialMessagingClient>,
                                                      public SocialMessagingWaiter<SocialMessagingClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SocialMessagingClientConfiguration ClientConfigurationType;
  typedef SocialMessagingEndpointProvider EndpointProviderType;
 
  SocialMessagingClient(const Aws::SocialMessaging::SocialMessagingClientConfiguration& clientConfiguration =
                            Aws::SocialMessaging::SocialMessagingClientConfiguration(),
                        std::shared_ptr<SocialMessagingEndpointProviderBase> endpointProvider = nullptr);
 
  SocialMessagingClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<SocialMessagingEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::SocialMessaging::SocialMessagingClientConfiguration& clientConfiguration =
                            Aws::SocialMessaging::SocialMessagingClientConfiguration());
 
  SocialMessagingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<SocialMessagingEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::SocialMessaging::SocialMessagingClientConfiguration& clientConfiguration =
                            Aws::SocialMessaging::SocialMessagingClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SocialMessagingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SocialMessagingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SocialMessagingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SocialMessagingClient();
 
  virtual Model::AssociateWhatsAppBusinessAccountOutcome AssociateWhatsAppBusinessAccount(
      const Model::AssociateWhatsAppBusinessAccountRequest& request = {}) const;
 
  template <typename AssociateWhatsAppBusinessAccountRequestT = Model::AssociateWhatsAppBusinessAccountRequest>
  Model::AssociateWhatsAppBusinessAccountOutcomeCallable AssociateWhatsAppBusinessAccountCallable(
      const AssociateWhatsAppBusinessAccountRequestT& request = {}) const {
    return SubmitCallable(&SocialMessagingClient::AssociateWhatsAppBusinessAccount, request);
  }
 
  template <typename AssociateWhatsAppBusinessAccountRequestT = Model::AssociateWhatsAppBusinessAccountRequest>
  void AssociateWhatsAppBusinessAccountAsync(const AssociateWhatsAppBusinessAccountResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const AssociateWhatsAppBusinessAccountRequestT& request = {}) const {
    return SubmitAsync(&SocialMessagingClient::AssociateWhatsAppBusinessAccount, request, handler, context);
  }
 
  virtual Model::CreateWhatsAppDatasetOutcome CreateWhatsAppDataset(const Model::CreateWhatsAppDatasetRequest& request) const;
 
  template <typename CreateWhatsAppDatasetRequestT = Model::CreateWhatsAppDatasetRequest>
  Model::CreateWhatsAppDatasetOutcomeCallable CreateWhatsAppDatasetCallable(const CreateWhatsAppDatasetRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::CreateWhatsAppDataset, request);
  }
 
  template <typename CreateWhatsAppDatasetRequestT = Model::CreateWhatsAppDatasetRequest>
  void CreateWhatsAppDatasetAsync(const CreateWhatsAppDatasetRequestT& request, const CreateWhatsAppDatasetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::CreateWhatsAppDataset, request, handler, context);
  }
 
  virtual Model::CreateWhatsAppFlowOutcome CreateWhatsAppFlow(const Model::CreateWhatsAppFlowRequest& request) const;
 
  template <typename CreateWhatsAppFlowRequestT = Model::CreateWhatsAppFlowRequest>
  Model::CreateWhatsAppFlowOutcomeCallable CreateWhatsAppFlowCallable(const CreateWhatsAppFlowRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::CreateWhatsAppFlow, request);
  }
 
  template <typename CreateWhatsAppFlowRequestT = Model::CreateWhatsAppFlowRequest>
  void CreateWhatsAppFlowAsync(const CreateWhatsAppFlowRequestT& request, const CreateWhatsAppFlowResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::CreateWhatsAppFlow, request, handler, context);
  }
 
  virtual Model::CreateWhatsAppMessageTemplateOutcome CreateWhatsAppMessageTemplate(
      const Model::CreateWhatsAppMessageTemplateRequest& request) const;
 
  template <typename CreateWhatsAppMessageTemplateRequestT = Model::CreateWhatsAppMessageTemplateRequest>
  Model::CreateWhatsAppMessageTemplateOutcomeCallable CreateWhatsAppMessageTemplateCallable(
      const CreateWhatsAppMessageTemplateRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::CreateWhatsAppMessageTemplate, request);
  }
 
  template <typename CreateWhatsAppMessageTemplateRequestT = Model::CreateWhatsAppMessageTemplateRequest>
  void CreateWhatsAppMessageTemplateAsync(const CreateWhatsAppMessageTemplateRequestT& request,
                                          const CreateWhatsAppMessageTemplateResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::CreateWhatsAppMessageTemplate, request, handler, context);
  }
 
  virtual Model::CreateWhatsAppMessageTemplateFromLibraryOutcome CreateWhatsAppMessageTemplateFromLibrary(
      const Model::CreateWhatsAppMessageTemplateFromLibraryRequest& request) const;
 
  template <typename CreateWhatsAppMessageTemplateFromLibraryRequestT = Model::CreateWhatsAppMessageTemplateFromLibraryRequest>
  Model::CreateWhatsAppMessageTemplateFromLibraryOutcomeCallable CreateWhatsAppMessageTemplateFromLibraryCallable(
      const CreateWhatsAppMessageTemplateFromLibraryRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::CreateWhatsAppMessageTemplateFromLibrary, request);
  }
 
  template <typename CreateWhatsAppMessageTemplateFromLibraryRequestT = Model::CreateWhatsAppMessageTemplateFromLibraryRequest>
  void CreateWhatsAppMessageTemplateFromLibraryAsync(
      const CreateWhatsAppMessageTemplateFromLibraryRequestT& request,
      const CreateWhatsAppMessageTemplateFromLibraryResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::CreateWhatsAppMessageTemplateFromLibrary, request, handler, context);
  }
 
  virtual Model::CreateWhatsAppMessageTemplateMediaOutcome CreateWhatsAppMessageTemplateMedia(
      const Model::CreateWhatsAppMessageTemplateMediaRequest& request) const;
 
  template <typename CreateWhatsAppMessageTemplateMediaRequestT = Model::CreateWhatsAppMessageTemplateMediaRequest>
  Model::CreateWhatsAppMessageTemplateMediaOutcomeCallable CreateWhatsAppMessageTemplateMediaCallable(
      const CreateWhatsAppMessageTemplateMediaRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::CreateWhatsAppMessageTemplateMedia, request);
  }
 
  template <typename CreateWhatsAppMessageTemplateMediaRequestT = Model::CreateWhatsAppMessageTemplateMediaRequest>
  void CreateWhatsAppMessageTemplateMediaAsync(const CreateWhatsAppMessageTemplateMediaRequestT& request,
                                               const CreateWhatsAppMessageTemplateMediaResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::CreateWhatsAppMessageTemplateMedia, request, handler, context);
  }
 
  virtual Model::DeleteWhatsAppFlowOutcome DeleteWhatsAppFlow(const Model::DeleteWhatsAppFlowRequest& request) const;
 
  template <typename DeleteWhatsAppFlowRequestT = Model::DeleteWhatsAppFlowRequest>
  Model::DeleteWhatsAppFlowOutcomeCallable DeleteWhatsAppFlowCallable(const DeleteWhatsAppFlowRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::DeleteWhatsAppFlow, request);
  }
 
  template <typename DeleteWhatsAppFlowRequestT = Model::DeleteWhatsAppFlowRequest>
  void DeleteWhatsAppFlowAsync(const DeleteWhatsAppFlowRequestT& request, const DeleteWhatsAppFlowResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::DeleteWhatsAppFlow, request, handler, context);
  }
 
  virtual Model::DeleteWhatsAppMessageMediaOutcome DeleteWhatsAppMessageMedia(
      const Model::DeleteWhatsAppMessageMediaRequest& request) const;
 
  template <typename DeleteWhatsAppMessageMediaRequestT = Model::DeleteWhatsAppMessageMediaRequest>
  Model::DeleteWhatsAppMessageMediaOutcomeCallable DeleteWhatsAppMessageMediaCallable(
      const DeleteWhatsAppMessageMediaRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::DeleteWhatsAppMessageMedia, request);
  }
 
  template <typename DeleteWhatsAppMessageMediaRequestT = Model::DeleteWhatsAppMessageMediaRequest>
  void DeleteWhatsAppMessageMediaAsync(const DeleteWhatsAppMessageMediaRequestT& request,
                                       const DeleteWhatsAppMessageMediaResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::DeleteWhatsAppMessageMedia, request, handler, context);
  }
 
  virtual Model::DeleteWhatsAppMessageTemplateOutcome DeleteWhatsAppMessageTemplate(
      const Model::DeleteWhatsAppMessageTemplateRequest& request) const;
 
  template <typename DeleteWhatsAppMessageTemplateRequestT = Model::DeleteWhatsAppMessageTemplateRequest>
  Model::DeleteWhatsAppMessageTemplateOutcomeCallable DeleteWhatsAppMessageTemplateCallable(
      const DeleteWhatsAppMessageTemplateRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::DeleteWhatsAppMessageTemplate, request);
  }
 
  template <typename DeleteWhatsAppMessageTemplateRequestT = Model::DeleteWhatsAppMessageTemplateRequest>
  void DeleteWhatsAppMessageTemplateAsync(const DeleteWhatsAppMessageTemplateRequestT& request,
                                          const DeleteWhatsAppMessageTemplateResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::DeleteWhatsAppMessageTemplate, request, handler, context);
  }
 
  virtual Model::DeprecateWhatsAppFlowOutcome DeprecateWhatsAppFlow(const Model::DeprecateWhatsAppFlowRequest& request) const;
 
  template <typename DeprecateWhatsAppFlowRequestT = Model::DeprecateWhatsAppFlowRequest>
  Model::DeprecateWhatsAppFlowOutcomeCallable DeprecateWhatsAppFlowCallable(const DeprecateWhatsAppFlowRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::DeprecateWhatsAppFlow, request);
  }
 
  template <typename DeprecateWhatsAppFlowRequestT = Model::DeprecateWhatsAppFlowRequest>
  void DeprecateWhatsAppFlowAsync(const DeprecateWhatsAppFlowRequestT& request, const DeprecateWhatsAppFlowResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::DeprecateWhatsAppFlow, request, handler, context);
  }
 
  virtual Model::DisassociateWhatsAppBusinessAccountOutcome DisassociateWhatsAppBusinessAccount(
      const Model::DisassociateWhatsAppBusinessAccountRequest& request) const;
 
  template <typename DisassociateWhatsAppBusinessAccountRequestT = Model::DisassociateWhatsAppBusinessAccountRequest>
  Model::DisassociateWhatsAppBusinessAccountOutcomeCallable DisassociateWhatsAppBusinessAccountCallable(
      const DisassociateWhatsAppBusinessAccountRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::DisassociateWhatsAppBusinessAccount, request);
  }
 
  template <typename DisassociateWhatsAppBusinessAccountRequestT = Model::DisassociateWhatsAppBusinessAccountRequest>
  void DisassociateWhatsAppBusinessAccountAsync(const DisassociateWhatsAppBusinessAccountRequestT& request,
                                                const DisassociateWhatsAppBusinessAccountResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::DisassociateWhatsAppBusinessAccount, request, handler, context);
  }
 
  virtual Model::GetLinkedWhatsAppBusinessAccountOutcome GetLinkedWhatsAppBusinessAccount(
      const Model::GetLinkedWhatsAppBusinessAccountRequest& request) const;
 
  template <typename GetLinkedWhatsAppBusinessAccountRequestT = Model::GetLinkedWhatsAppBusinessAccountRequest>
  Model::GetLinkedWhatsAppBusinessAccountOutcomeCallable GetLinkedWhatsAppBusinessAccountCallable(
      const GetLinkedWhatsAppBusinessAccountRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::GetLinkedWhatsAppBusinessAccount, request);
  }
 
  template <typename GetLinkedWhatsAppBusinessAccountRequestT = Model::GetLinkedWhatsAppBusinessAccountRequest>
  void GetLinkedWhatsAppBusinessAccountAsync(const GetLinkedWhatsAppBusinessAccountRequestT& request,
                                             const GetLinkedWhatsAppBusinessAccountResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::GetLinkedWhatsAppBusinessAccount, request, handler, context);
  }
 
  virtual Model::GetLinkedWhatsAppBusinessAccountPhoneNumberOutcome GetLinkedWhatsAppBusinessAccountPhoneNumber(
      const Model::GetLinkedWhatsAppBusinessAccountPhoneNumberRequest& request) const;
 
  template <typename GetLinkedWhatsAppBusinessAccountPhoneNumberRequestT = Model::GetLinkedWhatsAppBusinessAccountPhoneNumberRequest>
  Model::GetLinkedWhatsAppBusinessAccountPhoneNumberOutcomeCallable GetLinkedWhatsAppBusinessAccountPhoneNumberCallable(
      const GetLinkedWhatsAppBusinessAccountPhoneNumberRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::GetLinkedWhatsAppBusinessAccountPhoneNumber, request);
  }
 
  template <typename GetLinkedWhatsAppBusinessAccountPhoneNumberRequestT = Model::GetLinkedWhatsAppBusinessAccountPhoneNumberRequest>
  void GetLinkedWhatsAppBusinessAccountPhoneNumberAsync(
      const GetLinkedWhatsAppBusinessAccountPhoneNumberRequestT& request,
      const GetLinkedWhatsAppBusinessAccountPhoneNumberResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::GetLinkedWhatsAppBusinessAccountPhoneNumber, request, handler, context);
  }
 
  virtual Model::GetWhatsAppBusinessPublicKeyOutcome GetWhatsAppBusinessPublicKey(
      const Model::GetWhatsAppBusinessPublicKeyRequest& request) const;
 
  template <typename GetWhatsAppBusinessPublicKeyRequestT = Model::GetWhatsAppBusinessPublicKeyRequest>
  Model::GetWhatsAppBusinessPublicKeyOutcomeCallable GetWhatsAppBusinessPublicKeyCallable(
      const GetWhatsAppBusinessPublicKeyRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::GetWhatsAppBusinessPublicKey, request);
  }
 
  template <typename GetWhatsAppBusinessPublicKeyRequestT = Model::GetWhatsAppBusinessPublicKeyRequest>
  void GetWhatsAppBusinessPublicKeyAsync(const GetWhatsAppBusinessPublicKeyRequestT& request,
                                         const GetWhatsAppBusinessPublicKeyResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::GetWhatsAppBusinessPublicKey, request, handler, context);
  }
 
  virtual Model::GetWhatsAppCallPermissionOutcome GetWhatsAppCallPermission(const Model::GetWhatsAppCallPermissionRequest& request) const;
 
  template <typename GetWhatsAppCallPermissionRequestT = Model::GetWhatsAppCallPermissionRequest>
  Model::GetWhatsAppCallPermissionOutcomeCallable GetWhatsAppCallPermissionCallable(
      const GetWhatsAppCallPermissionRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::GetWhatsAppCallPermission, request);
  }
 
  template <typename GetWhatsAppCallPermissionRequestT = Model::GetWhatsAppCallPermissionRequest>
  void GetWhatsAppCallPermissionAsync(const GetWhatsAppCallPermissionRequestT& request,
                                      const GetWhatsAppCallPermissionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::GetWhatsAppCallPermission, request, handler, context);
  }
 
  virtual Model::GetWhatsAppFlowOutcome GetWhatsAppFlow(const Model::GetWhatsAppFlowRequest& request) const;
 
  template <typename GetWhatsAppFlowRequestT = Model::GetWhatsAppFlowRequest>
  Model::GetWhatsAppFlowOutcomeCallable GetWhatsAppFlowCallable(const GetWhatsAppFlowRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::GetWhatsAppFlow, request);
  }
 
  template <typename GetWhatsAppFlowRequestT = Model::GetWhatsAppFlowRequest>
  void GetWhatsAppFlowAsync(const GetWhatsAppFlowRequestT& request, const GetWhatsAppFlowResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::GetWhatsAppFlow, request, handler, context);
  }
 
  virtual Model::GetWhatsAppFlowPreviewOutcome GetWhatsAppFlowPreview(const Model::GetWhatsAppFlowPreviewRequest& request) const;
 
  template <typename GetWhatsAppFlowPreviewRequestT = Model::GetWhatsAppFlowPreviewRequest>
  Model::GetWhatsAppFlowPreviewOutcomeCallable GetWhatsAppFlowPreviewCallable(const GetWhatsAppFlowPreviewRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::GetWhatsAppFlowPreview, request);
  }
 
  template <typename GetWhatsAppFlowPreviewRequestT = Model::GetWhatsAppFlowPreviewRequest>
  void GetWhatsAppFlowPreviewAsync(const GetWhatsAppFlowPreviewRequestT& request,
                                   const GetWhatsAppFlowPreviewResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::GetWhatsAppFlowPreview, request, handler, context);
  }
 
  virtual Model::GetWhatsAppMessageMediaOutcome GetWhatsAppMessageMedia(const Model::GetWhatsAppMessageMediaRequest& request) const;
 
  template <typename GetWhatsAppMessageMediaRequestT = Model::GetWhatsAppMessageMediaRequest>
  Model::GetWhatsAppMessageMediaOutcomeCallable GetWhatsAppMessageMediaCallable(const GetWhatsAppMessageMediaRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::GetWhatsAppMessageMedia, request);
  }
 
  template <typename GetWhatsAppMessageMediaRequestT = Model::GetWhatsAppMessageMediaRequest>
  void GetWhatsAppMessageMediaAsync(const GetWhatsAppMessageMediaRequestT& request,
                                    const GetWhatsAppMessageMediaResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::GetWhatsAppMessageMedia, request, handler, context);
  }
 
  virtual Model::GetWhatsAppMessageTemplateOutcome GetWhatsAppMessageTemplate(
      const Model::GetWhatsAppMessageTemplateRequest& request) const;
 
  template <typename GetWhatsAppMessageTemplateRequestT = Model::GetWhatsAppMessageTemplateRequest>
  Model::GetWhatsAppMessageTemplateOutcomeCallable GetWhatsAppMessageTemplateCallable(
      const GetWhatsAppMessageTemplateRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::GetWhatsAppMessageTemplate, request);
  }
 
  template <typename GetWhatsAppMessageTemplateRequestT = Model::GetWhatsAppMessageTemplateRequest>
  void GetWhatsAppMessageTemplateAsync(const GetWhatsAppMessageTemplateRequestT& request,
                                       const GetWhatsAppMessageTemplateResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::GetWhatsAppMessageTemplate, request, handler, context);
  }
 
  virtual Model::ListLinkedWhatsAppBusinessAccountsOutcome ListLinkedWhatsAppBusinessAccounts(
      const Model::ListLinkedWhatsAppBusinessAccountsRequest& request = {}) const;
 
  template <typename ListLinkedWhatsAppBusinessAccountsRequestT = Model::ListLinkedWhatsAppBusinessAccountsRequest>
  Model::ListLinkedWhatsAppBusinessAccountsOutcomeCallable ListLinkedWhatsAppBusinessAccountsCallable(
      const ListLinkedWhatsAppBusinessAccountsRequestT& request = {}) const {
    return SubmitCallable(&SocialMessagingClient::ListLinkedWhatsAppBusinessAccounts, request);
  }
 
  template <typename ListLinkedWhatsAppBusinessAccountsRequestT = Model::ListLinkedWhatsAppBusinessAccountsRequest>
  void ListLinkedWhatsAppBusinessAccountsAsync(const ListLinkedWhatsAppBusinessAccountsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const ListLinkedWhatsAppBusinessAccountsRequestT& request = {}) const {
    return SubmitAsync(&SocialMessagingClient::ListLinkedWhatsAppBusinessAccounts, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWhatsAppFlowAssetsOutcome ListWhatsAppFlowAssets(const Model::ListWhatsAppFlowAssetsRequest& request) const;
 
  template <typename ListWhatsAppFlowAssetsRequestT = Model::ListWhatsAppFlowAssetsRequest>
  Model::ListWhatsAppFlowAssetsOutcomeCallable ListWhatsAppFlowAssetsCallable(const ListWhatsAppFlowAssetsRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::ListWhatsAppFlowAssets, request);
  }
 
  template <typename ListWhatsAppFlowAssetsRequestT = Model::ListWhatsAppFlowAssetsRequest>
  void ListWhatsAppFlowAssetsAsync(const ListWhatsAppFlowAssetsRequestT& request,
                                   const ListWhatsAppFlowAssetsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::ListWhatsAppFlowAssets, request, handler, context);
  }
 
  virtual Model::ListWhatsAppFlowsOutcome ListWhatsAppFlows(const Model::ListWhatsAppFlowsRequest& request) const;
 
  template <typename ListWhatsAppFlowsRequestT = Model::ListWhatsAppFlowsRequest>
  Model::ListWhatsAppFlowsOutcomeCallable ListWhatsAppFlowsCallable(const ListWhatsAppFlowsRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::ListWhatsAppFlows, request);
  }
 
  template <typename ListWhatsAppFlowsRequestT = Model::ListWhatsAppFlowsRequest>
  void ListWhatsAppFlowsAsync(const ListWhatsAppFlowsRequestT& request, const ListWhatsAppFlowsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::ListWhatsAppFlows, request, handler, context);
  }
 
  virtual Model::ListWhatsAppMessageTemplatesOutcome ListWhatsAppMessageTemplates(
      const Model::ListWhatsAppMessageTemplatesRequest& request) const;
 
  template <typename ListWhatsAppMessageTemplatesRequestT = Model::ListWhatsAppMessageTemplatesRequest>
  Model::ListWhatsAppMessageTemplatesOutcomeCallable ListWhatsAppMessageTemplatesCallable(
      const ListWhatsAppMessageTemplatesRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::ListWhatsAppMessageTemplates, request);
  }
 
  template <typename ListWhatsAppMessageTemplatesRequestT = Model::ListWhatsAppMessageTemplatesRequest>
  void ListWhatsAppMessageTemplatesAsync(const ListWhatsAppMessageTemplatesRequestT& request,
                                         const ListWhatsAppMessageTemplatesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::ListWhatsAppMessageTemplates, request, handler, context);
  }
 
  virtual Model::ListWhatsAppTemplateLibraryOutcome ListWhatsAppTemplateLibrary(
      const Model::ListWhatsAppTemplateLibraryRequest& request) const;
 
  template <typename ListWhatsAppTemplateLibraryRequestT = Model::ListWhatsAppTemplateLibraryRequest>
  Model::ListWhatsAppTemplateLibraryOutcomeCallable ListWhatsAppTemplateLibraryCallable(
      const ListWhatsAppTemplateLibraryRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::ListWhatsAppTemplateLibrary, request);
  }
 
  template <typename ListWhatsAppTemplateLibraryRequestT = Model::ListWhatsAppTemplateLibraryRequest>
  void ListWhatsAppTemplateLibraryAsync(const ListWhatsAppTemplateLibraryRequestT& request,
                                        const ListWhatsAppTemplateLibraryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::ListWhatsAppTemplateLibrary, request, handler, context);
  }
 
  virtual Model::PostWhatsAppMessageMediaOutcome PostWhatsAppMessageMedia(const Model::PostWhatsAppMessageMediaRequest& request) const;
 
  template <typename PostWhatsAppMessageMediaRequestT = Model::PostWhatsAppMessageMediaRequest>
  Model::PostWhatsAppMessageMediaOutcomeCallable PostWhatsAppMessageMediaCallable(const PostWhatsAppMessageMediaRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::PostWhatsAppMessageMedia, request);
  }
 
  template <typename PostWhatsAppMessageMediaRequestT = Model::PostWhatsAppMessageMediaRequest>
  void PostWhatsAppMessageMediaAsync(const PostWhatsAppMessageMediaRequestT& request,
                                     const PostWhatsAppMessageMediaResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::PostWhatsAppMessageMedia, request, handler, context);
  }
 
  virtual Model::PublishWhatsAppFlowOutcome PublishWhatsAppFlow(const Model::PublishWhatsAppFlowRequest& request) const;
 
  template <typename PublishWhatsAppFlowRequestT = Model::PublishWhatsAppFlowRequest>
  Model::PublishWhatsAppFlowOutcomeCallable PublishWhatsAppFlowCallable(const PublishWhatsAppFlowRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::PublishWhatsAppFlow, request);
  }
 
  template <typename PublishWhatsAppFlowRequestT = Model::PublishWhatsAppFlowRequest>
  void PublishWhatsAppFlowAsync(const PublishWhatsAppFlowRequestT& request, const PublishWhatsAppFlowResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::PublishWhatsAppFlow, request, handler, context);
  }
 
  virtual Model::PutWhatsAppBusinessAccountEventDestinationsOutcome PutWhatsAppBusinessAccountEventDestinations(
      const Model::PutWhatsAppBusinessAccountEventDestinationsRequest& request) const;
 
  template <typename PutWhatsAppBusinessAccountEventDestinationsRequestT = Model::PutWhatsAppBusinessAccountEventDestinationsRequest>
  Model::PutWhatsAppBusinessAccountEventDestinationsOutcomeCallable PutWhatsAppBusinessAccountEventDestinationsCallable(
      const PutWhatsAppBusinessAccountEventDestinationsRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::PutWhatsAppBusinessAccountEventDestinations, request);
  }
 
  template <typename PutWhatsAppBusinessAccountEventDestinationsRequestT = Model::PutWhatsAppBusinessAccountEventDestinationsRequest>
  void PutWhatsAppBusinessAccountEventDestinationsAsync(
      const PutWhatsAppBusinessAccountEventDestinationsRequestT& request,
      const PutWhatsAppBusinessAccountEventDestinationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::PutWhatsAppBusinessAccountEventDestinations, request, handler, context);
  }
 
  virtual Model::PutWhatsAppBusinessPublicKeyOutcome PutWhatsAppBusinessPublicKey(
      const Model::PutWhatsAppBusinessPublicKeyRequest& request) const;
 
  template <typename PutWhatsAppBusinessPublicKeyRequestT = Model::PutWhatsAppBusinessPublicKeyRequest>
  Model::PutWhatsAppBusinessPublicKeyOutcomeCallable PutWhatsAppBusinessPublicKeyCallable(
      const PutWhatsAppBusinessPublicKeyRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::PutWhatsAppBusinessPublicKey, request);
  }
 
  template <typename PutWhatsAppBusinessPublicKeyRequestT = Model::PutWhatsAppBusinessPublicKeyRequest>
  void PutWhatsAppBusinessPublicKeyAsync(const PutWhatsAppBusinessPublicKeyRequestT& request,
                                         const PutWhatsAppBusinessPublicKeyResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::PutWhatsAppBusinessPublicKey, request, handler, context);
  }
 
  virtual Model::SendWhatsAppCallEventOutcome SendWhatsAppCallEvent(const Model::SendWhatsAppCallEventRequest& request) const;
 
  template <typename SendWhatsAppCallEventRequestT = Model::SendWhatsAppCallEventRequest>
  Model::SendWhatsAppCallEventOutcomeCallable SendWhatsAppCallEventCallable(const SendWhatsAppCallEventRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::SendWhatsAppCallEvent, request);
  }
 
  template <typename SendWhatsAppCallEventRequestT = Model::SendWhatsAppCallEventRequest>
  void SendWhatsAppCallEventAsync(const SendWhatsAppCallEventRequestT& request, const SendWhatsAppCallEventResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::SendWhatsAppCallEvent, request, handler, context);
  }
 
  virtual Model::SendWhatsAppConversionEventOutcome SendWhatsAppConversionEvent(
      const Model::SendWhatsAppConversionEventRequest& request) const;
 
  template <typename SendWhatsAppConversionEventRequestT = Model::SendWhatsAppConversionEventRequest>
  Model::SendWhatsAppConversionEventOutcomeCallable SendWhatsAppConversionEventCallable(
      const SendWhatsAppConversionEventRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::SendWhatsAppConversionEvent, request);
  }
 
  template <typename SendWhatsAppConversionEventRequestT = Model::SendWhatsAppConversionEventRequest>
  void SendWhatsAppConversionEventAsync(const SendWhatsAppConversionEventRequestT& request,
                                        const SendWhatsAppConversionEventResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::SendWhatsAppConversionEvent, request, handler, context);
  }
 
  virtual Model::SendWhatsAppMessageOutcome SendWhatsAppMessage(const Model::SendWhatsAppMessageRequest& request) const;
 
  template <typename SendWhatsAppMessageRequestT = Model::SendWhatsAppMessageRequest>
  Model::SendWhatsAppMessageOutcomeCallable SendWhatsAppMessageCallable(const SendWhatsAppMessageRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::SendWhatsAppMessage, request);
  }
 
  template <typename SendWhatsAppMessageRequestT = Model::SendWhatsAppMessageRequest>
  void SendWhatsAppMessageAsync(const SendWhatsAppMessageRequestT& request, const SendWhatsAppMessageResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::SendWhatsAppMessage, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateLinkedWhatsAppBusinessAccountPhoneNumberOutcome UpdateLinkedWhatsAppBusinessAccountPhoneNumber(
      const Model::UpdateLinkedWhatsAppBusinessAccountPhoneNumberRequest& request) const;
 
  template <typename UpdateLinkedWhatsAppBusinessAccountPhoneNumberRequestT = Model::UpdateLinkedWhatsAppBusinessAccountPhoneNumberRequest>
  Model::UpdateLinkedWhatsAppBusinessAccountPhoneNumberOutcomeCallable UpdateLinkedWhatsAppBusinessAccountPhoneNumberCallable(
      const UpdateLinkedWhatsAppBusinessAccountPhoneNumberRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::UpdateLinkedWhatsAppBusinessAccountPhoneNumber, request);
  }
 
  template <typename UpdateLinkedWhatsAppBusinessAccountPhoneNumberRequestT = Model::UpdateLinkedWhatsAppBusinessAccountPhoneNumberRequest>
  void UpdateLinkedWhatsAppBusinessAccountPhoneNumberAsync(
      const UpdateLinkedWhatsAppBusinessAccountPhoneNumberRequestT& request,
      const UpdateLinkedWhatsAppBusinessAccountPhoneNumberResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::UpdateLinkedWhatsAppBusinessAccountPhoneNumber, request, handler, context);
  }
 
  virtual Model::UpdateWhatsAppFlowOutcome UpdateWhatsAppFlow(const Model::UpdateWhatsAppFlowRequest& request) const;
 
  template <typename UpdateWhatsAppFlowRequestT = Model::UpdateWhatsAppFlowRequest>
  Model::UpdateWhatsAppFlowOutcomeCallable UpdateWhatsAppFlowCallable(const UpdateWhatsAppFlowRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::UpdateWhatsAppFlow, request);
  }
 
  template <typename UpdateWhatsAppFlowRequestT = Model::UpdateWhatsAppFlowRequest>
  void UpdateWhatsAppFlowAsync(const UpdateWhatsAppFlowRequestT& request, const UpdateWhatsAppFlowResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::UpdateWhatsAppFlow, request, handler, context);
  }
 
  virtual Model::UpdateWhatsAppFlowAssetsOutcome UpdateWhatsAppFlowAssets(const Model::UpdateWhatsAppFlowAssetsRequest& request) const;
 
  template <typename UpdateWhatsAppFlowAssetsRequestT = Model::UpdateWhatsAppFlowAssetsRequest>
  Model::UpdateWhatsAppFlowAssetsOutcomeCallable UpdateWhatsAppFlowAssetsCallable(const UpdateWhatsAppFlowAssetsRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::UpdateWhatsAppFlowAssets, request);
  }
 
  template <typename UpdateWhatsAppFlowAssetsRequestT = Model::UpdateWhatsAppFlowAssetsRequest>
  void UpdateWhatsAppFlowAssetsAsync(const UpdateWhatsAppFlowAssetsRequestT& request,
                                     const UpdateWhatsAppFlowAssetsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::UpdateWhatsAppFlowAssets, request, handler, context);
  }
 
  virtual Model::UpdateWhatsAppMessageTemplateOutcome UpdateWhatsAppMessageTemplate(
      const Model::UpdateWhatsAppMessageTemplateRequest& request) const;
 
  template <typename UpdateWhatsAppMessageTemplateRequestT = Model::UpdateWhatsAppMessageTemplateRequest>
  Model::UpdateWhatsAppMessageTemplateOutcomeCallable UpdateWhatsAppMessageTemplateCallable(
      const UpdateWhatsAppMessageTemplateRequestT& request) const {
    return SubmitCallable(&SocialMessagingClient::UpdateWhatsAppMessageTemplate, request);
  }
 
  template <typename UpdateWhatsAppMessageTemplateRequestT = Model::UpdateWhatsAppMessageTemplateRequest>
  void UpdateWhatsAppMessageTemplateAsync(const UpdateWhatsAppMessageTemplateRequestT& request,
                                          const UpdateWhatsAppMessageTemplateResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SocialMessagingClient::UpdateWhatsAppMessageTemplate, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SocialMessagingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SocialMessagingClient>;
  void init(const SocialMessagingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SocialMessagingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SocialMessagingClientConfiguration m_clientConfiguration;
  std::shared_ptr<SocialMessagingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SocialMessaging
}  // namespace Aws