TnbClient.h

 
#pragma once
#include <aws/tnb/Tnb_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/tnb/TnbServiceClientModel.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