AppflowClient.h

 
#pragma once
#include <aws/appflow/AppflowPaginationBase.h>
#include <aws/appflow/AppflowServiceClientModel.h>
#include <aws/appflow/AppflowWaiter.h>
#include <aws/appflow/Appflow_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace Appflow {
class AWS_APPFLOW_API AppflowClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<AppflowClient>,
                                      public AppflowPaginationBase<AppflowClient>,
                                      public AppflowWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AppflowEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AppflowClient>;
  void init(const AppflowClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AppflowError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AppflowClientConfiguration m_clientConfiguration;
  std::shared_ptr<AppflowEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Appflow
}  // namespace Aws