S3TablesClient.h

 
#pragma once
#include <aws/s3tables/S3Tables_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/s3tables/S3TablesServiceClientModel.h>
 
namespace Aws
{
namespace S3Tables
{
  class AWS_S3TABLES_API S3TablesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<S3TablesEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<S3TablesClient>;
      void init(const S3TablesClientConfiguration& clientConfiguration);
 
      S3TablesClientConfiguration m_clientConfiguration;
      std::shared_ptr<S3TablesEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace S3Tables
} // namespace Aws