EFSClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/elasticfilesystem/EFSServiceClientModel.h>
#include <aws/elasticfilesystem/EFS_EXPORTS.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