B2BIClient.h

 
#pragma once
#include <aws/b2bi/B2BI_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/b2bi/B2BIServiceClientModel.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