OdbClient.h

 
#pragma once
#include <aws/odb/Odb_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/odb/OdbServiceClientModel.h>
 
namespace Aws
{
namespace odb
{
  class AWS_ODB_API OdbClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<OdbClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef OdbClientConfiguration ClientConfigurationType;
      typedef OdbEndpointProvider EndpointProviderType;
 
        OdbClient(const Aws::odb::OdbClientConfiguration& clientConfiguration = Aws::odb::OdbClientConfiguration(),
                  std::shared_ptr<OdbEndpointProviderBase> endpointProvider = nullptr);
 
        OdbClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<OdbEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::odb::OdbClientConfiguration& clientConfiguration = Aws::odb::OdbClientConfiguration());
 
        OdbClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<OdbEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::odb::OdbClientConfiguration& clientConfiguration = Aws::odb::OdbClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        OdbClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        OdbClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        OdbClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~OdbClient();
 
        virtual Model::AcceptMarketplaceRegistrationOutcome AcceptMarketplaceRegistration(const Model::AcceptMarketplaceRegistrationRequest& request) const;
 
        template<typename AcceptMarketplaceRegistrationRequestT = Model::AcceptMarketplaceRegistrationRequest>
        Model::AcceptMarketplaceRegistrationOutcomeCallable AcceptMarketplaceRegistrationCallable(const AcceptMarketplaceRegistrationRequestT& request) const
        {
            return SubmitCallable(&OdbClient::AcceptMarketplaceRegistration, request);
        }
 
