ChatbotClient.h

 
#pragma once
#include <aws/chatbot/Chatbot_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/chatbot/ChatbotServiceClientModel.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/identity/auth/built-in/SigV4AuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
#include <smithy/client/serializer/JsonOutcomeSerializer.h>
#include <aws/chatbot/ChatbotErrorMarshaller.h>
 
namespace Aws
{
namespace chatbot
{
  AWS_CHATBOT_API extern const char SERVICE_NAME[];
  class AWS_CHATBOT_API ChatbotClient : smithy::client::AwsSmithyClientT<Aws::chatbot::SERVICE_NAME,
      Aws::chatbot::ChatbotClientConfiguration,
      smithy::SigV4AuthSchemeResolver<>,
      Aws::Crt::Variant<smithy::SigV4AuthScheme>,
      ChatbotEndpointProviderBase,
      smithy::client::JsonOutcomeSerializer,
      smithy::client::JsonOutcome,
      Aws::Client::ChatbotErrorMarshaller>,
    Aws::Client::ClientWithAsyncTemplateMethods<ChatbotClient>
  {
    public:
      static const char* GetServiceName();
      static const char* GetAllocationTag();
      inline const char* GetServiceClientName() const override { return "chatbot"; }
 
      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>;
 
  };
 
} // namespace chatbot
} // namespace Aws