LakeFormationClient.h

 
#pragma once
#include <aws/lakeformation/LakeFormation_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/lakeformation/LakeFormationServiceClientModel.h>
 
namespace Aws
{
namespace LakeFormation
{
  class AWS_LAKEFORMATION_API LakeFormationClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<LakeFormationClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef LakeFormationClientConfiguration ClientConfigurationType;
      typedef LakeFormationEndpointProvider EndpointProviderType;
 
        LakeFormationClient(const Aws::LakeFormation::LakeFormationClientConfiguration& clientConfiguration = Aws::LakeFormation::LakeFormationClientConfiguration(),
                            std::shared_ptr<LakeFormationEndpointProviderBase> endpointProvider = nullptr);
 
        LakeFormationClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<LakeFormationEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::LakeFormation::LakeFormationClientConfiguration& clientConfiguration = Aws::LakeFormation::LakeFormationClientConfiguration());
 
        LakeFormationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<LakeFormationEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::LakeFormation::LakeFormationClientConfiguration& clientConfiguration = Aws::LakeFormation::LakeFormationClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        LakeFormationClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LakeFormationClient(const Aws::Auth::AWSCredentials& credentials,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LakeFormationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~LakeFormationClient();
 
        virtual Model::AddLFTagsToResourceOutcome AddLFTagsToResource(const Model::AddLFTagsToResourceRequest& request) const;
 
        template<typename AddLFTagsToResourceRequestT = Model::AddLFTagsToResourceRequest>
        Model::AddLFTagsToResourceOutcomeCallable AddLFTagsToResourceCallable(const AddLFTagsToResourceRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::AddLFTagsToResource, request);
        }
 
