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/OdbWaiter.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 OdbWaiter<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::CreateAutonomousDatabaseOutcome CreateAutonomousDatabase(const Model::CreateAutonomousDatabaseRequest& request = {}) const;
 
  template <typename CreateAutonomousDatabaseRequestT = Model::CreateAutonomousDatabaseRequest>
  Model::CreateAutonomousDatabaseOutcomeCallable CreateAutonomousDatabaseCallable(
      const CreateAutonomousDatabaseRequestT& request = {}) const {
    return SubmitCallable(&OdbClient::CreateAutonomousDatabase, request);
  }
 
  template <typename CreateAutonomousDatabaseRequestT = Model::CreateAutonomousDatabaseRequest>
  void CreateAutonomousDatabaseAsync(const CreateAutonomousDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const CreateAutonomousDatabaseRequestT& request = {}) const {
    return SubmitAsync(&OdbClient::CreateAutonomousDatabase, request, handler, context);
  }
 
  virtual Model::CreateAutonomousDatabaseBackupOutcome CreateAutonomousDatabaseBackup(
      const Model::CreateAutonomousDatabaseBackupRequest& request) const;
 
  template <typename CreateAutonomousDatabaseBackupRequestT = Model::CreateAutonomousDatabaseBackupRequest>
  Model::CreateAutonomousDatabaseBackupOutcomeCallable CreateAutonomousDatabaseBackupCallable(
      const CreateAutonomousDatabaseBackupRequestT& request) const {
    return SubmitCallable(&OdbClient::CreateAutonomousDatabaseBackup, request);
  }
 
  template <typename CreateAutonomousDatabaseBackupRequestT = Model::CreateAutonomousDatabaseBackupRequest>
  void CreateAutonomousDatabaseBackupAsync(const CreateAutonomousDatabaseBackupRequestT& request,
                                           const CreateAutonomousDatabaseBackupResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::CreateAutonomousDatabaseBackup, request, handler, context);
  }
 
  virtual Model::CreateAutonomousDatabaseWalletOutcome CreateAutonomousDatabaseWallet(
      const Model::CreateAutonomousDatabaseWalletRequest& request) const;
 
  template <typename CreateAutonomousDatabaseWalletRequestT = Model::CreateAutonomousDatabaseWalletRequest>
  Model::CreateAutonomousDatabaseWalletOutcomeCallable CreateAutonomousDatabaseWalletCallable(
      const CreateAutonomousDatabaseWalletRequestT& request) const {
    return SubmitCallable(&OdbClient::CreateAutonomousDatabaseWallet, request);
  }
 
  template <typename CreateAutonomousDatabaseWalletRequestT = Model::CreateAutonomousDatabaseWalletRequest>
  void CreateAutonomousDatabaseWalletAsync(const CreateAutonomousDatabaseWalletRequestT& request,
                                           const CreateAutonomousDatabaseWalletResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::CreateAutonomousDatabaseWallet, 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::DeleteAutonomousDatabaseOutcome DeleteAutonomousDatabase(const Model::DeleteAutonomousDatabaseRequest& request) const;
 
  template <typename DeleteAutonomousDatabaseRequestT = Model::DeleteAutonomousDatabaseRequest>
  Model::DeleteAutonomousDatabaseOutcomeCallable DeleteAutonomousDatabaseCallable(const DeleteAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::DeleteAutonomousDatabase, request);
  }
 
  template <typename DeleteAutonomousDatabaseRequestT = Model::DeleteAutonomousDatabaseRequest>
  void DeleteAutonomousDatabaseAsync(const DeleteAutonomousDatabaseRequestT& request,
                                     const DeleteAutonomousDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::DeleteAutonomousDatabase, request, handler, context);
  }
 
  virtual Model::DeleteAutonomousDatabaseBackupOutcome DeleteAutonomousDatabaseBackup(
      const Model::DeleteAutonomousDatabaseBackupRequest& request) const;
 
  template <typename DeleteAutonomousDatabaseBackupRequestT = Model::DeleteAutonomousDatabaseBackupRequest>
  Model::DeleteAutonomousDatabaseBackupOutcomeCallable DeleteAutonomousDatabaseBackupCallable(
      const DeleteAutonomousDatabaseBackupRequestT& request) const {
    return SubmitCallable(&OdbClient::DeleteAutonomousDatabaseBackup, request);
  }
 
  template <typename DeleteAutonomousDatabaseBackupRequestT = Model::DeleteAutonomousDatabaseBackupRequest>
  void DeleteAutonomousDatabaseBackupAsync(const DeleteAutonomousDatabaseBackupRequestT& request,
                                           const DeleteAutonomousDatabaseBackupResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::DeleteAutonomousDatabaseBackup, 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::FailoverAutonomousDatabaseOutcome FailoverAutonomousDatabase(
      const Model::FailoverAutonomousDatabaseRequest& request) const;
 
  template <typename FailoverAutonomousDatabaseRequestT = Model::FailoverAutonomousDatabaseRequest>
  Model::FailoverAutonomousDatabaseOutcomeCallable FailoverAutonomousDatabaseCallable(
      const FailoverAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::FailoverAutonomousDatabase, request);
  }
 
  template <typename FailoverAutonomousDatabaseRequestT = Model::FailoverAutonomousDatabaseRequest>
  void FailoverAutonomousDatabaseAsync(const FailoverAutonomousDatabaseRequestT& request,
                                       const FailoverAutonomousDatabaseResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::FailoverAutonomousDatabase, request, handler, context);
  }
 
  virtual Model::GetAutonomousDatabaseOutcome GetAutonomousDatabase(const Model::GetAutonomousDatabaseRequest& request) const;
 
  template <typename GetAutonomousDatabaseRequestT = Model::GetAutonomousDatabaseRequest>
  Model::GetAutonomousDatabaseOutcomeCallable GetAutonomousDatabaseCallable(const GetAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::GetAutonomousDatabase, request);
  }
 
  template <typename GetAutonomousDatabaseRequestT = Model::GetAutonomousDatabaseRequest>
  void GetAutonomousDatabaseAsync(const GetAutonomousDatabaseRequestT& request, const GetAutonomousDatabaseResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::GetAutonomousDatabase, request, handler, context);
  }
 
  virtual Model::GetAutonomousDatabaseBackupOutcome GetAutonomousDatabaseBackup(
      const Model::GetAutonomousDatabaseBackupRequest& request) const;
 
  template <typename GetAutonomousDatabaseBackupRequestT = Model::GetAutonomousDatabaseBackupRequest>
  Model::GetAutonomousDatabaseBackupOutcomeCallable GetAutonomousDatabaseBackupCallable(
      const GetAutonomousDatabaseBackupRequestT& request) const {
    return SubmitCallable(&OdbClient::GetAutonomousDatabaseBackup, request);
  }
 
  template <typename GetAutonomousDatabaseBackupRequestT = Model::GetAutonomousDatabaseBackupRequest>
  void GetAutonomousDatabaseBackupAsync(const GetAutonomousDatabaseBackupRequestT& request,
                                        const GetAutonomousDatabaseBackupResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::GetAutonomousDatabaseBackup, request, handler, context);
  }
 
  virtual Model::GetAutonomousDatabaseWalletDetailsOutcome GetAutonomousDatabaseWalletDetails(
      const Model::GetAutonomousDatabaseWalletDetailsRequest& request) const;
 
  template <typename GetAutonomousDatabaseWalletDetailsRequestT = Model::GetAutonomousDatabaseWalletDetailsRequest>
  Model::GetAutonomousDatabaseWalletDetailsOutcomeCallable GetAutonomousDatabaseWalletDetailsCallable(
      const GetAutonomousDatabaseWalletDetailsRequestT& request) const {
    return SubmitCallable(&OdbClient::GetAutonomousDatabaseWalletDetails, request);
  }
 
  template <typename GetAutonomousDatabaseWalletDetailsRequestT = Model::GetAutonomousDatabaseWalletDetailsRequest>
  void GetAutonomousDatabaseWalletDetailsAsync(const GetAutonomousDatabaseWalletDetailsRequestT& request,
                                               const GetAutonomousDatabaseWalletDetailsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::GetAutonomousDatabaseWalletDetails, 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::ListAutonomousDatabaseBackupsOutcome ListAutonomousDatabaseBackups(
      const Model::ListAutonomousDatabaseBackupsRequest& request) const;
 
  template <typename ListAutonomousDatabaseBackupsRequestT = Model::ListAutonomousDatabaseBackupsRequest>
  Model::ListAutonomousDatabaseBackupsOutcomeCallable ListAutonomousDatabaseBackupsCallable(
      const ListAutonomousDatabaseBackupsRequestT& request) const {
    return SubmitCallable(&OdbClient::ListAutonomousDatabaseBackups, request);
  }
 
  template <typename ListAutonomousDatabaseBackupsRequestT = Model::ListAutonomousDatabaseBackupsRequest>
  void ListAutonomousDatabaseBackupsAsync(const ListAutonomousDatabaseBackupsRequestT& request,
                                          const ListAutonomousDatabaseBackupsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::ListAutonomousDatabaseBackups, request, handler, context);
  }
 
  virtual Model::ListAutonomousDatabaseCharacterSetsOutcome ListAutonomousDatabaseCharacterSets(
      const Model::ListAutonomousDatabaseCharacterSetsRequest& request = {}) const;
 
  template <typename ListAutonomousDatabaseCharacterSetsRequestT = Model::ListAutonomousDatabaseCharacterSetsRequest>
  Model::ListAutonomousDatabaseCharacterSetsOutcomeCallable ListAutonomousDatabaseCharacterSetsCallable(
      const ListAutonomousDatabaseCharacterSetsRequestT& request = {}) const {
    return SubmitCallable(&OdbClient::ListAutonomousDatabaseCharacterSets, request);
  }
 
  template <typename ListAutonomousDatabaseCharacterSetsRequestT = Model::ListAutonomousDatabaseCharacterSetsRequest>
  void ListAutonomousDatabaseCharacterSetsAsync(const ListAutonomousDatabaseCharacterSetsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const ListAutonomousDatabaseCharacterSetsRequestT& request = {}) const {
    return SubmitAsync(&OdbClient::ListAutonomousDatabaseCharacterSets, request, handler, context);
  }
 
  virtual Model::ListAutonomousDatabaseClonesOutcome ListAutonomousDatabaseClones(
      const Model::ListAutonomousDatabaseClonesRequest& request) const;
 
  template <typename ListAutonomousDatabaseClonesRequestT = Model::ListAutonomousDatabaseClonesRequest>
  Model::ListAutonomousDatabaseClonesOutcomeCallable ListAutonomousDatabaseClonesCallable(
      const ListAutonomousDatabaseClonesRequestT& request) const {
    return SubmitCallable(&OdbClient::ListAutonomousDatabaseClones, request);
  }
 
  template <typename ListAutonomousDatabaseClonesRequestT = Model::ListAutonomousDatabaseClonesRequest>
  void ListAutonomousDatabaseClonesAsync(const ListAutonomousDatabaseClonesRequestT& request,
                                         const ListAutonomousDatabaseClonesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::ListAutonomousDatabaseClones, request, handler, context);
  }
 
  virtual Model::ListAutonomousDatabasePeersOutcome ListAutonomousDatabasePeers(
      const Model::ListAutonomousDatabasePeersRequest& request) const;
 
  template <typename ListAutonomousDatabasePeersRequestT = Model::ListAutonomousDatabasePeersRequest>
  Model::ListAutonomousDatabasePeersOutcomeCallable ListAutonomousDatabasePeersCallable(
      const ListAutonomousDatabasePeersRequestT& request) const {
    return SubmitCallable(&OdbClient::ListAutonomousDatabasePeers, request);
  }
 
  template <typename ListAutonomousDatabasePeersRequestT = Model::ListAutonomousDatabasePeersRequest>
  void ListAutonomousDatabasePeersAsync(const ListAutonomousDatabasePeersRequestT& request,
                                        const ListAutonomousDatabasePeersResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::ListAutonomousDatabasePeers, request, handler, context);
  }
 
  virtual Model::ListAutonomousDatabaseVersionsOutcome ListAutonomousDatabaseVersions(
      const Model::ListAutonomousDatabaseVersionsRequest& request = {}) const;
 
  template <typename ListAutonomousDatabaseVersionsRequestT = Model::ListAutonomousDatabaseVersionsRequest>
  Model::ListAutonomousDatabaseVersionsOutcomeCallable ListAutonomousDatabaseVersionsCallable(
      const ListAutonomousDatabaseVersionsRequestT& request = {}) const {
    return SubmitCallable(&OdbClient::ListAutonomousDatabaseVersions, request);
  }
 
  template <typename ListAutonomousDatabaseVersionsRequestT = Model::ListAutonomousDatabaseVersionsRequest>
  void ListAutonomousDatabaseVersionsAsync(const ListAutonomousDatabaseVersionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListAutonomousDatabaseVersionsRequestT& request = {}) const {
    return SubmitAsync(&OdbClient::ListAutonomousDatabaseVersions, request, handler, context);
  }
 
  virtual Model::ListAutonomousDatabasesOutcome ListAutonomousDatabases(const Model::ListAutonomousDatabasesRequest& request = {}) const;
 
  template <typename ListAutonomousDatabasesRequestT = Model::ListAutonomousDatabasesRequest>
  Model::ListAutonomousDatabasesOutcomeCallable ListAutonomousDatabasesCallable(const ListAutonomousDatabasesRequestT& request = {}) const {
    return SubmitCallable(&OdbClient::ListAutonomousDatabases, request);
  }
 
  template <typename ListAutonomousDatabasesRequestT = Model::ListAutonomousDatabasesRequest>
  void ListAutonomousDatabasesAsync(const ListAutonomousDatabasesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListAutonomousDatabasesRequestT& request = {}) const {
    return SubmitAsync(&OdbClient::ListAutonomousDatabases, 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::RebootAutonomousDatabaseOutcome RebootAutonomousDatabase(const Model::RebootAutonomousDatabaseRequest& request) const;
 
  template <typename RebootAutonomousDatabaseRequestT = Model::RebootAutonomousDatabaseRequest>
  Model::RebootAutonomousDatabaseOutcomeCallable RebootAutonomousDatabaseCallable(const RebootAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::RebootAutonomousDatabase, request);
  }
 
  template <typename RebootAutonomousDatabaseRequestT = Model::RebootAutonomousDatabaseRequest>
  void RebootAutonomousDatabaseAsync(const RebootAutonomousDatabaseRequestT& request,
                                     const RebootAutonomousDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::RebootAutonomousDatabase, 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::RestoreAutonomousDatabaseOutcome RestoreAutonomousDatabase(const Model::RestoreAutonomousDatabaseRequest& request) const;
 
  template <typename RestoreAutonomousDatabaseRequestT = Model::RestoreAutonomousDatabaseRequest>
  Model::RestoreAutonomousDatabaseOutcomeCallable RestoreAutonomousDatabaseCallable(
      const RestoreAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::RestoreAutonomousDatabase, request);
  }
 
  template <typename RestoreAutonomousDatabaseRequestT = Model::RestoreAutonomousDatabaseRequest>
  void RestoreAutonomousDatabaseAsync(const RestoreAutonomousDatabaseRequestT& request,
                                      const RestoreAutonomousDatabaseResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::RestoreAutonomousDatabase, request, handler, context);
  }
 
  virtual Model::ShrinkAutonomousDatabaseOutcome ShrinkAutonomousDatabase(const Model::ShrinkAutonomousDatabaseRequest& request) const;
 
  template <typename ShrinkAutonomousDatabaseRequestT = Model::ShrinkAutonomousDatabaseRequest>
  Model::ShrinkAutonomousDatabaseOutcomeCallable ShrinkAutonomousDatabaseCallable(const ShrinkAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::ShrinkAutonomousDatabase, request);
  }
 
  template <typename ShrinkAutonomousDatabaseRequestT = Model::ShrinkAutonomousDatabaseRequest>
  void ShrinkAutonomousDatabaseAsync(const ShrinkAutonomousDatabaseRequestT& request,
                                     const ShrinkAutonomousDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::ShrinkAutonomousDatabase, request, handler, context);
  }
 
  virtual Model::StartAutonomousDatabaseOutcome StartAutonomousDatabase(const Model::StartAutonomousDatabaseRequest& request) const;
 
  template <typename StartAutonomousDatabaseRequestT = Model::StartAutonomousDatabaseRequest>
  Model::StartAutonomousDatabaseOutcomeCallable StartAutonomousDatabaseCallable(const StartAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::StartAutonomousDatabase, request);
  }
 
  template <typename StartAutonomousDatabaseRequestT = Model::StartAutonomousDatabaseRequest>
  void StartAutonomousDatabaseAsync(const StartAutonomousDatabaseRequestT& request,
                                    const StartAutonomousDatabaseResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::StartAutonomousDatabase, 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::StopAutonomousDatabaseOutcome StopAutonomousDatabase(const Model::StopAutonomousDatabaseRequest& request) const;
 
  template <typename StopAutonomousDatabaseRequestT = Model::StopAutonomousDatabaseRequest>
  Model::StopAutonomousDatabaseOutcomeCallable StopAutonomousDatabaseCallable(const StopAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::StopAutonomousDatabase, request);
  }
 
  template <typename StopAutonomousDatabaseRequestT = Model::StopAutonomousDatabaseRequest>
  void StopAutonomousDatabaseAsync(const StopAutonomousDatabaseRequestT& request,
                                   const StopAutonomousDatabaseResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::StopAutonomousDatabase, 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::SwitchoverAutonomousDatabaseOutcome SwitchoverAutonomousDatabase(
      const Model::SwitchoverAutonomousDatabaseRequest& request) const;
 
  template <typename SwitchoverAutonomousDatabaseRequestT = Model::SwitchoverAutonomousDatabaseRequest>
  Model::SwitchoverAutonomousDatabaseOutcomeCallable SwitchoverAutonomousDatabaseCallable(
      const SwitchoverAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::SwitchoverAutonomousDatabase, request);
  }
 
  template <typename SwitchoverAutonomousDatabaseRequestT = Model::SwitchoverAutonomousDatabaseRequest>
  void SwitchoverAutonomousDatabaseAsync(const SwitchoverAutonomousDatabaseRequestT& request,
                                         const SwitchoverAutonomousDatabaseResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::SwitchoverAutonomousDatabase, 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::UpdateAutonomousDatabaseOutcome UpdateAutonomousDatabase(const Model::UpdateAutonomousDatabaseRequest& request) const;
 
  template <typename UpdateAutonomousDatabaseRequestT = Model::UpdateAutonomousDatabaseRequest>
  Model::UpdateAutonomousDatabaseOutcomeCallable UpdateAutonomousDatabaseCallable(const UpdateAutonomousDatabaseRequestT& request) const {
    return SubmitCallable(&OdbClient::UpdateAutonomousDatabase, request);
  }
 
  template <typename UpdateAutonomousDatabaseRequestT = Model::UpdateAutonomousDatabaseRequest>
  void UpdateAutonomousDatabaseAsync(const UpdateAutonomousDatabaseRequestT& request,
                                     const UpdateAutonomousDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::UpdateAutonomousDatabase, request, handler, context);
  }
 
  virtual Model::UpdateAutonomousDatabaseBackupOutcome UpdateAutonomousDatabaseBackup(
      const Model::UpdateAutonomousDatabaseBackupRequest& request) const;
 
  template <typename UpdateAutonomousDatabaseBackupRequestT = Model::UpdateAutonomousDatabaseBackupRequest>
  Model::UpdateAutonomousDatabaseBackupOutcomeCallable UpdateAutonomousDatabaseBackupCallable(
      const UpdateAutonomousDatabaseBackupRequestT& request) const {
    return SubmitCallable(&OdbClient::UpdateAutonomousDatabaseBackup, request);
  }
 
  template <typename UpdateAutonomousDatabaseBackupRequestT = Model::UpdateAutonomousDatabaseBackupRequest>
  void UpdateAutonomousDatabaseBackupAsync(const UpdateAutonomousDatabaseBackupRequestT& request,
                                           const UpdateAutonomousDatabaseBackupResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OdbClient::UpdateAutonomousDatabaseBackup, 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);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, OdbError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  OdbClientConfiguration m_clientConfiguration;
  std::shared_ptr<OdbEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace odb
}  // namespace Aws