OdbClient.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/odb/OdbPaginationBase.h>
#include <aws/odb/OdbServiceClientModel.h>
#include <aws/odb/Odb_EXPORTS.h>
 
namespace Aws {
namespace odb {
class AWS_ODB_API OdbClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<OdbClient>,
                              public OdbPaginationBase<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::AssociateIamRoleToResourceOutcome AssociateIamRoleToResource(
      const Model::AssociateIamRoleToResourceRequest& request) const;
 
  template <typename AssociateIamRoleToResourceRequestT = Model::AssociateIamRoleToResourceRequest>
  Model::AssociateIamRoleToResourceOutcomeCallable AssociateIamRoleToResourceCallable(
      const AssociateIamRoleToResourceRequestT& request) const {
    return SubmitCallable(&OdbClient::AssociateIamRoleToResource, request);
  }
 
  template <typename AssociateIamRoleToResourceRequestT = Model::AssociateIamRoleToResourceRequest>
  void AssociateIamRoleToResourceAsync(const AssociateIamRoleToResourceRequestT& request,
                                       const AssociateIamRoleToResourceResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::AssociateIamRoleToResource, 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::DisassociateIamRoleFromResourceOutcome DisassociateIamRoleFromResource(
      const Model::DisassociateIamRoleFromResourceRequest& request) const;
 
  template <typename DisassociateIamRoleFromResourceRequestT = Model::DisassociateIamRoleFromResourceRequest>
  Model::DisassociateIamRoleFromResourceOutcomeCallable DisassociateIamRoleFromResourceCallable(
      const DisassociateIamRoleFromResourceRequestT& request) const {
    return SubmitCallable(&OdbClient::DisassociateIamRoleFromResource, request);
  }
 
  template <typename DisassociateIamRoleFromResourceRequestT = Model::DisassociateIamRoleFromResourceRequest>
  void DisassociateIamRoleFromResourceAsync(const DisassociateIamRoleFromResourceRequestT& request,
                                            const DisassociateIamRoleFromResourceResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::DisassociateIamRoleFromResource, 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);
  }
 
  virtual Model::UpdateOdbPeeringConnectionOutcome UpdateOdbPeeringConnection(
      const Model::UpdateOdbPeeringConnectionRequest& request) const;
 
  template <typename UpdateOdbPeeringConnectionRequestT = Model::UpdateOdbPeeringConnectionRequest>
  Model::UpdateOdbPeeringConnectionOutcomeCallable UpdateOdbPeeringConnectionCallable(
      const UpdateOdbPeeringConnectionRequestT& request) const {
    return SubmitCallable(&OdbClient::UpdateOdbPeeringConnection, request);
  }
 
  template <typename UpdateOdbPeeringConnectionRequestT = Model::UpdateOdbPeeringConnectionRequest>
  void UpdateOdbPeeringConnectionAsync(const UpdateOdbPeeringConnectionRequestT& request,
                                       const UpdateOdbPeeringConnectionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::UpdateOdbPeeringConnection, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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