AppflowClient.h

 
#pragma once
#include <aws/appflow/Appflow_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/appflow/AppflowServiceClientModel.h>
 
namespace Aws
{
namespace Appflow
{
  class AWS_APPFLOW_API AppflowClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AppflowClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AppflowClientConfiguration ClientConfigurationType;
      typedef AppflowEndpointProvider EndpointProviderType;
 
        AppflowClient(const Aws::Appflow::AppflowClientConfiguration& clientConfiguration = Aws::Appflow::AppflowClientConfiguration(),
                      std::shared_ptr<AppflowEndpointProviderBase> endpointProvider = nullptr);
 
        AppflowClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<AppflowEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Appflow::AppflowClientConfiguration& clientConfiguration = Aws::Appflow::AppflowClientConfiguration());
 
        AppflowClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<AppflowEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Appflow::AppflowClientConfiguration& clientConfiguration = Aws::Appflow::AppflowClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AppflowClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppflowClient(const Aws::Auth::AWSCredentials& credentials,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppflowClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AppflowClient();
 
        virtual Model::CancelFlowExecutionsOutcome CancelFlowExecutions(const Model::CancelFlowExecutionsRequest& request) const;
 
        template<typename CancelFlowExecutionsRequestT = Model::CancelFlowExecutionsRequest>
        Model::CancelFlowExecutionsOutcomeCallable CancelFlowExecutionsCallable(const CancelFlowExecutionsRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::CancelFlowExecutions, request);
        }
 
