SupportAppClient.h

 
#pragma once
#include <aws/support-app/SupportApp_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/support-app/SupportAppServiceClientModel.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/support-app/SupportAppErrorMarshaller.h>
 
namespace Aws
{
namespace SupportApp
{
  AWS_SUPPORTAPP_API extern const char SERVICE_NAME[];
  class AWS_SUPPORTAPP_API SupportAppClient : smithy::client::AwsSmithyClientT<Aws::SupportApp::SERVICE_NAME,
      Aws::SupportApp::SupportAppClientConfiguration,
      smithy::SigV4AuthSchemeResolver<>,
      Aws::Crt::Variant<smithy::SigV4AuthScheme>,
      SupportAppEndpointProviderBase,
      smithy::client::JsonOutcomeSerializer,
      smithy::client::JsonOutcome,
      Aws::Client::SupportAppErrorMarshaller>,
    Aws::Client::ClientWithAsyncTemplateMethods<SupportAppClient>
  {
    public:
      static const char* GetServiceName();
      static const char* GetAllocationTag();
      inline const char* GetServiceClientName() const override { return "Support App"; }
 
      typedef SupportAppClientConfiguration ClientConfigurationType;
      typedef SupportAppEndpointProvider EndpointProviderType;
 
        SupportAppClient(const Aws::SupportApp::SupportAppClientConfiguration& clientConfiguration = Aws::SupportApp::SupportAppClientConfiguration(),
                         std::shared_ptr<SupportAppEndpointProviderBase> endpointProvider = nullptr);
 
        SupportAppClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<SupportAppEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::SupportApp::SupportAppClientConfiguration& clientConfiguration = Aws::SupportApp::SupportAppClientConfiguration());
 
        SupportAppClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<SupportAppEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::SupportApp::SupportAppClientConfiguration& clientConfiguration = Aws::SupportApp::SupportAppClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SupportAppClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SupportAppClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SupportAppClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SupportAppClient();
 
        virtual Model::CreateSlackChannelConfigurationOutcome CreateSlackChannelConfiguration(const Model::CreateSlackChannelConfigurationRequest& request) const;
 
