ServiceCatalogClient.h

 
#pragma once
#include <aws/servicecatalog/ServiceCatalog_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/servicecatalog/ServiceCatalogServiceClientModel.h>
 
namespace Aws
{
namespace ServiceCatalog
{
  class AWS_SERVICECATALOG_API ServiceCatalogClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ServiceCatalogClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ServiceCatalogClientConfiguration ClientConfigurationType;
      typedef ServiceCatalogEndpointProvider EndpointProviderType;
 
        ServiceCatalogClient(const Aws::ServiceCatalog::ServiceCatalogClientConfiguration& clientConfiguration = Aws::ServiceCatalog::ServiceCatalogClientConfiguration(),
                             std::shared_ptr<ServiceCatalogEndpointProviderBase> endpointProvider = nullptr);
 
        ServiceCatalogClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<ServiceCatalogEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::ServiceCatalog::ServiceCatalogClientConfiguration& clientConfiguration = Aws::ServiceCatalog::ServiceCatalogClientConfiguration());
 
        ServiceCatalogClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<ServiceCatalogEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::ServiceCatalog::ServiceCatalogClientConfiguration& clientConfiguration = Aws::ServiceCatalog::ServiceCatalogClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ServiceCatalogClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ServiceCatalogClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ServiceCatalogClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ServiceCatalogClient();
 
        virtual Model::AcceptPortfolioShareOutcome AcceptPortfolioShare(const Model::AcceptPortfolioShareRequest& request) const;
 