        template<typename AcceptMarketplaceRegistrationRequestT = Model::AcceptMarketplaceRegistrationRequest>
        void AcceptMarketplaceRegistrationAsync(const AcceptMarketplaceRegistrationRequestT& request, const AcceptMarketplaceRegistrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::AcceptMarketplaceRegistration, request, handler, context);
        }
 
        virtual Model::CreateCloudAutonomousVmClusterOutcome CreateCloudAutonomousVmCluster(const Model::CreateCloudAutonomousVmClusterRequest& request) const;
 
        template<typename CreateCloudAutonomousVmClusterRequestT = Model::CreateCloudAutonomousVmClusterRequest>
        Model::CreateCloudAutonomousVmClusterOutcomeCallable CreateCloudAutonomousVmClusterCallable(const CreateCloudAutonomousVmClusterRequestT& request) const
        {
            return SubmitCallable(&OdbClient::CreateCloudAutonomousVmCluster, request);
        }
 
        template<typename CreateCloudAutonomousVmClusterRequestT = Model::CreateCloudAutonomousVmClusterRequest>
        void CreateCloudAutonomousVmClusterAsync(const CreateCloudAutonomousVmClusterRequestT& request, const CreateCloudAutonomousVmClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::CreateCloudAutonomousVmCluster, request, handler, context);
        }
 
        virtual Model::CreateCloudExadataInfrastructureOutcome CreateCloudExadataInfrastructure(const Model::CreateCloudExadataInfrastructureRequest& request) const;
 
        template<typename CreateCloudExadataInfrastructureRequestT = Model::CreateCloudExadataInfrastructureRequest>
        Model::CreateCloudExadataInfrastructureOutcomeCallable CreateCloudExadataInfrastructureCallable(const CreateCloudExadataInfrastructureRequestT& request) const
        {
            return SubmitCallable(&OdbClient::CreateCloudExadataInfrastructure, request);
        }
 
        template<typename CreateCloudExadataInfrastructureRequestT = Model::CreateCloudExadataInfrastructureRequest>
        void CreateCloudExadataInfrastructureAsync(const CreateCloudExadataInfrastructureRequestT& request, const CreateCloudExadataInfrastructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::CreateCloudExadataInfrastructure, request, handler, context);
        }
 
        virtual Model::CreateCloudVmClusterOutcome CreateCloudVmCluster(const Model::CreateCloudVmClusterRequest& request) const;
 
        template<typename CreateCloudVmClusterRequestT = Model::CreateCloudVmClusterRequest>
        Model::CreateCloudVmClusterOutcomeCallable CreateCloudVmClusterCallable(const CreateCloudVmClusterRequestT& request) const
        {
            return SubmitCallable(&OdbClient::CreateCloudVmCluster, request);
        }
 
        template<typename CreateCloudVmClusterRequestT = Model::CreateCloudVmClusterRequest>
        void CreateCloudVmClusterAsync(const CreateCloudVmClusterRequestT& request, const CreateCloudVmClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::CreateCloudVmCluster, request, handler, context);
        }
 
        virtual Model::CreateOdbNetworkOutcome CreateOdbNetwork(const Model::CreateOdbNetworkRequest& request) const;
 
        template<typename CreateOdbNetworkRequestT = Model::CreateOdbNetworkRequest>
        Model::CreateOdbNetworkOutcomeCallable CreateOdbNetworkCallable(const CreateOdbNetworkRequestT& request) const
        {
            return SubmitCallable(&OdbClient::CreateOdbNetwork, request);
        }
 
        template<typename CreateOdbNetworkRequestT = Model::CreateOdbNetworkRequest>
        void CreateOdbNetworkAsync(const CreateOdbNetworkRequestT& request, const CreateOdbNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::CreateOdbNetwork, request, handler, context);
        }
 
        virtual Model::CreateOdbPeeringConnectionOutcome CreateOdbPeeringConnection(const Model::CreateOdbPeeringConnectionRequest& request) const;
 
        template<typename CreateOdbPeeringConnectionRequestT = Model::CreateOdbPeeringConnectionRequest>
        Model::CreateOdbPeeringConnectionOutcomeCallable CreateOdbPeeringConnectionCallable(const CreateOdbPeeringConnectionRequestT& request) const
        {
            return SubmitCallable(&OdbClient::CreateOdbPeeringConnection, request);
        }
 
        template<typename CreateOdbPeeringConnectionRequestT = Model::CreateOdbPeeringConnectionRequest>
        void CreateOdbPeeringConnectionAsync(const CreateOdbPeeringConnectionRequestT& request, const CreateOdbPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::CreateOdbPeeringConnection, request, handler, context);
        }
 
        virtual Model::DeleteCloudAutonomousVmClusterOutcome DeleteCloudAutonomousVmCluster(const Model::DeleteCloudAutonomousVmClusterRequest& request) const;
 
        template<typename DeleteCloudAutonomousVmClusterRequestT = Model::DeleteCloudAutonomousVmClusterRequest>
        Model::DeleteCloudAutonomousVmClusterOutcomeCallable DeleteCloudAutonomousVmClusterCallable(const DeleteCloudAutonomousVmClusterRequestT& request) const
        {
            return SubmitCallable(&OdbClient::DeleteCloudAutonomousVmCluster, request);
        }
 
        template<typename DeleteCloudAutonomousVmClusterRequestT = Model::DeleteCloudAutonomousVmClusterRequest>
        void DeleteCloudAutonomousVmClusterAsync(const DeleteCloudAutonomousVmClusterRequestT& request, const DeleteCloudAutonomousVmClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::DeleteCloudAutonomousVmCluster, request, handler, context);
        }
 
        virtual Model::DeleteCloudExadataInfrastructureOutcome DeleteCloudExadataInfrastructure(const Model::DeleteCloudExadataInfrastructureRequest& request) const;
 
        template<typename DeleteCloudExadataInfrastructureRequestT = Model::DeleteCloudExadataInfrastructureRequest>
        Model::DeleteCloudExadataInfrastructureOutcomeCallable DeleteCloudExadataInfrastructureCallable(const DeleteCloudExadataInfrastructureRequestT& request) const
        {
            return SubmitCallable(&OdbClient::DeleteCloudExadataInfrastructure, request);
        }
 
        template<typename DeleteCloudExadataInfrastructureRequestT = Model::DeleteCloudExadataInfrastructureRequest>
        void DeleteCloudExadataInfrastructureAsync(const DeleteCloudExadataInfrastructureRequestT& request, const DeleteCloudExadataInfrastructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::DeleteCloudExadataInfrastructure, request, handler, context);
        }
 
        virtual Model::DeleteCloudVmClusterOutcome DeleteCloudVmCluster(const Model::DeleteCloudVmClusterRequest& request) const;
 
        template<typename DeleteCloudVmClusterRequestT = Model::DeleteCloudVmClusterRequest>
        Model::DeleteCloudVmClusterOutcomeCallable DeleteCloudVmClusterCallable(const DeleteCloudVmClusterRequestT& request) const
        {
            return SubmitCallable(&OdbClient::DeleteCloudVmCluster, request);
        }
 
        template<typename DeleteCloudVmClusterRequestT = Model::DeleteCloudVmClusterRequest>
        void DeleteCloudVmClusterAsync(const DeleteCloudVmClusterRequestT& request, const DeleteCloudVmClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::DeleteCloudVmCluster, request, handler, context);
        }
 
        virtual Model::DeleteOdbNetworkOutcome DeleteOdbNetwork(const Model::DeleteOdbNetworkRequest& request) const;
 
        template<typename DeleteOdbNetworkRequestT = Model::DeleteOdbNetworkRequest>
        Model::DeleteOdbNetworkOutcomeCallable DeleteOdbNetworkCallable(const DeleteOdbNetworkRequestT& request) const
        {
            return SubmitCallable(&OdbClient::DeleteOdbNetwork, request);
        }
 
        template<typename DeleteOdbNetworkRequestT = Model::DeleteOdbNetworkRequest>
        void DeleteOdbNetworkAsync(const DeleteOdbNetworkRequestT& request, const DeleteOdbNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::DeleteOdbNetwork, request, handler, context);
        }
 
        virtual Model::DeleteOdbPeeringConnectionOutcome DeleteOdbPeeringConnection(const Model::DeleteOdbPeeringConnectionRequest& request) const;
 
        template<typename DeleteOdbPeeringConnectionRequestT = Model::DeleteOdbPeeringConnectionRequest>
        Model::DeleteOdbPeeringConnectionOutcomeCallable DeleteOdbPeeringConnectionCallable(const DeleteOdbPeeringConnectionRequestT& request) const
        {
            return SubmitCallable(&OdbClient::DeleteOdbPeeringConnection, request);
        }
 
        template<typename DeleteOdbPeeringConnectionRequestT = Model::DeleteOdbPeeringConnectionRequest>
        void DeleteOdbPeeringConnectionAsync(const DeleteOdbPeeringConnectionRequestT& request, const DeleteOdbPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::DeleteOdbPeeringConnection, request, handler, context);
        }
 
        virtual Model::GetCloudAutonomousVmClusterOutcome GetCloudAutonomousVmCluster(const Model::GetCloudAutonomousVmClusterRequest& request) const;
 
        template<typename GetCloudAutonomousVmClusterRequestT = Model::GetCloudAutonomousVmClusterRequest>
        Model::GetCloudAutonomousVmClusterOutcomeCallable GetCloudAutonomousVmClusterCallable(const GetCloudAutonomousVmClusterRequestT& request) const
        {
            return SubmitCallable(&OdbClient::GetCloudAutonomousVmCluster, request);
        }
 
        template<typename GetCloudAutonomousVmClusterRequestT = Model::GetCloudAutonomousVmClusterRequest>
        void GetCloudAutonomousVmClusterAsync(const GetCloudAutonomousVmClusterRequestT& request, const GetCloudAutonomousVmClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::GetCloudAutonomousVmCluster, request, handler, context);
        }
 
        virtual Model::GetCloudExadataInfrastructureOutcome GetCloudExadataInfrastructure(const Model::GetCloudExadataInfrastructureRequest& request) const;
 
        template<typename GetCloudExadataInfrastructureRequestT = Model::GetCloudExadataInfrastructureRequest>
        Model::GetCloudExadataInfrastructureOutcomeCallable GetCloudExadataInfrastructureCallable(const GetCloudExadataInfrastructureRequestT& request) const
        {
            return SubmitCallable(&OdbClient::GetCloudExadataInfrastructure, request);
        }
 
        template<typename GetCloudExadataInfrastructureRequestT = Model::GetCloudExadataInfrastructureRequest>
        void GetCloudExadataInfrastructureAsync(const GetCloudExadataInfrastructureRequestT& request, const GetCloudExadataInfrastructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::GetCloudExadataInfrastructure, request, handler, context);
        }
 
        virtual Model::GetCloudExadataInfrastructureUnallocatedResourcesOutcome GetCloudExadataInfrastructureUnallocatedResources(const Model::GetCloudExadataInfrastructureUnallocatedResourcesRequest& request) const;
 
        template<typename GetCloudExadataInfrastructureUnallocatedResourcesRequestT = Model::GetCloudExadataInfrastructureUnallocatedResourcesRequest>
        Model::GetCloudExadataInfrastructureUnallocatedResourcesOutcomeCallable GetCloudExadataInfrastructureUnallocatedResourcesCallable(const GetCloudExadataInfrastructureUnallocatedResourcesRequestT& request) const
        {
            return SubmitCallable(&OdbClient::GetCloudExadataInfrastructureUnallocatedResources, request);
        }
 
        template<typename GetCloudExadataInfrastructureUnallocatedResourcesRequestT = Model::GetCloudExadataInfrastructureUnallocatedResourcesRequest>
        void GetCloudExadataInfrastructureUnallocatedResourcesAsync(const GetCloudExadataInfrastructureUnallocatedResourcesRequestT& request, const GetCloudExadataInfrastructureUnallocatedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::GetCloudExadataInfrastructureUnallocatedResources, request, handler, context);
        }
 
        virtual Model::GetCloudVmClusterOutcome GetCloudVmCluster(const Model::GetCloudVmClusterRequest& request) const;
 
        template<typename GetCloudVmClusterRequestT = Model::GetCloudVmClusterRequest>
        Model::GetCloudVmClusterOutcomeCallable GetCloudVmClusterCallable(const GetCloudVmClusterRequestT& request) const
        {
            return SubmitCallable(&OdbClient::GetCloudVmCluster, request);
        }
 
        template<typename GetCloudVmClusterRequestT = Model::GetCloudVmClusterRequest>
        void GetCloudVmClusterAsync(const GetCloudVmClusterRequestT& request, const GetCloudVmClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::GetCloudVmCluster, request, handler, context);
        }
 
        virtual Model::GetDbNodeOutcome GetDbNode(const Model::GetDbNodeRequest& request) const;
 
        template<typename GetDbNodeRequestT = Model::GetDbNodeRequest>
        Model::GetDbNodeOutcomeCallable GetDbNodeCallable(const GetDbNodeRequestT& request) const
        {
            return SubmitCallable(&OdbClient::GetDbNode, request);
        }
 
        template<typename GetDbNodeRequestT = Model::GetDbNodeRequest>
        void GetDbNodeAsync(const GetDbNodeRequestT& request, const GetDbNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::GetDbNode, request, handler, context);
        }
 
        virtual Model::GetDbServerOutcome GetDbServer(const Model::GetDbServerRequest& request) const;
 
        template<typename GetDbServerRequestT = Model::GetDbServerRequest>
        Model::GetDbServerOutcomeCallable GetDbServerCallable(const GetDbServerRequestT& request) const
        {
            return SubmitCallable(&OdbClient::GetDbServer, request);
        }
 
        template<typename GetDbServerRequestT = Model::GetDbServerRequest>
        void GetDbServerAsync(const GetDbServerRequestT& request, const GetDbServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::GetDbServer, request, handler, context);
        }
 
        virtual Model::GetOciOnboardingStatusOutcome GetOciOnboardingStatus(const Model::GetOciOnboardingStatusRequest& request = {}) const;
 
        template<typename GetOciOnboardingStatusRequestT = Model::GetOciOnboardingStatusRequest>
        Model::GetOciOnboardingStatusOutcomeCallable GetOciOnboardingStatusCallable(const GetOciOnboardingStatusRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::GetOciOnboardingStatus, request);
        }
 
        template<typename GetOciOnboardingStatusRequestT = Model::GetOciOnboardingStatusRequest>
        void GetOciOnboardingStatusAsync(const GetOciOnboardingStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetOciOnboardingStatusRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::GetOciOnboardingStatus, request, handler, context);
        }
 
        virtual Model::GetOdbNetworkOutcome GetOdbNetwork(const Model::GetOdbNetworkRequest& request) const;
 
        template<typename GetOdbNetworkRequestT = Model::GetOdbNetworkRequest>
        Model::GetOdbNetworkOutcomeCallable GetOdbNetworkCallable(const GetOdbNetworkRequestT& request) const
        {
            return SubmitCallable(&OdbClient::GetOdbNetwork, request);
        }
 
        template<typename GetOdbNetworkRequestT = Model::GetOdbNetworkRequest>
        void GetOdbNetworkAsync(const GetOdbNetworkRequestT& request, const GetOdbNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::GetOdbNetwork, request, handler, context);
        }
 
        virtual Model::GetOdbPeeringConnectionOutcome GetOdbPeeringConnection(const Model::GetOdbPeeringConnectionRequest& request) const;
 
        template<typename GetOdbPeeringConnectionRequestT = Model::GetOdbPeeringConnectionRequest>
        Model::GetOdbPeeringConnectionOutcomeCallable GetOdbPeeringConnectionCallable(const GetOdbPeeringConnectionRequestT& request) const
        {
            return SubmitCallable(&OdbClient::GetOdbPeeringConnection, request);
        }
 
        template<typename GetOdbPeeringConnectionRequestT = Model::GetOdbPeeringConnectionRequest>
        void GetOdbPeeringConnectionAsync(const GetOdbPeeringConnectionRequestT& request, const GetOdbPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::GetOdbPeeringConnection, request, handler, context);
        }
 
        virtual Model::InitializeServiceOutcome InitializeService(const Model::InitializeServiceRequest& request = {}) const;
 
        template<typename InitializeServiceRequestT = Model::InitializeServiceRequest>
        Model::InitializeServiceOutcomeCallable InitializeServiceCallable(const InitializeServiceRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::InitializeService, request);
        }
 
        template<typename InitializeServiceRequestT = Model::InitializeServiceRequest>
        void InitializeServiceAsync(const InitializeServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const InitializeServiceRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::InitializeService, request, handler, context);
        }
 
        virtual Model::ListAutonomousVirtualMachinesOutcome ListAutonomousVirtualMachines(const Model::ListAutonomousVirtualMachinesRequest& request) const;
 
        template<typename ListAutonomousVirtualMachinesRequestT = Model::ListAutonomousVirtualMachinesRequest>
        Model::ListAutonomousVirtualMachinesOutcomeCallable ListAutonomousVirtualMachinesCallable(const ListAutonomousVirtualMachinesRequestT& request) const
        {
            return SubmitCallable(&OdbClient::ListAutonomousVirtualMachines, request);
        }
 
        template<typename ListAutonomousVirtualMachinesRequestT = Model::ListAutonomousVirtualMachinesRequest>
        void ListAutonomousVirtualMachinesAsync(const ListAutonomousVirtualMachinesRequestT& request, const ListAutonomousVirtualMachinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::ListAutonomousVirtualMachines, request, handler, context);
        }
 
        virtual Model::ListCloudAutonomousVmClustersOutcome ListCloudAutonomousVmClusters(const Model::ListCloudAutonomousVmClustersRequest& request = {}) const;
 
        template<typename ListCloudAutonomousVmClustersRequestT = Model::ListCloudAutonomousVmClustersRequest>
        Model::ListCloudAutonomousVmClustersOutcomeCallable ListCloudAutonomousVmClustersCallable(const ListCloudAutonomousVmClustersRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::ListCloudAutonomousVmClusters, request);
        }
 
        template<typename ListCloudAutonomousVmClustersRequestT = Model::ListCloudAutonomousVmClustersRequest>
        void ListCloudAutonomousVmClustersAsync(const ListCloudAutonomousVmClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCloudAutonomousVmClustersRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::ListCloudAutonomousVmClusters, request, handler, context);
        }
 
        virtual Model::ListCloudExadataInfrastructuresOutcome ListCloudExadataInfrastructures(const Model::ListCloudExadataInfrastructuresRequest& request = {}) const;
 
        template<typename ListCloudExadataInfrastructuresRequestT = Model::ListCloudExadataInfrastructuresRequest>
        Model::ListCloudExadataInfrastructuresOutcomeCallable ListCloudExadataInfrastructuresCallable(const ListCloudExadataInfrastructuresRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::ListCloudExadataInfrastructures, request);
        }
 
        template<typename ListCloudExadataInfrastructuresRequestT = Model::ListCloudExadataInfrastructuresRequest>
        void ListCloudExadataInfrastructuresAsync(const ListCloudExadataInfrastructuresResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCloudExadataInfrastructuresRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::ListCloudExadataInfrastructures, request, handler, context);
        }
 
        virtual Model::ListCloudVmClustersOutcome ListCloudVmClusters(const Model::ListCloudVmClustersRequest& request = {}) const;
 
        template<typename ListCloudVmClustersRequestT = Model::ListCloudVmClustersRequest>
        Model::ListCloudVmClustersOutcomeCallable ListCloudVmClustersCallable(const ListCloudVmClustersRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::ListCloudVmClusters, request);
        }
 
        template<typename ListCloudVmClustersRequestT = Model::ListCloudVmClustersRequest>
        void ListCloudVmClustersAsync(const ListCloudVmClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCloudVmClustersRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::ListCloudVmClusters, request, handler, context);
        }
 
        virtual Model::ListDbNodesOutcome ListDbNodes(const Model::ListDbNodesRequest& request) const;
 
        template<typename ListDbNodesRequestT = Model::ListDbNodesRequest>
        Model::ListDbNodesOutcomeCallable ListDbNodesCallable(const ListDbNodesRequestT& request) const
        {
            return SubmitCallable(&OdbClient::ListDbNodes, request);
        }
 
        template<typename ListDbNodesRequestT = Model::ListDbNodesRequest>
        void ListDbNodesAsync(const ListDbNodesRequestT& request, const ListDbNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::ListDbNodes, request, handler, context);
        }
 
        virtual Model::ListDbServersOutcome ListDbServers(const Model::ListDbServersRequest& request) const;
 
        template<typename ListDbServersRequestT = Model::ListDbServersRequest>
        Model::ListDbServersOutcomeCallable ListDbServersCallable(const ListDbServersRequestT& request) const
        {
            return SubmitCallable(&OdbClient::ListDbServers, request);
        }
 
        template<typename ListDbServersRequestT = Model::ListDbServersRequest>
        void ListDbServersAsync(const ListDbServersRequestT& request, const ListDbServersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::ListDbServers, request, handler, context);
        }
 
        virtual Model::ListDbSystemShapesOutcome ListDbSystemShapes(const Model::ListDbSystemShapesRequest& request = {}) const;
 
        template<typename ListDbSystemShapesRequestT = Model::ListDbSystemShapesRequest>
        Model::ListDbSystemShapesOutcomeCallable ListDbSystemShapesCallable(const ListDbSystemShapesRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::ListDbSystemShapes, request);
        }
 
        template<typename ListDbSystemShapesRequestT = Model::ListDbSystemShapesRequest>
        void ListDbSystemShapesAsync(const ListDbSystemShapesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDbSystemShapesRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::ListDbSystemShapes, request, handler, context);
        }
 
        virtual Model::ListGiVersionsOutcome ListGiVersions(const Model::ListGiVersionsRequest& request = {}) const;
 
        template<typename ListGiVersionsRequestT = Model::ListGiVersionsRequest>
        Model::ListGiVersionsOutcomeCallable ListGiVersionsCallable(const ListGiVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::ListGiVersions, request);
        }
 
        template<typename ListGiVersionsRequestT = Model::ListGiVersionsRequest>
        void ListGiVersionsAsync(const ListGiVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGiVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::ListGiVersions, request, handler, context);
        }
 
        virtual Model::ListOdbNetworksOutcome ListOdbNetworks(const Model::ListOdbNetworksRequest& request = {}) const;
 
        template<typename ListOdbNetworksRequestT = Model::ListOdbNetworksRequest>
        Model::ListOdbNetworksOutcomeCallable ListOdbNetworksCallable(const ListOdbNetworksRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::ListOdbNetworks, request);
        }
 
        template<typename ListOdbNetworksRequestT = Model::ListOdbNetworksRequest>
        void ListOdbNetworksAsync(const ListOdbNetworksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOdbNetworksRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::ListOdbNetworks, request, handler, context);
        }
 
        virtual Model::ListOdbPeeringConnectionsOutcome ListOdbPeeringConnections(const Model::ListOdbPeeringConnectionsRequest& request = {}) const;
 
        template<typename ListOdbPeeringConnectionsRequestT = Model::ListOdbPeeringConnectionsRequest>
        Model::ListOdbPeeringConnectionsOutcomeCallable ListOdbPeeringConnectionsCallable(const ListOdbPeeringConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&OdbClient::ListOdbPeeringConnections, request);
        }
 
        template<typename ListOdbPeeringConnectionsRequestT = Model::ListOdbPeeringConnectionsRequest>
        void ListOdbPeeringConnectionsAsync(const ListOdbPeeringConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOdbPeeringConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&OdbClient::ListOdbPeeringConnections, request, handler, context);
        }
 
        virtual Model::ListSystemVersionsOutcome ListSystemVersions(const Model::ListSystemVersionsRequest& request) const;
 
        template<typename ListSystemVersionsRequestT = Model::ListSystemVersionsRequest>
        Model::ListSystemVersionsOutcomeCallable ListSystemVersionsCallable(const ListSystemVersionsRequestT& request) const
        {
            return SubmitCallable(&OdbClient::ListSystemVersions, request);
        }
 
        template<typename ListSystemVersionsRequestT = Model::ListSystemVersionsRequest>
        void ListSystemVersionsAsync(const ListSystemVersionsRequestT& request, const ListSystemVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::ListSystemVersions, 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(&OdbClient::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(&OdbClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::RebootDbNodeOutcome RebootDbNode(const Model::RebootDbNodeRequest& request) const;
 
        template<typename RebootDbNodeRequestT = Model::RebootDbNodeRequest>
        Model::RebootDbNodeOutcomeCallable RebootDbNodeCallable(const RebootDbNodeRequestT& request) const
        {
            return SubmitCallable(&OdbClient::RebootDbNode, request);
        }
 
        template<typename RebootDbNodeRequestT = Model::RebootDbNodeRequest>
        void RebootDbNodeAsync(const RebootDbNodeRequestT& request, const RebootDbNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::RebootDbNode, request, handler, context);
        }
 
        virtual Model::StartDbNodeOutcome StartDbNode(const Model::StartDbNodeRequest& request) const;
 
        template<typename StartDbNodeRequestT = Model::StartDbNodeRequest>
        Model::StartDbNodeOutcomeCallable StartDbNodeCallable(const StartDbNodeRequestT& request) const
        {
            return SubmitCallable(&OdbClient::StartDbNode, request);
        }
 
        template<typename StartDbNodeRequestT = Model::StartDbNodeRequest>
        void StartDbNodeAsync(const StartDbNodeRequestT& request, const StartDbNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::StartDbNode, request, handler, context);
        }
 
        virtual Model::StopDbNodeOutcome StopDbNode(const Model::StopDbNodeRequest& request) const;
 
        template<typename StopDbNodeRequestT = Model::StopDbNodeRequest>
        Model::StopDbNodeOutcomeCallable StopDbNodeCallable(const StopDbNodeRequestT& request) const
        {
            return SubmitCallable(&OdbClient::StopDbNode, request);
        }
 
        template<typename StopDbNodeRequestT = Model::StopDbNodeRequest>
        void StopDbNodeAsync(const StopDbNodeRequestT& request, const StopDbNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::StopDbNode, 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(&OdbClient::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(&OdbClient::TagResource, 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(&OdbClient::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(&OdbClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateCloudExadataInfrastructureOutcome UpdateCloudExadataInfrastructure(const Model::UpdateCloudExadataInfrastructureRequest& request) const;
 
        template<typename UpdateCloudExadataInfrastructureRequestT = Model::UpdateCloudExadataInfrastructureRequest>
        Model::UpdateCloudExadataInfrastructureOutcomeCallable UpdateCloudExadataInfrastructureCallable(const UpdateCloudExadataInfrastructureRequestT& request) const
        {
            return SubmitCallable(&OdbClient::UpdateCloudExadataInfrastructure, request);
        }
 
        template<typename UpdateCloudExadataInfrastructureRequestT = Model::UpdateCloudExadataInfrastructureRequest>
        void UpdateCloudExadataInfrastructureAsync(const UpdateCloudExadataInfrastructureRequestT& request, const UpdateCloudExadataInfrastructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::UpdateCloudExadataInfrastructure, request, handler, context);
        }
 
        virtual Model::UpdateOdbNetworkOutcome UpdateOdbNetwork(const Model::UpdateOdbNetworkRequest& request) const;
 
        template<typename UpdateOdbNetworkRequestT = Model::UpdateOdbNetworkRequest>
        Model::UpdateOdbNetworkOutcomeCallable UpdateOdbNetworkCallable(const UpdateOdbNetworkRequestT& request) const
        {
            return SubmitCallable(&OdbClient::UpdateOdbNetwork, request);
        }
 
        template<typename UpdateOdbNetworkRequestT = Model::UpdateOdbNetworkRequest>
        void UpdateOdbNetworkAsync(const UpdateOdbNetworkRequestT& request, const UpdateOdbNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OdbClient::UpdateOdbNetwork, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<OdbEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<OdbClient>;
      void init(const OdbClientConfiguration& clientConfiguration);
 
      OdbClientConfiguration m_clientConfiguration;
      std::shared_ptr<OdbEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace odb
} // namespace Aws