S3TablesClient.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/s3tables/S3TablesPaginationBase.h>
#include <aws/s3tables/S3TablesServiceClientModel.h>
#include <aws/s3tables/S3TablesWaiter.h>
#include <aws/s3tables/S3Tables_EXPORTS.h>
 
namespace Aws {
namespace S3Tables {
class AWS_S3TABLES_API S3TablesClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<S3TablesClient>,
                                        public S3TablesPaginationBase<S3TablesClient>,
                                        public S3TablesWaiter<S3TablesClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef S3TablesClientConfiguration ClientConfigurationType;
  typedef S3TablesEndpointProvider EndpointProviderType;
 
  S3TablesClient(const Aws::S3Tables::S3TablesClientConfiguration& clientConfiguration = Aws::S3Tables::S3TablesClientConfiguration(),
                 std::shared_ptr<S3TablesEndpointProviderBase> endpointProvider = nullptr);
 
  S3TablesClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<S3TablesEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::S3Tables::S3TablesClientConfiguration& clientConfiguration = Aws::S3Tables::S3TablesClientConfiguration());
 
  S3TablesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<S3TablesEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::S3Tables::S3TablesClientConfiguration& clientConfiguration = Aws::S3Tables::S3TablesClientConfiguration());
 
  /* Legacy constructors due deprecation */
  S3TablesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  S3TablesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  S3TablesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~S3TablesClient();
 
  virtual Model::CreateNamespaceOutcome CreateNamespace(const Model::CreateNamespaceRequest& request) const;
 
  template <typename CreateNamespaceRequestT = Model::CreateNamespaceRequest>
  Model::CreateNamespaceOutcomeCallable CreateNamespaceCallable(const CreateNamespaceRequestT& request) const {
    return SubmitCallable(&S3TablesClient::CreateNamespace, request);
  }
 
  template <typename CreateNamespaceRequestT = Model::CreateNamespaceRequest>
  void CreateNamespaceAsync(const CreateNamespaceRequestT& request, const CreateNamespaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::CreateNamespace, request, handler, context);
  }
 
  virtual Model::CreateTableOutcome CreateTable(const Model::CreateTableRequest& request) const;
 
  template <typename CreateTableRequestT = Model::CreateTableRequest>
  Model::CreateTableOutcomeCallable CreateTableCallable(const CreateTableRequestT& request) const {
    return SubmitCallable(&S3TablesClient::CreateTable, request);
  }
 
  template <typename CreateTableRequestT = Model::CreateTableRequest>
  void CreateTableAsync(const CreateTableRequestT& request, const CreateTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::CreateTable, request, handler, context);
  }
 
  virtual Model::CreateTableBucketOutcome CreateTableBucket(const Model::CreateTableBucketRequest& request) const;
 
  template <typename CreateTableBucketRequestT = Model::CreateTableBucketRequest>
  Model::CreateTableBucketOutcomeCallable CreateTableBucketCallable(const CreateTableBucketRequestT& request) const {
    return SubmitCallable(&S3TablesClient::CreateTableBucket, request);
  }
 
  template <typename CreateTableBucketRequestT = Model::CreateTableBucketRequest>
  void CreateTableBucketAsync(const CreateTableBucketRequestT& request, const CreateTableBucketResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::CreateTableBucket, request, handler, context);
  }
 
  virtual Model::DeleteNamespaceOutcome DeleteNamespace(const Model::DeleteNamespaceRequest& request) const;
 
  template <typename DeleteNamespaceRequestT = Model::DeleteNamespaceRequest>
  Model::DeleteNamespaceOutcomeCallable DeleteNamespaceCallable(const DeleteNamespaceRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteNamespace, request);
  }
 
  template <typename DeleteNamespaceRequestT = Model::DeleteNamespaceRequest>
  void DeleteNamespaceAsync(const DeleteNamespaceRequestT& request, const DeleteNamespaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteNamespace, request, handler, context);
  }
 
  virtual Model::DeleteTableOutcome DeleteTable(const Model::DeleteTableRequest& request) const;
 
  template <typename DeleteTableRequestT = Model::DeleteTableRequest>
  Model::DeleteTableOutcomeCallable DeleteTableCallable(const DeleteTableRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteTable, request);
  }
 
  template <typename DeleteTableRequestT = Model::DeleteTableRequest>
  void DeleteTableAsync(const DeleteTableRequestT& request, const DeleteTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteTable, request, handler, context);
  }
 
  virtual Model::DeleteTableBucketOutcome DeleteTableBucket(const Model::DeleteTableBucketRequest& request) const;
 
  template <typename DeleteTableBucketRequestT = Model::DeleteTableBucketRequest>
  Model::DeleteTableBucketOutcomeCallable DeleteTableBucketCallable(const DeleteTableBucketRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteTableBucket, request);
  }
 
  template <typename DeleteTableBucketRequestT = Model::DeleteTableBucketRequest>
  void DeleteTableBucketAsync(const DeleteTableBucketRequestT& request, const DeleteTableBucketResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteTableBucket, request, handler, context);
  }
 
  virtual Model::DeleteTableBucketEncryptionOutcome DeleteTableBucketEncryption(
      const Model::DeleteTableBucketEncryptionRequest& request) const;
 
  template <typename DeleteTableBucketEncryptionRequestT = Model::DeleteTableBucketEncryptionRequest>
  Model::DeleteTableBucketEncryptionOutcomeCallable DeleteTableBucketEncryptionCallable(
      const DeleteTableBucketEncryptionRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteTableBucketEncryption, request);
  }
 
  template <typename DeleteTableBucketEncryptionRequestT = Model::DeleteTableBucketEncryptionRequest>
  void DeleteTableBucketEncryptionAsync(const DeleteTableBucketEncryptionRequestT& request,
                                        const DeleteTableBucketEncryptionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteTableBucketEncryption, request, handler, context);
  }
 
  virtual Model::DeleteTableBucketMetricsConfigurationOutcome DeleteTableBucketMetricsConfiguration(
      const Model::DeleteTableBucketMetricsConfigurationRequest& request) const;
 
  template <typename DeleteTableBucketMetricsConfigurationRequestT = Model::DeleteTableBucketMetricsConfigurationRequest>
  Model::DeleteTableBucketMetricsConfigurationOutcomeCallable DeleteTableBucketMetricsConfigurationCallable(
      const DeleteTableBucketMetricsConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteTableBucketMetricsConfiguration, request);
  }
 
  template <typename DeleteTableBucketMetricsConfigurationRequestT = Model::DeleteTableBucketMetricsConfigurationRequest>
  void DeleteTableBucketMetricsConfigurationAsync(const DeleteTableBucketMetricsConfigurationRequestT& request,
                                                  const DeleteTableBucketMetricsConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteTableBucketMetricsConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteTableBucketPolicyOutcome DeleteTableBucketPolicy(const Model::DeleteTableBucketPolicyRequest& request) const;
 
  template <typename DeleteTableBucketPolicyRequestT = Model::DeleteTableBucketPolicyRequest>
  Model::DeleteTableBucketPolicyOutcomeCallable DeleteTableBucketPolicyCallable(const DeleteTableBucketPolicyRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteTableBucketPolicy, request);
  }
 
  template <typename DeleteTableBucketPolicyRequestT = Model::DeleteTableBucketPolicyRequest>
  void DeleteTableBucketPolicyAsync(const DeleteTableBucketPolicyRequestT& request,
                                    const DeleteTableBucketPolicyResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteTableBucketPolicy, request, handler, context);
  }
 
  virtual Model::DeleteTableBucketReplicationOutcome DeleteTableBucketReplication(
      const Model::DeleteTableBucketReplicationRequest& request) const;
 
  template <typename DeleteTableBucketReplicationRequestT = Model::DeleteTableBucketReplicationRequest>
  Model::DeleteTableBucketReplicationOutcomeCallable DeleteTableBucketReplicationCallable(
      const DeleteTableBucketReplicationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteTableBucketReplication, request);
  }
 
  template <typename DeleteTableBucketReplicationRequestT = Model::DeleteTableBucketReplicationRequest>
  void DeleteTableBucketReplicationAsync(const DeleteTableBucketReplicationRequestT& request,
                                         const DeleteTableBucketReplicationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteTableBucketReplication, request, handler, context);
  }
 
  virtual Model::DeleteTablePolicyOutcome DeleteTablePolicy(const Model::DeleteTablePolicyRequest& request) const;
 
  template <typename DeleteTablePolicyRequestT = Model::DeleteTablePolicyRequest>
  Model::DeleteTablePolicyOutcomeCallable DeleteTablePolicyCallable(const DeleteTablePolicyRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteTablePolicy, request);
  }
 
  template <typename DeleteTablePolicyRequestT = Model::DeleteTablePolicyRequest>
  void DeleteTablePolicyAsync(const DeleteTablePolicyRequestT& request, const DeleteTablePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteTablePolicy, request, handler, context);
  }
 
  virtual Model::DeleteTableReplicationOutcome DeleteTableReplication(const Model::DeleteTableReplicationRequest& request) const;
 
  template <typename DeleteTableReplicationRequestT = Model::DeleteTableReplicationRequest>
  Model::DeleteTableReplicationOutcomeCallable DeleteTableReplicationCallable(const DeleteTableReplicationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::DeleteTableReplication, request);
  }
 
  template <typename DeleteTableReplicationRequestT = Model::DeleteTableReplicationRequest>
  void DeleteTableReplicationAsync(const DeleteTableReplicationRequestT& request,
                                   const DeleteTableReplicationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::DeleteTableReplication, request, handler, context);
  }
 
  virtual Model::GetNamespaceOutcome GetNamespace(const Model::GetNamespaceRequest& request) const;
 
  template <typename GetNamespaceRequestT = Model::GetNamespaceRequest>
  Model::GetNamespaceOutcomeCallable GetNamespaceCallable(const GetNamespaceRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetNamespace, request);
  }
 
  template <typename GetNamespaceRequestT = Model::GetNamespaceRequest>
  void GetNamespaceAsync(const GetNamespaceRequestT& request, const GetNamespaceResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetNamespace, request, handler, context);
  }
 
  virtual Model::GetTableOutcome GetTable(const Model::GetTableRequest& request = {}) const;
 
  template <typename GetTableRequestT = Model::GetTableRequest>
  Model::GetTableOutcomeCallable GetTableCallable(const GetTableRequestT& request = {}) const {
    return SubmitCallable(&S3TablesClient::GetTable, request);
  }
 
  template <typename GetTableRequestT = Model::GetTableRequest>
  void GetTableAsync(const GetTableResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const GetTableRequestT& request = {}) const {
    return SubmitAsync(&S3TablesClient::GetTable, request, handler, context);
  }
 
  virtual Model::GetTableBucketOutcome GetTableBucket(const Model::GetTableBucketRequest& request) const;
 
  template <typename GetTableBucketRequestT = Model::GetTableBucketRequest>
  Model::GetTableBucketOutcomeCallable GetTableBucketCallable(const GetTableBucketRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableBucket, request);
  }
 
  template <typename GetTableBucketRequestT = Model::GetTableBucketRequest>
  void GetTableBucketAsync(const GetTableBucketRequestT& request, const GetTableBucketResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableBucket, request, handler, context);
  }
 
  virtual Model::GetTableBucketEncryptionOutcome GetTableBucketEncryption(const Model::GetTableBucketEncryptionRequest& request) const;
 
  template <typename GetTableBucketEncryptionRequestT = Model::GetTableBucketEncryptionRequest>
  Model::GetTableBucketEncryptionOutcomeCallable GetTableBucketEncryptionCallable(const GetTableBucketEncryptionRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableBucketEncryption, request);
  }
 
  template <typename GetTableBucketEncryptionRequestT = Model::GetTableBucketEncryptionRequest>
  void GetTableBucketEncryptionAsync(const GetTableBucketEncryptionRequestT& request,
                                     const GetTableBucketEncryptionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableBucketEncryption, request, handler, context);
  }
 
  virtual Model::GetTableBucketMaintenanceConfigurationOutcome GetTableBucketMaintenanceConfiguration(
      const Model::GetTableBucketMaintenanceConfigurationRequest& request) const;
 
  template <typename GetTableBucketMaintenanceConfigurationRequestT = Model::GetTableBucketMaintenanceConfigurationRequest>
  Model::GetTableBucketMaintenanceConfigurationOutcomeCallable GetTableBucketMaintenanceConfigurationCallable(
      const GetTableBucketMaintenanceConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableBucketMaintenanceConfiguration, request);
  }
 
  template <typename GetTableBucketMaintenanceConfigurationRequestT = Model::GetTableBucketMaintenanceConfigurationRequest>
  void GetTableBucketMaintenanceConfigurationAsync(const GetTableBucketMaintenanceConfigurationRequestT& request,
                                                   const GetTableBucketMaintenanceConfigurationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableBucketMaintenanceConfiguration, request, handler, context);
  }
 
  virtual Model::GetTableBucketMetricsConfigurationOutcome GetTableBucketMetricsConfiguration(
      const Model::GetTableBucketMetricsConfigurationRequest& request) const;
 
  template <typename GetTableBucketMetricsConfigurationRequestT = Model::GetTableBucketMetricsConfigurationRequest>
  Model::GetTableBucketMetricsConfigurationOutcomeCallable GetTableBucketMetricsConfigurationCallable(
      const GetTableBucketMetricsConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableBucketMetricsConfiguration, request);
  }
 
  template <typename GetTableBucketMetricsConfigurationRequestT = Model::GetTableBucketMetricsConfigurationRequest>
  void GetTableBucketMetricsConfigurationAsync(const GetTableBucketMetricsConfigurationRequestT& request,
                                               const GetTableBucketMetricsConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableBucketMetricsConfiguration, request, handler, context);
  }
 
  virtual Model::GetTableBucketPolicyOutcome GetTableBucketPolicy(const Model::GetTableBucketPolicyRequest& request) const;
 
  template <typename GetTableBucketPolicyRequestT = Model::GetTableBucketPolicyRequest>
  Model::GetTableBucketPolicyOutcomeCallable GetTableBucketPolicyCallable(const GetTableBucketPolicyRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableBucketPolicy, request);
  }
 
  template <typename GetTableBucketPolicyRequestT = Model::GetTableBucketPolicyRequest>
  void GetTableBucketPolicyAsync(const GetTableBucketPolicyRequestT& request, const GetTableBucketPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableBucketPolicy, request, handler, context);
  }
 
  virtual Model::GetTableBucketReplicationOutcome GetTableBucketReplication(const Model::GetTableBucketReplicationRequest& request) const;
 
  template <typename GetTableBucketReplicationRequestT = Model::GetTableBucketReplicationRequest>
  Model::GetTableBucketReplicationOutcomeCallable GetTableBucketReplicationCallable(
      const GetTableBucketReplicationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableBucketReplication, request);
  }
 
  template <typename GetTableBucketReplicationRequestT = Model::GetTableBucketReplicationRequest>
  void GetTableBucketReplicationAsync(const GetTableBucketReplicationRequestT& request,
                                      const GetTableBucketReplicationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableBucketReplication, request, handler, context);
  }
 
  virtual Model::GetTableBucketStorageClassOutcome GetTableBucketStorageClass(
      const Model::GetTableBucketStorageClassRequest& request) const;
 
  template <typename GetTableBucketStorageClassRequestT = Model::GetTableBucketStorageClassRequest>
  Model::GetTableBucketStorageClassOutcomeCallable GetTableBucketStorageClassCallable(
      const GetTableBucketStorageClassRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableBucketStorageClass, request);
  }
 
  template <typename GetTableBucketStorageClassRequestT = Model::GetTableBucketStorageClassRequest>
  void GetTableBucketStorageClassAsync(const GetTableBucketStorageClassRequestT& request,
                                       const GetTableBucketStorageClassResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableBucketStorageClass, request, handler, context);
  }
 
  virtual Model::GetTableEncryptionOutcome GetTableEncryption(const Model::GetTableEncryptionRequest& request) const;
 
  template <typename GetTableEncryptionRequestT = Model::GetTableEncryptionRequest>
  Model::GetTableEncryptionOutcomeCallable GetTableEncryptionCallable(const GetTableEncryptionRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableEncryption, request);
  }
 
  template <typename GetTableEncryptionRequestT = Model::GetTableEncryptionRequest>
  void GetTableEncryptionAsync(const GetTableEncryptionRequestT& request, const GetTableEncryptionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableEncryption, request, handler, context);
  }
 
  virtual Model::GetTableMaintenanceConfigurationOutcome GetTableMaintenanceConfiguration(
      const Model::GetTableMaintenanceConfigurationRequest& request) const;
 
  template <typename GetTableMaintenanceConfigurationRequestT = Model::GetTableMaintenanceConfigurationRequest>
  Model::GetTableMaintenanceConfigurationOutcomeCallable GetTableMaintenanceConfigurationCallable(
      const GetTableMaintenanceConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableMaintenanceConfiguration, request);
  }
 
  template <typename GetTableMaintenanceConfigurationRequestT = Model::GetTableMaintenanceConfigurationRequest>
  void GetTableMaintenanceConfigurationAsync(const GetTableMaintenanceConfigurationRequestT& request,
                                             const GetTableMaintenanceConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableMaintenanceConfiguration, request, handler, context);
  }
 
  virtual Model::GetTableMaintenanceJobStatusOutcome GetTableMaintenanceJobStatus(
      const Model::GetTableMaintenanceJobStatusRequest& request) const;
 
  template <typename GetTableMaintenanceJobStatusRequestT = Model::GetTableMaintenanceJobStatusRequest>
  Model::GetTableMaintenanceJobStatusOutcomeCallable GetTableMaintenanceJobStatusCallable(
      const GetTableMaintenanceJobStatusRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableMaintenanceJobStatus, request);
  }
 
  template <typename GetTableMaintenanceJobStatusRequestT = Model::GetTableMaintenanceJobStatusRequest>
  void GetTableMaintenanceJobStatusAsync(const GetTableMaintenanceJobStatusRequestT& request,
                                         const GetTableMaintenanceJobStatusResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableMaintenanceJobStatus, request, handler, context);
  }
 
  virtual Model::GetTableMetadataLocationOutcome GetTableMetadataLocation(const Model::GetTableMetadataLocationRequest& request) const;
 
  template <typename GetTableMetadataLocationRequestT = Model::GetTableMetadataLocationRequest>
  Model::GetTableMetadataLocationOutcomeCallable GetTableMetadataLocationCallable(const GetTableMetadataLocationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableMetadataLocation, request);
  }
 
  template <typename GetTableMetadataLocationRequestT = Model::GetTableMetadataLocationRequest>
  void GetTableMetadataLocationAsync(const GetTableMetadataLocationRequestT& request,
                                     const GetTableMetadataLocationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableMetadataLocation, request, handler, context);
  }
 
  virtual Model::GetTablePolicyOutcome GetTablePolicy(const Model::GetTablePolicyRequest& request) const;
 
  template <typename GetTablePolicyRequestT = Model::GetTablePolicyRequest>
  Model::GetTablePolicyOutcomeCallable GetTablePolicyCallable(const GetTablePolicyRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTablePolicy, request);
  }
 
  template <typename GetTablePolicyRequestT = Model::GetTablePolicyRequest>
  void GetTablePolicyAsync(const GetTablePolicyRequestT& request, const GetTablePolicyResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTablePolicy, request, handler, context);
  }
 
  virtual Model::GetTableRecordExpirationConfigurationOutcome GetTableRecordExpirationConfiguration(
      const Model::GetTableRecordExpirationConfigurationRequest& request) const;
 
  template <typename GetTableRecordExpirationConfigurationRequestT = Model::GetTableRecordExpirationConfigurationRequest>
  Model::GetTableRecordExpirationConfigurationOutcomeCallable GetTableRecordExpirationConfigurationCallable(
      const GetTableRecordExpirationConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableRecordExpirationConfiguration, request);
  }
 
  template <typename GetTableRecordExpirationConfigurationRequestT = Model::GetTableRecordExpirationConfigurationRequest>
  void GetTableRecordExpirationConfigurationAsync(const GetTableRecordExpirationConfigurationRequestT& request,
                                                  const GetTableRecordExpirationConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableRecordExpirationConfiguration, request, handler, context);
  }
 
  virtual Model::GetTableRecordExpirationJobStatusOutcome GetTableRecordExpirationJobStatus(
      const Model::GetTableRecordExpirationJobStatusRequest& request) const;
 
  template <typename GetTableRecordExpirationJobStatusRequestT = Model::GetTableRecordExpirationJobStatusRequest>
  Model::GetTableRecordExpirationJobStatusOutcomeCallable GetTableRecordExpirationJobStatusCallable(
      const GetTableRecordExpirationJobStatusRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableRecordExpirationJobStatus, request);
  }
 
  template <typename GetTableRecordExpirationJobStatusRequestT = Model::GetTableRecordExpirationJobStatusRequest>
  void GetTableRecordExpirationJobStatusAsync(const GetTableRecordExpirationJobStatusRequestT& request,
                                              const GetTableRecordExpirationJobStatusResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableRecordExpirationJobStatus, request, handler, context);
  }
 
  virtual Model::GetTableReplicationOutcome GetTableReplication(const Model::GetTableReplicationRequest& request) const;
 
  template <typename GetTableReplicationRequestT = Model::GetTableReplicationRequest>
  Model::GetTableReplicationOutcomeCallable GetTableReplicationCallable(const GetTableReplicationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableReplication, request);
  }
 
  template <typename GetTableReplicationRequestT = Model::GetTableReplicationRequest>
  void GetTableReplicationAsync(const GetTableReplicationRequestT& request, const GetTableReplicationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableReplication, request, handler, context);
  }
 
  virtual Model::GetTableReplicationStatusOutcome GetTableReplicationStatus(const Model::GetTableReplicationStatusRequest& request) const;
 
  template <typename GetTableReplicationStatusRequestT = Model::GetTableReplicationStatusRequest>
  Model::GetTableReplicationStatusOutcomeCallable GetTableReplicationStatusCallable(
      const GetTableReplicationStatusRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableReplicationStatus, request);
  }
 
  template <typename GetTableReplicationStatusRequestT = Model::GetTableReplicationStatusRequest>
  void GetTableReplicationStatusAsync(const GetTableReplicationStatusRequestT& request,
                                      const GetTableReplicationStatusResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableReplicationStatus, request, handler, context);
  }
 
  virtual Model::GetTableStorageClassOutcome GetTableStorageClass(const Model::GetTableStorageClassRequest& request) const;
 
  template <typename GetTableStorageClassRequestT = Model::GetTableStorageClassRequest>
  Model::GetTableStorageClassOutcomeCallable GetTableStorageClassCallable(const GetTableStorageClassRequestT& request) const {
    return SubmitCallable(&S3TablesClient::GetTableStorageClass, request);
  }
 
  template <typename GetTableStorageClassRequestT = Model::GetTableStorageClassRequest>
  void GetTableStorageClassAsync(const GetTableStorageClassRequestT& request, const GetTableStorageClassResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::GetTableStorageClass, request, handler, context);
  }
 
  virtual Model::ListNamespacesOutcome ListNamespaces(const Model::ListNamespacesRequest& request) const;
 
  template <typename ListNamespacesRequestT = Model::ListNamespacesRequest>
  Model::ListNamespacesOutcomeCallable ListNamespacesCallable(const ListNamespacesRequestT& request) const {
    return SubmitCallable(&S3TablesClient::ListNamespaces, request);
  }
 
  template <typename ListNamespacesRequestT = Model::ListNamespacesRequest>
  void ListNamespacesAsync(const ListNamespacesRequestT& request, const ListNamespacesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::ListNamespaces, request, handler, context);
  }
 
  virtual Model::ListTableBucketsOutcome ListTableBuckets(const Model::ListTableBucketsRequest& request = {}) const;
 
  template <typename ListTableBucketsRequestT = Model::ListTableBucketsRequest>
  Model::ListTableBucketsOutcomeCallable ListTableBucketsCallable(const ListTableBucketsRequestT& request = {}) const {
    return SubmitCallable(&S3TablesClient::ListTableBuckets, request);
  }
 
  template <typename ListTableBucketsRequestT = Model::ListTableBucketsRequest>
  void ListTableBucketsAsync(const ListTableBucketsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListTableBucketsRequestT& request = {}) const {
    return SubmitAsync(&S3TablesClient::ListTableBuckets, request, handler, context);
  }
 
  virtual Model::ListTablesOutcome ListTables(const Model::ListTablesRequest& request) const;
 
  template <typename ListTablesRequestT = Model::ListTablesRequest>
  Model::ListTablesOutcomeCallable ListTablesCallable(const ListTablesRequestT& request) const {
    return SubmitCallable(&S3TablesClient::ListTables, request);
  }
 
  template <typename ListTablesRequestT = Model::ListTablesRequest>
  void ListTablesAsync(const ListTablesRequestT& request, const ListTablesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::ListTables, 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(&S3TablesClient::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(&S3TablesClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutTableBucketEncryptionOutcome PutTableBucketEncryption(const Model::PutTableBucketEncryptionRequest& request) const;
 
  template <typename PutTableBucketEncryptionRequestT = Model::PutTableBucketEncryptionRequest>
  Model::PutTableBucketEncryptionOutcomeCallable PutTableBucketEncryptionCallable(const PutTableBucketEncryptionRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableBucketEncryption, request);
  }
 
  template <typename PutTableBucketEncryptionRequestT = Model::PutTableBucketEncryptionRequest>
  void PutTableBucketEncryptionAsync(const PutTableBucketEncryptionRequestT& request,
                                     const PutTableBucketEncryptionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableBucketEncryption, request, handler, context);
  }
 
  virtual Model::PutTableBucketMaintenanceConfigurationOutcome PutTableBucketMaintenanceConfiguration(
      const Model::PutTableBucketMaintenanceConfigurationRequest& request) const;
 
  template <typename PutTableBucketMaintenanceConfigurationRequestT = Model::PutTableBucketMaintenanceConfigurationRequest>
  Model::PutTableBucketMaintenanceConfigurationOutcomeCallable PutTableBucketMaintenanceConfigurationCallable(
      const PutTableBucketMaintenanceConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableBucketMaintenanceConfiguration, request);
  }
 
  template <typename PutTableBucketMaintenanceConfigurationRequestT = Model::PutTableBucketMaintenanceConfigurationRequest>
  void PutTableBucketMaintenanceConfigurationAsync(const PutTableBucketMaintenanceConfigurationRequestT& request,
                                                   const PutTableBucketMaintenanceConfigurationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableBucketMaintenanceConfiguration, request, handler, context);
  }
 
  virtual Model::PutTableBucketMetricsConfigurationOutcome PutTableBucketMetricsConfiguration(
      const Model::PutTableBucketMetricsConfigurationRequest& request) const;
 
  template <typename PutTableBucketMetricsConfigurationRequestT = Model::PutTableBucketMetricsConfigurationRequest>
  Model::PutTableBucketMetricsConfigurationOutcomeCallable PutTableBucketMetricsConfigurationCallable(
      const PutTableBucketMetricsConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableBucketMetricsConfiguration, request);
  }
 
  template <typename PutTableBucketMetricsConfigurationRequestT = Model::PutTableBucketMetricsConfigurationRequest>
  void PutTableBucketMetricsConfigurationAsync(const PutTableBucketMetricsConfigurationRequestT& request,
                                               const PutTableBucketMetricsConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableBucketMetricsConfiguration, request, handler, context);
  }
 
  virtual Model::PutTableBucketPolicyOutcome PutTableBucketPolicy(const Model::PutTableBucketPolicyRequest& request) const;
 
  template <typename PutTableBucketPolicyRequestT = Model::PutTableBucketPolicyRequest>
  Model::PutTableBucketPolicyOutcomeCallable PutTableBucketPolicyCallable(const PutTableBucketPolicyRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableBucketPolicy, request);
  }
 
  template <typename PutTableBucketPolicyRequestT = Model::PutTableBucketPolicyRequest>
  void PutTableBucketPolicyAsync(const PutTableBucketPolicyRequestT& request, const PutTableBucketPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableBucketPolicy, request, handler, context);
  }
 
  virtual Model::PutTableBucketReplicationOutcome PutTableBucketReplication(const Model::PutTableBucketReplicationRequest& request) const;
 
  template <typename PutTableBucketReplicationRequestT = Model::PutTableBucketReplicationRequest>
  Model::PutTableBucketReplicationOutcomeCallable PutTableBucketReplicationCallable(
      const PutTableBucketReplicationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableBucketReplication, request);
  }
 
  template <typename PutTableBucketReplicationRequestT = Model::PutTableBucketReplicationRequest>
  void PutTableBucketReplicationAsync(const PutTableBucketReplicationRequestT& request,
                                      const PutTableBucketReplicationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableBucketReplication, request, handler, context);
  }
 
  virtual Model::PutTableBucketStorageClassOutcome PutTableBucketStorageClass(
      const Model::PutTableBucketStorageClassRequest& request) const;
 
  template <typename PutTableBucketStorageClassRequestT = Model::PutTableBucketStorageClassRequest>
  Model::PutTableBucketStorageClassOutcomeCallable PutTableBucketStorageClassCallable(
      const PutTableBucketStorageClassRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableBucketStorageClass, request);
  }
 
  template <typename PutTableBucketStorageClassRequestT = Model::PutTableBucketStorageClassRequest>
  void PutTableBucketStorageClassAsync(const PutTableBucketStorageClassRequestT& request,
                                       const PutTableBucketStorageClassResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableBucketStorageClass, request, handler, context);
  }
 
  virtual Model::PutTableMaintenanceConfigurationOutcome PutTableMaintenanceConfiguration(
      const Model::PutTableMaintenanceConfigurationRequest& request) const;
 
  template <typename PutTableMaintenanceConfigurationRequestT = Model::PutTableMaintenanceConfigurationRequest>
  Model::PutTableMaintenanceConfigurationOutcomeCallable PutTableMaintenanceConfigurationCallable(
      const PutTableMaintenanceConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableMaintenanceConfiguration, request);
  }
 
  template <typename PutTableMaintenanceConfigurationRequestT = Model::PutTableMaintenanceConfigurationRequest>
  void PutTableMaintenanceConfigurationAsync(const PutTableMaintenanceConfigurationRequestT& request,
                                             const PutTableMaintenanceConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableMaintenanceConfiguration, request, handler, context);
  }
 
  virtual Model::PutTablePolicyOutcome PutTablePolicy(const Model::PutTablePolicyRequest& request) const;
 
  template <typename PutTablePolicyRequestT = Model::PutTablePolicyRequest>
  Model::PutTablePolicyOutcomeCallable PutTablePolicyCallable(const PutTablePolicyRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTablePolicy, request);
  }
 
  template <typename PutTablePolicyRequestT = Model::PutTablePolicyRequest>
  void PutTablePolicyAsync(const PutTablePolicyRequestT& request, const PutTablePolicyResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTablePolicy, request, handler, context);
  }
 
  virtual Model::PutTableRecordExpirationConfigurationOutcome PutTableRecordExpirationConfiguration(
      const Model::PutTableRecordExpirationConfigurationRequest& request) const;
 
  template <typename PutTableRecordExpirationConfigurationRequestT = Model::PutTableRecordExpirationConfigurationRequest>
  Model::PutTableRecordExpirationConfigurationOutcomeCallable PutTableRecordExpirationConfigurationCallable(
      const PutTableRecordExpirationConfigurationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableRecordExpirationConfiguration, request);
  }
 
  template <typename PutTableRecordExpirationConfigurationRequestT = Model::PutTableRecordExpirationConfigurationRequest>
  void PutTableRecordExpirationConfigurationAsync(const PutTableRecordExpirationConfigurationRequestT& request,
                                                  const PutTableRecordExpirationConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableRecordExpirationConfiguration, request, handler, context);
  }
 
  virtual Model::PutTableReplicationOutcome PutTableReplication(const Model::PutTableReplicationRequest& request) const;
 
  template <typename PutTableReplicationRequestT = Model::PutTableReplicationRequest>
  Model::PutTableReplicationOutcomeCallable PutTableReplicationCallable(const PutTableReplicationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::PutTableReplication, request);
  }
 
  template <typename PutTableReplicationRequestT = Model::PutTableReplicationRequest>
  void PutTableReplicationAsync(const PutTableReplicationRequestT& request, const PutTableReplicationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::PutTableReplication, request, handler, context);
  }
 
  virtual Model::RenameTableOutcome RenameTable(const Model::RenameTableRequest& request) const;
 
  template <typename RenameTableRequestT = Model::RenameTableRequest>
  Model::RenameTableOutcomeCallable RenameTableCallable(const RenameTableRequestT& request) const {
    return SubmitCallable(&S3TablesClient::RenameTable, request);
  }
 
  template <typename RenameTableRequestT = Model::RenameTableRequest>
  void RenameTableAsync(const RenameTableRequestT& request, const RenameTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::RenameTable, 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(&S3TablesClient::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(&S3TablesClient::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(&S3TablesClient::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(&S3TablesClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateTableMetadataLocationOutcome UpdateTableMetadataLocation(
      const Model::UpdateTableMetadataLocationRequest& request) const;
 
  template <typename UpdateTableMetadataLocationRequestT = Model::UpdateTableMetadataLocationRequest>
  Model::UpdateTableMetadataLocationOutcomeCallable UpdateTableMetadataLocationCallable(
      const UpdateTableMetadataLocationRequestT& request) const {
    return SubmitCallable(&S3TablesClient::UpdateTableMetadataLocation, request);
  }
 
  template <typename UpdateTableMetadataLocationRequestT = Model::UpdateTableMetadataLocationRequest>
  void UpdateTableMetadataLocationAsync(const UpdateTableMetadataLocationRequestT& request,
                                        const UpdateTableMetadataLocationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3TablesClient::UpdateTableMetadataLocation, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<S3TablesEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<S3TablesClient>;
  void init(const S3TablesClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, S3TablesError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  S3TablesClientConfiguration m_clientConfiguration;
  std::shared_ptr<S3TablesEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace S3Tables
}  // namespace Aws