        template<typename CancelFlowExecutionsRequestT = Model::CancelFlowExecutionsRequest>
        void CancelFlowExecutionsAsync(const CancelFlowExecutionsRequestT& request, const CancelFlowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::CancelFlowExecutions, request, handler, context);
        }
 
        virtual Model::CreateConnectorProfileOutcome CreateConnectorProfile(const Model::CreateConnectorProfileRequest& request) const;
 
        template<typename CreateConnectorProfileRequestT = Model::CreateConnectorProfileRequest>
        Model::CreateConnectorProfileOutcomeCallable CreateConnectorProfileCallable(const CreateConnectorProfileRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::CreateConnectorProfile, request);
        }
 
        template<typename CreateConnectorProfileRequestT = Model::CreateConnectorProfileRequest>
        void CreateConnectorProfileAsync(const CreateConnectorProfileRequestT& request, const CreateConnectorProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::CreateConnectorProfile, request, handler, context);
        }
 
        virtual Model::CreateFlowOutcome CreateFlow(const Model::CreateFlowRequest& request) const;
 
        template<typename CreateFlowRequestT = Model::CreateFlowRequest>
        Model::CreateFlowOutcomeCallable CreateFlowCallable(const CreateFlowRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::CreateFlow, request);
        }
 
        template<typename CreateFlowRequestT = Model::CreateFlowRequest>
        void CreateFlowAsync(const CreateFlowRequestT& request, const CreateFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::CreateFlow, request, handler, context);
        }
 
        virtual Model::DeleteConnectorProfileOutcome DeleteConnectorProfile(const Model::DeleteConnectorProfileRequest& request) const;
 
        template<typename DeleteConnectorProfileRequestT = Model::DeleteConnectorProfileRequest>
        Model::DeleteConnectorProfileOutcomeCallable DeleteConnectorProfileCallable(const DeleteConnectorProfileRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::DeleteConnectorProfile, request);
        }
 
        template<typename DeleteConnectorProfileRequestT = Model::DeleteConnectorProfileRequest>
        void DeleteConnectorProfileAsync(const DeleteConnectorProfileRequestT& request, const DeleteConnectorProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::DeleteConnectorProfile, request, handler, context);
        }
 
        virtual Model::DeleteFlowOutcome DeleteFlow(const Model::DeleteFlowRequest& request) const;
 
        template<typename DeleteFlowRequestT = Model::DeleteFlowRequest>
        Model::DeleteFlowOutcomeCallable DeleteFlowCallable(const DeleteFlowRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::DeleteFlow, request);
        }
 
        template<typename DeleteFlowRequestT = Model::DeleteFlowRequest>
        void DeleteFlowAsync(const DeleteFlowRequestT& request, const DeleteFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::DeleteFlow, request, handler, context);
        }
 
        virtual Model::DescribeConnectorOutcome DescribeConnector(const Model::DescribeConnectorRequest& request) const;
 
        template<typename DescribeConnectorRequestT = Model::DescribeConnectorRequest>
        Model::DescribeConnectorOutcomeCallable DescribeConnectorCallable(const DescribeConnectorRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::DescribeConnector, request);
        }
 
        template<typename DescribeConnectorRequestT = Model::DescribeConnectorRequest>
        void DescribeConnectorAsync(const DescribeConnectorRequestT& request, const DescribeConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::DescribeConnector, request, handler, context);
        }
 
        virtual Model::DescribeConnectorEntityOutcome DescribeConnectorEntity(const Model::DescribeConnectorEntityRequest& request) const;
 
        template<typename DescribeConnectorEntityRequestT = Model::DescribeConnectorEntityRequest>
        Model::DescribeConnectorEntityOutcomeCallable DescribeConnectorEntityCallable(const DescribeConnectorEntityRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::DescribeConnectorEntity, request);
        }
 
        template<typename DescribeConnectorEntityRequestT = Model::DescribeConnectorEntityRequest>
        void DescribeConnectorEntityAsync(const DescribeConnectorEntityRequestT& request, const DescribeConnectorEntityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::DescribeConnectorEntity, request, handler, context);
        }
 
        virtual Model::DescribeConnectorProfilesOutcome DescribeConnectorProfiles(const Model::DescribeConnectorProfilesRequest& request = {}) const;
 
        template<typename DescribeConnectorProfilesRequestT = Model::DescribeConnectorProfilesRequest>
        Model::DescribeConnectorProfilesOutcomeCallable DescribeConnectorProfilesCallable(const DescribeConnectorProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&AppflowClient::DescribeConnectorProfiles, request);
        }
 
        template<typename DescribeConnectorProfilesRequestT = Model::DescribeConnectorProfilesRequest>
        void DescribeConnectorProfilesAsync(const DescribeConnectorProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeConnectorProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&AppflowClient::DescribeConnectorProfiles, request, handler, context);
        }
 
        virtual Model::DescribeConnectorsOutcome DescribeConnectors(const Model::DescribeConnectorsRequest& request = {}) const;
 
        template<typename DescribeConnectorsRequestT = Model::DescribeConnectorsRequest>
        Model::DescribeConnectorsOutcomeCallable DescribeConnectorsCallable(const DescribeConnectorsRequestT& request = {}) const
        {
            return SubmitCallable(&AppflowClient::DescribeConnectors, request);
        }
 
        template<typename DescribeConnectorsRequestT = Model::DescribeConnectorsRequest>
        void DescribeConnectorsAsync(const DescribeConnectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeConnectorsRequestT& request = {}) const
        {
            return SubmitAsync(&AppflowClient::DescribeConnectors, request, handler, context);
        }
 
        virtual Model::DescribeFlowOutcome DescribeFlow(const Model::DescribeFlowRequest& request) const;
 
        template<typename DescribeFlowRequestT = Model::DescribeFlowRequest>
        Model::DescribeFlowOutcomeCallable DescribeFlowCallable(const DescribeFlowRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::DescribeFlow, request);
        }
 
        template<typename DescribeFlowRequestT = Model::DescribeFlowRequest>
        void DescribeFlowAsync(const DescribeFlowRequestT& request, const DescribeFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::DescribeFlow, request, handler, context);
        }
 
        virtual Model::DescribeFlowExecutionRecordsOutcome DescribeFlowExecutionRecords(const Model::DescribeFlowExecutionRecordsRequest& request) const;
 
        template<typename DescribeFlowExecutionRecordsRequestT = Model::DescribeFlowExecutionRecordsRequest>
        Model::DescribeFlowExecutionRecordsOutcomeCallable DescribeFlowExecutionRecordsCallable(const DescribeFlowExecutionRecordsRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::DescribeFlowExecutionRecords, request);
        }
 
        template<typename DescribeFlowExecutionRecordsRequestT = Model::DescribeFlowExecutionRecordsRequest>
        void DescribeFlowExecutionRecordsAsync(const DescribeFlowExecutionRecordsRequestT& request, const DescribeFlowExecutionRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::DescribeFlowExecutionRecords, request, handler, context);
        }
 
        virtual Model::ListConnectorEntitiesOutcome ListConnectorEntities(const Model::ListConnectorEntitiesRequest& request = {}) const;
 
        template<typename ListConnectorEntitiesRequestT = Model::ListConnectorEntitiesRequest>
        Model::ListConnectorEntitiesOutcomeCallable ListConnectorEntitiesCallable(const ListConnectorEntitiesRequestT& request = {}) const
        {
            return SubmitCallable(&AppflowClient::ListConnectorEntities, request);
        }
 
        template<typename ListConnectorEntitiesRequestT = Model::ListConnectorEntitiesRequest>
        void ListConnectorEntitiesAsync(const ListConnectorEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConnectorEntitiesRequestT& request = {}) const
        {
            return SubmitAsync(&AppflowClient::ListConnectorEntities, request, handler, context);
        }
 
        virtual Model::ListConnectorsOutcome ListConnectors(const Model::ListConnectorsRequest& request = {}) const;
 
        template<typename ListConnectorsRequestT = Model::ListConnectorsRequest>
        Model::ListConnectorsOutcomeCallable ListConnectorsCallable(const ListConnectorsRequestT& request = {}) const
        {
            return SubmitCallable(&AppflowClient::ListConnectors, request);
        }
 
        template<typename ListConnectorsRequestT = Model::ListConnectorsRequest>
        void ListConnectorsAsync(const ListConnectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConnectorsRequestT& request = {}) const
        {
            return SubmitAsync(&AppflowClient::ListConnectors, request, handler, context);
        }
 
        virtual Model::ListFlowsOutcome ListFlows(const Model::ListFlowsRequest& request = {}) const;
 
        template<typename ListFlowsRequestT = Model::ListFlowsRequest>
        Model::ListFlowsOutcomeCallable ListFlowsCallable(const ListFlowsRequestT& request = {}) const
        {
            return SubmitCallable(&AppflowClient::ListFlows, request);
        }
 
        template<typename ListFlowsRequestT = Model::ListFlowsRequest>
        void ListFlowsAsync(const ListFlowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFlowsRequestT& request = {}) const
        {
            return SubmitAsync(&AppflowClient::ListFlows, 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(&AppflowClient::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(&AppflowClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::RegisterConnectorOutcome RegisterConnector(const Model::RegisterConnectorRequest& request = {}) const;
 
        template<typename RegisterConnectorRequestT = Model::RegisterConnectorRequest>
        Model::RegisterConnectorOutcomeCallable RegisterConnectorCallable(const RegisterConnectorRequestT& request = {}) const
        {
            return SubmitCallable(&AppflowClient::RegisterConnector, request);
        }
 
        template<typename RegisterConnectorRequestT = Model::RegisterConnectorRequest>
        void RegisterConnectorAsync(const RegisterConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RegisterConnectorRequestT& request = {}) const
        {
            return SubmitAsync(&AppflowClient::RegisterConnector, request, handler, context);
        }
 
        virtual Model::ResetConnectorMetadataCacheOutcome ResetConnectorMetadataCache(const Model::ResetConnectorMetadataCacheRequest& request = {}) const;
 
        template<typename ResetConnectorMetadataCacheRequestT = Model::ResetConnectorMetadataCacheRequest>
        Model::ResetConnectorMetadataCacheOutcomeCallable ResetConnectorMetadataCacheCallable(const ResetConnectorMetadataCacheRequestT& request = {}) const
        {
            return SubmitCallable(&AppflowClient::ResetConnectorMetadataCache, request);
        }
 
        template<typename ResetConnectorMetadataCacheRequestT = Model::ResetConnectorMetadataCacheRequest>
        void ResetConnectorMetadataCacheAsync(const ResetConnectorMetadataCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ResetConnectorMetadataCacheRequestT& request = {}) const
        {
            return SubmitAsync(&AppflowClient::ResetConnectorMetadataCache, request, handler, context);
        }
 
        virtual Model::StartFlowOutcome StartFlow(const Model::StartFlowRequest& request) const;
 
        template<typename StartFlowRequestT = Model::StartFlowRequest>
        Model::StartFlowOutcomeCallable StartFlowCallable(const StartFlowRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::StartFlow, request);
        }
 
        template<typename StartFlowRequestT = Model::StartFlowRequest>
        void StartFlowAsync(const StartFlowRequestT& request, const StartFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::StartFlow, request, handler, context);
        }
 
        virtual Model::StopFlowOutcome StopFlow(const Model::StopFlowRequest& request) const;
 
        template<typename StopFlowRequestT = Model::StopFlowRequest>
        Model::StopFlowOutcomeCallable StopFlowCallable(const StopFlowRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::StopFlow, request);
        }
 
        template<typename StopFlowRequestT = Model::StopFlowRequest>
        void StopFlowAsync(const StopFlowRequestT& request, const StopFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::StopFlow, 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(&AppflowClient::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(&AppflowClient::TagResource, request, handler, context);
        }
 
        virtual Model::UnregisterConnectorOutcome UnregisterConnector(const Model::UnregisterConnectorRequest& request) const;
 
        template<typename UnregisterConnectorRequestT = Model::UnregisterConnectorRequest>
        Model::UnregisterConnectorOutcomeCallable UnregisterConnectorCallable(const UnregisterConnectorRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::UnregisterConnector, request);
        }
 
        template<typename UnregisterConnectorRequestT = Model::UnregisterConnectorRequest>
        void UnregisterConnectorAsync(const UnregisterConnectorRequestT& request, const UnregisterConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::UnregisterConnector, 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(&AppflowClient::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(&AppflowClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateConnectorProfileOutcome UpdateConnectorProfile(const Model::UpdateConnectorProfileRequest& request) const;
 
        template<typename UpdateConnectorProfileRequestT = Model::UpdateConnectorProfileRequest>
        Model::UpdateConnectorProfileOutcomeCallable UpdateConnectorProfileCallable(const UpdateConnectorProfileRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::UpdateConnectorProfile, request);
        }
 
        template<typename UpdateConnectorProfileRequestT = Model::UpdateConnectorProfileRequest>
        void UpdateConnectorProfileAsync(const UpdateConnectorProfileRequestT& request, const UpdateConnectorProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::UpdateConnectorProfile, request, handler, context);
        }
 
        virtual Model::UpdateConnectorRegistrationOutcome UpdateConnectorRegistration(const Model::UpdateConnectorRegistrationRequest& request) const;
 
        template<typename UpdateConnectorRegistrationRequestT = Model::UpdateConnectorRegistrationRequest>
        Model::UpdateConnectorRegistrationOutcomeCallable UpdateConnectorRegistrationCallable(const UpdateConnectorRegistrationRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::UpdateConnectorRegistration, request);
        }
 
        template<typename UpdateConnectorRegistrationRequestT = Model::UpdateConnectorRegistrationRequest>
        void UpdateConnectorRegistrationAsync(const UpdateConnectorRegistrationRequestT& request, const UpdateConnectorRegistrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::UpdateConnectorRegistration, request, handler, context);
        }
 
        virtual Model::UpdateFlowOutcome UpdateFlow(const Model::UpdateFlowRequest& request) const;
 
        template<typename UpdateFlowRequestT = Model::UpdateFlowRequest>
        Model::UpdateFlowOutcomeCallable UpdateFlowCallable(const UpdateFlowRequestT& request) const
        {
            return SubmitCallable(&AppflowClient::UpdateFlow, request);
        }
 
        template<typename UpdateFlowRequestT = Model::UpdateFlowRequest>
        void UpdateFlowAsync(const UpdateFlowRequestT& request, const UpdateFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppflowClient::UpdateFlow, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AppflowEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AppflowClient>;
      void init(const AppflowClientConfiguration& clientConfiguration);
 
      AppflowClientConfiguration m_clientConfiguration;
      std::shared_ptr<AppflowEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Appflow
} // namespace Aws