EFSClient.h

 
#pragma once
#include <aws/elasticfilesystem/EFS_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/elasticfilesystem/EFSServiceClientModel.h>
 
namespace Aws
{
namespace EFS
{
  class AWS_EFS_API EFSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<EFSClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef EFSClientConfiguration ClientConfigurationType;
      typedef EFSEndpointProvider EndpointProviderType;
 
        EFSClient(const Aws::EFS::EFSClientConfiguration& clientConfiguration = Aws::EFS::EFSClientConfiguration(),
                  std::shared_ptr<EFSEndpointProviderBase> endpointProvider = nullptr);
 
        EFSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<EFSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::EFS::EFSClientConfiguration& clientConfiguration = Aws::EFS::EFSClientConfiguration());
 
        EFSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<EFSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::EFS::EFSClientConfiguration& clientConfiguration = Aws::EFS::EFSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        EFSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        EFSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        EFSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~EFSClient();
 
        virtual Model::CreateAccessPointOutcome CreateAccessPoint(const Model::CreateAccessPointRequest& request) const;
 
        template<typename CreateAccessPointRequestT = Model::CreateAccessPointRequest>
        Model::CreateAccessPointOutcomeCallable CreateAccessPointCallable(const CreateAccessPointRequestT& request) const
        {
            return SubmitCallable(&EFSClient::CreateAccessPoint, request);
        }
 