        template<typename CreateSlackChannelConfigurationRequestT = Model::CreateSlackChannelConfigurationRequest>
        Model::CreateSlackChannelConfigurationOutcomeCallable CreateSlackChannelConfigurationCallable(const CreateSlackChannelConfigurationRequestT& request) const
        {
            return SubmitCallable(&SupportAppClient::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(&SupportAppClient::CreateSlackChannelConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteAccountAliasOutcome DeleteAccountAlias(const Model::DeleteAccountAliasRequest& request = {}) const;
 
        template<typename DeleteAccountAliasRequestT = Model::DeleteAccountAliasRequest>
        Model::DeleteAccountAliasOutcomeCallable DeleteAccountAliasCallable(const DeleteAccountAliasRequestT& request = {}) const
        {
            return SubmitCallable(&SupportAppClient::DeleteAccountAlias, request);
        }
 
        template<typename DeleteAccountAliasRequestT = Model::DeleteAccountAliasRequest>
        void DeleteAccountAliasAsync(const DeleteAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteAccountAliasRequestT& request = {}) const
        {
            return SubmitAsync(&SupportAppClient::DeleteAccountAlias, 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(&SupportAppClient::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(&SupportAppClient::DeleteSlackChannelConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteSlackWorkspaceConfigurationOutcome DeleteSlackWorkspaceConfiguration(const Model::DeleteSlackWorkspaceConfigurationRequest& request) const;
 
        template<typename DeleteSlackWorkspaceConfigurationRequestT = Model::DeleteSlackWorkspaceConfigurationRequest>
        Model::DeleteSlackWorkspaceConfigurationOutcomeCallable DeleteSlackWorkspaceConfigurationCallable(const DeleteSlackWorkspaceConfigurationRequestT& request) const
        {
            return SubmitCallable(&SupportAppClient::DeleteSlackWorkspaceConfiguration, request);
        }
 
        template<typename DeleteSlackWorkspaceConfigurationRequestT = Model::DeleteSlackWorkspaceConfigurationRequest>
        void DeleteSlackWorkspaceConfigurationAsync(const DeleteSlackWorkspaceConfigurationRequestT& request, const DeleteSlackWorkspaceConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupportAppClient::DeleteSlackWorkspaceConfiguration, request, handler, context);
        }
 
        virtual Model::GetAccountAliasOutcome GetAccountAlias(const Model::GetAccountAliasRequest& request = {}) const;
 
        template<typename GetAccountAliasRequestT = Model::GetAccountAliasRequest>
        Model::GetAccountAliasOutcomeCallable GetAccountAliasCallable(const GetAccountAliasRequestT& request = {}) const
        {
            return SubmitCallable(&SupportAppClient::GetAccountAlias, request);
        }
 
        template<typename GetAccountAliasRequestT = Model::GetAccountAliasRequest>
        void GetAccountAliasAsync(const GetAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountAliasRequestT& request = {}) const
        {
            return SubmitAsync(&SupportAppClient::GetAccountAlias, request, handler, context);
        }
 
        virtual Model::ListSlackChannelConfigurationsOutcome ListSlackChannelConfigurations(const Model::ListSlackChannelConfigurationsRequest& request = {}) const;
 
        template<typename ListSlackChannelConfigurationsRequestT = Model::ListSlackChannelConfigurationsRequest>
        Model::ListSlackChannelConfigurationsOutcomeCallable ListSlackChannelConfigurationsCallable(const ListSlackChannelConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&SupportAppClient::ListSlackChannelConfigurations, request);
        }
 
        template<typename ListSlackChannelConfigurationsRequestT = Model::ListSlackChannelConfigurationsRequest>
        void ListSlackChannelConfigurationsAsync(const ListSlackChannelConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSlackChannelConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&SupportAppClient::ListSlackChannelConfigurations, request, handler, context);
        }
 
        virtual Model::ListSlackWorkspaceConfigurationsOutcome ListSlackWorkspaceConfigurations(const Model::ListSlackWorkspaceConfigurationsRequest& request = {}) const;
 
        template<typename ListSlackWorkspaceConfigurationsRequestT = Model::ListSlackWorkspaceConfigurationsRequest>
        Model::ListSlackWorkspaceConfigurationsOutcomeCallable ListSlackWorkspaceConfigurationsCallable(const ListSlackWorkspaceConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&SupportAppClient::ListSlackWorkspaceConfigurations, request);
        }
 
        template<typename ListSlackWorkspaceConfigurationsRequestT = Model::ListSlackWorkspaceConfigurationsRequest>
        void ListSlackWorkspaceConfigurationsAsync(const ListSlackWorkspaceConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSlackWorkspaceConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&SupportAppClient::ListSlackWorkspaceConfigurations, request, handler, context);
        }
 
        virtual Model::PutAccountAliasOutcome PutAccountAlias(const Model::PutAccountAliasRequest& request) const;
 
        template<typename PutAccountAliasRequestT = Model::PutAccountAliasRequest>
        Model::PutAccountAliasOutcomeCallable PutAccountAliasCallable(const PutAccountAliasRequestT& request) const
        {
            return SubmitCallable(&SupportAppClient::PutAccountAlias, request);
        }
 
        template<typename PutAccountAliasRequestT = Model::PutAccountAliasRequest>
        void PutAccountAliasAsync(const PutAccountAliasRequestT& request, const PutAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupportAppClient::PutAccountAlias, request, handler, context);
        }
 
        virtual Model::RegisterSlackWorkspaceForOrganizationOutcome RegisterSlackWorkspaceForOrganization(const Model::RegisterSlackWorkspaceForOrganizationRequest& request) const;
 
        template<typename RegisterSlackWorkspaceForOrganizationRequestT = Model::RegisterSlackWorkspaceForOrganizationRequest>
        Model::RegisterSlackWorkspaceForOrganizationOutcomeCallable RegisterSlackWorkspaceForOrganizationCallable(const RegisterSlackWorkspaceForOrganizationRequestT& request) const
        {
            return SubmitCallable(&SupportAppClient::RegisterSlackWorkspaceForOrganization, request);
        }
 
        template<typename RegisterSlackWorkspaceForOrganizationRequestT = Model::RegisterSlackWorkspaceForOrganizationRequest>
        void RegisterSlackWorkspaceForOrganizationAsync(const RegisterSlackWorkspaceForOrganizationRequestT& request, const RegisterSlackWorkspaceForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupportAppClient::RegisterSlackWorkspaceForOrganization, 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(&SupportAppClient::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(&SupportAppClient::UpdateSlackChannelConfiguration, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SupportAppEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SupportAppClient>;
 
  };
 
} // namespace SupportApp
} // namespace Aws