ServiceCatalogClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/crt/cbor/Cbor.h>
#include <aws/servicecatalog/ServiceCatalogPaginationBase.h>
#include <aws/servicecatalog/ServiceCatalogServiceClientModel.h>
#include <aws/servicecatalog/ServiceCatalogWaiter.h>
#include <aws/servicecatalog/ServiceCatalog_EXPORTS.h>
 
namespace Aws {
namespace ServiceCatalog {
class AWS_SERVICECATALOG_API ServiceCatalogClient : public Aws::Client::AWSRpcV2CborClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<ServiceCatalogClient>,
                                                    public ServiceCatalogPaginationBase<ServiceCatalogClient>,
                                                    public ServiceCatalogWaiter<ServiceCatalogClient> {
 public:
  typedef Aws::Client::AWSRpcV2CborClient 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ServiceCatalogEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ServiceCatalogClient>;
  void init(const ServiceCatalogClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ServiceCatalogError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ServiceCatalogClientConfiguration m_clientConfiguration;
  std::shared_ptr<ServiceCatalogEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ServiceCatalog
}  // namespace Aws