        template<typename AddLFTagsToResourceRequestT = Model::AddLFTagsToResourceRequest>
        void AddLFTagsToResourceAsync(const AddLFTagsToResourceRequestT& request, const AddLFTagsToResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::AddLFTagsToResource, request, handler, context);
        }
 
        virtual Model::AssumeDecoratedRoleWithSAMLOutcome AssumeDecoratedRoleWithSAML(const Model::AssumeDecoratedRoleWithSAMLRequest& request) const;
 
        template<typename AssumeDecoratedRoleWithSAMLRequestT = Model::AssumeDecoratedRoleWithSAMLRequest>
        Model::AssumeDecoratedRoleWithSAMLOutcomeCallable AssumeDecoratedRoleWithSAMLCallable(const AssumeDecoratedRoleWithSAMLRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::AssumeDecoratedRoleWithSAML, request);
        }
 
        template<typename AssumeDecoratedRoleWithSAMLRequestT = Model::AssumeDecoratedRoleWithSAMLRequest>
        void AssumeDecoratedRoleWithSAMLAsync(const AssumeDecoratedRoleWithSAMLRequestT& request, const AssumeDecoratedRoleWithSAMLResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::AssumeDecoratedRoleWithSAML, request, handler, context);
        }
 
        virtual Model::BatchGrantPermissionsOutcome BatchGrantPermissions(const Model::BatchGrantPermissionsRequest& request) const;
 
        template<typename BatchGrantPermissionsRequestT = Model::BatchGrantPermissionsRequest>
        Model::BatchGrantPermissionsOutcomeCallable BatchGrantPermissionsCallable(const BatchGrantPermissionsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::BatchGrantPermissions, request);
        }
 
        template<typename BatchGrantPermissionsRequestT = Model::BatchGrantPermissionsRequest>
        void BatchGrantPermissionsAsync(const BatchGrantPermissionsRequestT& request, const BatchGrantPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::BatchGrantPermissions, request, handler, context);
        }
 
        virtual Model::BatchRevokePermissionsOutcome BatchRevokePermissions(const Model::BatchRevokePermissionsRequest& request) const;
 
        template<typename BatchRevokePermissionsRequestT = Model::BatchRevokePermissionsRequest>
        Model::BatchRevokePermissionsOutcomeCallable BatchRevokePermissionsCallable(const BatchRevokePermissionsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::BatchRevokePermissions, request);
        }
 
        template<typename BatchRevokePermissionsRequestT = Model::BatchRevokePermissionsRequest>
        void BatchRevokePermissionsAsync(const BatchRevokePermissionsRequestT& request, const BatchRevokePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::BatchRevokePermissions, request, handler, context);
        }
 
        virtual Model::CancelTransactionOutcome CancelTransaction(const Model::CancelTransactionRequest& request) const;
 
        template<typename CancelTransactionRequestT = Model::CancelTransactionRequest>
        Model::CancelTransactionOutcomeCallable CancelTransactionCallable(const CancelTransactionRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::CancelTransaction, request);
        }
 
        template<typename CancelTransactionRequestT = Model::CancelTransactionRequest>
        void CancelTransactionAsync(const CancelTransactionRequestT& request, const CancelTransactionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::CancelTransaction, request, handler, context);
        }
 
        virtual Model::CommitTransactionOutcome CommitTransaction(const Model::CommitTransactionRequest& request) const;
 
        template<typename CommitTransactionRequestT = Model::CommitTransactionRequest>
        Model::CommitTransactionOutcomeCallable CommitTransactionCallable(const CommitTransactionRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::CommitTransaction, request);
        }
 
        template<typename CommitTransactionRequestT = Model::CommitTransactionRequest>
        void CommitTransactionAsync(const CommitTransactionRequestT& request, const CommitTransactionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::CommitTransaction, request, handler, context);
        }
 
        virtual Model::CreateDataCellsFilterOutcome CreateDataCellsFilter(const Model::CreateDataCellsFilterRequest& request) const;
 
        template<typename CreateDataCellsFilterRequestT = Model::CreateDataCellsFilterRequest>
        Model::CreateDataCellsFilterOutcomeCallable CreateDataCellsFilterCallable(const CreateDataCellsFilterRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::CreateDataCellsFilter, request);
        }
 
        template<typename CreateDataCellsFilterRequestT = Model::CreateDataCellsFilterRequest>
        void CreateDataCellsFilterAsync(const CreateDataCellsFilterRequestT& request, const CreateDataCellsFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::CreateDataCellsFilter, request, handler, context);
        }
 
        virtual Model::CreateLFTagOutcome CreateLFTag(const Model::CreateLFTagRequest& request) const;
 
        template<typename CreateLFTagRequestT = Model::CreateLFTagRequest>
        Model::CreateLFTagOutcomeCallable CreateLFTagCallable(const CreateLFTagRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::CreateLFTag, request);
        }
 
        template<typename CreateLFTagRequestT = Model::CreateLFTagRequest>
        void CreateLFTagAsync(const CreateLFTagRequestT& request, const CreateLFTagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::CreateLFTag, request, handler, context);
        }
 
        virtual Model::CreateLFTagExpressionOutcome CreateLFTagExpression(const Model::CreateLFTagExpressionRequest& request) const;
 
        template<typename CreateLFTagExpressionRequestT = Model::CreateLFTagExpressionRequest>
        Model::CreateLFTagExpressionOutcomeCallable CreateLFTagExpressionCallable(const CreateLFTagExpressionRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::CreateLFTagExpression, request);
        }
 
        template<typename CreateLFTagExpressionRequestT = Model::CreateLFTagExpressionRequest>
        void CreateLFTagExpressionAsync(const CreateLFTagExpressionRequestT& request, const CreateLFTagExpressionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::CreateLFTagExpression, request, handler, context);
        }
 
        virtual Model::CreateLakeFormationIdentityCenterConfigurationOutcome CreateLakeFormationIdentityCenterConfiguration(const Model::CreateLakeFormationIdentityCenterConfigurationRequest& request = {}) const;
 
        template<typename CreateLakeFormationIdentityCenterConfigurationRequestT = Model::CreateLakeFormationIdentityCenterConfigurationRequest>
        Model::CreateLakeFormationIdentityCenterConfigurationOutcomeCallable CreateLakeFormationIdentityCenterConfigurationCallable(const CreateLakeFormationIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::CreateLakeFormationIdentityCenterConfiguration, request);
        }
 
        template<typename CreateLakeFormationIdentityCenterConfigurationRequestT = Model::CreateLakeFormationIdentityCenterConfigurationRequest>
        void CreateLakeFormationIdentityCenterConfigurationAsync(const CreateLakeFormationIdentityCenterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateLakeFormationIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::CreateLakeFormationIdentityCenterConfiguration, request, handler, context);
        }
 
        virtual Model::CreateLakeFormationOptInOutcome CreateLakeFormationOptIn(const Model::CreateLakeFormationOptInRequest& request) const;
 
        template<typename CreateLakeFormationOptInRequestT = Model::CreateLakeFormationOptInRequest>
        Model::CreateLakeFormationOptInOutcomeCallable CreateLakeFormationOptInCallable(const CreateLakeFormationOptInRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::CreateLakeFormationOptIn, request);
        }
 
        template<typename CreateLakeFormationOptInRequestT = Model::CreateLakeFormationOptInRequest>
        void CreateLakeFormationOptInAsync(const CreateLakeFormationOptInRequestT& request, const CreateLakeFormationOptInResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::CreateLakeFormationOptIn, request, handler, context);
        }
 
        virtual Model::DeleteDataCellsFilterOutcome DeleteDataCellsFilter(const Model::DeleteDataCellsFilterRequest& request = {}) const;
 
        template<typename DeleteDataCellsFilterRequestT = Model::DeleteDataCellsFilterRequest>
        Model::DeleteDataCellsFilterOutcomeCallable DeleteDataCellsFilterCallable(const DeleteDataCellsFilterRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::DeleteDataCellsFilter, request);
        }
 
        template<typename DeleteDataCellsFilterRequestT = Model::DeleteDataCellsFilterRequest>
        void DeleteDataCellsFilterAsync(const DeleteDataCellsFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteDataCellsFilterRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::DeleteDataCellsFilter, request, handler, context);
        }
 
        virtual Model::DeleteLFTagOutcome DeleteLFTag(const Model::DeleteLFTagRequest& request) const;
 
        template<typename DeleteLFTagRequestT = Model::DeleteLFTagRequest>
        Model::DeleteLFTagOutcomeCallable DeleteLFTagCallable(const DeleteLFTagRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::DeleteLFTag, request);
        }
 
        template<typename DeleteLFTagRequestT = Model::DeleteLFTagRequest>
        void DeleteLFTagAsync(const DeleteLFTagRequestT& request, const DeleteLFTagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::DeleteLFTag, request, handler, context);
        }
 
        virtual Model::DeleteLFTagExpressionOutcome DeleteLFTagExpression(const Model::DeleteLFTagExpressionRequest& request) const;
 
        template<typename DeleteLFTagExpressionRequestT = Model::DeleteLFTagExpressionRequest>
        Model::DeleteLFTagExpressionOutcomeCallable DeleteLFTagExpressionCallable(const DeleteLFTagExpressionRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::DeleteLFTagExpression, request);
        }
 
        template<typename DeleteLFTagExpressionRequestT = Model::DeleteLFTagExpressionRequest>
        void DeleteLFTagExpressionAsync(const DeleteLFTagExpressionRequestT& request, const DeleteLFTagExpressionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::DeleteLFTagExpression, request, handler, context);
        }
 
        virtual Model::DeleteLakeFormationIdentityCenterConfigurationOutcome DeleteLakeFormationIdentityCenterConfiguration(const Model::DeleteLakeFormationIdentityCenterConfigurationRequest& request = {}) const;
 
        template<typename DeleteLakeFormationIdentityCenterConfigurationRequestT = Model::DeleteLakeFormationIdentityCenterConfigurationRequest>
        Model::DeleteLakeFormationIdentityCenterConfigurationOutcomeCallable DeleteLakeFormationIdentityCenterConfigurationCallable(const DeleteLakeFormationIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::DeleteLakeFormationIdentityCenterConfiguration, request);
        }
 
        template<typename DeleteLakeFormationIdentityCenterConfigurationRequestT = Model::DeleteLakeFormationIdentityCenterConfigurationRequest>
        void DeleteLakeFormationIdentityCenterConfigurationAsync(const DeleteLakeFormationIdentityCenterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteLakeFormationIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::DeleteLakeFormationIdentityCenterConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteLakeFormationOptInOutcome DeleteLakeFormationOptIn(const Model::DeleteLakeFormationOptInRequest& request) const;
 
        template<typename DeleteLakeFormationOptInRequestT = Model::DeleteLakeFormationOptInRequest>
        Model::DeleteLakeFormationOptInOutcomeCallable DeleteLakeFormationOptInCallable(const DeleteLakeFormationOptInRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::DeleteLakeFormationOptIn, request);
        }
 
        template<typename DeleteLakeFormationOptInRequestT = Model::DeleteLakeFormationOptInRequest>
        void DeleteLakeFormationOptInAsync(const DeleteLakeFormationOptInRequestT& request, const DeleteLakeFormationOptInResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::DeleteLakeFormationOptIn, request, handler, context);
        }
 
        virtual Model::DeleteObjectsOnCancelOutcome DeleteObjectsOnCancel(const Model::DeleteObjectsOnCancelRequest& request) const;
 
        template<typename DeleteObjectsOnCancelRequestT = Model::DeleteObjectsOnCancelRequest>
        Model::DeleteObjectsOnCancelOutcomeCallable DeleteObjectsOnCancelCallable(const DeleteObjectsOnCancelRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::DeleteObjectsOnCancel, request);
        }
 
        template<typename DeleteObjectsOnCancelRequestT = Model::DeleteObjectsOnCancelRequest>
        void DeleteObjectsOnCancelAsync(const DeleteObjectsOnCancelRequestT& request, const DeleteObjectsOnCancelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::DeleteObjectsOnCancel, request, handler, context);
        }
 
        virtual Model::DeregisterResourceOutcome DeregisterResource(const Model::DeregisterResourceRequest& request) const;
 
        template<typename DeregisterResourceRequestT = Model::DeregisterResourceRequest>
        Model::DeregisterResourceOutcomeCallable DeregisterResourceCallable(const DeregisterResourceRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::DeregisterResource, request);
        }
 
        template<typename DeregisterResourceRequestT = Model::DeregisterResourceRequest>
        void DeregisterResourceAsync(const DeregisterResourceRequestT& request, const DeregisterResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::DeregisterResource, request, handler, context);
        }
 
        virtual Model::DescribeLakeFormationIdentityCenterConfigurationOutcome DescribeLakeFormationIdentityCenterConfiguration(const Model::DescribeLakeFormationIdentityCenterConfigurationRequest& request = {}) const;
 
        template<typename DescribeLakeFormationIdentityCenterConfigurationRequestT = Model::DescribeLakeFormationIdentityCenterConfigurationRequest>
        Model::DescribeLakeFormationIdentityCenterConfigurationOutcomeCallable DescribeLakeFormationIdentityCenterConfigurationCallable(const DescribeLakeFormationIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::DescribeLakeFormationIdentityCenterConfiguration, request);
        }
 
        template<typename DescribeLakeFormationIdentityCenterConfigurationRequestT = Model::DescribeLakeFormationIdentityCenterConfigurationRequest>
        void DescribeLakeFormationIdentityCenterConfigurationAsync(const DescribeLakeFormationIdentityCenterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLakeFormationIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::DescribeLakeFormationIdentityCenterConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeResourceOutcome DescribeResource(const Model::DescribeResourceRequest& request) const;
 
        template<typename DescribeResourceRequestT = Model::DescribeResourceRequest>
        Model::DescribeResourceOutcomeCallable DescribeResourceCallable(const DescribeResourceRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::DescribeResource, request);
        }
 
        template<typename DescribeResourceRequestT = Model::DescribeResourceRequest>
        void DescribeResourceAsync(const DescribeResourceRequestT& request, const DescribeResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::DescribeResource, request, handler, context);
        }
 
        virtual Model::DescribeTransactionOutcome DescribeTransaction(const Model::DescribeTransactionRequest& request) const;
 
        template<typename DescribeTransactionRequestT = Model::DescribeTransactionRequest>
        Model::DescribeTransactionOutcomeCallable DescribeTransactionCallable(const DescribeTransactionRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::DescribeTransaction, request);
        }
 
        template<typename DescribeTransactionRequestT = Model::DescribeTransactionRequest>
        void DescribeTransactionAsync(const DescribeTransactionRequestT& request, const DescribeTransactionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::DescribeTransaction, request, handler, context);
        }
 
        virtual Model::ExtendTransactionOutcome ExtendTransaction(const Model::ExtendTransactionRequest& request = {}) const;
 
        template<typename ExtendTransactionRequestT = Model::ExtendTransactionRequest>
        Model::ExtendTransactionOutcomeCallable ExtendTransactionCallable(const ExtendTransactionRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::ExtendTransaction, request);
        }
 
        template<typename ExtendTransactionRequestT = Model::ExtendTransactionRequest>
        void ExtendTransactionAsync(const ExtendTransactionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ExtendTransactionRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::ExtendTransaction, request, handler, context);
        }
 
        virtual Model::GetDataCellsFilterOutcome GetDataCellsFilter(const Model::GetDataCellsFilterRequest& request) const;
 
        template<typename GetDataCellsFilterRequestT = Model::GetDataCellsFilterRequest>
        Model::GetDataCellsFilterOutcomeCallable GetDataCellsFilterCallable(const GetDataCellsFilterRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetDataCellsFilter, request);
        }
 
        template<typename GetDataCellsFilterRequestT = Model::GetDataCellsFilterRequest>
        void GetDataCellsFilterAsync(const GetDataCellsFilterRequestT& request, const GetDataCellsFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetDataCellsFilter, request, handler, context);
        }
 
        virtual Model::GetDataLakePrincipalOutcome GetDataLakePrincipal(const Model::GetDataLakePrincipalRequest& request = {}) const;
 
        template<typename GetDataLakePrincipalRequestT = Model::GetDataLakePrincipalRequest>
        Model::GetDataLakePrincipalOutcomeCallable GetDataLakePrincipalCallable(const GetDataLakePrincipalRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::GetDataLakePrincipal, request);
        }
 
        template<typename GetDataLakePrincipalRequestT = Model::GetDataLakePrincipalRequest>
        void GetDataLakePrincipalAsync(const GetDataLakePrincipalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDataLakePrincipalRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::GetDataLakePrincipal, request, handler, context);
        }
 
        virtual Model::GetDataLakeSettingsOutcome GetDataLakeSettings(const Model::GetDataLakeSettingsRequest& request = {}) const;
 
        template<typename GetDataLakeSettingsRequestT = Model::GetDataLakeSettingsRequest>
        Model::GetDataLakeSettingsOutcomeCallable GetDataLakeSettingsCallable(const GetDataLakeSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::GetDataLakeSettings, request);
        }
 
        template<typename GetDataLakeSettingsRequestT = Model::GetDataLakeSettingsRequest>
        void GetDataLakeSettingsAsync(const GetDataLakeSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDataLakeSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::GetDataLakeSettings, request, handler, context);
        }
 
        virtual Model::GetEffectivePermissionsForPathOutcome GetEffectivePermissionsForPath(const Model::GetEffectivePermissionsForPathRequest& request) const;
 
        template<typename GetEffectivePermissionsForPathRequestT = Model::GetEffectivePermissionsForPathRequest>
        Model::GetEffectivePermissionsForPathOutcomeCallable GetEffectivePermissionsForPathCallable(const GetEffectivePermissionsForPathRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetEffectivePermissionsForPath, request);
        }
 
        template<typename GetEffectivePermissionsForPathRequestT = Model::GetEffectivePermissionsForPathRequest>
        void GetEffectivePermissionsForPathAsync(const GetEffectivePermissionsForPathRequestT& request, const GetEffectivePermissionsForPathResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetEffectivePermissionsForPath, request, handler, context);
        }
 
        virtual Model::GetLFTagOutcome GetLFTag(const Model::GetLFTagRequest& request) const;
 
        template<typename GetLFTagRequestT = Model::GetLFTagRequest>
        Model::GetLFTagOutcomeCallable GetLFTagCallable(const GetLFTagRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetLFTag, request);
        }
 
        template<typename GetLFTagRequestT = Model::GetLFTagRequest>
        void GetLFTagAsync(const GetLFTagRequestT& request, const GetLFTagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetLFTag, request, handler, context);
        }
 
        virtual Model::GetLFTagExpressionOutcome GetLFTagExpression(const Model::GetLFTagExpressionRequest& request) const;
 
        template<typename GetLFTagExpressionRequestT = Model::GetLFTagExpressionRequest>
        Model::GetLFTagExpressionOutcomeCallable GetLFTagExpressionCallable(const GetLFTagExpressionRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetLFTagExpression, request);
        }
 
        template<typename GetLFTagExpressionRequestT = Model::GetLFTagExpressionRequest>
        void GetLFTagExpressionAsync(const GetLFTagExpressionRequestT& request, const GetLFTagExpressionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetLFTagExpression, request, handler, context);
        }
 
        virtual Model::GetQueryStateOutcome GetQueryState(const Model::GetQueryStateRequest& request) const;
 
        template<typename GetQueryStateRequestT = Model::GetQueryStateRequest>
        Model::GetQueryStateOutcomeCallable GetQueryStateCallable(const GetQueryStateRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetQueryState, request);
        }
 
        template<typename GetQueryStateRequestT = Model::GetQueryStateRequest>
        void GetQueryStateAsync(const GetQueryStateRequestT& request, const GetQueryStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetQueryState, request, handler, context);
        }
 
        virtual Model::GetQueryStatisticsOutcome GetQueryStatistics(const Model::GetQueryStatisticsRequest& request) const;
 
        template<typename GetQueryStatisticsRequestT = Model::GetQueryStatisticsRequest>
        Model::GetQueryStatisticsOutcomeCallable GetQueryStatisticsCallable(const GetQueryStatisticsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetQueryStatistics, request);
        }
 
        template<typename GetQueryStatisticsRequestT = Model::GetQueryStatisticsRequest>
        void GetQueryStatisticsAsync(const GetQueryStatisticsRequestT& request, const GetQueryStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetQueryStatistics, request, handler, context);
        }
 
        virtual Model::GetResourceLFTagsOutcome GetResourceLFTags(const Model::GetResourceLFTagsRequest& request) const;
 
        template<typename GetResourceLFTagsRequestT = Model::GetResourceLFTagsRequest>
        Model::GetResourceLFTagsOutcomeCallable GetResourceLFTagsCallable(const GetResourceLFTagsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetResourceLFTags, request);
        }
 
        template<typename GetResourceLFTagsRequestT = Model::GetResourceLFTagsRequest>
        void GetResourceLFTagsAsync(const GetResourceLFTagsRequestT& request, const GetResourceLFTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetResourceLFTags, request, handler, context);
        }
 
        virtual Model::GetTableObjectsOutcome GetTableObjects(const Model::GetTableObjectsRequest& request) const;
 
        template<typename GetTableObjectsRequestT = Model::GetTableObjectsRequest>
        Model::GetTableObjectsOutcomeCallable GetTableObjectsCallable(const GetTableObjectsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetTableObjects, request);
        }
 
        template<typename GetTableObjectsRequestT = Model::GetTableObjectsRequest>
        void GetTableObjectsAsync(const GetTableObjectsRequestT& request, const GetTableObjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetTableObjects, request, handler, context);
        }
 
        virtual Model::GetTemporaryGluePartitionCredentialsOutcome GetTemporaryGluePartitionCredentials(const Model::GetTemporaryGluePartitionCredentialsRequest& request) const;
 
        template<typename GetTemporaryGluePartitionCredentialsRequestT = Model::GetTemporaryGluePartitionCredentialsRequest>
        Model::GetTemporaryGluePartitionCredentialsOutcomeCallable GetTemporaryGluePartitionCredentialsCallable(const GetTemporaryGluePartitionCredentialsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetTemporaryGluePartitionCredentials, request);
        }
 
        template<typename GetTemporaryGluePartitionCredentialsRequestT = Model::GetTemporaryGluePartitionCredentialsRequest>
        void GetTemporaryGluePartitionCredentialsAsync(const GetTemporaryGluePartitionCredentialsRequestT& request, const GetTemporaryGluePartitionCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetTemporaryGluePartitionCredentials, request, handler, context);
        }
 
        virtual Model::GetTemporaryGlueTableCredentialsOutcome GetTemporaryGlueTableCredentials(const Model::GetTemporaryGlueTableCredentialsRequest& request) const;
 
        template<typename GetTemporaryGlueTableCredentialsRequestT = Model::GetTemporaryGlueTableCredentialsRequest>
        Model::GetTemporaryGlueTableCredentialsOutcomeCallable GetTemporaryGlueTableCredentialsCallable(const GetTemporaryGlueTableCredentialsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetTemporaryGlueTableCredentials, request);
        }
 
        template<typename GetTemporaryGlueTableCredentialsRequestT = Model::GetTemporaryGlueTableCredentialsRequest>
        void GetTemporaryGlueTableCredentialsAsync(const GetTemporaryGlueTableCredentialsRequestT& request, const GetTemporaryGlueTableCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetTemporaryGlueTableCredentials, request, handler, context);
        }
 
        virtual Model::GetWorkUnitResultsOutcome GetWorkUnitResults(const Model::GetWorkUnitResultsRequest& request) const;
 
        template<typename GetWorkUnitResultsRequestT = Model::GetWorkUnitResultsRequest>
        Model::GetWorkUnitResultsOutcomeCallable GetWorkUnitResultsCallable(const GetWorkUnitResultsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetWorkUnitResults, request);
        }
 
        template<typename GetWorkUnitResultsRequestT = Model::GetWorkUnitResultsRequest>
        void GetWorkUnitResultsAsync(const GetWorkUnitResultsRequestT& request, const GetWorkUnitResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetWorkUnitResults, request, handler, context);
        }
 
        virtual Model::GetWorkUnitsOutcome GetWorkUnits(const Model::GetWorkUnitsRequest& request) const;
 
        template<typename GetWorkUnitsRequestT = Model::GetWorkUnitsRequest>
        Model::GetWorkUnitsOutcomeCallable GetWorkUnitsCallable(const GetWorkUnitsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GetWorkUnits, request);
        }
 
        template<typename GetWorkUnitsRequestT = Model::GetWorkUnitsRequest>
        void GetWorkUnitsAsync(const GetWorkUnitsRequestT& request, const GetWorkUnitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GetWorkUnits, request, handler, context);
        }
 
        virtual Model::GrantPermissionsOutcome GrantPermissions(const Model::GrantPermissionsRequest& request) const;
 
        template<typename GrantPermissionsRequestT = Model::GrantPermissionsRequest>
        Model::GrantPermissionsOutcomeCallable GrantPermissionsCallable(const GrantPermissionsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::GrantPermissions, request);
        }
 
        template<typename GrantPermissionsRequestT = Model::GrantPermissionsRequest>
        void GrantPermissionsAsync(const GrantPermissionsRequestT& request, const GrantPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::GrantPermissions, request, handler, context);
        }
 
        virtual Model::ListDataCellsFilterOutcome ListDataCellsFilter(const Model::ListDataCellsFilterRequest& request = {}) const;
 
        template<typename ListDataCellsFilterRequestT = Model::ListDataCellsFilterRequest>
        Model::ListDataCellsFilterOutcomeCallable ListDataCellsFilterCallable(const ListDataCellsFilterRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::ListDataCellsFilter, request);
        }
 
        template<typename ListDataCellsFilterRequestT = Model::ListDataCellsFilterRequest>
        void ListDataCellsFilterAsync(const ListDataCellsFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataCellsFilterRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::ListDataCellsFilter, request, handler, context);
        }
 
        virtual Model::ListLFTagExpressionsOutcome ListLFTagExpressions(const Model::ListLFTagExpressionsRequest& request = {}) const;
 
        template<typename ListLFTagExpressionsRequestT = Model::ListLFTagExpressionsRequest>
        Model::ListLFTagExpressionsOutcomeCallable ListLFTagExpressionsCallable(const ListLFTagExpressionsRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::ListLFTagExpressions, request);
        }
 
        template<typename ListLFTagExpressionsRequestT = Model::ListLFTagExpressionsRequest>
        void ListLFTagExpressionsAsync(const ListLFTagExpressionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLFTagExpressionsRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::ListLFTagExpressions, request, handler, context);
        }
 
        virtual Model::ListLFTagsOutcome ListLFTags(const Model::ListLFTagsRequest& request = {}) const;
 
        template<typename ListLFTagsRequestT = Model::ListLFTagsRequest>
        Model::ListLFTagsOutcomeCallable ListLFTagsCallable(const ListLFTagsRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::ListLFTags, request);
        }
 
        template<typename ListLFTagsRequestT = Model::ListLFTagsRequest>
        void ListLFTagsAsync(const ListLFTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLFTagsRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::ListLFTags, request, handler, context);
        }
 
        virtual Model::ListLakeFormationOptInsOutcome ListLakeFormationOptIns(const Model::ListLakeFormationOptInsRequest& request = {}) const;
 
        template<typename ListLakeFormationOptInsRequestT = Model::ListLakeFormationOptInsRequest>
        Model::ListLakeFormationOptInsOutcomeCallable ListLakeFormationOptInsCallable(const ListLakeFormationOptInsRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::ListLakeFormationOptIns, request);
        }
 
        template<typename ListLakeFormationOptInsRequestT = Model::ListLakeFormationOptInsRequest>
        void ListLakeFormationOptInsAsync(const ListLakeFormationOptInsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLakeFormationOptInsRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::ListLakeFormationOptIns, request, handler, context);
        }
 
        virtual Model::ListPermissionsOutcome ListPermissions(const Model::ListPermissionsRequest& request = {}) const;
 
        template<typename ListPermissionsRequestT = Model::ListPermissionsRequest>
        Model::ListPermissionsOutcomeCallable ListPermissionsCallable(const ListPermissionsRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::ListPermissions, request);
        }
 
        template<typename ListPermissionsRequestT = Model::ListPermissionsRequest>
        void ListPermissionsAsync(const ListPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPermissionsRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::ListPermissions, request, handler, context);
        }
 
        virtual Model::ListResourcesOutcome ListResources(const Model::ListResourcesRequest& request = {}) const;
 
        template<typename ListResourcesRequestT = Model::ListResourcesRequest>
        Model::ListResourcesOutcomeCallable ListResourcesCallable(const ListResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::ListResources, request);
        }
 
        template<typename ListResourcesRequestT = Model::ListResourcesRequest>
        void ListResourcesAsync(const ListResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::ListResources, request, handler, context);
        }
 
        virtual Model::ListTableStorageOptimizersOutcome ListTableStorageOptimizers(const Model::ListTableStorageOptimizersRequest& request) const;
 
        template<typename ListTableStorageOptimizersRequestT = Model::ListTableStorageOptimizersRequest>
        Model::ListTableStorageOptimizersOutcomeCallable ListTableStorageOptimizersCallable(const ListTableStorageOptimizersRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::ListTableStorageOptimizers, request);
        }
 
        template<typename ListTableStorageOptimizersRequestT = Model::ListTableStorageOptimizersRequest>
        void ListTableStorageOptimizersAsync(const ListTableStorageOptimizersRequestT& request, const ListTableStorageOptimizersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::ListTableStorageOptimizers, request, handler, context);
        }
 
        virtual Model::ListTransactionsOutcome ListTransactions(const Model::ListTransactionsRequest& request = {}) const;
 
        template<typename ListTransactionsRequestT = Model::ListTransactionsRequest>
        Model::ListTransactionsOutcomeCallable ListTransactionsCallable(const ListTransactionsRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::ListTransactions, request);
        }
 
        template<typename ListTransactionsRequestT = Model::ListTransactionsRequest>
        void ListTransactionsAsync(const ListTransactionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTransactionsRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::ListTransactions, request, handler, context);
        }
 
        virtual Model::PutDataLakeSettingsOutcome PutDataLakeSettings(const Model::PutDataLakeSettingsRequest& request) const;
 
        template<typename PutDataLakeSettingsRequestT = Model::PutDataLakeSettingsRequest>
        Model::PutDataLakeSettingsOutcomeCallable PutDataLakeSettingsCallable(const PutDataLakeSettingsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::PutDataLakeSettings, request);
        }
 
        template<typename PutDataLakeSettingsRequestT = Model::PutDataLakeSettingsRequest>
        void PutDataLakeSettingsAsync(const PutDataLakeSettingsRequestT& request, const PutDataLakeSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::PutDataLakeSettings, request, handler, context);
        }
 
        virtual Model::RegisterResourceOutcome RegisterResource(const Model::RegisterResourceRequest& request) const;
 
        template<typename RegisterResourceRequestT = Model::RegisterResourceRequest>
        Model::RegisterResourceOutcomeCallable RegisterResourceCallable(const RegisterResourceRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::RegisterResource, request);
        }
 
        template<typename RegisterResourceRequestT = Model::RegisterResourceRequest>
        void RegisterResourceAsync(const RegisterResourceRequestT& request, const RegisterResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::RegisterResource, request, handler, context);
        }
 
        virtual Model::RemoveLFTagsFromResourceOutcome RemoveLFTagsFromResource(const Model::RemoveLFTagsFromResourceRequest& request) const;
 
        template<typename RemoveLFTagsFromResourceRequestT = Model::RemoveLFTagsFromResourceRequest>
        Model::RemoveLFTagsFromResourceOutcomeCallable RemoveLFTagsFromResourceCallable(const RemoveLFTagsFromResourceRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::RemoveLFTagsFromResource, request);
        }
 
        template<typename RemoveLFTagsFromResourceRequestT = Model::RemoveLFTagsFromResourceRequest>
        void RemoveLFTagsFromResourceAsync(const RemoveLFTagsFromResourceRequestT& request, const RemoveLFTagsFromResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::RemoveLFTagsFromResource, request, handler, context);
        }
 
        virtual Model::RevokePermissionsOutcome RevokePermissions(const Model::RevokePermissionsRequest& request) const;
 
        template<typename RevokePermissionsRequestT = Model::RevokePermissionsRequest>
        Model::RevokePermissionsOutcomeCallable RevokePermissionsCallable(const RevokePermissionsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::RevokePermissions, request);
        }
 
        template<typename RevokePermissionsRequestT = Model::RevokePermissionsRequest>
        void RevokePermissionsAsync(const RevokePermissionsRequestT& request, const RevokePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::RevokePermissions, request, handler, context);
        }
 
        virtual Model::SearchDatabasesByLFTagsOutcome SearchDatabasesByLFTags(const Model::SearchDatabasesByLFTagsRequest& request) const;
 
        template<typename SearchDatabasesByLFTagsRequestT = Model::SearchDatabasesByLFTagsRequest>
        Model::SearchDatabasesByLFTagsOutcomeCallable SearchDatabasesByLFTagsCallable(const SearchDatabasesByLFTagsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::SearchDatabasesByLFTags, request);
        }
 
        template<typename SearchDatabasesByLFTagsRequestT = Model::SearchDatabasesByLFTagsRequest>
        void SearchDatabasesByLFTagsAsync(const SearchDatabasesByLFTagsRequestT& request, const SearchDatabasesByLFTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::SearchDatabasesByLFTags, request, handler, context);
        }
 
        virtual Model::SearchTablesByLFTagsOutcome SearchTablesByLFTags(const Model::SearchTablesByLFTagsRequest& request) const;
 
        template<typename SearchTablesByLFTagsRequestT = Model::SearchTablesByLFTagsRequest>
        Model::SearchTablesByLFTagsOutcomeCallable SearchTablesByLFTagsCallable(const SearchTablesByLFTagsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::SearchTablesByLFTags, request);
        }
 
        template<typename SearchTablesByLFTagsRequestT = Model::SearchTablesByLFTagsRequest>
        void SearchTablesByLFTagsAsync(const SearchTablesByLFTagsRequestT& request, const SearchTablesByLFTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::SearchTablesByLFTags, request, handler, context);
        }
 
        virtual Model::StartQueryPlanningOutcome StartQueryPlanning(const Model::StartQueryPlanningRequest& request) const;
 
        template<typename StartQueryPlanningRequestT = Model::StartQueryPlanningRequest>
        Model::StartQueryPlanningOutcomeCallable StartQueryPlanningCallable(const StartQueryPlanningRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::StartQueryPlanning, request);
        }
 
        template<typename StartQueryPlanningRequestT = Model::StartQueryPlanningRequest>
        void StartQueryPlanningAsync(const StartQueryPlanningRequestT& request, const StartQueryPlanningResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::StartQueryPlanning, request, handler, context);
        }
 
        virtual Model::StartTransactionOutcome StartTransaction(const Model::StartTransactionRequest& request = {}) const;
 
        template<typename StartTransactionRequestT = Model::StartTransactionRequest>
        Model::StartTransactionOutcomeCallable StartTransactionCallable(const StartTransactionRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::StartTransaction, request);
        }
 
        template<typename StartTransactionRequestT = Model::StartTransactionRequest>
        void StartTransactionAsync(const StartTransactionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const StartTransactionRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::StartTransaction, request, handler, context);
        }
 
        virtual Model::UpdateDataCellsFilterOutcome UpdateDataCellsFilter(const Model::UpdateDataCellsFilterRequest& request) const;
 
        template<typename UpdateDataCellsFilterRequestT = Model::UpdateDataCellsFilterRequest>
        Model::UpdateDataCellsFilterOutcomeCallable UpdateDataCellsFilterCallable(const UpdateDataCellsFilterRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::UpdateDataCellsFilter, request);
        }
 
        template<typename UpdateDataCellsFilterRequestT = Model::UpdateDataCellsFilterRequest>
        void UpdateDataCellsFilterAsync(const UpdateDataCellsFilterRequestT& request, const UpdateDataCellsFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::UpdateDataCellsFilter, request, handler, context);
        }
 
        virtual Model::UpdateLFTagOutcome UpdateLFTag(const Model::UpdateLFTagRequest& request) const;
 
        template<typename UpdateLFTagRequestT = Model::UpdateLFTagRequest>
        Model::UpdateLFTagOutcomeCallable UpdateLFTagCallable(const UpdateLFTagRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::UpdateLFTag, request);
        }
 
        template<typename UpdateLFTagRequestT = Model::UpdateLFTagRequest>
        void UpdateLFTagAsync(const UpdateLFTagRequestT& request, const UpdateLFTagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::UpdateLFTag, request, handler, context);
        }
 
        virtual Model::UpdateLFTagExpressionOutcome UpdateLFTagExpression(const Model::UpdateLFTagExpressionRequest& request) const;
 
        template<typename UpdateLFTagExpressionRequestT = Model::UpdateLFTagExpressionRequest>
        Model::UpdateLFTagExpressionOutcomeCallable UpdateLFTagExpressionCallable(const UpdateLFTagExpressionRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::UpdateLFTagExpression, request);
        }
 
        template<typename UpdateLFTagExpressionRequestT = Model::UpdateLFTagExpressionRequest>
        void UpdateLFTagExpressionAsync(const UpdateLFTagExpressionRequestT& request, const UpdateLFTagExpressionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::UpdateLFTagExpression, request, handler, context);
        }
 
        virtual Model::UpdateLakeFormationIdentityCenterConfigurationOutcome UpdateLakeFormationIdentityCenterConfiguration(const Model::UpdateLakeFormationIdentityCenterConfigurationRequest& request = {}) const;
 
        template<typename UpdateLakeFormationIdentityCenterConfigurationRequestT = Model::UpdateLakeFormationIdentityCenterConfigurationRequest>
        Model::UpdateLakeFormationIdentityCenterConfigurationOutcomeCallable UpdateLakeFormationIdentityCenterConfigurationCallable(const UpdateLakeFormationIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&LakeFormationClient::UpdateLakeFormationIdentityCenterConfiguration, request);
        }
 
        template<typename UpdateLakeFormationIdentityCenterConfigurationRequestT = Model::UpdateLakeFormationIdentityCenterConfigurationRequest>
        void UpdateLakeFormationIdentityCenterConfigurationAsync(const UpdateLakeFormationIdentityCenterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateLakeFormationIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&LakeFormationClient::UpdateLakeFormationIdentityCenterConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateResourceOutcome UpdateResource(const Model::UpdateResourceRequest& request) const;
 
        template<typename UpdateResourceRequestT = Model::UpdateResourceRequest>
        Model::UpdateResourceOutcomeCallable UpdateResourceCallable(const UpdateResourceRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::UpdateResource, request);
        }
 
        template<typename UpdateResourceRequestT = Model::UpdateResourceRequest>
        void UpdateResourceAsync(const UpdateResourceRequestT& request, const UpdateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::UpdateResource, request, handler, context);
        }
 
        virtual Model::UpdateTableObjectsOutcome UpdateTableObjects(const Model::UpdateTableObjectsRequest& request) const;
 
        template<typename UpdateTableObjectsRequestT = Model::UpdateTableObjectsRequest>
        Model::UpdateTableObjectsOutcomeCallable UpdateTableObjectsCallable(const UpdateTableObjectsRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::UpdateTableObjects, request);
        }
 
        template<typename UpdateTableObjectsRequestT = Model::UpdateTableObjectsRequest>
        void UpdateTableObjectsAsync(const UpdateTableObjectsRequestT& request, const UpdateTableObjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::UpdateTableObjects, request, handler, context);
        }
 
        virtual Model::UpdateTableStorageOptimizerOutcome UpdateTableStorageOptimizer(const Model::UpdateTableStorageOptimizerRequest& request) const;
 
        template<typename UpdateTableStorageOptimizerRequestT = Model::UpdateTableStorageOptimizerRequest>
        Model::UpdateTableStorageOptimizerOutcomeCallable UpdateTableStorageOptimizerCallable(const UpdateTableStorageOptimizerRequestT& request) const
        {
            return SubmitCallable(&LakeFormationClient::UpdateTableStorageOptimizer, request);
        }
 
        template<typename UpdateTableStorageOptimizerRequestT = Model::UpdateTableStorageOptimizerRequest>
        void UpdateTableStorageOptimizerAsync(const UpdateTableStorageOptimizerRequestT& request, const UpdateTableStorageOptimizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LakeFormationClient::UpdateTableStorageOptimizer, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<LakeFormationEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<LakeFormationClient>;
      void init(const LakeFormationClientConfiguration& clientConfiguration);
 
      LakeFormationClientConfiguration m_clientConfiguration;
      std::shared_ptr<LakeFormationEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace LakeFormation
} // namespace Aws