AppIntegrationsServiceClient.h

 
#pragma once
#include <aws/appintegrations/AppIntegrationsServicePaginationBase.h>
#include <aws/appintegrations/AppIntegrationsServiceServiceClientModel.h>
#include <aws/appintegrations/AppIntegrationsServiceWaiter.h>
#include <aws/appintegrations/AppIntegrationsService_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 AppIntegrationsService {
class AWS_APPINTEGRATIONSSERVICE_API AppIntegrationsServiceClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<AppIntegrationsServiceClient>,
      public AppIntegrationsServicePaginationBase<AppIntegrationsServiceClient>,
      public AppIntegrationsServiceWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AppIntegrationsServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AppIntegrationsServiceClient>;
  void init(const AppIntegrationsServiceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AppIntegrationsServiceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AppIntegrationsServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<AppIntegrationsServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AppIntegrationsService
}  // namespace Aws