        template<typename AcceptPortfolioShareRequestT = Model::AcceptPortfolioShareRequest>
        Model::AcceptPortfolioShareOutcomeCallable AcceptPortfolioShareCallable(const AcceptPortfolioShareRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::AcceptPortfolioShare, request);
        }
 
        template<typename AcceptPortfolioShareRequestT = Model::AcceptPortfolioShareRequest>
        void AcceptPortfolioShareAsync(const AcceptPortfolioShareRequestT& request, const AcceptPortfolioShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::AcceptPortfolioShare, request, handler, context);
        }
 
        virtual Model::AssociateBudgetWithResourceOutcome AssociateBudgetWithResource(const Model::AssociateBudgetWithResourceRequest& request) const;
 
        template<typename AssociateBudgetWithResourceRequestT = Model::AssociateBudgetWithResourceRequest>
        Model::AssociateBudgetWithResourceOutcomeCallable AssociateBudgetWithResourceCallable(const AssociateBudgetWithResourceRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::AssociateBudgetWithResource, request);
        }
 
        template<typename AssociateBudgetWithResourceRequestT = Model::AssociateBudgetWithResourceRequest>
        void AssociateBudgetWithResourceAsync(const AssociateBudgetWithResourceRequestT& request, const AssociateBudgetWithResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::AssociateBudgetWithResource, request, handler, context);
        }
 
        virtual Model::AssociatePrincipalWithPortfolioOutcome AssociatePrincipalWithPortfolio(const Model::AssociatePrincipalWithPortfolioRequest& request) const;
 
        template<typename AssociatePrincipalWithPortfolioRequestT = Model::AssociatePrincipalWithPortfolioRequest>
        Model::AssociatePrincipalWithPortfolioOutcomeCallable AssociatePrincipalWithPortfolioCallable(const AssociatePrincipalWithPortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::AssociatePrincipalWithPortfolio, request);
        }
 
        template<typename AssociatePrincipalWithPortfolioRequestT = Model::AssociatePrincipalWithPortfolioRequest>
        void AssociatePrincipalWithPortfolioAsync(const AssociatePrincipalWithPortfolioRequestT& request, const AssociatePrincipalWithPortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::AssociatePrincipalWithPortfolio, request, handler, context);
        }
 
        virtual Model::AssociateProductWithPortfolioOutcome AssociateProductWithPortfolio(const Model::AssociateProductWithPortfolioRequest& request) const;
 
        template<typename AssociateProductWithPortfolioRequestT = Model::AssociateProductWithPortfolioRequest>
        Model::AssociateProductWithPortfolioOutcomeCallable AssociateProductWithPortfolioCallable(const AssociateProductWithPortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::AssociateProductWithPortfolio, request);
        }
 
        template<typename AssociateProductWithPortfolioRequestT = Model::AssociateProductWithPortfolioRequest>
        void AssociateProductWithPortfolioAsync(const AssociateProductWithPortfolioRequestT& request, const AssociateProductWithPortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::AssociateProductWithPortfolio, request, handler, context);
        }
 
        virtual Model::AssociateServiceActionWithProvisioningArtifactOutcome AssociateServiceActionWithProvisioningArtifact(const Model::AssociateServiceActionWithProvisioningArtifactRequest& request) const;
 
        template<typename AssociateServiceActionWithProvisioningArtifactRequestT = Model::AssociateServiceActionWithProvisioningArtifactRequest>
        Model::AssociateServiceActionWithProvisioningArtifactOutcomeCallable AssociateServiceActionWithProvisioningArtifactCallable(const AssociateServiceActionWithProvisioningArtifactRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::AssociateServiceActionWithProvisioningArtifact, request);
        }
 
        template<typename AssociateServiceActionWithProvisioningArtifactRequestT = Model::AssociateServiceActionWithProvisioningArtifactRequest>
        void AssociateServiceActionWithProvisioningArtifactAsync(const AssociateServiceActionWithProvisioningArtifactRequestT& request, const AssociateServiceActionWithProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::AssociateServiceActionWithProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::AssociateTagOptionWithResourceOutcome AssociateTagOptionWithResource(const Model::AssociateTagOptionWithResourceRequest& request) const;
 
        template<typename AssociateTagOptionWithResourceRequestT = Model::AssociateTagOptionWithResourceRequest>
        Model::AssociateTagOptionWithResourceOutcomeCallable AssociateTagOptionWithResourceCallable(const AssociateTagOptionWithResourceRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::AssociateTagOptionWithResource, request);
        }
 
        template<typename AssociateTagOptionWithResourceRequestT = Model::AssociateTagOptionWithResourceRequest>
        void AssociateTagOptionWithResourceAsync(const AssociateTagOptionWithResourceRequestT& request, const AssociateTagOptionWithResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::AssociateTagOptionWithResource, request, handler, context);
        }
 
        virtual Model::BatchAssociateServiceActionWithProvisioningArtifactOutcome BatchAssociateServiceActionWithProvisioningArtifact(const Model::BatchAssociateServiceActionWithProvisioningArtifactRequest& request) const;
 
        template<typename BatchAssociateServiceActionWithProvisioningArtifactRequestT = Model::BatchAssociateServiceActionWithProvisioningArtifactRequest>
        Model::BatchAssociateServiceActionWithProvisioningArtifactOutcomeCallable BatchAssociateServiceActionWithProvisioningArtifactCallable(const BatchAssociateServiceActionWithProvisioningArtifactRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::BatchAssociateServiceActionWithProvisioningArtifact, request);
        }
 
        template<typename BatchAssociateServiceActionWithProvisioningArtifactRequestT = Model::BatchAssociateServiceActionWithProvisioningArtifactRequest>
        void BatchAssociateServiceActionWithProvisioningArtifactAsync(const BatchAssociateServiceActionWithProvisioningArtifactRequestT& request, const BatchAssociateServiceActionWithProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::BatchAssociateServiceActionWithProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::BatchDisassociateServiceActionFromProvisioningArtifactOutcome BatchDisassociateServiceActionFromProvisioningArtifact(const Model::BatchDisassociateServiceActionFromProvisioningArtifactRequest& request) const;
 
        template<typename BatchDisassociateServiceActionFromProvisioningArtifactRequestT = Model::BatchDisassociateServiceActionFromProvisioningArtifactRequest>
        Model::BatchDisassociateServiceActionFromProvisioningArtifactOutcomeCallable BatchDisassociateServiceActionFromProvisioningArtifactCallable(const BatchDisassociateServiceActionFromProvisioningArtifactRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::BatchDisassociateServiceActionFromProvisioningArtifact, request);
        }
 
        template<typename BatchDisassociateServiceActionFromProvisioningArtifactRequestT = Model::BatchDisassociateServiceActionFromProvisioningArtifactRequest>
        void BatchDisassociateServiceActionFromProvisioningArtifactAsync(const BatchDisassociateServiceActionFromProvisioningArtifactRequestT& request, const BatchDisassociateServiceActionFromProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::BatchDisassociateServiceActionFromProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::CopyProductOutcome CopyProduct(const Model::CopyProductRequest& request) const;
 
        template<typename CopyProductRequestT = Model::CopyProductRequest>
        Model::CopyProductOutcomeCallable CopyProductCallable(const CopyProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CopyProduct, request);
        }
 
        template<typename CopyProductRequestT = Model::CopyProductRequest>
        void CopyProductAsync(const CopyProductRequestT& request, const CopyProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CopyProduct, request, handler, context);
        }
 
        virtual Model::CreateConstraintOutcome CreateConstraint(const Model::CreateConstraintRequest& request) const;
 
        template<typename CreateConstraintRequestT = Model::CreateConstraintRequest>
        Model::CreateConstraintOutcomeCallable CreateConstraintCallable(const CreateConstraintRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CreateConstraint, request);
        }
 
        template<typename CreateConstraintRequestT = Model::CreateConstraintRequest>
        void CreateConstraintAsync(const CreateConstraintRequestT& request, const CreateConstraintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CreateConstraint, request, handler, context);
        }
 
        virtual Model::CreatePortfolioOutcome CreatePortfolio(const Model::CreatePortfolioRequest& request) const;
 
        template<typename CreatePortfolioRequestT = Model::CreatePortfolioRequest>
        Model::CreatePortfolioOutcomeCallable CreatePortfolioCallable(const CreatePortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CreatePortfolio, request);
        }
 
        template<typename CreatePortfolioRequestT = Model::CreatePortfolioRequest>
        void CreatePortfolioAsync(const CreatePortfolioRequestT& request, const CreatePortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CreatePortfolio, request, handler, context);
        }
 
        virtual Model::CreatePortfolioShareOutcome CreatePortfolioShare(const Model::CreatePortfolioShareRequest& request) const;
 
        template<typename CreatePortfolioShareRequestT = Model::CreatePortfolioShareRequest>
        Model::CreatePortfolioShareOutcomeCallable CreatePortfolioShareCallable(const CreatePortfolioShareRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CreatePortfolioShare, request);
        }
 
        template<typename CreatePortfolioShareRequestT = Model::CreatePortfolioShareRequest>
        void CreatePortfolioShareAsync(const CreatePortfolioShareRequestT& request, const CreatePortfolioShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CreatePortfolioShare, request, handler, context);
        }
 
        virtual Model::CreateProductOutcome CreateProduct(const Model::CreateProductRequest& request) const;
 
        template<typename CreateProductRequestT = Model::CreateProductRequest>
        Model::CreateProductOutcomeCallable CreateProductCallable(const CreateProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CreateProduct, request);
        }
 
        template<typename CreateProductRequestT = Model::CreateProductRequest>
        void CreateProductAsync(const CreateProductRequestT& request, const CreateProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CreateProduct, request, handler, context);
        }
 
        virtual Model::CreateProvisionedProductPlanOutcome CreateProvisionedProductPlan(const Model::CreateProvisionedProductPlanRequest& request) const;
 
        template<typename CreateProvisionedProductPlanRequestT = Model::CreateProvisionedProductPlanRequest>
        Model::CreateProvisionedProductPlanOutcomeCallable CreateProvisionedProductPlanCallable(const CreateProvisionedProductPlanRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CreateProvisionedProductPlan, request);
        }
 
        template<typename CreateProvisionedProductPlanRequestT = Model::CreateProvisionedProductPlanRequest>
        void CreateProvisionedProductPlanAsync(const CreateProvisionedProductPlanRequestT& request, const CreateProvisionedProductPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CreateProvisionedProductPlan, request, handler, context);
        }
 
        virtual Model::CreateProvisioningArtifactOutcome CreateProvisioningArtifact(const Model::CreateProvisioningArtifactRequest& request) const;
 
        template<typename CreateProvisioningArtifactRequestT = Model::CreateProvisioningArtifactRequest>
        Model::CreateProvisioningArtifactOutcomeCallable CreateProvisioningArtifactCallable(const CreateProvisioningArtifactRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CreateProvisioningArtifact, request);
        }
 
        template<typename CreateProvisioningArtifactRequestT = Model::CreateProvisioningArtifactRequest>
        void CreateProvisioningArtifactAsync(const CreateProvisioningArtifactRequestT& request, const CreateProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CreateProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::CreateServiceActionOutcome CreateServiceAction(const Model::CreateServiceActionRequest& request) const;
 
        template<typename CreateServiceActionRequestT = Model::CreateServiceActionRequest>
        Model::CreateServiceActionOutcomeCallable CreateServiceActionCallable(const CreateServiceActionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CreateServiceAction, request);
        }
 
        template<typename CreateServiceActionRequestT = Model::CreateServiceActionRequest>
        void CreateServiceActionAsync(const CreateServiceActionRequestT& request, const CreateServiceActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CreateServiceAction, request, handler, context);
        }
 
        virtual Model::CreateTagOptionOutcome CreateTagOption(const Model::CreateTagOptionRequest& request) const;
 
        template<typename CreateTagOptionRequestT = Model::CreateTagOptionRequest>
        Model::CreateTagOptionOutcomeCallable CreateTagOptionCallable(const CreateTagOptionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::CreateTagOption, request);
        }
 
        template<typename CreateTagOptionRequestT = Model::CreateTagOptionRequest>
        void CreateTagOptionAsync(const CreateTagOptionRequestT& request, const CreateTagOptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::CreateTagOption, request, handler, context);
        }
 
        virtual Model::DeleteConstraintOutcome DeleteConstraint(const Model::DeleteConstraintRequest& request) const;
 
        template<typename DeleteConstraintRequestT = Model::DeleteConstraintRequest>
        Model::DeleteConstraintOutcomeCallable DeleteConstraintCallable(const DeleteConstraintRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DeleteConstraint, request);
        }
 
        template<typename DeleteConstraintRequestT = Model::DeleteConstraintRequest>
        void DeleteConstraintAsync(const DeleteConstraintRequestT& request, const DeleteConstraintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DeleteConstraint, request, handler, context);
        }
 
        virtual Model::DeletePortfolioOutcome DeletePortfolio(const Model::DeletePortfolioRequest& request) const;
 
        template<typename DeletePortfolioRequestT = Model::DeletePortfolioRequest>
        Model::DeletePortfolioOutcomeCallable DeletePortfolioCallable(const DeletePortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DeletePortfolio, request);
        }
 
        template<typename DeletePortfolioRequestT = Model::DeletePortfolioRequest>
        void DeletePortfolioAsync(const DeletePortfolioRequestT& request, const DeletePortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DeletePortfolio, request, handler, context);
        }
 
        virtual Model::DeletePortfolioShareOutcome DeletePortfolioShare(const Model::DeletePortfolioShareRequest& request) const;
 
        template<typename DeletePortfolioShareRequestT = Model::DeletePortfolioShareRequest>
        Model::DeletePortfolioShareOutcomeCallable DeletePortfolioShareCallable(const DeletePortfolioShareRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DeletePortfolioShare, request);
        }
 
        template<typename DeletePortfolioShareRequestT = Model::DeletePortfolioShareRequest>
        void DeletePortfolioShareAsync(const DeletePortfolioShareRequestT& request, const DeletePortfolioShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DeletePortfolioShare, request, handler, context);
        }
 
        virtual Model::DeleteProductOutcome DeleteProduct(const Model::DeleteProductRequest& request) const;
 
        template<typename DeleteProductRequestT = Model::DeleteProductRequest>
        Model::DeleteProductOutcomeCallable DeleteProductCallable(const DeleteProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DeleteProduct, request);
        }
 
        template<typename DeleteProductRequestT = Model::DeleteProductRequest>
        void DeleteProductAsync(const DeleteProductRequestT& request, const DeleteProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DeleteProduct, request, handler, context);
        }
 
        virtual Model::DeleteProvisionedProductPlanOutcome DeleteProvisionedProductPlan(const Model::DeleteProvisionedProductPlanRequest& request) const;
 
        template<typename DeleteProvisionedProductPlanRequestT = Model::DeleteProvisionedProductPlanRequest>
        Model::DeleteProvisionedProductPlanOutcomeCallable DeleteProvisionedProductPlanCallable(const DeleteProvisionedProductPlanRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DeleteProvisionedProductPlan, request);
        }
 
        template<typename DeleteProvisionedProductPlanRequestT = Model::DeleteProvisionedProductPlanRequest>
        void DeleteProvisionedProductPlanAsync(const DeleteProvisionedProductPlanRequestT& request, const DeleteProvisionedProductPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DeleteProvisionedProductPlan, request, handler, context);
        }
 
        virtual Model::DeleteProvisioningArtifactOutcome DeleteProvisioningArtifact(const Model::DeleteProvisioningArtifactRequest& request) const;
 
        template<typename DeleteProvisioningArtifactRequestT = Model::DeleteProvisioningArtifactRequest>
        Model::DeleteProvisioningArtifactOutcomeCallable DeleteProvisioningArtifactCallable(const DeleteProvisioningArtifactRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DeleteProvisioningArtifact, request);
        }
 
        template<typename DeleteProvisioningArtifactRequestT = Model::DeleteProvisioningArtifactRequest>
        void DeleteProvisioningArtifactAsync(const DeleteProvisioningArtifactRequestT& request, const DeleteProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DeleteProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::DeleteServiceActionOutcome DeleteServiceAction(const Model::DeleteServiceActionRequest& request) const;
 
        template<typename DeleteServiceActionRequestT = Model::DeleteServiceActionRequest>
        Model::DeleteServiceActionOutcomeCallable DeleteServiceActionCallable(const DeleteServiceActionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DeleteServiceAction, request);
        }
 
        template<typename DeleteServiceActionRequestT = Model::DeleteServiceActionRequest>
        void DeleteServiceActionAsync(const DeleteServiceActionRequestT& request, const DeleteServiceActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DeleteServiceAction, request, handler, context);
        }
 
        virtual Model::DeleteTagOptionOutcome DeleteTagOption(const Model::DeleteTagOptionRequest& request) const;
 
        template<typename DeleteTagOptionRequestT = Model::DeleteTagOptionRequest>
        Model::DeleteTagOptionOutcomeCallable DeleteTagOptionCallable(const DeleteTagOptionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DeleteTagOption, request);
        }
 
        template<typename DeleteTagOptionRequestT = Model::DeleteTagOptionRequest>
        void DeleteTagOptionAsync(const DeleteTagOptionRequestT& request, const DeleteTagOptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DeleteTagOption, request, handler, context);
        }
 
        virtual Model::DescribeConstraintOutcome DescribeConstraint(const Model::DescribeConstraintRequest& request) const;
 
        template<typename DescribeConstraintRequestT = Model::DescribeConstraintRequest>
        Model::DescribeConstraintOutcomeCallable DescribeConstraintCallable(const DescribeConstraintRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeConstraint, request);
        }
 
        template<typename DescribeConstraintRequestT = Model::DescribeConstraintRequest>
        void DescribeConstraintAsync(const DescribeConstraintRequestT& request, const DescribeConstraintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeConstraint, request, handler, context);
        }
 
        virtual Model::DescribeCopyProductStatusOutcome DescribeCopyProductStatus(const Model::DescribeCopyProductStatusRequest& request) const;
 
        template<typename DescribeCopyProductStatusRequestT = Model::DescribeCopyProductStatusRequest>
        Model::DescribeCopyProductStatusOutcomeCallable DescribeCopyProductStatusCallable(const DescribeCopyProductStatusRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeCopyProductStatus, request);
        }
 
        template<typename DescribeCopyProductStatusRequestT = Model::DescribeCopyProductStatusRequest>
        void DescribeCopyProductStatusAsync(const DescribeCopyProductStatusRequestT& request, const DescribeCopyProductStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeCopyProductStatus, request, handler, context);
        }
 
        virtual Model::DescribePortfolioOutcome DescribePortfolio(const Model::DescribePortfolioRequest& request) const;
 
        template<typename DescribePortfolioRequestT = Model::DescribePortfolioRequest>
        Model::DescribePortfolioOutcomeCallable DescribePortfolioCallable(const DescribePortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribePortfolio, request);
        }
 
        template<typename DescribePortfolioRequestT = Model::DescribePortfolioRequest>
        void DescribePortfolioAsync(const DescribePortfolioRequestT& request, const DescribePortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribePortfolio, request, handler, context);
        }
 
        virtual Model::DescribePortfolioShareStatusOutcome DescribePortfolioShareStatus(const Model::DescribePortfolioShareStatusRequest& request) const;
 
        template<typename DescribePortfolioShareStatusRequestT = Model::DescribePortfolioShareStatusRequest>
        Model::DescribePortfolioShareStatusOutcomeCallable DescribePortfolioShareStatusCallable(const DescribePortfolioShareStatusRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribePortfolioShareStatus, request);
        }
 
        template<typename DescribePortfolioShareStatusRequestT = Model::DescribePortfolioShareStatusRequest>
        void DescribePortfolioShareStatusAsync(const DescribePortfolioShareStatusRequestT& request, const DescribePortfolioShareStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribePortfolioShareStatus, request, handler, context);
        }
 
        virtual Model::DescribePortfolioSharesOutcome DescribePortfolioShares(const Model::DescribePortfolioSharesRequest& request) const;
 
        template<typename DescribePortfolioSharesRequestT = Model::DescribePortfolioSharesRequest>
        Model::DescribePortfolioSharesOutcomeCallable DescribePortfolioSharesCallable(const DescribePortfolioSharesRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribePortfolioShares, request);
        }
 
        template<typename DescribePortfolioSharesRequestT = Model::DescribePortfolioSharesRequest>
        void DescribePortfolioSharesAsync(const DescribePortfolioSharesRequestT& request, const DescribePortfolioSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribePortfolioShares, request, handler, context);
        }
 
        virtual Model::DescribeProductOutcome DescribeProduct(const Model::DescribeProductRequest& request = {}) const;
 
        template<typename DescribeProductRequestT = Model::DescribeProductRequest>
        Model::DescribeProductOutcomeCallable DescribeProductCallable(const DescribeProductRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeProduct, request);
        }
 
        template<typename DescribeProductRequestT = Model::DescribeProductRequest>
        void DescribeProductAsync(const DescribeProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeProductRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeProduct, request, handler, context);
        }
 
        virtual Model::DescribeProductAsAdminOutcome DescribeProductAsAdmin(const Model::DescribeProductAsAdminRequest& request = {}) const;
 
        template<typename DescribeProductAsAdminRequestT = Model::DescribeProductAsAdminRequest>
        Model::DescribeProductAsAdminOutcomeCallable DescribeProductAsAdminCallable(const DescribeProductAsAdminRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeProductAsAdmin, request);
        }
 
        template<typename DescribeProductAsAdminRequestT = Model::DescribeProductAsAdminRequest>
        void DescribeProductAsAdminAsync(const DescribeProductAsAdminResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeProductAsAdminRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeProductAsAdmin, request, handler, context);
        }
 
        virtual Model::DescribeProductViewOutcome DescribeProductView(const Model::DescribeProductViewRequest& request) const;
 
        template<typename DescribeProductViewRequestT = Model::DescribeProductViewRequest>
        Model::DescribeProductViewOutcomeCallable DescribeProductViewCallable(const DescribeProductViewRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeProductView, request);
        }
 
        template<typename DescribeProductViewRequestT = Model::DescribeProductViewRequest>
        void DescribeProductViewAsync(const DescribeProductViewRequestT& request, const DescribeProductViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeProductView, request, handler, context);
        }
 
        virtual Model::DescribeProvisionedProductOutcome DescribeProvisionedProduct(const Model::DescribeProvisionedProductRequest& request = {}) const;
 
        template<typename DescribeProvisionedProductRequestT = Model::DescribeProvisionedProductRequest>
        Model::DescribeProvisionedProductOutcomeCallable DescribeProvisionedProductCallable(const DescribeProvisionedProductRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeProvisionedProduct, request);
        }
 
        template<typename DescribeProvisionedProductRequestT = Model::DescribeProvisionedProductRequest>
        void DescribeProvisionedProductAsync(const DescribeProvisionedProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeProvisionedProductRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeProvisionedProduct, request, handler, context);
        }
 
        virtual Model::DescribeProvisionedProductPlanOutcome DescribeProvisionedProductPlan(const Model::DescribeProvisionedProductPlanRequest& request) const;
 
        template<typename DescribeProvisionedProductPlanRequestT = Model::DescribeProvisionedProductPlanRequest>
        Model::DescribeProvisionedProductPlanOutcomeCallable DescribeProvisionedProductPlanCallable(const DescribeProvisionedProductPlanRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeProvisionedProductPlan, request);
        }
 
        template<typename DescribeProvisionedProductPlanRequestT = Model::DescribeProvisionedProductPlanRequest>
        void DescribeProvisionedProductPlanAsync(const DescribeProvisionedProductPlanRequestT& request, const DescribeProvisionedProductPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeProvisionedProductPlan, request, handler, context);
        }
 
        virtual Model::DescribeProvisioningArtifactOutcome DescribeProvisioningArtifact(const Model::DescribeProvisioningArtifactRequest& request = {}) const;
 
        template<typename DescribeProvisioningArtifactRequestT = Model::DescribeProvisioningArtifactRequest>
        Model::DescribeProvisioningArtifactOutcomeCallable DescribeProvisioningArtifactCallable(const DescribeProvisioningArtifactRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeProvisioningArtifact, request);
        }
 
        template<typename DescribeProvisioningArtifactRequestT = Model::DescribeProvisioningArtifactRequest>
        void DescribeProvisioningArtifactAsync(const DescribeProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeProvisioningArtifactRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::DescribeProvisioningParametersOutcome DescribeProvisioningParameters(const Model::DescribeProvisioningParametersRequest& request = {}) const;
 
        template<typename DescribeProvisioningParametersRequestT = Model::DescribeProvisioningParametersRequest>
        Model::DescribeProvisioningParametersOutcomeCallable DescribeProvisioningParametersCallable(const DescribeProvisioningParametersRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeProvisioningParameters, request);
        }
 
        template<typename DescribeProvisioningParametersRequestT = Model::DescribeProvisioningParametersRequest>
        void DescribeProvisioningParametersAsync(const DescribeProvisioningParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeProvisioningParametersRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeProvisioningParameters, request, handler, context);
        }
 
        virtual Model::DescribeRecordOutcome DescribeRecord(const Model::DescribeRecordRequest& request) const;
 
        template<typename DescribeRecordRequestT = Model::DescribeRecordRequest>
        Model::DescribeRecordOutcomeCallable DescribeRecordCallable(const DescribeRecordRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeRecord, request);
        }
 
        template<typename DescribeRecordRequestT = Model::DescribeRecordRequest>
        void DescribeRecordAsync(const DescribeRecordRequestT& request, const DescribeRecordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeRecord, request, handler, context);
        }
 
        virtual Model::DescribeServiceActionOutcome DescribeServiceAction(const Model::DescribeServiceActionRequest& request) const;
 
        template<typename DescribeServiceActionRequestT = Model::DescribeServiceActionRequest>
        Model::DescribeServiceActionOutcomeCallable DescribeServiceActionCallable(const DescribeServiceActionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeServiceAction, request);
        }
 
        template<typename DescribeServiceActionRequestT = Model::DescribeServiceActionRequest>
        void DescribeServiceActionAsync(const DescribeServiceActionRequestT& request, const DescribeServiceActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeServiceAction, request, handler, context);
        }
 
        virtual Model::DescribeServiceActionExecutionParametersOutcome DescribeServiceActionExecutionParameters(const Model::DescribeServiceActionExecutionParametersRequest& request) const;
 
        template<typename DescribeServiceActionExecutionParametersRequestT = Model::DescribeServiceActionExecutionParametersRequest>
        Model::DescribeServiceActionExecutionParametersOutcomeCallable DescribeServiceActionExecutionParametersCallable(const DescribeServiceActionExecutionParametersRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeServiceActionExecutionParameters, request);
        }
 
        template<typename DescribeServiceActionExecutionParametersRequestT = Model::DescribeServiceActionExecutionParametersRequest>
        void DescribeServiceActionExecutionParametersAsync(const DescribeServiceActionExecutionParametersRequestT& request, const DescribeServiceActionExecutionParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeServiceActionExecutionParameters, request, handler, context);
        }
 
        virtual Model::DescribeTagOptionOutcome DescribeTagOption(const Model::DescribeTagOptionRequest& request) const;
 
        template<typename DescribeTagOptionRequestT = Model::DescribeTagOptionRequest>
        Model::DescribeTagOptionOutcomeCallable DescribeTagOptionCallable(const DescribeTagOptionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DescribeTagOption, request);
        }
 
        template<typename DescribeTagOptionRequestT = Model::DescribeTagOptionRequest>
        void DescribeTagOptionAsync(const DescribeTagOptionRequestT& request, const DescribeTagOptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DescribeTagOption, request, handler, context);
        }
 
        virtual Model::DisableAWSOrganizationsAccessOutcome DisableAWSOrganizationsAccess(const Model::DisableAWSOrganizationsAccessRequest& request = {}) const;
 
        template<typename DisableAWSOrganizationsAccessRequestT = Model::DisableAWSOrganizationsAccessRequest>
        Model::DisableAWSOrganizationsAccessOutcomeCallable DisableAWSOrganizationsAccessCallable(const DisableAWSOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::DisableAWSOrganizationsAccess, request);
        }
 
        template<typename DisableAWSOrganizationsAccessRequestT = Model::DisableAWSOrganizationsAccessRequest>
        void DisableAWSOrganizationsAccessAsync(const DisableAWSOrganizationsAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisableAWSOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::DisableAWSOrganizationsAccess, request, handler, context);
        }
 
        virtual Model::DisassociateBudgetFromResourceOutcome DisassociateBudgetFromResource(const Model::DisassociateBudgetFromResourceRequest& request) const;
 
        template<typename DisassociateBudgetFromResourceRequestT = Model::DisassociateBudgetFromResourceRequest>
        Model::DisassociateBudgetFromResourceOutcomeCallable DisassociateBudgetFromResourceCallable(const DisassociateBudgetFromResourceRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DisassociateBudgetFromResource, request);
        }
 
        template<typename DisassociateBudgetFromResourceRequestT = Model::DisassociateBudgetFromResourceRequest>
        void DisassociateBudgetFromResourceAsync(const DisassociateBudgetFromResourceRequestT& request, const DisassociateBudgetFromResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DisassociateBudgetFromResource, request, handler, context);
        }
 
        virtual Model::DisassociatePrincipalFromPortfolioOutcome DisassociatePrincipalFromPortfolio(const Model::DisassociatePrincipalFromPortfolioRequest& request) const;
 
        template<typename DisassociatePrincipalFromPortfolioRequestT = Model::DisassociatePrincipalFromPortfolioRequest>
        Model::DisassociatePrincipalFromPortfolioOutcomeCallable DisassociatePrincipalFromPortfolioCallable(const DisassociatePrincipalFromPortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DisassociatePrincipalFromPortfolio, request);
        }
 
        template<typename DisassociatePrincipalFromPortfolioRequestT = Model::DisassociatePrincipalFromPortfolioRequest>
        void DisassociatePrincipalFromPortfolioAsync(const DisassociatePrincipalFromPortfolioRequestT& request, const DisassociatePrincipalFromPortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DisassociatePrincipalFromPortfolio, request, handler, context);
        }
 
        virtual Model::DisassociateProductFromPortfolioOutcome DisassociateProductFromPortfolio(const Model::DisassociateProductFromPortfolioRequest& request) const;
 
        template<typename DisassociateProductFromPortfolioRequestT = Model::DisassociateProductFromPortfolioRequest>
        Model::DisassociateProductFromPortfolioOutcomeCallable DisassociateProductFromPortfolioCallable(const DisassociateProductFromPortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DisassociateProductFromPortfolio, request);
        }
 
        template<typename DisassociateProductFromPortfolioRequestT = Model::DisassociateProductFromPortfolioRequest>
        void DisassociateProductFromPortfolioAsync(const DisassociateProductFromPortfolioRequestT& request, const DisassociateProductFromPortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DisassociateProductFromPortfolio, request, handler, context);
        }
 
        virtual Model::DisassociateServiceActionFromProvisioningArtifactOutcome DisassociateServiceActionFromProvisioningArtifact(const Model::DisassociateServiceActionFromProvisioningArtifactRequest& request) const;
 
        template<typename DisassociateServiceActionFromProvisioningArtifactRequestT = Model::DisassociateServiceActionFromProvisioningArtifactRequest>
        Model::DisassociateServiceActionFromProvisioningArtifactOutcomeCallable DisassociateServiceActionFromProvisioningArtifactCallable(const DisassociateServiceActionFromProvisioningArtifactRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DisassociateServiceActionFromProvisioningArtifact, request);
        }
 
        template<typename DisassociateServiceActionFromProvisioningArtifactRequestT = Model::DisassociateServiceActionFromProvisioningArtifactRequest>
        void DisassociateServiceActionFromProvisioningArtifactAsync(const DisassociateServiceActionFromProvisioningArtifactRequestT& request, const DisassociateServiceActionFromProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DisassociateServiceActionFromProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::DisassociateTagOptionFromResourceOutcome DisassociateTagOptionFromResource(const Model::DisassociateTagOptionFromResourceRequest& request) const;
 
        template<typename DisassociateTagOptionFromResourceRequestT = Model::DisassociateTagOptionFromResourceRequest>
        Model::DisassociateTagOptionFromResourceOutcomeCallable DisassociateTagOptionFromResourceCallable(const DisassociateTagOptionFromResourceRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::DisassociateTagOptionFromResource, request);
        }
 
        template<typename DisassociateTagOptionFromResourceRequestT = Model::DisassociateTagOptionFromResourceRequest>
        void DisassociateTagOptionFromResourceAsync(const DisassociateTagOptionFromResourceRequestT& request, const DisassociateTagOptionFromResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::DisassociateTagOptionFromResource, request, handler, context);
        }
 
        virtual Model::EnableAWSOrganizationsAccessOutcome EnableAWSOrganizationsAccess(const Model::EnableAWSOrganizationsAccessRequest& request = {}) const;
 
        template<typename EnableAWSOrganizationsAccessRequestT = Model::EnableAWSOrganizationsAccessRequest>
        Model::EnableAWSOrganizationsAccessOutcomeCallable EnableAWSOrganizationsAccessCallable(const EnableAWSOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::EnableAWSOrganizationsAccess, request);
        }
 
        template<typename EnableAWSOrganizationsAccessRequestT = Model::EnableAWSOrganizationsAccessRequest>
        void EnableAWSOrganizationsAccessAsync(const EnableAWSOrganizationsAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const EnableAWSOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::EnableAWSOrganizationsAccess, request, handler, context);
        }
 
        virtual Model::ExecuteProvisionedProductPlanOutcome ExecuteProvisionedProductPlan(const Model::ExecuteProvisionedProductPlanRequest& request) const;
 
        template<typename ExecuteProvisionedProductPlanRequestT = Model::ExecuteProvisionedProductPlanRequest>
        Model::ExecuteProvisionedProductPlanOutcomeCallable ExecuteProvisionedProductPlanCallable(const ExecuteProvisionedProductPlanRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ExecuteProvisionedProductPlan, request);
        }
 
        template<typename ExecuteProvisionedProductPlanRequestT = Model::ExecuteProvisionedProductPlanRequest>
        void ExecuteProvisionedProductPlanAsync(const ExecuteProvisionedProductPlanRequestT& request, const ExecuteProvisionedProductPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ExecuteProvisionedProductPlan, request, handler, context);
        }
 
        virtual Model::ExecuteProvisionedProductServiceActionOutcome ExecuteProvisionedProductServiceAction(const Model::ExecuteProvisionedProductServiceActionRequest& request) const;
 
        template<typename ExecuteProvisionedProductServiceActionRequestT = Model::ExecuteProvisionedProductServiceActionRequest>
        Model::ExecuteProvisionedProductServiceActionOutcomeCallable ExecuteProvisionedProductServiceActionCallable(const ExecuteProvisionedProductServiceActionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ExecuteProvisionedProductServiceAction, request);
        }
 
        template<typename ExecuteProvisionedProductServiceActionRequestT = Model::ExecuteProvisionedProductServiceActionRequest>
        void ExecuteProvisionedProductServiceActionAsync(const ExecuteProvisionedProductServiceActionRequestT& request, const ExecuteProvisionedProductServiceActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ExecuteProvisionedProductServiceAction, request, handler, context);
        }
 
        virtual Model::GetAWSOrganizationsAccessStatusOutcome GetAWSOrganizationsAccessStatus(const Model::GetAWSOrganizationsAccessStatusRequest& request = {}) const;
 
        template<typename GetAWSOrganizationsAccessStatusRequestT = Model::GetAWSOrganizationsAccessStatusRequest>
        Model::GetAWSOrganizationsAccessStatusOutcomeCallable GetAWSOrganizationsAccessStatusCallable(const GetAWSOrganizationsAccessStatusRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::GetAWSOrganizationsAccessStatus, request);
        }
 
        template<typename GetAWSOrganizationsAccessStatusRequestT = Model::GetAWSOrganizationsAccessStatusRequest>
        void GetAWSOrganizationsAccessStatusAsync(const GetAWSOrganizationsAccessStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAWSOrganizationsAccessStatusRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::GetAWSOrganizationsAccessStatus, request, handler, context);
        }
 
        virtual Model::GetProvisionedProductOutputsOutcome GetProvisionedProductOutputs(const Model::GetProvisionedProductOutputsRequest& request = {}) const;
 
        template<typename GetProvisionedProductOutputsRequestT = Model::GetProvisionedProductOutputsRequest>
        Model::GetProvisionedProductOutputsOutcomeCallable GetProvisionedProductOutputsCallable(const GetProvisionedProductOutputsRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::GetProvisionedProductOutputs, request);
        }
 
        template<typename GetProvisionedProductOutputsRequestT = Model::GetProvisionedProductOutputsRequest>
        void GetProvisionedProductOutputsAsync(const GetProvisionedProductOutputsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetProvisionedProductOutputsRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::GetProvisionedProductOutputs, request, handler, context);
        }
 
        virtual Model::ImportAsProvisionedProductOutcome ImportAsProvisionedProduct(const Model::ImportAsProvisionedProductRequest& request) const;
 
        template<typename ImportAsProvisionedProductRequestT = Model::ImportAsProvisionedProductRequest>
        Model::ImportAsProvisionedProductOutcomeCallable ImportAsProvisionedProductCallable(const ImportAsProvisionedProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ImportAsProvisionedProduct, request);
        }
 
        template<typename ImportAsProvisionedProductRequestT = Model::ImportAsProvisionedProductRequest>
        void ImportAsProvisionedProductAsync(const ImportAsProvisionedProductRequestT& request, const ImportAsProvisionedProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ImportAsProvisionedProduct, request, handler, context);
        }
 
        virtual Model::ListAcceptedPortfolioSharesOutcome ListAcceptedPortfolioShares(const Model::ListAcceptedPortfolioSharesRequest& request = {}) const;
 
        template<typename ListAcceptedPortfolioSharesRequestT = Model::ListAcceptedPortfolioSharesRequest>
        Model::ListAcceptedPortfolioSharesOutcomeCallable ListAcceptedPortfolioSharesCallable(const ListAcceptedPortfolioSharesRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListAcceptedPortfolioShares, request);
        }
 
        template<typename ListAcceptedPortfolioSharesRequestT = Model::ListAcceptedPortfolioSharesRequest>
        void ListAcceptedPortfolioSharesAsync(const ListAcceptedPortfolioSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAcceptedPortfolioSharesRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListAcceptedPortfolioShares, request, handler, context);
        }
 
        virtual Model::ListBudgetsForResourceOutcome ListBudgetsForResource(const Model::ListBudgetsForResourceRequest& request) const;
 
        template<typename ListBudgetsForResourceRequestT = Model::ListBudgetsForResourceRequest>
        Model::ListBudgetsForResourceOutcomeCallable ListBudgetsForResourceCallable(const ListBudgetsForResourceRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListBudgetsForResource, request);
        }
 
        template<typename ListBudgetsForResourceRequestT = Model::ListBudgetsForResourceRequest>
        void ListBudgetsForResourceAsync(const ListBudgetsForResourceRequestT& request, const ListBudgetsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListBudgetsForResource, request, handler, context);
        }
 
        virtual Model::ListConstraintsForPortfolioOutcome ListConstraintsForPortfolio(const Model::ListConstraintsForPortfolioRequest& request) const;
 
        template<typename ListConstraintsForPortfolioRequestT = Model::ListConstraintsForPortfolioRequest>
        Model::ListConstraintsForPortfolioOutcomeCallable ListConstraintsForPortfolioCallable(const ListConstraintsForPortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListConstraintsForPortfolio, request);
        }
 
        template<typename ListConstraintsForPortfolioRequestT = Model::ListConstraintsForPortfolioRequest>
        void ListConstraintsForPortfolioAsync(const ListConstraintsForPortfolioRequestT& request, const ListConstraintsForPortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListConstraintsForPortfolio, request, handler, context);
        }
 
        virtual Model::ListLaunchPathsOutcome ListLaunchPaths(const Model::ListLaunchPathsRequest& request) const;
 
        template<typename ListLaunchPathsRequestT = Model::ListLaunchPathsRequest>
        Model::ListLaunchPathsOutcomeCallable ListLaunchPathsCallable(const ListLaunchPathsRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListLaunchPaths, request);
        }
 
        template<typename ListLaunchPathsRequestT = Model::ListLaunchPathsRequest>
        void ListLaunchPathsAsync(const ListLaunchPathsRequestT& request, const ListLaunchPathsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListLaunchPaths, request, handler, context);
        }
 
        virtual Model::ListOrganizationPortfolioAccessOutcome ListOrganizationPortfolioAccess(const Model::ListOrganizationPortfolioAccessRequest& request) const;
 
        template<typename ListOrganizationPortfolioAccessRequestT = Model::ListOrganizationPortfolioAccessRequest>
        Model::ListOrganizationPortfolioAccessOutcomeCallable ListOrganizationPortfolioAccessCallable(const ListOrganizationPortfolioAccessRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListOrganizationPortfolioAccess, request);
        }
 
        template<typename ListOrganizationPortfolioAccessRequestT = Model::ListOrganizationPortfolioAccessRequest>
        void ListOrganizationPortfolioAccessAsync(const ListOrganizationPortfolioAccessRequestT& request, const ListOrganizationPortfolioAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListOrganizationPortfolioAccess, request, handler, context);
        }
 
        virtual Model::ListPortfolioAccessOutcome ListPortfolioAccess(const Model::ListPortfolioAccessRequest& request) const;
 
        template<typename ListPortfolioAccessRequestT = Model::ListPortfolioAccessRequest>
        Model::ListPortfolioAccessOutcomeCallable ListPortfolioAccessCallable(const ListPortfolioAccessRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListPortfolioAccess, request);
        }
 
        template<typename ListPortfolioAccessRequestT = Model::ListPortfolioAccessRequest>
        void ListPortfolioAccessAsync(const ListPortfolioAccessRequestT& request, const ListPortfolioAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListPortfolioAccess, request, handler, context);
        }
 
        virtual Model::ListPortfoliosOutcome ListPortfolios(const Model::ListPortfoliosRequest& request = {}) const;
 
        template<typename ListPortfoliosRequestT = Model::ListPortfoliosRequest>
        Model::ListPortfoliosOutcomeCallable ListPortfoliosCallable(const ListPortfoliosRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListPortfolios, request);
        }
 
        template<typename ListPortfoliosRequestT = Model::ListPortfoliosRequest>
        void ListPortfoliosAsync(const ListPortfoliosResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPortfoliosRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListPortfolios, request, handler, context);
        }
 
        virtual Model::ListPortfoliosForProductOutcome ListPortfoliosForProduct(const Model::ListPortfoliosForProductRequest& request) const;
 
        template<typename ListPortfoliosForProductRequestT = Model::ListPortfoliosForProductRequest>
        Model::ListPortfoliosForProductOutcomeCallable ListPortfoliosForProductCallable(const ListPortfoliosForProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListPortfoliosForProduct, request);
        }
 
        template<typename ListPortfoliosForProductRequestT = Model::ListPortfoliosForProductRequest>
        void ListPortfoliosForProductAsync(const ListPortfoliosForProductRequestT& request, const ListPortfoliosForProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListPortfoliosForProduct, request, handler, context);
        }
 
        virtual Model::ListPrincipalsForPortfolioOutcome ListPrincipalsForPortfolio(const Model::ListPrincipalsForPortfolioRequest& request) const;
 
        template<typename ListPrincipalsForPortfolioRequestT = Model::ListPrincipalsForPortfolioRequest>
        Model::ListPrincipalsForPortfolioOutcomeCallable ListPrincipalsForPortfolioCallable(const ListPrincipalsForPortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListPrincipalsForPortfolio, request);
        }
 
        template<typename ListPrincipalsForPortfolioRequestT = Model::ListPrincipalsForPortfolioRequest>
        void ListPrincipalsForPortfolioAsync(const ListPrincipalsForPortfolioRequestT& request, const ListPrincipalsForPortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListPrincipalsForPortfolio, request, handler, context);
        }
 
        virtual Model::ListProvisionedProductPlansOutcome ListProvisionedProductPlans(const Model::ListProvisionedProductPlansRequest& request = {}) const;
 
        template<typename ListProvisionedProductPlansRequestT = Model::ListProvisionedProductPlansRequest>
        Model::ListProvisionedProductPlansOutcomeCallable ListProvisionedProductPlansCallable(const ListProvisionedProductPlansRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListProvisionedProductPlans, request);
        }
 
        template<typename ListProvisionedProductPlansRequestT = Model::ListProvisionedProductPlansRequest>
        void ListProvisionedProductPlansAsync(const ListProvisionedProductPlansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProvisionedProductPlansRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListProvisionedProductPlans, request, handler, context);
        }
 
        virtual Model::ListProvisioningArtifactsOutcome ListProvisioningArtifacts(const Model::ListProvisioningArtifactsRequest& request) const;
 
        template<typename ListProvisioningArtifactsRequestT = Model::ListProvisioningArtifactsRequest>
        Model::ListProvisioningArtifactsOutcomeCallable ListProvisioningArtifactsCallable(const ListProvisioningArtifactsRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListProvisioningArtifacts, request);
        }
 
        template<typename ListProvisioningArtifactsRequestT = Model::ListProvisioningArtifactsRequest>
        void ListProvisioningArtifactsAsync(const ListProvisioningArtifactsRequestT& request, const ListProvisioningArtifactsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListProvisioningArtifacts, request, handler, context);
        }
 
        virtual Model::ListProvisioningArtifactsForServiceActionOutcome ListProvisioningArtifactsForServiceAction(const Model::ListProvisioningArtifactsForServiceActionRequest& request) const;
 
        template<typename ListProvisioningArtifactsForServiceActionRequestT = Model::ListProvisioningArtifactsForServiceActionRequest>
        Model::ListProvisioningArtifactsForServiceActionOutcomeCallable ListProvisioningArtifactsForServiceActionCallable(const ListProvisioningArtifactsForServiceActionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListProvisioningArtifactsForServiceAction, request);
        }
 
        template<typename ListProvisioningArtifactsForServiceActionRequestT = Model::ListProvisioningArtifactsForServiceActionRequest>
        void ListProvisioningArtifactsForServiceActionAsync(const ListProvisioningArtifactsForServiceActionRequestT& request, const ListProvisioningArtifactsForServiceActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListProvisioningArtifactsForServiceAction, request, handler, context);
        }
 
        virtual Model::ListRecordHistoryOutcome ListRecordHistory(const Model::ListRecordHistoryRequest& request = {}) const;
 
        template<typename ListRecordHistoryRequestT = Model::ListRecordHistoryRequest>
        Model::ListRecordHistoryOutcomeCallable ListRecordHistoryCallable(const ListRecordHistoryRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListRecordHistory, request);
        }
 
        template<typename ListRecordHistoryRequestT = Model::ListRecordHistoryRequest>
        void ListRecordHistoryAsync(const ListRecordHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRecordHistoryRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListRecordHistory, request, handler, context);
        }
 
        virtual Model::ListResourcesForTagOptionOutcome ListResourcesForTagOption(const Model::ListResourcesForTagOptionRequest& request) const;
 
        template<typename ListResourcesForTagOptionRequestT = Model::ListResourcesForTagOptionRequest>
        Model::ListResourcesForTagOptionOutcomeCallable ListResourcesForTagOptionCallable(const ListResourcesForTagOptionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListResourcesForTagOption, request);
        }
 
        template<typename ListResourcesForTagOptionRequestT = Model::ListResourcesForTagOptionRequest>
        void ListResourcesForTagOptionAsync(const ListResourcesForTagOptionRequestT& request, const ListResourcesForTagOptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListResourcesForTagOption, request, handler, context);
        }
 
        virtual Model::ListServiceActionsOutcome ListServiceActions(const Model::ListServiceActionsRequest& request = {}) const;
 
        template<typename ListServiceActionsRequestT = Model::ListServiceActionsRequest>
        Model::ListServiceActionsOutcomeCallable ListServiceActionsCallable(const ListServiceActionsRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListServiceActions, request);
        }
 
        template<typename ListServiceActionsRequestT = Model::ListServiceActionsRequest>
        void ListServiceActionsAsync(const ListServiceActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceActionsRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListServiceActions, request, handler, context);
        }
 
        virtual Model::ListServiceActionsForProvisioningArtifactOutcome ListServiceActionsForProvisioningArtifact(const Model::ListServiceActionsForProvisioningArtifactRequest& request) const;
 
        template<typename ListServiceActionsForProvisioningArtifactRequestT = Model::ListServiceActionsForProvisioningArtifactRequest>
        Model::ListServiceActionsForProvisioningArtifactOutcomeCallable ListServiceActionsForProvisioningArtifactCallable(const ListServiceActionsForProvisioningArtifactRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListServiceActionsForProvisioningArtifact, request);
        }
 
        template<typename ListServiceActionsForProvisioningArtifactRequestT = Model::ListServiceActionsForProvisioningArtifactRequest>
        void ListServiceActionsForProvisioningArtifactAsync(const ListServiceActionsForProvisioningArtifactRequestT& request, const ListServiceActionsForProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListServiceActionsForProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::ListStackInstancesForProvisionedProductOutcome ListStackInstancesForProvisionedProduct(const Model::ListStackInstancesForProvisionedProductRequest& request) const;
 
        template<typename ListStackInstancesForProvisionedProductRequestT = Model::ListStackInstancesForProvisionedProductRequest>
        Model::ListStackInstancesForProvisionedProductOutcomeCallable ListStackInstancesForProvisionedProductCallable(const ListStackInstancesForProvisionedProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListStackInstancesForProvisionedProduct, request);
        }
 
        template<typename ListStackInstancesForProvisionedProductRequestT = Model::ListStackInstancesForProvisionedProductRequest>
        void ListStackInstancesForProvisionedProductAsync(const ListStackInstancesForProvisionedProductRequestT& request, const ListStackInstancesForProvisionedProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListStackInstancesForProvisionedProduct, request, handler, context);
        }
 
        virtual Model::ListTagOptionsOutcome ListTagOptions(const Model::ListTagOptionsRequest& request = {}) const;
 
        template<typename ListTagOptionsRequestT = Model::ListTagOptionsRequest>
        Model::ListTagOptionsOutcomeCallable ListTagOptionsCallable(const ListTagOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::ListTagOptions, request);
        }
 
        template<typename ListTagOptionsRequestT = Model::ListTagOptionsRequest>
        void ListTagOptionsAsync(const ListTagOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTagOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::ListTagOptions, request, handler, context);
        }
 
        virtual Model::NotifyProvisionProductEngineWorkflowResultOutcome NotifyProvisionProductEngineWorkflowResult(const Model::NotifyProvisionProductEngineWorkflowResultRequest& request) const;
 
        template<typename NotifyProvisionProductEngineWorkflowResultRequestT = Model::NotifyProvisionProductEngineWorkflowResultRequest>
        Model::NotifyProvisionProductEngineWorkflowResultOutcomeCallable NotifyProvisionProductEngineWorkflowResultCallable(const NotifyProvisionProductEngineWorkflowResultRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::NotifyProvisionProductEngineWorkflowResult, request);
        }
 
        template<typename NotifyProvisionProductEngineWorkflowResultRequestT = Model::NotifyProvisionProductEngineWorkflowResultRequest>
        void NotifyProvisionProductEngineWorkflowResultAsync(const NotifyProvisionProductEngineWorkflowResultRequestT& request, const NotifyProvisionProductEngineWorkflowResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::NotifyProvisionProductEngineWorkflowResult, request, handler, context);
        }
 
        virtual Model::NotifyTerminateProvisionedProductEngineWorkflowResultOutcome NotifyTerminateProvisionedProductEngineWorkflowResult(const Model::NotifyTerminateProvisionedProductEngineWorkflowResultRequest& request) const;
 
        template<typename NotifyTerminateProvisionedProductEngineWorkflowResultRequestT = Model::NotifyTerminateProvisionedProductEngineWorkflowResultRequest>
        Model::NotifyTerminateProvisionedProductEngineWorkflowResultOutcomeCallable NotifyTerminateProvisionedProductEngineWorkflowResultCallable(const NotifyTerminateProvisionedProductEngineWorkflowResultRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::NotifyTerminateProvisionedProductEngineWorkflowResult, request);
        }
 
        template<typename NotifyTerminateProvisionedProductEngineWorkflowResultRequestT = Model::NotifyTerminateProvisionedProductEngineWorkflowResultRequest>
        void NotifyTerminateProvisionedProductEngineWorkflowResultAsync(const NotifyTerminateProvisionedProductEngineWorkflowResultRequestT& request, const NotifyTerminateProvisionedProductEngineWorkflowResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::NotifyTerminateProvisionedProductEngineWorkflowResult, request, handler, context);
        }
 
        virtual Model::NotifyUpdateProvisionedProductEngineWorkflowResultOutcome NotifyUpdateProvisionedProductEngineWorkflowResult(const Model::NotifyUpdateProvisionedProductEngineWorkflowResultRequest& request) const;
 
        template<typename NotifyUpdateProvisionedProductEngineWorkflowResultRequestT = Model::NotifyUpdateProvisionedProductEngineWorkflowResultRequest>
        Model::NotifyUpdateProvisionedProductEngineWorkflowResultOutcomeCallable NotifyUpdateProvisionedProductEngineWorkflowResultCallable(const NotifyUpdateProvisionedProductEngineWorkflowResultRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::NotifyUpdateProvisionedProductEngineWorkflowResult, request);
        }
 
        template<typename NotifyUpdateProvisionedProductEngineWorkflowResultRequestT = Model::NotifyUpdateProvisionedProductEngineWorkflowResultRequest>
        void NotifyUpdateProvisionedProductEngineWorkflowResultAsync(const NotifyUpdateProvisionedProductEngineWorkflowResultRequestT& request, const NotifyUpdateProvisionedProductEngineWorkflowResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::NotifyUpdateProvisionedProductEngineWorkflowResult, request, handler, context);
        }
 
        virtual Model::ProvisionProductOutcome ProvisionProduct(const Model::ProvisionProductRequest& request) const;
 
        template<typename ProvisionProductRequestT = Model::ProvisionProductRequest>
        Model::ProvisionProductOutcomeCallable ProvisionProductCallable(const ProvisionProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::ProvisionProduct, request);
        }
 
        template<typename ProvisionProductRequestT = Model::ProvisionProductRequest>
        void ProvisionProductAsync(const ProvisionProductRequestT& request, const ProvisionProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::ProvisionProduct, request, handler, context);
        }
 
        virtual Model::RejectPortfolioShareOutcome RejectPortfolioShare(const Model::RejectPortfolioShareRequest& request) const;
 
        template<typename RejectPortfolioShareRequestT = Model::RejectPortfolioShareRequest>
        Model::RejectPortfolioShareOutcomeCallable RejectPortfolioShareCallable(const RejectPortfolioShareRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::RejectPortfolioShare, request);
        }
 
        template<typename RejectPortfolioShareRequestT = Model::RejectPortfolioShareRequest>
        void RejectPortfolioShareAsync(const RejectPortfolioShareRequestT& request, const RejectPortfolioShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::RejectPortfolioShare, request, handler, context);
        }
 
        virtual Model::ScanProvisionedProductsOutcome ScanProvisionedProducts(const Model::ScanProvisionedProductsRequest& request = {}) const;
 
        template<typename ScanProvisionedProductsRequestT = Model::ScanProvisionedProductsRequest>
        Model::ScanProvisionedProductsOutcomeCallable ScanProvisionedProductsCallable(const ScanProvisionedProductsRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::ScanProvisionedProducts, request);
        }
 
        template<typename ScanProvisionedProductsRequestT = Model::ScanProvisionedProductsRequest>
        void ScanProvisionedProductsAsync(const ScanProvisionedProductsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ScanProvisionedProductsRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::ScanProvisionedProducts, request, handler, context);
        }
 
        virtual Model::SearchProductsOutcome SearchProducts(const Model::SearchProductsRequest& request = {}) const;
 
        template<typename SearchProductsRequestT = Model::SearchProductsRequest>
        Model::SearchProductsOutcomeCallable SearchProductsCallable(const SearchProductsRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::SearchProducts, request);
        }
 
        template<typename SearchProductsRequestT = Model::SearchProductsRequest>
        void SearchProductsAsync(const SearchProductsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SearchProductsRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::SearchProducts, request, handler, context);
        }
 
        virtual Model::SearchProductsAsAdminOutcome SearchProductsAsAdmin(const Model::SearchProductsAsAdminRequest& request = {}) const;
 
        template<typename SearchProductsAsAdminRequestT = Model::SearchProductsAsAdminRequest>
        Model::SearchProductsAsAdminOutcomeCallable SearchProductsAsAdminCallable(const SearchProductsAsAdminRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::SearchProductsAsAdmin, request);
        }
 
        template<typename SearchProductsAsAdminRequestT = Model::SearchProductsAsAdminRequest>
        void SearchProductsAsAdminAsync(const SearchProductsAsAdminResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SearchProductsAsAdminRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::SearchProductsAsAdmin, request, handler, context);
        }
 
        virtual Model::SearchProvisionedProductsOutcome SearchProvisionedProducts(const Model::SearchProvisionedProductsRequest& request = {}) const;
 
        template<typename SearchProvisionedProductsRequestT = Model::SearchProvisionedProductsRequest>
        Model::SearchProvisionedProductsOutcomeCallable SearchProvisionedProductsCallable(const SearchProvisionedProductsRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceCatalogClient::SearchProvisionedProducts, request);
        }
 
        template<typename SearchProvisionedProductsRequestT = Model::SearchProvisionedProductsRequest>
        void SearchProvisionedProductsAsync(const SearchProvisionedProductsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SearchProvisionedProductsRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceCatalogClient::SearchProvisionedProducts, request, handler, context);
        }
 
        virtual Model::TerminateProvisionedProductOutcome TerminateProvisionedProduct(const Model::TerminateProvisionedProductRequest& request) const;
 
        template<typename TerminateProvisionedProductRequestT = Model::TerminateProvisionedProductRequest>
        Model::TerminateProvisionedProductOutcomeCallable TerminateProvisionedProductCallable(const TerminateProvisionedProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::TerminateProvisionedProduct, request);
        }
 
        template<typename TerminateProvisionedProductRequestT = Model::TerminateProvisionedProductRequest>
        void TerminateProvisionedProductAsync(const TerminateProvisionedProductRequestT& request, const TerminateProvisionedProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::TerminateProvisionedProduct, request, handler, context);
        }
 
        virtual Model::UpdateConstraintOutcome UpdateConstraint(const Model::UpdateConstraintRequest& request) const;
 
        template<typename UpdateConstraintRequestT = Model::UpdateConstraintRequest>
        Model::UpdateConstraintOutcomeCallable UpdateConstraintCallable(const UpdateConstraintRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdateConstraint, request);
        }
 
        template<typename UpdateConstraintRequestT = Model::UpdateConstraintRequest>
        void UpdateConstraintAsync(const UpdateConstraintRequestT& request, const UpdateConstraintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdateConstraint, request, handler, context);
        }
 
        virtual Model::UpdatePortfolioOutcome UpdatePortfolio(const Model::UpdatePortfolioRequest& request) const;
 
        template<typename UpdatePortfolioRequestT = Model::UpdatePortfolioRequest>
        Model::UpdatePortfolioOutcomeCallable UpdatePortfolioCallable(const UpdatePortfolioRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdatePortfolio, request);
        }
 
        template<typename UpdatePortfolioRequestT = Model::UpdatePortfolioRequest>
        void UpdatePortfolioAsync(const UpdatePortfolioRequestT& request, const UpdatePortfolioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdatePortfolio, request, handler, context);
        }
 
        virtual Model::UpdatePortfolioShareOutcome UpdatePortfolioShare(const Model::UpdatePortfolioShareRequest& request) const;
 
        template<typename UpdatePortfolioShareRequestT = Model::UpdatePortfolioShareRequest>
        Model::UpdatePortfolioShareOutcomeCallable UpdatePortfolioShareCallable(const UpdatePortfolioShareRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdatePortfolioShare, request);
        }
 
        template<typename UpdatePortfolioShareRequestT = Model::UpdatePortfolioShareRequest>
        void UpdatePortfolioShareAsync(const UpdatePortfolioShareRequestT& request, const UpdatePortfolioShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdatePortfolioShare, request, handler, context);
        }
 
        virtual Model::UpdateProductOutcome UpdateProduct(const Model::UpdateProductRequest& request) const;
 
        template<typename UpdateProductRequestT = Model::UpdateProductRequest>
        Model::UpdateProductOutcomeCallable UpdateProductCallable(const UpdateProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdateProduct, request);
        }
 
        template<typename UpdateProductRequestT = Model::UpdateProductRequest>
        void UpdateProductAsync(const UpdateProductRequestT& request, const UpdateProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdateProduct, request, handler, context);
        }
 
        virtual Model::UpdateProvisionedProductOutcome UpdateProvisionedProduct(const Model::UpdateProvisionedProductRequest& request) const;
 
        template<typename UpdateProvisionedProductRequestT = Model::UpdateProvisionedProductRequest>
        Model::UpdateProvisionedProductOutcomeCallable UpdateProvisionedProductCallable(const UpdateProvisionedProductRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdateProvisionedProduct, request);
        }
 
        template<typename UpdateProvisionedProductRequestT = Model::UpdateProvisionedProductRequest>
        void UpdateProvisionedProductAsync(const UpdateProvisionedProductRequestT& request, const UpdateProvisionedProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdateProvisionedProduct, request, handler, context);
        }
 
        virtual Model::UpdateProvisionedProductPropertiesOutcome UpdateProvisionedProductProperties(const Model::UpdateProvisionedProductPropertiesRequest& request) const;
 
        template<typename UpdateProvisionedProductPropertiesRequestT = Model::UpdateProvisionedProductPropertiesRequest>
        Model::UpdateProvisionedProductPropertiesOutcomeCallable UpdateProvisionedProductPropertiesCallable(const UpdateProvisionedProductPropertiesRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdateProvisionedProductProperties, request);
        }
 
        template<typename UpdateProvisionedProductPropertiesRequestT = Model::UpdateProvisionedProductPropertiesRequest>
        void UpdateProvisionedProductPropertiesAsync(const UpdateProvisionedProductPropertiesRequestT& request, const UpdateProvisionedProductPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdateProvisionedProductProperties, request, handler, context);
        }
 
        virtual Model::UpdateProvisioningArtifactOutcome UpdateProvisioningArtifact(const Model::UpdateProvisioningArtifactRequest& request) const;
 
        template<typename UpdateProvisioningArtifactRequestT = Model::UpdateProvisioningArtifactRequest>
        Model::UpdateProvisioningArtifactOutcomeCallable UpdateProvisioningArtifactCallable(const UpdateProvisioningArtifactRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdateProvisioningArtifact, request);
        }
 
        template<typename UpdateProvisioningArtifactRequestT = Model::UpdateProvisioningArtifactRequest>
        void UpdateProvisioningArtifactAsync(const UpdateProvisioningArtifactRequestT& request, const UpdateProvisioningArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdateProvisioningArtifact, request, handler, context);
        }
 
        virtual Model::UpdateServiceActionOutcome UpdateServiceAction(const Model::UpdateServiceActionRequest& request) const;
 
        template<typename UpdateServiceActionRequestT = Model::UpdateServiceActionRequest>
        Model::UpdateServiceActionOutcomeCallable UpdateServiceActionCallable(const UpdateServiceActionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdateServiceAction, request);
        }
 
        template<typename UpdateServiceActionRequestT = Model::UpdateServiceActionRequest>
        void UpdateServiceActionAsync(const UpdateServiceActionRequestT& request, const UpdateServiceActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdateServiceAction, request, handler, context);
        }
 
        virtual Model::UpdateTagOptionOutcome UpdateTagOption(const Model::UpdateTagOptionRequest& request) const;
 
        template<typename UpdateTagOptionRequestT = Model::UpdateTagOptionRequest>
        Model::UpdateTagOptionOutcomeCallable UpdateTagOptionCallable(const UpdateTagOptionRequestT& request) const
        {
            return SubmitCallable(&ServiceCatalogClient::UpdateTagOption, request);
        }
 
        template<typename UpdateTagOptionRequestT = Model::UpdateTagOptionRequest>
        void UpdateTagOptionAsync(const UpdateTagOptionRequestT& request, const UpdateTagOptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceCatalogClient::UpdateTagOption, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ServiceCatalogEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ServiceCatalogClient>;
      void init(const ServiceCatalogClientConfiguration& clientConfiguration);
 
      ServiceCatalogClientConfiguration m_clientConfiguration;
      std::shared_ptr<ServiceCatalogEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ServiceCatalog
} // namespace Aws