TnbClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/tnb/TnbServiceClientModel.h>
#include <aws/tnb/Tnb_EXPORTS.h>
 
namespace Aws {
namespace tnb {
class AWS_TNB_API TnbClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<TnbClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef TnbClientConfiguration ClientConfigurationType;
  typedef TnbEndpointProvider EndpointProviderType;
 
  TnbClient(const Aws::tnb::TnbClientConfiguration& clientConfiguration = Aws::tnb::TnbClientConfiguration(),
            std::shared_ptr<TnbEndpointProviderBase> endpointProvider = nullptr);
 
  TnbClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<TnbEndpointProviderBase> endpointProvider = nullptr,
            const Aws::tnb::TnbClientConfiguration& clientConfiguration = Aws::tnb::TnbClientConfiguration());
 
  TnbClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<TnbEndpointProviderBase> endpointProvider = nullptr,
            const Aws::tnb::TnbClientConfiguration& clientConfiguration = Aws::tnb::TnbClientConfiguration());
 
  /* Legacy constructors due deprecation */
  TnbClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TnbClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TnbClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~TnbClient();
 
  virtual Model::CancelSolNetworkOperationOutcome CancelSolNetworkOperation(const Model::CancelSolNetworkOperationRequest& request) const;
 
  template <typename CancelSolNetworkOperationRequestT = Model::CancelSolNetworkOperationRequest>
  Model::CancelSolNetworkOperationOutcomeCallable CancelSolNetworkOperationCallable(
      const CancelSolNetworkOperationRequestT& request) const {
    return SubmitCallable(&TnbClient::CancelSolNetworkOperation, request);
  }
 
  template <typename CancelSolNetworkOperationRequestT = Model::CancelSolNetworkOperationRequest>
  void CancelSolNetworkOperationAsync(const CancelSolNetworkOperationRequestT& request,
                                      const CancelSolNetworkOperationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::CancelSolNetworkOperation, request, handler, context);
  }
 
  virtual Model::CreateSolFunctionPackageOutcome CreateSolFunctionPackage(const Model::CreateSolFunctionPackageRequest& request = {}) const;
 
  template <typename CreateSolFunctionPackageRequestT = Model::CreateSolFunctionPackageRequest>
  Model::CreateSolFunctionPackageOutcomeCallable CreateSolFunctionPackageCallable(
      const CreateSolFunctionPackageRequestT& request = {}) const {
    return SubmitCallable(&TnbClient::CreateSolFunctionPackage, request);
  }
 
  template <typename CreateSolFunctionPackageRequestT = Model::CreateSolFunctionPackageRequest>
  void CreateSolFunctionPackageAsync(const CreateSolFunctionPackageResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const CreateSolFunctionPackageRequestT& request = {}) const {
    return SubmitAsync(&TnbClient::CreateSolFunctionPackage, request, handler, context);
  }
 
  virtual Model::CreateSolNetworkInstanceOutcome CreateSolNetworkInstance(const Model::CreateSolNetworkInstanceRequest& request) const;
 
  template <typename CreateSolNetworkInstanceRequestT = Model::CreateSolNetworkInstanceRequest>
  Model::CreateSolNetworkInstanceOutcomeCallable CreateSolNetworkInstanceCallable(const CreateSolNetworkInstanceRequestT& request) const {
    return SubmitCallable(&TnbClient::CreateSolNetworkInstance, request);
  }
 
  template <typename CreateSolNetworkInstanceRequestT = Model::CreateSolNetworkInstanceRequest>
  void CreateSolNetworkInstanceAsync(const CreateSolNetworkInstanceRequestT& request,
                                     const CreateSolNetworkInstanceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::CreateSolNetworkInstance, request, handler, context);
  }
 
  virtual Model::CreateSolNetworkPackageOutcome CreateSolNetworkPackage(const Model::CreateSolNetworkPackageRequest& request = {}) const;
 
  template <typename CreateSolNetworkPackageRequestT = Model::CreateSolNetworkPackageRequest>
  Model::CreateSolNetworkPackageOutcomeCallable CreateSolNetworkPackageCallable(const CreateSolNetworkPackageRequestT& request = {}) const {
    return SubmitCallable(&TnbClient::CreateSolNetworkPackage, request);
  }
 
  template <typename CreateSolNetworkPackageRequestT = Model::CreateSolNetworkPackageRequest>
  void CreateSolNetworkPackageAsync(const CreateSolNetworkPackageResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const CreateSolNetworkPackageRequestT& request = {}) const {
    return SubmitAsync(&TnbClient::CreateSolNetworkPackage, request, handler, context);
  }
 
  virtual Model::DeleteSolFunctionPackageOutcome DeleteSolFunctionPackage(const Model::DeleteSolFunctionPackageRequest& request) const;
 
  template <typename DeleteSolFunctionPackageRequestT = Model::DeleteSolFunctionPackageRequest>
  Model::DeleteSolFunctionPackageOutcomeCallable DeleteSolFunctionPackageCallable(const DeleteSolFunctionPackageRequestT& request) const {
    return SubmitCallable(&TnbClient::DeleteSolFunctionPackage, request);
  }
 
  template <typename DeleteSolFunctionPackageRequestT = Model::DeleteSolFunctionPackageRequest>
  void DeleteSolFunctionPackageAsync(const DeleteSolFunctionPackageRequestT& request,
                                     const DeleteSolFunctionPackageResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::DeleteSolFunctionPackage, request, handler, context);
  }
 
  virtual Model::DeleteSolNetworkInstanceOutcome DeleteSolNetworkInstance(const Model::DeleteSolNetworkInstanceRequest& request) const;
 
  template <typename DeleteSolNetworkInstanceRequestT = Model::DeleteSolNetworkInstanceRequest>
  Model::DeleteSolNetworkInstanceOutcomeCallable DeleteSolNetworkInstanceCallable(const DeleteSolNetworkInstanceRequestT& request) const {
    return SubmitCallable(&TnbClient::DeleteSolNetworkInstance, request);
  }
 
  template <typename DeleteSolNetworkInstanceRequestT = Model::DeleteSolNetworkInstanceRequest>
  void DeleteSolNetworkInstanceAsync(const DeleteSolNetworkInstanceRequestT& request,
                                     const DeleteSolNetworkInstanceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::DeleteSolNetworkInstance, request, handler, context);
  }
 
  virtual Model::DeleteSolNetworkPackageOutcome DeleteSolNetworkPackage(const Model::DeleteSolNetworkPackageRequest& request) const;
 
  template <typename DeleteSolNetworkPackageRequestT = Model::DeleteSolNetworkPackageRequest>
  Model::DeleteSolNetworkPackageOutcomeCallable DeleteSolNetworkPackageCallable(const DeleteSolNetworkPackageRequestT& request) const {
    return SubmitCallable(&TnbClient::DeleteSolNetworkPackage, request);
  }
 
  template <typename DeleteSolNetworkPackageRequestT = Model::DeleteSolNetworkPackageRequest>
  void DeleteSolNetworkPackageAsync(const DeleteSolNetworkPackageRequestT& request,
                                    const DeleteSolNetworkPackageResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::DeleteSolNetworkPackage, request, handler, context);
  }
 
  virtual Model::GetSolFunctionInstanceOutcome GetSolFunctionInstance(const Model::GetSolFunctionInstanceRequest& request) const;
 
  template <typename GetSolFunctionInstanceRequestT = Model::GetSolFunctionInstanceRequest>
  Model::GetSolFunctionInstanceOutcomeCallable GetSolFunctionInstanceCallable(const GetSolFunctionInstanceRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolFunctionInstance, request);
  }
 
  template <typename GetSolFunctionInstanceRequestT = Model::GetSolFunctionInstanceRequest>
  void GetSolFunctionInstanceAsync(const GetSolFunctionInstanceRequestT& request,
                                   const GetSolFunctionInstanceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolFunctionInstance, request, handler, context);
  }
 
  virtual Model::GetSolFunctionPackageOutcome GetSolFunctionPackage(const Model::GetSolFunctionPackageRequest& request) const;
 
  template <typename GetSolFunctionPackageRequestT = Model::GetSolFunctionPackageRequest>
  Model::GetSolFunctionPackageOutcomeCallable GetSolFunctionPackageCallable(const GetSolFunctionPackageRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolFunctionPackage, request);
  }
 
  template <typename GetSolFunctionPackageRequestT = Model::GetSolFunctionPackageRequest>
  void GetSolFunctionPackageAsync(const GetSolFunctionPackageRequestT& request, const GetSolFunctionPackageResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolFunctionPackage, request, handler, context);
  }
 
  virtual Model::GetSolFunctionPackageContentOutcome GetSolFunctionPackageContent(
      const Model::GetSolFunctionPackageContentRequest& request) const;
 
  template <typename GetSolFunctionPackageContentRequestT = Model::GetSolFunctionPackageContentRequest>
  Model::GetSolFunctionPackageContentOutcomeCallable GetSolFunctionPackageContentCallable(
      const GetSolFunctionPackageContentRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolFunctionPackageContent, request);
  }
 
  template <typename GetSolFunctionPackageContentRequestT = Model::GetSolFunctionPackageContentRequest>
  void GetSolFunctionPackageContentAsync(const GetSolFunctionPackageContentRequestT& request,
                                         const GetSolFunctionPackageContentResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolFunctionPackageContent, request, handler, context);
  }
 
  virtual Model::GetSolFunctionPackageDescriptorOutcome GetSolFunctionPackageDescriptor(
      const Model::GetSolFunctionPackageDescriptorRequest& request) const;
 
  template <typename GetSolFunctionPackageDescriptorRequestT = Model::GetSolFunctionPackageDescriptorRequest>
  Model::GetSolFunctionPackageDescriptorOutcomeCallable GetSolFunctionPackageDescriptorCallable(
      const GetSolFunctionPackageDescriptorRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolFunctionPackageDescriptor, request);
  }
 
  template <typename GetSolFunctionPackageDescriptorRequestT = Model::GetSolFunctionPackageDescriptorRequest>
  void GetSolFunctionPackageDescriptorAsync(const GetSolFunctionPackageDescriptorRequestT& request,
                                            const GetSolFunctionPackageDescriptorResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolFunctionPackageDescriptor, request, handler, context);
  }
 
  virtual Model::GetSolNetworkInstanceOutcome GetSolNetworkInstance(const Model::GetSolNetworkInstanceRequest& request) const;
 
  template <typename GetSolNetworkInstanceRequestT = Model::GetSolNetworkInstanceRequest>
  Model::GetSolNetworkInstanceOutcomeCallable GetSolNetworkInstanceCallable(const GetSolNetworkInstanceRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolNetworkInstance, request);
  }
 
  template <typename GetSolNetworkInstanceRequestT = Model::GetSolNetworkInstanceRequest>
  void GetSolNetworkInstanceAsync(const GetSolNetworkInstanceRequestT& request, const GetSolNetworkInstanceResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolNetworkInstance, request, handler, context);
  }
 
  virtual Model::GetSolNetworkOperationOutcome GetSolNetworkOperation(const Model::GetSolNetworkOperationRequest& request) const;
 
  template <typename GetSolNetworkOperationRequestT = Model::GetSolNetworkOperationRequest>
  Model::GetSolNetworkOperationOutcomeCallable GetSolNetworkOperationCallable(const GetSolNetworkOperationRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolNetworkOperation, request);
  }
 
  template <typename GetSolNetworkOperationRequestT = Model::GetSolNetworkOperationRequest>
  void GetSolNetworkOperationAsync(const GetSolNetworkOperationRequestT& request,
                                   const GetSolNetworkOperationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolNetworkOperation, request, handler, context);
  }
 
  virtual Model::GetSolNetworkPackageOutcome GetSolNetworkPackage(const Model::GetSolNetworkPackageRequest& request) const;
 
  template <typename GetSolNetworkPackageRequestT = Model::GetSolNetworkPackageRequest>
  Model::GetSolNetworkPackageOutcomeCallable GetSolNetworkPackageCallable(const GetSolNetworkPackageRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolNetworkPackage, request);
  }
 
  template <typename GetSolNetworkPackageRequestT = Model::GetSolNetworkPackageRequest>
  void GetSolNetworkPackageAsync(const GetSolNetworkPackageRequestT& request, const GetSolNetworkPackageResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolNetworkPackage, request, handler, context);
  }
 
  virtual Model::GetSolNetworkPackageContentOutcome GetSolNetworkPackageContent(
      const Model::GetSolNetworkPackageContentRequest& request) const;
 
  template <typename GetSolNetworkPackageContentRequestT = Model::GetSolNetworkPackageContentRequest>
  Model::GetSolNetworkPackageContentOutcomeCallable GetSolNetworkPackageContentCallable(
      const GetSolNetworkPackageContentRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolNetworkPackageContent, request);
  }
 
  template <typename GetSolNetworkPackageContentRequestT = Model::GetSolNetworkPackageContentRequest>
  void GetSolNetworkPackageContentAsync(const GetSolNetworkPackageContentRequestT& request,
                                        const GetSolNetworkPackageContentResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolNetworkPackageContent, request, handler, context);
  }
 
  virtual Model::GetSolNetworkPackageDescriptorOutcome GetSolNetworkPackageDescriptor(
      const Model::GetSolNetworkPackageDescriptorRequest& request) const;
 
  template <typename GetSolNetworkPackageDescriptorRequestT = Model::GetSolNetworkPackageDescriptorRequest>
  Model::GetSolNetworkPackageDescriptorOutcomeCallable GetSolNetworkPackageDescriptorCallable(
      const GetSolNetworkPackageDescriptorRequestT& request) const {
    return SubmitCallable(&TnbClient::GetSolNetworkPackageDescriptor, request);
  }
 
  template <typename GetSolNetworkPackageDescriptorRequestT = Model::GetSolNetworkPackageDescriptorRequest>
  void GetSolNetworkPackageDescriptorAsync(const GetSolNetworkPackageDescriptorRequestT& request,
                                           const GetSolNetworkPackageDescriptorResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::GetSolNetworkPackageDescriptor, request, handler, context);
  }
 
  virtual Model::InstantiateSolNetworkInstanceOutcome InstantiateSolNetworkInstance(
      const Model::InstantiateSolNetworkInstanceRequest& request) const;
 
  template <typename InstantiateSolNetworkInstanceRequestT = Model::InstantiateSolNetworkInstanceRequest>
  Model::InstantiateSolNetworkInstanceOutcomeCallable InstantiateSolNetworkInstanceCallable(
      const InstantiateSolNetworkInstanceRequestT& request) const {
    return SubmitCallable(&TnbClient::InstantiateSolNetworkInstance, request);
  }
 
  template <typename InstantiateSolNetworkInstanceRequestT = Model::InstantiateSolNetworkInstanceRequest>
  void InstantiateSolNetworkInstanceAsync(const InstantiateSolNetworkInstanceRequestT& request,
                                          const InstantiateSolNetworkInstanceResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::InstantiateSolNetworkInstance, request, handler, context);
  }
 
  virtual Model::ListSolFunctionInstancesOutcome ListSolFunctionInstances(const Model::ListSolFunctionInstancesRequest& request = {}) const;
 
  template <typename ListSolFunctionInstancesRequestT = Model::ListSolFunctionInstancesRequest>
  Model::ListSolFunctionInstancesOutcomeCallable ListSolFunctionInstancesCallable(
      const ListSolFunctionInstancesRequestT& request = {}) const {
    return SubmitCallable(&TnbClient::ListSolFunctionInstances, request);
  }
 
  template <typename ListSolFunctionInstancesRequestT = Model::ListSolFunctionInstancesRequest>
  void ListSolFunctionInstancesAsync(const ListSolFunctionInstancesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListSolFunctionInstancesRequestT& request = {}) const {
    return SubmitAsync(&TnbClient::ListSolFunctionInstances, request, handler, context);
  }
 
  virtual Model::ListSolFunctionPackagesOutcome ListSolFunctionPackages(const Model::ListSolFunctionPackagesRequest& request = {}) const;
 
  template <typename ListSolFunctionPackagesRequestT = Model::ListSolFunctionPackagesRequest>
  Model::ListSolFunctionPackagesOutcomeCallable ListSolFunctionPackagesCallable(const ListSolFunctionPackagesRequestT& request = {}) const {
    return SubmitCallable(&TnbClient::ListSolFunctionPackages, request);
  }
 
  template <typename ListSolFunctionPackagesRequestT = Model::ListSolFunctionPackagesRequest>
  void ListSolFunctionPackagesAsync(const ListSolFunctionPackagesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListSolFunctionPackagesRequestT& request = {}) const {
    return SubmitAsync(&TnbClient::ListSolFunctionPackages, request, handler, context);
  }
 
  virtual Model::ListSolNetworkInstancesOutcome ListSolNetworkInstances(const Model::ListSolNetworkInstancesRequest& request = {}) const;
 
  template <typename ListSolNetworkInstancesRequestT = Model::ListSolNetworkInstancesRequest>
  Model::ListSolNetworkInstancesOutcomeCallable ListSolNetworkInstancesCallable(const ListSolNetworkInstancesRequestT& request = {}) const {
    return SubmitCallable(&TnbClient::ListSolNetworkInstances, request);
  }
 
  template <typename ListSolNetworkInstancesRequestT = Model::ListSolNetworkInstancesRequest>
  void ListSolNetworkInstancesAsync(const ListSolNetworkInstancesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListSolNetworkInstancesRequestT& request = {}) const {
    return SubmitAsync(&TnbClient::ListSolNetworkInstances, request, handler, context);
  }
 
  virtual Model::ListSolNetworkOperationsOutcome ListSolNetworkOperations(const Model::ListSolNetworkOperationsRequest& request = {}) const;
 
  template <typename ListSolNetworkOperationsRequestT = Model::ListSolNetworkOperationsRequest>
  Model::ListSolNetworkOperationsOutcomeCallable ListSolNetworkOperationsCallable(
      const ListSolNetworkOperationsRequestT& request = {}) const {
    return SubmitCallable(&TnbClient::ListSolNetworkOperations, request);
  }
 
  template <typename ListSolNetworkOperationsRequestT = Model::ListSolNetworkOperationsRequest>
  void ListSolNetworkOperationsAsync(const ListSolNetworkOperationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListSolNetworkOperationsRequestT& request = {}) const {
    return SubmitAsync(&TnbClient::ListSolNetworkOperations, request, handler, context);
  }
 
  virtual Model::ListSolNetworkPackagesOutcome ListSolNetworkPackages(const Model::ListSolNetworkPackagesRequest& request = {}) const;
 
  template <typename ListSolNetworkPackagesRequestT = Model::ListSolNetworkPackagesRequest>
  Model::ListSolNetworkPackagesOutcomeCallable ListSolNetworkPackagesCallable(const ListSolNetworkPackagesRequestT& request = {}) const {
    return SubmitCallable(&TnbClient::ListSolNetworkPackages, request);
  }
 
  template <typename ListSolNetworkPackagesRequestT = Model::ListSolNetworkPackagesRequest>
  void ListSolNetworkPackagesAsync(const ListSolNetworkPackagesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListSolNetworkPackagesRequestT& request = {}) const {
    return SubmitAsync(&TnbClient::ListSolNetworkPackages, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&TnbClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutSolFunctionPackageContentOutcome PutSolFunctionPackageContent(
      const Model::PutSolFunctionPackageContentRequest& request) const;
 
  template <typename PutSolFunctionPackageContentRequestT = Model::PutSolFunctionPackageContentRequest>
  Model::PutSolFunctionPackageContentOutcomeCallable PutSolFunctionPackageContentCallable(
      const PutSolFunctionPackageContentRequestT& request) const {
    return SubmitCallable(&TnbClient::PutSolFunctionPackageContent, request);
  }
 
  template <typename PutSolFunctionPackageContentRequestT = Model::PutSolFunctionPackageContentRequest>
  void PutSolFunctionPackageContentAsync(const PutSolFunctionPackageContentRequestT& request,
                                         const PutSolFunctionPackageContentResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::PutSolFunctionPackageContent, request, handler, context);
  }
 
  virtual Model::PutSolNetworkPackageContentOutcome PutSolNetworkPackageContent(
      const Model::PutSolNetworkPackageContentRequest& request) const;
 
  template <typename PutSolNetworkPackageContentRequestT = Model::PutSolNetworkPackageContentRequest>
  Model::PutSolNetworkPackageContentOutcomeCallable PutSolNetworkPackageContentCallable(
      const PutSolNetworkPackageContentRequestT& request) const {
    return SubmitCallable(&TnbClient::PutSolNetworkPackageContent, request);
  }
 
  template <typename PutSolNetworkPackageContentRequestT = Model::PutSolNetworkPackageContentRequest>
  void PutSolNetworkPackageContentAsync(const PutSolNetworkPackageContentRequestT& request,
                                        const PutSolNetworkPackageContentResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::PutSolNetworkPackageContent, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&TnbClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::TagResource, request, handler, context);
  }
 
  virtual Model::TerminateSolNetworkInstanceOutcome TerminateSolNetworkInstance(
      const Model::TerminateSolNetworkInstanceRequest& request) const;
 
  template <typename TerminateSolNetworkInstanceRequestT = Model::TerminateSolNetworkInstanceRequest>
  Model::TerminateSolNetworkInstanceOutcomeCallable TerminateSolNetworkInstanceCallable(
      const TerminateSolNetworkInstanceRequestT& request) const {
    return SubmitCallable(&TnbClient::TerminateSolNetworkInstance, request);
  }
 
  template <typename TerminateSolNetworkInstanceRequestT = Model::TerminateSolNetworkInstanceRequest>
  void TerminateSolNetworkInstanceAsync(const TerminateSolNetworkInstanceRequestT& request,
                                        const TerminateSolNetworkInstanceResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::TerminateSolNetworkInstance, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&TnbClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateSolFunctionPackageOutcome UpdateSolFunctionPackage(const Model::UpdateSolFunctionPackageRequest& request) const;
 
  template <typename UpdateSolFunctionPackageRequestT = Model::UpdateSolFunctionPackageRequest>
  Model::UpdateSolFunctionPackageOutcomeCallable UpdateSolFunctionPackageCallable(const UpdateSolFunctionPackageRequestT& request) const {
    return SubmitCallable(&TnbClient::UpdateSolFunctionPackage, request);
  }
 
  template <typename UpdateSolFunctionPackageRequestT = Model::UpdateSolFunctionPackageRequest>
  void UpdateSolFunctionPackageAsync(const UpdateSolFunctionPackageRequestT& request,
                                     const UpdateSolFunctionPackageResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::UpdateSolFunctionPackage, request, handler, context);
  }
 
  virtual Model::UpdateSolNetworkInstanceOutcome UpdateSolNetworkInstance(const Model::UpdateSolNetworkInstanceRequest& request) const;
 
  template <typename UpdateSolNetworkInstanceRequestT = Model::UpdateSolNetworkInstanceRequest>
  Model::UpdateSolNetworkInstanceOutcomeCallable UpdateSolNetworkInstanceCallable(const UpdateSolNetworkInstanceRequestT& request) const {
    return SubmitCallable(&TnbClient::UpdateSolNetworkInstance, request);
  }
 
  template <typename UpdateSolNetworkInstanceRequestT = Model::UpdateSolNetworkInstanceRequest>
  void UpdateSolNetworkInstanceAsync(const UpdateSolNetworkInstanceRequestT& request,
                                     const UpdateSolNetworkInstanceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::UpdateSolNetworkInstance, request, handler, context);
  }
 
  virtual Model::UpdateSolNetworkPackageOutcome UpdateSolNetworkPackage(const Model::UpdateSolNetworkPackageRequest& request) const;
 
  template <typename UpdateSolNetworkPackageRequestT = Model::UpdateSolNetworkPackageRequest>
  Model::UpdateSolNetworkPackageOutcomeCallable UpdateSolNetworkPackageCallable(const UpdateSolNetworkPackageRequestT& request) const {
    return SubmitCallable(&TnbClient::UpdateSolNetworkPackage, request);
  }
 
  template <typename UpdateSolNetworkPackageRequestT = Model::UpdateSolNetworkPackageRequest>
  void UpdateSolNetworkPackageAsync(const UpdateSolNetworkPackageRequestT& request,
                                    const UpdateSolNetworkPackageResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::UpdateSolNetworkPackage, request, handler, context);
  }
 
  virtual Model::ValidateSolFunctionPackageContentOutcome ValidateSolFunctionPackageContent(
      const Model::ValidateSolFunctionPackageContentRequest& request) const;
 
  template <typename ValidateSolFunctionPackageContentRequestT = Model::ValidateSolFunctionPackageContentRequest>
  Model::ValidateSolFunctionPackageContentOutcomeCallable ValidateSolFunctionPackageContentCallable(
      const ValidateSolFunctionPackageContentRequestT& request) const {
    return SubmitCallable(&TnbClient::ValidateSolFunctionPackageContent, request);
  }
 
  template <typename ValidateSolFunctionPackageContentRequestT = Model::ValidateSolFunctionPackageContentRequest>
  void ValidateSolFunctionPackageContentAsync(const ValidateSolFunctionPackageContentRequestT& request,
                                              const ValidateSolFunctionPackageContentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::ValidateSolFunctionPackageContent, request, handler, context);
  }
 
  virtual Model::ValidateSolNetworkPackageContentOutcome ValidateSolNetworkPackageContent(
      const Model::ValidateSolNetworkPackageContentRequest& request) const;
 
  template <typename ValidateSolNetworkPackageContentRequestT = Model::ValidateSolNetworkPackageContentRequest>
  Model::ValidateSolNetworkPackageContentOutcomeCallable ValidateSolNetworkPackageContentCallable(
      const ValidateSolNetworkPackageContentRequestT& request) const {
    return SubmitCallable(&TnbClient::ValidateSolNetworkPackageContent, request);
  }
 
  template <typename ValidateSolNetworkPackageContentRequestT = Model::ValidateSolNetworkPackageContentRequest>
  void ValidateSolNetworkPackageContentAsync(const ValidateSolNetworkPackageContentRequestT& request,
                                             const ValidateSolNetworkPackageContentResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TnbClient::ValidateSolNetworkPackageContent, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<TnbEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<TnbClient>;
  void init(const TnbClientConfiguration& clientConfiguration);
 
  TnbClientConfiguration m_clientConfiguration;
  std::shared_ptr<TnbEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace tnb
}  // namespace Aws