AppIntegrationsServiceClient.h

 
#pragma once
#include <aws/appintegrations/AppIntegrationsService_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/appintegrations/AppIntegrationsServiceServiceClientModel.h>
 
namespace Aws
{
namespace AppIntegrationsService
{
  class AWS_APPINTEGRATIONSSERVICE_API AppIntegrationsServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AppIntegrationsServiceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AppIntegrationsServiceClientConfiguration ClientConfigurationType;
      typedef AppIntegrationsServiceEndpointProvider EndpointProviderType;
 
        AppIntegrationsServiceClient(const Aws::AppIntegrationsService::AppIntegrationsServiceClientConfiguration& clientConfiguration = Aws::AppIntegrationsService::AppIntegrationsServiceClientConfiguration(),
                                     std::shared_ptr<AppIntegrationsServiceEndpointProviderBase> endpointProvider = nullptr);
 
        AppIntegrationsServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                     std::shared_ptr<AppIntegrationsServiceEndpointProviderBase> endpointProvider = nullptr,
                                     const Aws::AppIntegrationsService::AppIntegrationsServiceClientConfiguration& clientConfiguration = Aws::AppIntegrationsService::AppIntegrationsServiceClientConfiguration());
 
        AppIntegrationsServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                     std::shared_ptr<AppIntegrationsServiceEndpointProviderBase> endpointProvider = nullptr,
                                     const Aws::AppIntegrationsService::AppIntegrationsServiceClientConfiguration& clientConfiguration = Aws::AppIntegrationsService::AppIntegrationsServiceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AppIntegrationsServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppIntegrationsServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppIntegrationsServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AppIntegrationsServiceClient();
 
        virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::CreateApplication, request);
        }
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::CreateApplication, request, handler, context);
        }
 
        virtual Model::CreateDataIntegrationOutcome CreateDataIntegration(const Model::CreateDataIntegrationRequest& request) const;
 
        template<typename CreateDataIntegrationRequestT = Model::CreateDataIntegrationRequest>
        Model::CreateDataIntegrationOutcomeCallable CreateDataIntegrationCallable(const CreateDataIntegrationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::CreateDataIntegration, request);
        }
 
        template<typename CreateDataIntegrationRequestT = Model::CreateDataIntegrationRequest>
        void CreateDataIntegrationAsync(const CreateDataIntegrationRequestT& request, const CreateDataIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::CreateDataIntegration, request, handler, context);
        }
 
        virtual Model::CreateDataIntegrationAssociationOutcome CreateDataIntegrationAssociation(const Model::CreateDataIntegrationAssociationRequest& request) const;
 
        template<typename CreateDataIntegrationAssociationRequestT = Model::CreateDataIntegrationAssociationRequest>
        Model::CreateDataIntegrationAssociationOutcomeCallable CreateDataIntegrationAssociationCallable(const CreateDataIntegrationAssociationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::CreateDataIntegrationAssociation, request);
        }
 
        template<typename CreateDataIntegrationAssociationRequestT = Model::CreateDataIntegrationAssociationRequest>
        void CreateDataIntegrationAssociationAsync(const CreateDataIntegrationAssociationRequestT& request, const CreateDataIntegrationAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::CreateDataIntegrationAssociation, request, handler, context);
        }
 
        virtual Model::CreateEventIntegrationOutcome CreateEventIntegration(const Model::CreateEventIntegrationRequest& request) const;
 
        template<typename CreateEventIntegrationRequestT = Model::CreateEventIntegrationRequest>
        Model::CreateEventIntegrationOutcomeCallable CreateEventIntegrationCallable(const CreateEventIntegrationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::CreateEventIntegration, request);
        }
 
        template<typename CreateEventIntegrationRequestT = Model::CreateEventIntegrationRequest>
        void CreateEventIntegrationAsync(const CreateEventIntegrationRequestT& request, const CreateEventIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::CreateEventIntegration, request, handler, context);
        }
 
        virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::DeleteApplication, request);
        }
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::DeleteApplication, request, handler, context);
        }
 
        virtual Model::DeleteDataIntegrationOutcome DeleteDataIntegration(const Model::DeleteDataIntegrationRequest& request) const;
 
        template<typename DeleteDataIntegrationRequestT = Model::DeleteDataIntegrationRequest>
        Model::DeleteDataIntegrationOutcomeCallable DeleteDataIntegrationCallable(const DeleteDataIntegrationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::DeleteDataIntegration, request);
        }
 
        template<typename DeleteDataIntegrationRequestT = Model::DeleteDataIntegrationRequest>
        void DeleteDataIntegrationAsync(const DeleteDataIntegrationRequestT& request, const DeleteDataIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::DeleteDataIntegration, request, handler, context);
        }
 
        virtual Model::DeleteEventIntegrationOutcome DeleteEventIntegration(const Model::DeleteEventIntegrationRequest& request) const;
 
        template<typename DeleteEventIntegrationRequestT = Model::DeleteEventIntegrationRequest>
        Model::DeleteEventIntegrationOutcomeCallable DeleteEventIntegrationCallable(const DeleteEventIntegrationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::DeleteEventIntegration, request);
        }
 
        template<typename DeleteEventIntegrationRequestT = Model::DeleteEventIntegrationRequest>
        void DeleteEventIntegrationAsync(const DeleteEventIntegrationRequestT& request, const DeleteEventIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::DeleteEventIntegration, request, handler, context);
        }
 
        virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::GetApplication, request);
        }
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::GetApplication, request, handler, context);
        }
 
        virtual Model::GetDataIntegrationOutcome GetDataIntegration(const Model::GetDataIntegrationRequest& request) const;
 
        template<typename GetDataIntegrationRequestT = Model::GetDataIntegrationRequest>
        Model::GetDataIntegrationOutcomeCallable GetDataIntegrationCallable(const GetDataIntegrationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::GetDataIntegration, request);
        }
 
        template<typename GetDataIntegrationRequestT = Model::GetDataIntegrationRequest>
        void GetDataIntegrationAsync(const GetDataIntegrationRequestT& request, const GetDataIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::GetDataIntegration, request, handler, context);
        }
 
        virtual Model::GetEventIntegrationOutcome GetEventIntegration(const Model::GetEventIntegrationRequest& request) const;
 
        template<typename GetEventIntegrationRequestT = Model::GetEventIntegrationRequest>
        Model::GetEventIntegrationOutcomeCallable GetEventIntegrationCallable(const GetEventIntegrationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::GetEventIntegration, request);
        }
 
        template<typename GetEventIntegrationRequestT = Model::GetEventIntegrationRequest>
        void GetEventIntegrationAsync(const GetEventIntegrationRequestT& request, const GetEventIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::GetEventIntegration, request, handler, context);
        }
 
        virtual Model::ListApplicationAssociationsOutcome ListApplicationAssociations(const Model::ListApplicationAssociationsRequest& request) const;
 
        template<typename ListApplicationAssociationsRequestT = Model::ListApplicationAssociationsRequest>
        Model::ListApplicationAssociationsOutcomeCallable ListApplicationAssociationsCallable(const ListApplicationAssociationsRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::ListApplicationAssociations, request);
        }
 
        template<typename ListApplicationAssociationsRequestT = Model::ListApplicationAssociationsRequest>
        void ListApplicationAssociationsAsync(const ListApplicationAssociationsRequestT& request, const ListApplicationAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::ListApplicationAssociations, request, handler, context);
        }
 
        virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::ListApplications, request);
        }
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::ListApplications, request, handler, context);
        }
 
        virtual Model::ListDataIntegrationAssociationsOutcome ListDataIntegrationAssociations(const Model::ListDataIntegrationAssociationsRequest& request) const;
 
        template<typename ListDataIntegrationAssociationsRequestT = Model::ListDataIntegrationAssociationsRequest>
        Model::ListDataIntegrationAssociationsOutcomeCallable ListDataIntegrationAssociationsCallable(const ListDataIntegrationAssociationsRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::ListDataIntegrationAssociations, request);
        }
 
        template<typename ListDataIntegrationAssociationsRequestT = Model::ListDataIntegrationAssociationsRequest>
        void ListDataIntegrationAssociationsAsync(const ListDataIntegrationAssociationsRequestT& request, const ListDataIntegrationAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::ListDataIntegrationAssociations, request, handler, context);
        }
 
        virtual Model::ListDataIntegrationsOutcome ListDataIntegrations(const Model::ListDataIntegrationsRequest& request = {}) const;
 
        template<typename ListDataIntegrationsRequestT = Model::ListDataIntegrationsRequest>
        Model::ListDataIntegrationsOutcomeCallable ListDataIntegrationsCallable(const ListDataIntegrationsRequestT& request = {}) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::ListDataIntegrations, request);
        }
 
        template<typename ListDataIntegrationsRequestT = Model::ListDataIntegrationsRequest>
        void ListDataIntegrationsAsync(const ListDataIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataIntegrationsRequestT& request = {}) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::ListDataIntegrations, request, handler, context);
        }
 
        virtual Model::ListEventIntegrationAssociationsOutcome ListEventIntegrationAssociations(const Model::ListEventIntegrationAssociationsRequest& request) const;
 
        template<typename ListEventIntegrationAssociationsRequestT = Model::ListEventIntegrationAssociationsRequest>
        Model::ListEventIntegrationAssociationsOutcomeCallable ListEventIntegrationAssociationsCallable(const ListEventIntegrationAssociationsRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::ListEventIntegrationAssociations, request);
        }
 
        template<typename ListEventIntegrationAssociationsRequestT = Model::ListEventIntegrationAssociationsRequest>
        void ListEventIntegrationAssociationsAsync(const ListEventIntegrationAssociationsRequestT& request, const ListEventIntegrationAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::ListEventIntegrationAssociations, request, handler, context);
        }
 
        virtual Model::ListEventIntegrationsOutcome ListEventIntegrations(const Model::ListEventIntegrationsRequest& request = {}) const;
 
        template<typename ListEventIntegrationsRequestT = Model::ListEventIntegrationsRequest>
        Model::ListEventIntegrationsOutcomeCallable ListEventIntegrationsCallable(const ListEventIntegrationsRequestT& request = {}) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::ListEventIntegrations, request);
        }
 
        template<typename ListEventIntegrationsRequestT = Model::ListEventIntegrationsRequest>
        void ListEventIntegrationsAsync(const ListEventIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEventIntegrationsRequestT& request = {}) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::ListEventIntegrations, 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(&AppIntegrationsServiceClient::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(&AppIntegrationsServiceClient::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(&AppIntegrationsServiceClient::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(&AppIntegrationsServiceClient::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(&AppIntegrationsServiceClient::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(&AppIntegrationsServiceClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::UpdateApplication, request);
        }
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::UpdateApplication, request, handler, context);
        }
 
        virtual Model::UpdateDataIntegrationOutcome UpdateDataIntegration(const Model::UpdateDataIntegrationRequest& request) const;
 
        template<typename UpdateDataIntegrationRequestT = Model::UpdateDataIntegrationRequest>
        Model::UpdateDataIntegrationOutcomeCallable UpdateDataIntegrationCallable(const UpdateDataIntegrationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::UpdateDataIntegration, request);
        }
 
        template<typename UpdateDataIntegrationRequestT = Model::UpdateDataIntegrationRequest>
        void UpdateDataIntegrationAsync(const UpdateDataIntegrationRequestT& request, const UpdateDataIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::UpdateDataIntegration, request, handler, context);
        }
 
        virtual Model::UpdateDataIntegrationAssociationOutcome UpdateDataIntegrationAssociation(const Model::UpdateDataIntegrationAssociationRequest& request) const;
 
        template<typename UpdateDataIntegrationAssociationRequestT = Model::UpdateDataIntegrationAssociationRequest>
        Model::UpdateDataIntegrationAssociationOutcomeCallable UpdateDataIntegrationAssociationCallable(const UpdateDataIntegrationAssociationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::UpdateDataIntegrationAssociation, request);
        }
 
        template<typename UpdateDataIntegrationAssociationRequestT = Model::UpdateDataIntegrationAssociationRequest>
        void UpdateDataIntegrationAssociationAsync(const UpdateDataIntegrationAssociationRequestT& request, const UpdateDataIntegrationAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::UpdateDataIntegrationAssociation, request, handler, context);
        }
 
        virtual Model::UpdateEventIntegrationOutcome UpdateEventIntegration(const Model::UpdateEventIntegrationRequest& request) const;
 
        template<typename UpdateEventIntegrationRequestT = Model::UpdateEventIntegrationRequest>
        Model::UpdateEventIntegrationOutcomeCallable UpdateEventIntegrationCallable(const UpdateEventIntegrationRequestT& request) const
        {
            return SubmitCallable(&AppIntegrationsServiceClient::UpdateEventIntegration, request);
        }
 
        template<typename UpdateEventIntegrationRequestT = Model::UpdateEventIntegrationRequest>
        void UpdateEventIntegrationAsync(const UpdateEventIntegrationRequestT& request, const UpdateEventIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppIntegrationsServiceClient::UpdateEventIntegration, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AppIntegrationsServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AppIntegrationsServiceClient>;
      void init(const AppIntegrationsServiceClientConfiguration& clientConfiguration);
 
      AppIntegrationsServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<AppIntegrationsServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AppIntegrationsService
} // namespace Aws