ChatbotClient.h

 
#pragma once
#include <aws/chatbot/ChatbotServiceClientModel.h>
#include <aws/chatbot/Chatbot_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 chatbot {
class AWS_CHATBOT_API ChatbotClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ChatbotClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ChatbotClientConfiguration ClientConfigurationType;
  typedef ChatbotEndpointProvider EndpointProviderType;
 
  ChatbotClient(const Aws::chatbot::ChatbotClientConfiguration& clientConfiguration = Aws::chatbot::ChatbotClientConfiguration(),
                std::shared_ptr<ChatbotEndpointProviderBase> endpointProvider = nullptr);
 
  ChatbotClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<ChatbotEndpointProviderBase> endpointProvider = nullptr,
                const Aws::chatbot::ChatbotClientConfiguration& clientConfiguration = Aws::chatbot::ChatbotClientConfiguration());
 
  ChatbotClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<ChatbotEndpointProviderBase> endpointProvider = nullptr,
                const Aws::chatbot::ChatbotClientConfiguration& clientConfiguration = Aws::chatbot::ChatbotClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ChatbotClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ChatbotClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ChatbotClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ChatbotClient();
 
  virtual Model::AssociateToConfigurationOutcome AssociateToConfiguration(const Model::AssociateToConfigurationRequest& request) const;
 
  template <typename AssociateToConfigurationRequestT = Model::AssociateToConfigurationRequest>
  Model::AssociateToConfigurationOutcomeCallable AssociateToConfigurationCallable(const AssociateToConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::AssociateToConfiguration, request);
  }
 
  template <typename AssociateToConfigurationRequestT = Model::AssociateToConfigurationRequest>
  void AssociateToConfigurationAsync(const AssociateToConfigurationRequestT& request,
                                     const AssociateToConfigurationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::AssociateToConfiguration, request, handler, context);
  }
 
  virtual Model::CreateChimeWebhookConfigurationOutcome CreateChimeWebhookConfiguration(
      const Model::CreateChimeWebhookConfigurationRequest& request) const;
 
  template <typename CreateChimeWebhookConfigurationRequestT = Model::CreateChimeWebhookConfigurationRequest>
  Model::CreateChimeWebhookConfigurationOutcomeCallable CreateChimeWebhookConfigurationCallable(
      const CreateChimeWebhookConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::CreateChimeWebhookConfiguration, request);
  }
 
  template <typename CreateChimeWebhookConfigurationRequestT = Model::CreateChimeWebhookConfigurationRequest>
  void CreateChimeWebhookConfigurationAsync(const CreateChimeWebhookConfigurationRequestT& request,
                                            const CreateChimeWebhookConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::CreateChimeWebhookConfiguration, request, handler, context);
  }
 
  virtual Model::CreateCustomActionOutcome CreateCustomAction(const Model::CreateCustomActionRequest& request) const;
 
  template <typename CreateCustomActionRequestT = Model::CreateCustomActionRequest>
  Model::CreateCustomActionOutcomeCallable CreateCustomActionCallable(const CreateCustomActionRequestT& request) const {
    return SubmitCallable(&ChatbotClient::CreateCustomAction, request);
  }
 
  template <typename CreateCustomActionRequestT = Model::CreateCustomActionRequest>
  void CreateCustomActionAsync(const CreateCustomActionRequestT& request, const CreateCustomActionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::CreateCustomAction, request, handler, context);
  }
 
  virtual Model::CreateMicrosoftTeamsChannelConfigurationOutcome CreateMicrosoftTeamsChannelConfiguration(
      const Model::CreateMicrosoftTeamsChannelConfigurationRequest& request) const;
 
  template <typename CreateMicrosoftTeamsChannelConfigurationRequestT = Model::CreateMicrosoftTeamsChannelConfigurationRequest>
  Model::CreateMicrosoftTeamsChannelConfigurationOutcomeCallable CreateMicrosoftTeamsChannelConfigurationCallable(
      const CreateMicrosoftTeamsChannelConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::CreateMicrosoftTeamsChannelConfiguration, request);
  }
 
  template <typename CreateMicrosoftTeamsChannelConfigurationRequestT = Model::CreateMicrosoftTeamsChannelConfigurationRequest>
  void CreateMicrosoftTeamsChannelConfigurationAsync(
      const CreateMicrosoftTeamsChannelConfigurationRequestT& request,
      const CreateMicrosoftTeamsChannelConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::CreateMicrosoftTeamsChannelConfiguration, request, handler, context);
  }
 
  virtual Model::CreateSlackChannelConfigurationOutcome CreateSlackChannelConfiguration(
      const Model::CreateSlackChannelConfigurationRequest& request) const;
 
  template <typename CreateSlackChannelConfigurationRequestT = Model::CreateSlackChannelConfigurationRequest>
  Model::CreateSlackChannelConfigurationOutcomeCallable CreateSlackChannelConfigurationCallable(
      const CreateSlackChannelConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::CreateSlackChannelConfiguration, request);
  }
 
  template <typename CreateSlackChannelConfigurationRequestT = Model::CreateSlackChannelConfigurationRequest>
  void CreateSlackChannelConfigurationAsync(const CreateSlackChannelConfigurationRequestT& request,
                                            const CreateSlackChannelConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::CreateSlackChannelConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteChimeWebhookConfigurationOutcome DeleteChimeWebhookConfiguration(
      const Model::DeleteChimeWebhookConfigurationRequest& request) const;
 
  template <typename DeleteChimeWebhookConfigurationRequestT = Model::DeleteChimeWebhookConfigurationRequest>
  Model::DeleteChimeWebhookConfigurationOutcomeCallable DeleteChimeWebhookConfigurationCallable(
      const DeleteChimeWebhookConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DeleteChimeWebhookConfiguration, request);
  }
 
  template <typename DeleteChimeWebhookConfigurationRequestT = Model::DeleteChimeWebhookConfigurationRequest>
  void DeleteChimeWebhookConfigurationAsync(const DeleteChimeWebhookConfigurationRequestT& request,
                                            const DeleteChimeWebhookConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DeleteChimeWebhookConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteCustomActionOutcome DeleteCustomAction(const Model::DeleteCustomActionRequest& request) const;
 
  template <typename DeleteCustomActionRequestT = Model::DeleteCustomActionRequest>
  Model::DeleteCustomActionOutcomeCallable DeleteCustomActionCallable(const DeleteCustomActionRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DeleteCustomAction, request);
  }
 
  template <typename DeleteCustomActionRequestT = Model::DeleteCustomActionRequest>
  void DeleteCustomActionAsync(const DeleteCustomActionRequestT& request, const DeleteCustomActionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DeleteCustomAction, request, handler, context);
  }
 
  virtual Model::DeleteMicrosoftTeamsChannelConfigurationOutcome DeleteMicrosoftTeamsChannelConfiguration(
      const Model::DeleteMicrosoftTeamsChannelConfigurationRequest& request) const;
 
  template <typename DeleteMicrosoftTeamsChannelConfigurationRequestT = Model::DeleteMicrosoftTeamsChannelConfigurationRequest>
  Model::DeleteMicrosoftTeamsChannelConfigurationOutcomeCallable DeleteMicrosoftTeamsChannelConfigurationCallable(
      const DeleteMicrosoftTeamsChannelConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DeleteMicrosoftTeamsChannelConfiguration, request);
  }
 
  template <typename DeleteMicrosoftTeamsChannelConfigurationRequestT = Model::DeleteMicrosoftTeamsChannelConfigurationRequest>
  void DeleteMicrosoftTeamsChannelConfigurationAsync(
      const DeleteMicrosoftTeamsChannelConfigurationRequestT& request,
      const DeleteMicrosoftTeamsChannelConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DeleteMicrosoftTeamsChannelConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteMicrosoftTeamsConfiguredTeamOutcome DeleteMicrosoftTeamsConfiguredTeam(
      const Model::DeleteMicrosoftTeamsConfiguredTeamRequest& request) const;
 
  template <typename DeleteMicrosoftTeamsConfiguredTeamRequestT = Model::DeleteMicrosoftTeamsConfiguredTeamRequest>
  Model::DeleteMicrosoftTeamsConfiguredTeamOutcomeCallable DeleteMicrosoftTeamsConfiguredTeamCallable(
      const DeleteMicrosoftTeamsConfiguredTeamRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DeleteMicrosoftTeamsConfiguredTeam, request);
  }
 
  template <typename DeleteMicrosoftTeamsConfiguredTeamRequestT = Model::DeleteMicrosoftTeamsConfiguredTeamRequest>
  void DeleteMicrosoftTeamsConfiguredTeamAsync(const DeleteMicrosoftTeamsConfiguredTeamRequestT& request,
                                               const DeleteMicrosoftTeamsConfiguredTeamResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DeleteMicrosoftTeamsConfiguredTeam, request, handler, context);
  }
 
  virtual Model::DeleteMicrosoftTeamsUserIdentityOutcome DeleteMicrosoftTeamsUserIdentity(
      const Model::DeleteMicrosoftTeamsUserIdentityRequest& request) const;
 
  template <typename DeleteMicrosoftTeamsUserIdentityRequestT = Model::DeleteMicrosoftTeamsUserIdentityRequest>
  Model::DeleteMicrosoftTeamsUserIdentityOutcomeCallable DeleteMicrosoftTeamsUserIdentityCallable(
      const DeleteMicrosoftTeamsUserIdentityRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DeleteMicrosoftTeamsUserIdentity, request);
  }
 
  template <typename DeleteMicrosoftTeamsUserIdentityRequestT = Model::DeleteMicrosoftTeamsUserIdentityRequest>
  void DeleteMicrosoftTeamsUserIdentityAsync(const DeleteMicrosoftTeamsUserIdentityRequestT& request,
                                             const DeleteMicrosoftTeamsUserIdentityResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DeleteMicrosoftTeamsUserIdentity, request, handler, context);
  }
 
  virtual Model::DeleteSlackChannelConfigurationOutcome DeleteSlackChannelConfiguration(
      const Model::DeleteSlackChannelConfigurationRequest& request) const;
 
  template <typename DeleteSlackChannelConfigurationRequestT = Model::DeleteSlackChannelConfigurationRequest>
  Model::DeleteSlackChannelConfigurationOutcomeCallable DeleteSlackChannelConfigurationCallable(
      const DeleteSlackChannelConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DeleteSlackChannelConfiguration, request);
  }
 
  template <typename DeleteSlackChannelConfigurationRequestT = Model::DeleteSlackChannelConfigurationRequest>
  void DeleteSlackChannelConfigurationAsync(const DeleteSlackChannelConfigurationRequestT& request,
                                            const DeleteSlackChannelConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DeleteSlackChannelConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteSlackUserIdentityOutcome DeleteSlackUserIdentity(const Model::DeleteSlackUserIdentityRequest& request) const;
 
  template <typename DeleteSlackUserIdentityRequestT = Model::DeleteSlackUserIdentityRequest>
  Model::DeleteSlackUserIdentityOutcomeCallable DeleteSlackUserIdentityCallable(const DeleteSlackUserIdentityRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DeleteSlackUserIdentity, request);
  }
 
  template <typename DeleteSlackUserIdentityRequestT = Model::DeleteSlackUserIdentityRequest>
  void DeleteSlackUserIdentityAsync(const DeleteSlackUserIdentityRequestT& request,
                                    const DeleteSlackUserIdentityResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DeleteSlackUserIdentity, request, handler, context);
  }
 
  virtual Model::DeleteSlackWorkspaceAuthorizationOutcome DeleteSlackWorkspaceAuthorization(
      const Model::DeleteSlackWorkspaceAuthorizationRequest& request) const;
 
  template <typename DeleteSlackWorkspaceAuthorizationRequestT = Model::DeleteSlackWorkspaceAuthorizationRequest>
  Model::DeleteSlackWorkspaceAuthorizationOutcomeCallable DeleteSlackWorkspaceAuthorizationCallable(
      const DeleteSlackWorkspaceAuthorizationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DeleteSlackWorkspaceAuthorization, request);
  }
 
  template <typename DeleteSlackWorkspaceAuthorizationRequestT = Model::DeleteSlackWorkspaceAuthorizationRequest>
  void DeleteSlackWorkspaceAuthorizationAsync(const DeleteSlackWorkspaceAuthorizationRequestT& request,
                                              const DeleteSlackWorkspaceAuthorizationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DeleteSlackWorkspaceAuthorization, request, handler, context);
  }
 
  virtual Model::DescribeChimeWebhookConfigurationsOutcome DescribeChimeWebhookConfigurations(
      const Model::DescribeChimeWebhookConfigurationsRequest& request = {}) const;
 
  template <typename DescribeChimeWebhookConfigurationsRequestT = Model::DescribeChimeWebhookConfigurationsRequest>
  Model::DescribeChimeWebhookConfigurationsOutcomeCallable DescribeChimeWebhookConfigurationsCallable(
      const DescribeChimeWebhookConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::DescribeChimeWebhookConfigurations, request);
  }
 
  template <typename DescribeChimeWebhookConfigurationsRequestT = Model::DescribeChimeWebhookConfigurationsRequest>
  void DescribeChimeWebhookConfigurationsAsync(const DescribeChimeWebhookConfigurationsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeChimeWebhookConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::DescribeChimeWebhookConfigurations, request, handler, context);
  }
 
  virtual Model::DescribeSlackChannelConfigurationsOutcome DescribeSlackChannelConfigurations(
      const Model::DescribeSlackChannelConfigurationsRequest& request = {}) const;
 
  template <typename DescribeSlackChannelConfigurationsRequestT = Model::DescribeSlackChannelConfigurationsRequest>
  Model::DescribeSlackChannelConfigurationsOutcomeCallable DescribeSlackChannelConfigurationsCallable(
      const DescribeSlackChannelConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::DescribeSlackChannelConfigurations, request);
  }
 
  template <typename DescribeSlackChannelConfigurationsRequestT = Model::DescribeSlackChannelConfigurationsRequest>
  void DescribeSlackChannelConfigurationsAsync(const DescribeSlackChannelConfigurationsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeSlackChannelConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::DescribeSlackChannelConfigurations, request, handler, context);
  }
 
  virtual Model::DescribeSlackUserIdentitiesOutcome DescribeSlackUserIdentities(
      const Model::DescribeSlackUserIdentitiesRequest& request = {}) const;
 
  template <typename DescribeSlackUserIdentitiesRequestT = Model::DescribeSlackUserIdentitiesRequest>
  Model::DescribeSlackUserIdentitiesOutcomeCallable DescribeSlackUserIdentitiesCallable(
      const DescribeSlackUserIdentitiesRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::DescribeSlackUserIdentities, request);
  }
 
  template <typename DescribeSlackUserIdentitiesRequestT = Model::DescribeSlackUserIdentitiesRequest>
  void DescribeSlackUserIdentitiesAsync(const DescribeSlackUserIdentitiesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeSlackUserIdentitiesRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::DescribeSlackUserIdentities, request, handler, context);
  }
 
  virtual Model::DescribeSlackWorkspacesOutcome DescribeSlackWorkspaces(const Model::DescribeSlackWorkspacesRequest& request = {}) const;
 
  template <typename DescribeSlackWorkspacesRequestT = Model::DescribeSlackWorkspacesRequest>
  Model::DescribeSlackWorkspacesOutcomeCallable DescribeSlackWorkspacesCallable(const DescribeSlackWorkspacesRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::DescribeSlackWorkspaces, request);
  }
 
  template <typename DescribeSlackWorkspacesRequestT = Model::DescribeSlackWorkspacesRequest>
  void DescribeSlackWorkspacesAsync(const DescribeSlackWorkspacesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeSlackWorkspacesRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::DescribeSlackWorkspaces, request, handler, context);
  }
 
  virtual Model::DisassociateFromConfigurationOutcome DisassociateFromConfiguration(
      const Model::DisassociateFromConfigurationRequest& request) const;
 
  template <typename DisassociateFromConfigurationRequestT = Model::DisassociateFromConfigurationRequest>
  Model::DisassociateFromConfigurationOutcomeCallable DisassociateFromConfigurationCallable(
      const DisassociateFromConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::DisassociateFromConfiguration, request);
  }
 
  template <typename DisassociateFromConfigurationRequestT = Model::DisassociateFromConfigurationRequest>
  void DisassociateFromConfigurationAsync(const DisassociateFromConfigurationRequestT& request,
                                          const DisassociateFromConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::DisassociateFromConfiguration, request, handler, context);
  }
 
  virtual Model::GetAccountPreferencesOutcome GetAccountPreferences(const Model::GetAccountPreferencesRequest& request = {}) const;
 
  template <typename GetAccountPreferencesRequestT = Model::GetAccountPreferencesRequest>
  Model::GetAccountPreferencesOutcomeCallable GetAccountPreferencesCallable(const GetAccountPreferencesRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::GetAccountPreferences, request);
  }
 
  template <typename GetAccountPreferencesRequestT = Model::GetAccountPreferencesRequest>
  void GetAccountPreferencesAsync(const GetAccountPreferencesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const GetAccountPreferencesRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::GetAccountPreferences, request, handler, context);
  }
 
  virtual Model::GetCustomActionOutcome GetCustomAction(const Model::GetCustomActionRequest& request) const;
 
  template <typename GetCustomActionRequestT = Model::GetCustomActionRequest>
  Model::GetCustomActionOutcomeCallable GetCustomActionCallable(const GetCustomActionRequestT& request) const {
    return SubmitCallable(&ChatbotClient::GetCustomAction, request);
  }
 
  template <typename GetCustomActionRequestT = Model::GetCustomActionRequest>
  void GetCustomActionAsync(const GetCustomActionRequestT& request, const GetCustomActionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::GetCustomAction, request, handler, context);
  }
 
  virtual Model::GetMicrosoftTeamsChannelConfigurationOutcome GetMicrosoftTeamsChannelConfiguration(
      const Model::GetMicrosoftTeamsChannelConfigurationRequest& request) const;
 
  template <typename GetMicrosoftTeamsChannelConfigurationRequestT = Model::GetMicrosoftTeamsChannelConfigurationRequest>
  Model::GetMicrosoftTeamsChannelConfigurationOutcomeCallable GetMicrosoftTeamsChannelConfigurationCallable(
      const GetMicrosoftTeamsChannelConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::GetMicrosoftTeamsChannelConfiguration, request);
  }
 
  template <typename GetMicrosoftTeamsChannelConfigurationRequestT = Model::GetMicrosoftTeamsChannelConfigurationRequest>
  void GetMicrosoftTeamsChannelConfigurationAsync(const GetMicrosoftTeamsChannelConfigurationRequestT& request,
                                                  const GetMicrosoftTeamsChannelConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::GetMicrosoftTeamsChannelConfiguration, request, handler, context);
  }
 
  virtual Model::ListAssociationsOutcome ListAssociations(const Model::ListAssociationsRequest& request) const;
 
  template <typename ListAssociationsRequestT = Model::ListAssociationsRequest>
  Model::ListAssociationsOutcomeCallable ListAssociationsCallable(const ListAssociationsRequestT& request) const {
    return SubmitCallable(&ChatbotClient::ListAssociations, request);
  }
 
  template <typename ListAssociationsRequestT = Model::ListAssociationsRequest>
  void ListAssociationsAsync(const ListAssociationsRequestT& request, const ListAssociationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::ListAssociations, request, handler, context);
  }
 
  virtual Model::ListCustomActionsOutcome ListCustomActions(const Model::ListCustomActionsRequest& request = {}) const;
 
  template <typename ListCustomActionsRequestT = Model::ListCustomActionsRequest>
  Model::ListCustomActionsOutcomeCallable ListCustomActionsCallable(const ListCustomActionsRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::ListCustomActions, request);
  }
 
  template <typename ListCustomActionsRequestT = Model::ListCustomActionsRequest>
  void ListCustomActionsAsync(const ListCustomActionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListCustomActionsRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::ListCustomActions, request, handler, context);
  }
 
  virtual Model::ListMicrosoftTeamsChannelConfigurationsOutcome ListMicrosoftTeamsChannelConfigurations(
      const Model::ListMicrosoftTeamsChannelConfigurationsRequest& request = {}) const;
 
  template <typename ListMicrosoftTeamsChannelConfigurationsRequestT = Model::ListMicrosoftTeamsChannelConfigurationsRequest>
  Model::ListMicrosoftTeamsChannelConfigurationsOutcomeCallable ListMicrosoftTeamsChannelConfigurationsCallable(
      const ListMicrosoftTeamsChannelConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::ListMicrosoftTeamsChannelConfigurations, request);
  }
 
  template <typename ListMicrosoftTeamsChannelConfigurationsRequestT = Model::ListMicrosoftTeamsChannelConfigurationsRequest>
  void ListMicrosoftTeamsChannelConfigurationsAsync(const ListMicrosoftTeamsChannelConfigurationsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                    const ListMicrosoftTeamsChannelConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::ListMicrosoftTeamsChannelConfigurations, request, handler, context);
  }
 
  virtual Model::ListMicrosoftTeamsConfiguredTeamsOutcome ListMicrosoftTeamsConfiguredTeams(
      const Model::ListMicrosoftTeamsConfiguredTeamsRequest& request = {}) const;
 
  template <typename ListMicrosoftTeamsConfiguredTeamsRequestT = Model::ListMicrosoftTeamsConfiguredTeamsRequest>
  Model::ListMicrosoftTeamsConfiguredTeamsOutcomeCallable ListMicrosoftTeamsConfiguredTeamsCallable(
      const ListMicrosoftTeamsConfiguredTeamsRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::ListMicrosoftTeamsConfiguredTeams, request);
  }
 
  template <typename ListMicrosoftTeamsConfiguredTeamsRequestT = Model::ListMicrosoftTeamsConfiguredTeamsRequest>
  void ListMicrosoftTeamsConfiguredTeamsAsync(const ListMicrosoftTeamsConfiguredTeamsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const ListMicrosoftTeamsConfiguredTeamsRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::ListMicrosoftTeamsConfiguredTeams, request, handler, context);
  }
 
  virtual Model::ListMicrosoftTeamsUserIdentitiesOutcome ListMicrosoftTeamsUserIdentities(
      const Model::ListMicrosoftTeamsUserIdentitiesRequest& request = {}) const;
 
  template <typename ListMicrosoftTeamsUserIdentitiesRequestT = Model::ListMicrosoftTeamsUserIdentitiesRequest>
  Model::ListMicrosoftTeamsUserIdentitiesOutcomeCallable ListMicrosoftTeamsUserIdentitiesCallable(
      const ListMicrosoftTeamsUserIdentitiesRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::ListMicrosoftTeamsUserIdentities, request);
  }
 
  template <typename ListMicrosoftTeamsUserIdentitiesRequestT = Model::ListMicrosoftTeamsUserIdentitiesRequest>
  void ListMicrosoftTeamsUserIdentitiesAsync(const ListMicrosoftTeamsUserIdentitiesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const ListMicrosoftTeamsUserIdentitiesRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::ListMicrosoftTeamsUserIdentities, 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(&ChatbotClient::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(&ChatbotClient::ListTagsForResource, 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(&ChatbotClient::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(&ChatbotClient::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(&ChatbotClient::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(&ChatbotClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccountPreferencesOutcome UpdateAccountPreferences(const Model::UpdateAccountPreferencesRequest& request = {}) const;
 
  template <typename UpdateAccountPreferencesRequestT = Model::UpdateAccountPreferencesRequest>
  Model::UpdateAccountPreferencesOutcomeCallable UpdateAccountPreferencesCallable(
      const UpdateAccountPreferencesRequestT& request = {}) const {
    return SubmitCallable(&ChatbotClient::UpdateAccountPreferences, request);
  }
 
  template <typename UpdateAccountPreferencesRequestT = Model::UpdateAccountPreferencesRequest>
  void UpdateAccountPreferencesAsync(const UpdateAccountPreferencesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const UpdateAccountPreferencesRequestT& request = {}) const {
    return SubmitAsync(&ChatbotClient::UpdateAccountPreferences, request, handler, context);
  }
 
  virtual Model::UpdateChimeWebhookConfigurationOutcome UpdateChimeWebhookConfiguration(
      const Model::UpdateChimeWebhookConfigurationRequest& request) const;
 
  template <typename UpdateChimeWebhookConfigurationRequestT = Model::UpdateChimeWebhookConfigurationRequest>
  Model::UpdateChimeWebhookConfigurationOutcomeCallable UpdateChimeWebhookConfigurationCallable(
      const UpdateChimeWebhookConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::UpdateChimeWebhookConfiguration, request);
  }
 
  template <typename UpdateChimeWebhookConfigurationRequestT = Model::UpdateChimeWebhookConfigurationRequest>
  void UpdateChimeWebhookConfigurationAsync(const UpdateChimeWebhookConfigurationRequestT& request,
                                            const UpdateChimeWebhookConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::UpdateChimeWebhookConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateCustomActionOutcome UpdateCustomAction(const Model::UpdateCustomActionRequest& request) const;
 
  template <typename UpdateCustomActionRequestT = Model::UpdateCustomActionRequest>
  Model::UpdateCustomActionOutcomeCallable UpdateCustomActionCallable(const UpdateCustomActionRequestT& request) const {
    return SubmitCallable(&ChatbotClient::UpdateCustomAction, request);
  }
 
  template <typename UpdateCustomActionRequestT = Model::UpdateCustomActionRequest>
  void UpdateCustomActionAsync(const UpdateCustomActionRequestT& request, const UpdateCustomActionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::UpdateCustomAction, request, handler, context);
  }
 
  virtual Model::UpdateMicrosoftTeamsChannelConfigurationOutcome UpdateMicrosoftTeamsChannelConfiguration(
      const Model::UpdateMicrosoftTeamsChannelConfigurationRequest& request) const;
 
  template <typename UpdateMicrosoftTeamsChannelConfigurationRequestT = Model::UpdateMicrosoftTeamsChannelConfigurationRequest>
  Model::UpdateMicrosoftTeamsChannelConfigurationOutcomeCallable UpdateMicrosoftTeamsChannelConfigurationCallable(
      const UpdateMicrosoftTeamsChannelConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::UpdateMicrosoftTeamsChannelConfiguration, request);
  }
 
  template <typename UpdateMicrosoftTeamsChannelConfigurationRequestT = Model::UpdateMicrosoftTeamsChannelConfigurationRequest>
  void UpdateMicrosoftTeamsChannelConfigurationAsync(
      const UpdateMicrosoftTeamsChannelConfigurationRequestT& request,
      const UpdateMicrosoftTeamsChannelConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::UpdateMicrosoftTeamsChannelConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateSlackChannelConfigurationOutcome UpdateSlackChannelConfiguration(
      const Model::UpdateSlackChannelConfigurationRequest& request) const;
 
  template <typename UpdateSlackChannelConfigurationRequestT = Model::UpdateSlackChannelConfigurationRequest>
  Model::UpdateSlackChannelConfigurationOutcomeCallable UpdateSlackChannelConfigurationCallable(
      const UpdateSlackChannelConfigurationRequestT& request) const {
    return SubmitCallable(&ChatbotClient::UpdateSlackChannelConfiguration, request);
  }
 
  template <typename UpdateSlackChannelConfigurationRequestT = Model::UpdateSlackChannelConfigurationRequest>
  void UpdateSlackChannelConfigurationAsync(const UpdateSlackChannelConfigurationRequestT& request,
                                            const UpdateSlackChannelConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ChatbotClient::UpdateSlackChannelConfiguration, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<ChatbotEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ChatbotClient>;
  void init(const ChatbotClientConfiguration& clientConfiguration);
 
  ChatbotClientConfiguration m_clientConfiguration;
  std::shared_ptr<ChatbotEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace chatbot
}  // namespace Aws