B2BIClient.h

 
#pragma once
#include <aws/b2bi/B2BIServiceClientModel.h>
#include <aws/b2bi/B2BI_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 B2BI {
class AWS_B2BI_API B2BIClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<B2BIClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef B2BIClientConfiguration ClientConfigurationType;
  typedef B2BIEndpointProvider EndpointProviderType;
 
  B2BIClient(const Aws::B2BI::B2BIClientConfiguration& clientConfiguration = Aws::B2BI::B2BIClientConfiguration(),
             std::shared_ptr<B2BIEndpointProviderBase> endpointProvider = nullptr);
 
  B2BIClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<B2BIEndpointProviderBase> endpointProvider = nullptr,
             const Aws::B2BI::B2BIClientConfiguration& clientConfiguration = Aws::B2BI::B2BIClientConfiguration());
 
  B2BIClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
             std::shared_ptr<B2BIEndpointProviderBase> endpointProvider = nullptr,
             const Aws::B2BI::B2BIClientConfiguration& clientConfiguration = Aws::B2BI::B2BIClientConfiguration());
 
  /* Legacy constructors due deprecation */
  B2BIClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  B2BIClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  B2BIClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
             const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~B2BIClient();
 
  virtual Model::CreateCapabilityOutcome CreateCapability(const Model::CreateCapabilityRequest& request) const;
 
  template <typename CreateCapabilityRequestT = Model::CreateCapabilityRequest>
  Model::CreateCapabilityOutcomeCallable CreateCapabilityCallable(const CreateCapabilityRequestT& request) const {
    return SubmitCallable(&B2BIClient::CreateCapability, request);
  }
 
  template <typename CreateCapabilityRequestT = Model::CreateCapabilityRequest>
  void CreateCapabilityAsync(const CreateCapabilityRequestT& request, const CreateCapabilityResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::CreateCapability, request, handler, context);
  }
 
  virtual Model::CreatePartnershipOutcome CreatePartnership(const Model::CreatePartnershipRequest& request) const;
 
  template <typename CreatePartnershipRequestT = Model::CreatePartnershipRequest>
  Model::CreatePartnershipOutcomeCallable CreatePartnershipCallable(const CreatePartnershipRequestT& request) const {
    return SubmitCallable(&B2BIClient::CreatePartnership, request);
  }
 
  template <typename CreatePartnershipRequestT = Model::CreatePartnershipRequest>
  void CreatePartnershipAsync(const CreatePartnershipRequestT& request, const CreatePartnershipResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::CreatePartnership, request, handler, context);
  }
 
  virtual Model::CreateProfileOutcome CreateProfile(const Model::CreateProfileRequest& request) const;
 
  template <typename CreateProfileRequestT = Model::CreateProfileRequest>
  Model::CreateProfileOutcomeCallable CreateProfileCallable(const CreateProfileRequestT& request) const {
    return SubmitCallable(&B2BIClient::CreateProfile, request);
  }
 
  template <typename CreateProfileRequestT = Model::CreateProfileRequest>
  void CreateProfileAsync(const CreateProfileRequestT& request, const CreateProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::CreateProfile, request, handler, context);
  }
 
  virtual Model::CreateStarterMappingTemplateOutcome CreateStarterMappingTemplate(
      const Model::CreateStarterMappingTemplateRequest& request) const;
 
  template <typename CreateStarterMappingTemplateRequestT = Model::CreateStarterMappingTemplateRequest>
  Model::CreateStarterMappingTemplateOutcomeCallable CreateStarterMappingTemplateCallable(
      const CreateStarterMappingTemplateRequestT& request) const {
    return SubmitCallable(&B2BIClient::CreateStarterMappingTemplate, request);
  }
 
  template <typename CreateStarterMappingTemplateRequestT = Model::CreateStarterMappingTemplateRequest>
  void CreateStarterMappingTemplateAsync(const CreateStarterMappingTemplateRequestT& request,
                                         const CreateStarterMappingTemplateResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::CreateStarterMappingTemplate, request, handler, context);
  }
 
  virtual Model::CreateTransformerOutcome CreateTransformer(const Model::CreateTransformerRequest& request) const;
 
  template <typename CreateTransformerRequestT = Model::CreateTransformerRequest>
  Model::CreateTransformerOutcomeCallable CreateTransformerCallable(const CreateTransformerRequestT& request) const {
    return SubmitCallable(&B2BIClient::CreateTransformer, request);
  }
 
  template <typename CreateTransformerRequestT = Model::CreateTransformerRequest>
  void CreateTransformerAsync(const CreateTransformerRequestT& request, const CreateTransformerResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::CreateTransformer, request, handler, context);
  }
 
  virtual Model::DeleteCapabilityOutcome DeleteCapability(const Model::DeleteCapabilityRequest& request) const;
 
  template <typename DeleteCapabilityRequestT = Model::DeleteCapabilityRequest>
  Model::DeleteCapabilityOutcomeCallable DeleteCapabilityCallable(const DeleteCapabilityRequestT& request) const {
    return SubmitCallable(&B2BIClient::DeleteCapability, request);
  }
 
  template <typename DeleteCapabilityRequestT = Model::DeleteCapabilityRequest>
  void DeleteCapabilityAsync(const DeleteCapabilityRequestT& request, const DeleteCapabilityResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::DeleteCapability, request, handler, context);
  }
 
  virtual Model::DeletePartnershipOutcome DeletePartnership(const Model::DeletePartnershipRequest& request) const;
 
  template <typename DeletePartnershipRequestT = Model::DeletePartnershipRequest>
  Model::DeletePartnershipOutcomeCallable DeletePartnershipCallable(const DeletePartnershipRequestT& request) const {
    return SubmitCallable(&B2BIClient::DeletePartnership, request);
  }
 
  template <typename DeletePartnershipRequestT = Model::DeletePartnershipRequest>
  void DeletePartnershipAsync(const DeletePartnershipRequestT& request, const DeletePartnershipResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::DeletePartnership, request, handler, context);
  }
 
  virtual Model::DeleteProfileOutcome DeleteProfile(const Model::DeleteProfileRequest& request) const;
 
  template <typename DeleteProfileRequestT = Model::DeleteProfileRequest>
  Model::DeleteProfileOutcomeCallable DeleteProfileCallable(const DeleteProfileRequestT& request) const {
    return SubmitCallable(&B2BIClient::DeleteProfile, request);
  }
 
  template <typename DeleteProfileRequestT = Model::DeleteProfileRequest>
  void DeleteProfileAsync(const DeleteProfileRequestT& request, const DeleteProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::DeleteProfile, request, handler, context);
  }
 
  virtual Model::DeleteTransformerOutcome DeleteTransformer(const Model::DeleteTransformerRequest& request) const;
 
  template <typename DeleteTransformerRequestT = Model::DeleteTransformerRequest>
  Model::DeleteTransformerOutcomeCallable DeleteTransformerCallable(const DeleteTransformerRequestT& request) const {
    return SubmitCallable(&B2BIClient::DeleteTransformer, request);
  }
 
  template <typename DeleteTransformerRequestT = Model::DeleteTransformerRequest>
  void DeleteTransformerAsync(const DeleteTransformerRequestT& request, const DeleteTransformerResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::DeleteTransformer, request, handler, context);
  }
 
  virtual Model::GenerateMappingOutcome GenerateMapping(const Model::GenerateMappingRequest& request) const;
 
  template <typename GenerateMappingRequestT = Model::GenerateMappingRequest>
  Model::GenerateMappingOutcomeCallable GenerateMappingCallable(const GenerateMappingRequestT& request) const {
    return SubmitCallable(&B2BIClient::GenerateMapping, request);
  }
 
  template <typename GenerateMappingRequestT = Model::GenerateMappingRequest>
  void GenerateMappingAsync(const GenerateMappingRequestT& request, const GenerateMappingResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::GenerateMapping, request, handler, context);
  }
 
  virtual Model::GetCapabilityOutcome GetCapability(const Model::GetCapabilityRequest& request) const;
 
  template <typename GetCapabilityRequestT = Model::GetCapabilityRequest>
  Model::GetCapabilityOutcomeCallable GetCapabilityCallable(const GetCapabilityRequestT& request) const {
    return SubmitCallable(&B2BIClient::GetCapability, request);
  }
 
  template <typename GetCapabilityRequestT = Model::GetCapabilityRequest>
  void GetCapabilityAsync(const GetCapabilityRequestT& request, const GetCapabilityResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::GetCapability, request, handler, context);
  }
 
  virtual Model::GetPartnershipOutcome GetPartnership(const Model::GetPartnershipRequest& request) const;
 
  template <typename GetPartnershipRequestT = Model::GetPartnershipRequest>
  Model::GetPartnershipOutcomeCallable GetPartnershipCallable(const GetPartnershipRequestT& request) const {
    return SubmitCallable(&B2BIClient::GetPartnership, request);
  }
 
  template <typename GetPartnershipRequestT = Model::GetPartnershipRequest>
  void GetPartnershipAsync(const GetPartnershipRequestT& request, const GetPartnershipResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::GetPartnership, request, handler, context);
  }
 
  virtual Model::GetProfileOutcome GetProfile(const Model::GetProfileRequest& request) const;
 
  template <typename GetProfileRequestT = Model::GetProfileRequest>
  Model::GetProfileOutcomeCallable GetProfileCallable(const GetProfileRequestT& request) const {
    return SubmitCallable(&B2BIClient::GetProfile, request);
  }
 
  template <typename GetProfileRequestT = Model::GetProfileRequest>
  void GetProfileAsync(const GetProfileRequestT& request, const GetProfileResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::GetProfile, request, handler, context);
  }
 
  virtual Model::GetTransformerOutcome GetTransformer(const Model::GetTransformerRequest& request) const;
 
  template <typename GetTransformerRequestT = Model::GetTransformerRequest>
  Model::GetTransformerOutcomeCallable GetTransformerCallable(const GetTransformerRequestT& request) const {
    return SubmitCallable(&B2BIClient::GetTransformer, request);
  }
 
  template <typename GetTransformerRequestT = Model::GetTransformerRequest>
  void GetTransformerAsync(const GetTransformerRequestT& request, const GetTransformerResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::GetTransformer, request, handler, context);
  }
 
  virtual Model::GetTransformerJobOutcome GetTransformerJob(const Model::GetTransformerJobRequest& request) const;
 
  template <typename GetTransformerJobRequestT = Model::GetTransformerJobRequest>
  Model::GetTransformerJobOutcomeCallable GetTransformerJobCallable(const GetTransformerJobRequestT& request) const {
    return SubmitCallable(&B2BIClient::GetTransformerJob, request);
  }
 
  template <typename GetTransformerJobRequestT = Model::GetTransformerJobRequest>
  void GetTransformerJobAsync(const GetTransformerJobRequestT& request, const GetTransformerJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::GetTransformerJob, request, handler, context);
  }
 
  virtual Model::ListCapabilitiesOutcome ListCapabilities(const Model::ListCapabilitiesRequest& request = {}) const;
 
  template <typename ListCapabilitiesRequestT = Model::ListCapabilitiesRequest>
  Model::ListCapabilitiesOutcomeCallable ListCapabilitiesCallable(const ListCapabilitiesRequestT& request = {}) const {
    return SubmitCallable(&B2BIClient::ListCapabilities, request);
  }
 
  template <typename ListCapabilitiesRequestT = Model::ListCapabilitiesRequest>
  void ListCapabilitiesAsync(const ListCapabilitiesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListCapabilitiesRequestT& request = {}) const {
    return SubmitAsync(&B2BIClient::ListCapabilities, request, handler, context);
  }
 
  virtual Model::ListPartnershipsOutcome ListPartnerships(const Model::ListPartnershipsRequest& request = {}) const;
 
  template <typename ListPartnershipsRequestT = Model::ListPartnershipsRequest>
  Model::ListPartnershipsOutcomeCallable ListPartnershipsCallable(const ListPartnershipsRequestT& request = {}) const {
    return SubmitCallable(&B2BIClient::ListPartnerships, request);
  }
 
  template <typename ListPartnershipsRequestT = Model::ListPartnershipsRequest>
  void ListPartnershipsAsync(const ListPartnershipsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListPartnershipsRequestT& request = {}) const {
    return SubmitAsync(&B2BIClient::ListPartnerships, request, handler, context);
  }
 
  virtual Model::ListProfilesOutcome ListProfiles(const Model::ListProfilesRequest& request = {}) const;
 
  template <typename ListProfilesRequestT = Model::ListProfilesRequest>
  Model::ListProfilesOutcomeCallable ListProfilesCallable(const ListProfilesRequestT& request = {}) const {
    return SubmitCallable(&B2BIClient::ListProfiles, request);
  }
 
  template <typename ListProfilesRequestT = Model::ListProfilesRequest>
  void ListProfilesAsync(const ListProfilesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProfilesRequestT& request = {}) const {
    return SubmitAsync(&B2BIClient::ListProfiles, 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(&B2BIClient::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(&B2BIClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTransformersOutcome ListTransformers(const Model::ListTransformersRequest& request = {}) const;
 
  template <typename ListTransformersRequestT = Model::ListTransformersRequest>
  Model::ListTransformersOutcomeCallable ListTransformersCallable(const ListTransformersRequestT& request = {}) const {
    return SubmitCallable(&B2BIClient::ListTransformers, request);
  }
 
  template <typename ListTransformersRequestT = Model::ListTransformersRequest>
  void ListTransformersAsync(const ListTransformersResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListTransformersRequestT& request = {}) const {
    return SubmitAsync(&B2BIClient::ListTransformers, request, handler, context);
  }
 
  virtual Model::StartTransformerJobOutcome StartTransformerJob(const Model::StartTransformerJobRequest& request) const;
 
  template <typename StartTransformerJobRequestT = Model::StartTransformerJobRequest>
  Model::StartTransformerJobOutcomeCallable StartTransformerJobCallable(const StartTransformerJobRequestT& request) const {
    return SubmitCallable(&B2BIClient::StartTransformerJob, request);
  }
 
  template <typename StartTransformerJobRequestT = Model::StartTransformerJobRequest>
  void StartTransformerJobAsync(const StartTransformerJobRequestT& request, const StartTransformerJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::StartTransformerJob, 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(&B2BIClient::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(&B2BIClient::TagResource, request, handler, context);
  }
 
  virtual Model::TestConversionOutcome TestConversion(const Model::TestConversionRequest& request) const;
 
  template <typename TestConversionRequestT = Model::TestConversionRequest>
  Model::TestConversionOutcomeCallable TestConversionCallable(const TestConversionRequestT& request) const {
    return SubmitCallable(&B2BIClient::TestConversion, request);
  }
 
  template <typename TestConversionRequestT = Model::TestConversionRequest>
  void TestConversionAsync(const TestConversionRequestT& request, const TestConversionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::TestConversion, request, handler, context);
  }
 
  virtual Model::TestMappingOutcome TestMapping(const Model::TestMappingRequest& request) const;
 
  template <typename TestMappingRequestT = Model::TestMappingRequest>
  Model::TestMappingOutcomeCallable TestMappingCallable(const TestMappingRequestT& request) const {
    return SubmitCallable(&B2BIClient::TestMapping, request);
  }
 
  template <typename TestMappingRequestT = Model::TestMappingRequest>
  void TestMappingAsync(const TestMappingRequestT& request, const TestMappingResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::TestMapping, request, handler, context);
  }
 
  virtual Model::TestParsingOutcome TestParsing(const Model::TestParsingRequest& request) const;
 
  template <typename TestParsingRequestT = Model::TestParsingRequest>
  Model::TestParsingOutcomeCallable TestParsingCallable(const TestParsingRequestT& request) const {
    return SubmitCallable(&B2BIClient::TestParsing, request);
  }
 
  template <typename TestParsingRequestT = Model::TestParsingRequest>
  void TestParsingAsync(const TestParsingRequestT& request, const TestParsingResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::TestParsing, 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(&B2BIClient::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(&B2BIClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCapabilityOutcome UpdateCapability(const Model::UpdateCapabilityRequest& request) const;
 
  template <typename UpdateCapabilityRequestT = Model::UpdateCapabilityRequest>
  Model::UpdateCapabilityOutcomeCallable UpdateCapabilityCallable(const UpdateCapabilityRequestT& request) const {
    return SubmitCallable(&B2BIClient::UpdateCapability, request);
  }
 
  template <typename UpdateCapabilityRequestT = Model::UpdateCapabilityRequest>
  void UpdateCapabilityAsync(const UpdateCapabilityRequestT& request, const UpdateCapabilityResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::UpdateCapability, request, handler, context);
  }
 
  virtual Model::UpdatePartnershipOutcome UpdatePartnership(const Model::UpdatePartnershipRequest& request) const;
 
  template <typename UpdatePartnershipRequestT = Model::UpdatePartnershipRequest>
  Model::UpdatePartnershipOutcomeCallable UpdatePartnershipCallable(const UpdatePartnershipRequestT& request) const {
    return SubmitCallable(&B2BIClient::UpdatePartnership, request);
  }
 
  template <typename UpdatePartnershipRequestT = Model::UpdatePartnershipRequest>
  void UpdatePartnershipAsync(const UpdatePartnershipRequestT& request, const UpdatePartnershipResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::UpdatePartnership, request, handler, context);
  }
 
  virtual Model::UpdateProfileOutcome UpdateProfile(const Model::UpdateProfileRequest& request) const;
 
  template <typename UpdateProfileRequestT = Model::UpdateProfileRequest>
  Model::UpdateProfileOutcomeCallable UpdateProfileCallable(const UpdateProfileRequestT& request) const {
    return SubmitCallable(&B2BIClient::UpdateProfile, request);
  }
 
  template <typename UpdateProfileRequestT = Model::UpdateProfileRequest>
  void UpdateProfileAsync(const UpdateProfileRequestT& request, const UpdateProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::UpdateProfile, request, handler, context);
  }
 
  virtual Model::UpdateTransformerOutcome UpdateTransformer(const Model::UpdateTransformerRequest& request) const;
 
  template <typename UpdateTransformerRequestT = Model::UpdateTransformerRequest>
  Model::UpdateTransformerOutcomeCallable UpdateTransformerCallable(const UpdateTransformerRequestT& request) const {
    return SubmitCallable(&B2BIClient::UpdateTransformer, request);
  }
 
  template <typename UpdateTransformerRequestT = Model::UpdateTransformerRequest>
  void UpdateTransformerAsync(const UpdateTransformerRequestT& request, const UpdateTransformerResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&B2BIClient::UpdateTransformer, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<B2BIEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<B2BIClient>;
  void init(const B2BIClientConfiguration& clientConfiguration);
 
  B2BIClientConfiguration m_clientConfiguration;
  std::shared_ptr<B2BIEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace B2BI
}  // namespace Aws