        template<typename CreateAccessPointRequestT = Model::CreateAccessPointRequest>
        void CreateAccessPointAsync(const CreateAccessPointRequestT& request, const CreateAccessPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::CreateAccessPoint, request, handler, context);
        }
 
        virtual Model::CreateFileSystemOutcome CreateFileSystem(const Model::CreateFileSystemRequest& request) const;
 
        template<typename CreateFileSystemRequestT = Model::CreateFileSystemRequest>
        Model::CreateFileSystemOutcomeCallable CreateFileSystemCallable(const CreateFileSystemRequestT& request) const
        {
            return SubmitCallable(&EFSClient::CreateFileSystem, request);
        }
 
        template<typename CreateFileSystemRequestT = Model::CreateFileSystemRequest>
        void CreateFileSystemAsync(const CreateFileSystemRequestT& request, const CreateFileSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::CreateFileSystem, request, handler, context);
        }
 
        virtual Model::CreateMountTargetOutcome CreateMountTarget(const Model::CreateMountTargetRequest& request) const;
 
        template<typename CreateMountTargetRequestT = Model::CreateMountTargetRequest>
        Model::CreateMountTargetOutcomeCallable CreateMountTargetCallable(const CreateMountTargetRequestT& request) const
        {
            return SubmitCallable(&EFSClient::CreateMountTarget, request);
        }
 
        template<typename CreateMountTargetRequestT = Model::CreateMountTargetRequest>
        void CreateMountTargetAsync(const CreateMountTargetRequestT& request, const CreateMountTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::CreateMountTarget, request, handler, context);
        }
 
        virtual Model::CreateReplicationConfigurationOutcome CreateReplicationConfiguration(const Model::CreateReplicationConfigurationRequest& request) const;
 
        template<typename CreateReplicationConfigurationRequestT = Model::CreateReplicationConfigurationRequest>
        Model::CreateReplicationConfigurationOutcomeCallable CreateReplicationConfigurationCallable(const CreateReplicationConfigurationRequestT& request) const
        {
            return SubmitCallable(&EFSClient::CreateReplicationConfiguration, request);
        }
 
        template<typename CreateReplicationConfigurationRequestT = Model::CreateReplicationConfigurationRequest>
        void CreateReplicationConfigurationAsync(const CreateReplicationConfigurationRequestT& request, const CreateReplicationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::CreateReplicationConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteAccessPointOutcome DeleteAccessPoint(const Model::DeleteAccessPointRequest& request) const;
 
        template<typename DeleteAccessPointRequestT = Model::DeleteAccessPointRequest>
        Model::DeleteAccessPointOutcomeCallable DeleteAccessPointCallable(const DeleteAccessPointRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DeleteAccessPoint, request);
        }
 
        template<typename DeleteAccessPointRequestT = Model::DeleteAccessPointRequest>
        void DeleteAccessPointAsync(const DeleteAccessPointRequestT& request, const DeleteAccessPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DeleteAccessPoint, request, handler, context);
        }
 
        virtual Model::DeleteFileSystemOutcome DeleteFileSystem(const Model::DeleteFileSystemRequest& request) const;
 
        template<typename DeleteFileSystemRequestT = Model::DeleteFileSystemRequest>
        Model::DeleteFileSystemOutcomeCallable DeleteFileSystemCallable(const DeleteFileSystemRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DeleteFileSystem, request);
        }
 
        template<typename DeleteFileSystemRequestT = Model::DeleteFileSystemRequest>
        void DeleteFileSystemAsync(const DeleteFileSystemRequestT& request, const DeleteFileSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DeleteFileSystem, request, handler, context);
        }
 
        virtual Model::DeleteFileSystemPolicyOutcome DeleteFileSystemPolicy(const Model::DeleteFileSystemPolicyRequest& request) const;
 
        template<typename DeleteFileSystemPolicyRequestT = Model::DeleteFileSystemPolicyRequest>
        Model::DeleteFileSystemPolicyOutcomeCallable DeleteFileSystemPolicyCallable(const DeleteFileSystemPolicyRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DeleteFileSystemPolicy, request);
        }
 
        template<typename DeleteFileSystemPolicyRequestT = Model::DeleteFileSystemPolicyRequest>
        void DeleteFileSystemPolicyAsync(const DeleteFileSystemPolicyRequestT& request, const DeleteFileSystemPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DeleteFileSystemPolicy, request, handler, context);
        }
 
        virtual Model::DeleteMountTargetOutcome DeleteMountTarget(const Model::DeleteMountTargetRequest& request) const;
 
        template<typename DeleteMountTargetRequestT = Model::DeleteMountTargetRequest>
        Model::DeleteMountTargetOutcomeCallable DeleteMountTargetCallable(const DeleteMountTargetRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DeleteMountTarget, request);
        }
 
        template<typename DeleteMountTargetRequestT = Model::DeleteMountTargetRequest>
        void DeleteMountTargetAsync(const DeleteMountTargetRequestT& request, const DeleteMountTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DeleteMountTarget, request, handler, context);
        }
 
        virtual Model::DeleteReplicationConfigurationOutcome DeleteReplicationConfiguration(const Model::DeleteReplicationConfigurationRequest& request) const;
 
        template<typename DeleteReplicationConfigurationRequestT = Model::DeleteReplicationConfigurationRequest>
        Model::DeleteReplicationConfigurationOutcomeCallable DeleteReplicationConfigurationCallable(const DeleteReplicationConfigurationRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DeleteReplicationConfiguration, request);
        }
 
        template<typename DeleteReplicationConfigurationRequestT = Model::DeleteReplicationConfigurationRequest>
        void DeleteReplicationConfigurationAsync(const DeleteReplicationConfigurationRequestT& request, const DeleteReplicationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DeleteReplicationConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeAccessPointsOutcome DescribeAccessPoints(const Model::DescribeAccessPointsRequest& request = {}) const;
 
        template<typename DescribeAccessPointsRequestT = Model::DescribeAccessPointsRequest>
        Model::DescribeAccessPointsOutcomeCallable DescribeAccessPointsCallable(const DescribeAccessPointsRequestT& request = {}) const
        {
            return SubmitCallable(&EFSClient::DescribeAccessPoints, request);
        }
 
        template<typename DescribeAccessPointsRequestT = Model::DescribeAccessPointsRequest>
        void DescribeAccessPointsAsync(const DescribeAccessPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccessPointsRequestT& request = {}) const
        {
            return SubmitAsync(&EFSClient::DescribeAccessPoints, request, handler, context);
        }
 
        virtual Model::DescribeAccountPreferencesOutcome DescribeAccountPreferences(const Model::DescribeAccountPreferencesRequest& request = {}) const;
 
        template<typename DescribeAccountPreferencesRequestT = Model::DescribeAccountPreferencesRequest>
        Model::DescribeAccountPreferencesOutcomeCallable DescribeAccountPreferencesCallable(const DescribeAccountPreferencesRequestT& request = {}) const
        {
            return SubmitCallable(&EFSClient::DescribeAccountPreferences, request);
        }
 
        template<typename DescribeAccountPreferencesRequestT = Model::DescribeAccountPreferencesRequest>
        void DescribeAccountPreferencesAsync(const DescribeAccountPreferencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountPreferencesRequestT& request = {}) const
        {
            return SubmitAsync(&EFSClient::DescribeAccountPreferences, request, handler, context);
        }
 
        virtual Model::DescribeBackupPolicyOutcome DescribeBackupPolicy(const Model::DescribeBackupPolicyRequest& request) const;
 
        template<typename DescribeBackupPolicyRequestT = Model::DescribeBackupPolicyRequest>
        Model::DescribeBackupPolicyOutcomeCallable DescribeBackupPolicyCallable(const DescribeBackupPolicyRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DescribeBackupPolicy, request);
        }
 
        template<typename DescribeBackupPolicyRequestT = Model::DescribeBackupPolicyRequest>
        void DescribeBackupPolicyAsync(const DescribeBackupPolicyRequestT& request, const DescribeBackupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DescribeBackupPolicy, request, handler, context);
        }
 
        virtual Model::DescribeFileSystemPolicyOutcome DescribeFileSystemPolicy(const Model::DescribeFileSystemPolicyRequest& request) const;
 
        template<typename DescribeFileSystemPolicyRequestT = Model::DescribeFileSystemPolicyRequest>
        Model::DescribeFileSystemPolicyOutcomeCallable DescribeFileSystemPolicyCallable(const DescribeFileSystemPolicyRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DescribeFileSystemPolicy, request);
        }
 
        template<typename DescribeFileSystemPolicyRequestT = Model::DescribeFileSystemPolicyRequest>
        void DescribeFileSystemPolicyAsync(const DescribeFileSystemPolicyRequestT& request, const DescribeFileSystemPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DescribeFileSystemPolicy, request, handler, context);
        }
 
        virtual Model::DescribeFileSystemsOutcome DescribeFileSystems(const Model::DescribeFileSystemsRequest& request = {}) const;
 
        template<typename DescribeFileSystemsRequestT = Model::DescribeFileSystemsRequest>
        Model::DescribeFileSystemsOutcomeCallable DescribeFileSystemsCallable(const DescribeFileSystemsRequestT& request = {}) const
        {
            return SubmitCallable(&EFSClient::DescribeFileSystems, request);
        }
 
        template<typename DescribeFileSystemsRequestT = Model::DescribeFileSystemsRequest>
        void DescribeFileSystemsAsync(const DescribeFileSystemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFileSystemsRequestT& request = {}) const
        {
            return SubmitAsync(&EFSClient::DescribeFileSystems, request, handler, context);
        }
 
        virtual Model::DescribeLifecycleConfigurationOutcome DescribeLifecycleConfiguration(const Model::DescribeLifecycleConfigurationRequest& request) const;
 
        template<typename DescribeLifecycleConfigurationRequestT = Model::DescribeLifecycleConfigurationRequest>
        Model::DescribeLifecycleConfigurationOutcomeCallable DescribeLifecycleConfigurationCallable(const DescribeLifecycleConfigurationRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DescribeLifecycleConfiguration, request);
        }
 
        template<typename DescribeLifecycleConfigurationRequestT = Model::DescribeLifecycleConfigurationRequest>
        void DescribeLifecycleConfigurationAsync(const DescribeLifecycleConfigurationRequestT& request, const DescribeLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DescribeLifecycleConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeMountTargetSecurityGroupsOutcome DescribeMountTargetSecurityGroups(const Model::DescribeMountTargetSecurityGroupsRequest& request) const;
 
        template<typename DescribeMountTargetSecurityGroupsRequestT = Model::DescribeMountTargetSecurityGroupsRequest>
        Model::DescribeMountTargetSecurityGroupsOutcomeCallable DescribeMountTargetSecurityGroupsCallable(const DescribeMountTargetSecurityGroupsRequestT& request) const
        {
            return SubmitCallable(&EFSClient::DescribeMountTargetSecurityGroups, request);
        }
 
        template<typename DescribeMountTargetSecurityGroupsRequestT = Model::DescribeMountTargetSecurityGroupsRequest>
        void DescribeMountTargetSecurityGroupsAsync(const DescribeMountTargetSecurityGroupsRequestT& request, const DescribeMountTargetSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::DescribeMountTargetSecurityGroups, request, handler, context);
        }
 
        virtual Model::DescribeMountTargetsOutcome DescribeMountTargets(const Model::DescribeMountTargetsRequest& request = {}) const;
 
        template<typename DescribeMountTargetsRequestT = Model::DescribeMountTargetsRequest>
        Model::DescribeMountTargetsOutcomeCallable DescribeMountTargetsCallable(const DescribeMountTargetsRequestT& request = {}) const
        {
            return SubmitCallable(&EFSClient::DescribeMountTargets, request);
        }
 
        template<typename DescribeMountTargetsRequestT = Model::DescribeMountTargetsRequest>
        void DescribeMountTargetsAsync(const DescribeMountTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMountTargetsRequestT& request = {}) const
        {
            return SubmitAsync(&EFSClient::DescribeMountTargets, request, handler, context);
        }
 
        virtual Model::DescribeReplicationConfigurationsOutcome DescribeReplicationConfigurations(const Model::DescribeReplicationConfigurationsRequest& request = {}) const;
 
        template<typename DescribeReplicationConfigurationsRequestT = Model::DescribeReplicationConfigurationsRequest>
        Model::DescribeReplicationConfigurationsOutcomeCallable DescribeReplicationConfigurationsCallable(const DescribeReplicationConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&EFSClient::DescribeReplicationConfigurations, request);
        }
 
        template<typename DescribeReplicationConfigurationsRequestT = Model::DescribeReplicationConfigurationsRequest>
        void DescribeReplicationConfigurationsAsync(const DescribeReplicationConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&EFSClient::DescribeReplicationConfigurations, 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(&EFSClient::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(&EFSClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ModifyMountTargetSecurityGroupsOutcome ModifyMountTargetSecurityGroups(const Model::ModifyMountTargetSecurityGroupsRequest& request) const;
 
        template<typename ModifyMountTargetSecurityGroupsRequestT = Model::ModifyMountTargetSecurityGroupsRequest>
        Model::ModifyMountTargetSecurityGroupsOutcomeCallable ModifyMountTargetSecurityGroupsCallable(const ModifyMountTargetSecurityGroupsRequestT& request) const
        {
            return SubmitCallable(&EFSClient::ModifyMountTargetSecurityGroups, request);
        }
 
        template<typename ModifyMountTargetSecurityGroupsRequestT = Model::ModifyMountTargetSecurityGroupsRequest>
        void ModifyMountTargetSecurityGroupsAsync(const ModifyMountTargetSecurityGroupsRequestT& request, const ModifyMountTargetSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::ModifyMountTargetSecurityGroups, request, handler, context);
        }
 
        virtual Model::PutAccountPreferencesOutcome PutAccountPreferences(const Model::PutAccountPreferencesRequest& request) const;
 
        template<typename PutAccountPreferencesRequestT = Model::PutAccountPreferencesRequest>
        Model::PutAccountPreferencesOutcomeCallable PutAccountPreferencesCallable(const PutAccountPreferencesRequestT& request) const
        {
            return SubmitCallable(&EFSClient::PutAccountPreferences, request);
        }
 
        template<typename PutAccountPreferencesRequestT = Model::PutAccountPreferencesRequest>
        void PutAccountPreferencesAsync(const PutAccountPreferencesRequestT& request, const PutAccountPreferencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::PutAccountPreferences, request, handler, context);
        }
 
        virtual Model::PutBackupPolicyOutcome PutBackupPolicy(const Model::PutBackupPolicyRequest& request) const;
 
        template<typename PutBackupPolicyRequestT = Model::PutBackupPolicyRequest>
        Model::PutBackupPolicyOutcomeCallable PutBackupPolicyCallable(const PutBackupPolicyRequestT& request) const
        {
            return SubmitCallable(&EFSClient::PutBackupPolicy, request);
        }
 
        template<typename PutBackupPolicyRequestT = Model::PutBackupPolicyRequest>
        void PutBackupPolicyAsync(const PutBackupPolicyRequestT& request, const PutBackupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::PutBackupPolicy, request, handler, context);
        }
 
        virtual Model::PutFileSystemPolicyOutcome PutFileSystemPolicy(const Model::PutFileSystemPolicyRequest& request) const;
 
        template<typename PutFileSystemPolicyRequestT = Model::PutFileSystemPolicyRequest>
        Model::PutFileSystemPolicyOutcomeCallable PutFileSystemPolicyCallable(const PutFileSystemPolicyRequestT& request) const
        {
            return SubmitCallable(&EFSClient::PutFileSystemPolicy, request);
        }
 
        template<typename PutFileSystemPolicyRequestT = Model::PutFileSystemPolicyRequest>
        void PutFileSystemPolicyAsync(const PutFileSystemPolicyRequestT& request, const PutFileSystemPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::PutFileSystemPolicy, request, handler, context);
        }
 
        virtual Model::PutLifecycleConfigurationOutcome PutLifecycleConfiguration(const Model::PutLifecycleConfigurationRequest& request) const;
 
        template<typename PutLifecycleConfigurationRequestT = Model::PutLifecycleConfigurationRequest>
        Model::PutLifecycleConfigurationOutcomeCallable PutLifecycleConfigurationCallable(const PutLifecycleConfigurationRequestT& request) const
        {
            return SubmitCallable(&EFSClient::PutLifecycleConfiguration, request);
        }
 
        template<typename PutLifecycleConfigurationRequestT = Model::PutLifecycleConfigurationRequest>
        void PutLifecycleConfigurationAsync(const PutLifecycleConfigurationRequestT& request, const PutLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::PutLifecycleConfiguration, 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(&EFSClient::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(&EFSClient::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(&EFSClient::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(&EFSClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateFileSystemOutcome UpdateFileSystem(const Model::UpdateFileSystemRequest& request) const;
 
        template<typename UpdateFileSystemRequestT = Model::UpdateFileSystemRequest>
        Model::UpdateFileSystemOutcomeCallable UpdateFileSystemCallable(const UpdateFileSystemRequestT& request) const
        {
            return SubmitCallable(&EFSClient::UpdateFileSystem, request);
        }
 
        template<typename UpdateFileSystemRequestT = Model::UpdateFileSystemRequest>
        void UpdateFileSystemAsync(const UpdateFileSystemRequestT& request, const UpdateFileSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::UpdateFileSystem, request, handler, context);
        }
 
        virtual Model::UpdateFileSystemProtectionOutcome UpdateFileSystemProtection(const Model::UpdateFileSystemProtectionRequest& request) const;
 
        template<typename UpdateFileSystemProtectionRequestT = Model::UpdateFileSystemProtectionRequest>
        Model::UpdateFileSystemProtectionOutcomeCallable UpdateFileSystemProtectionCallable(const UpdateFileSystemProtectionRequestT& request) const
        {
            return SubmitCallable(&EFSClient::UpdateFileSystemProtection, request);
        }
 
        template<typename UpdateFileSystemProtectionRequestT = Model::UpdateFileSystemProtectionRequest>
        void UpdateFileSystemProtectionAsync(const UpdateFileSystemProtectionRequestT& request, const UpdateFileSystemProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EFSClient::UpdateFileSystemProtection, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<EFSEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<EFSClient>;
      void init(const EFSClientConfiguration& clientConfiguration);
 
      EFSClientConfiguration m_clientConfiguration;
      std::shared_ptr<EFSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace EFS
} // namespace Aws