WorkMailClient.h

 
#pragma once
#include <aws/workmail/WorkMail_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/workmail/WorkMailServiceClientModel.h>
 
namespace Aws
{
namespace WorkMail
{
  class AWS_WORKMAIL_API WorkMailClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<WorkMailClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef WorkMailClientConfiguration ClientConfigurationType;
      typedef WorkMailEndpointProvider EndpointProviderType;
 
        WorkMailClient(const Aws::WorkMail::WorkMailClientConfiguration& clientConfiguration = Aws::WorkMail::WorkMailClientConfiguration(),
                       std::shared_ptr<WorkMailEndpointProviderBase> endpointProvider = nullptr);
 
        WorkMailClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<WorkMailEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::WorkMail::WorkMailClientConfiguration& clientConfiguration = Aws::WorkMail::WorkMailClientConfiguration());
 
        WorkMailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<WorkMailEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::WorkMail::WorkMailClientConfiguration& clientConfiguration = Aws::WorkMail::WorkMailClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        WorkMailClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WorkMailClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WorkMailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~WorkMailClient();
 
        virtual Model::AssociateDelegateToResourceOutcome AssociateDelegateToResource(const Model::AssociateDelegateToResourceRequest& request) const;
 
        template<typename AssociateDelegateToResourceRequestT = Model::AssociateDelegateToResourceRequest>
        Model::AssociateDelegateToResourceOutcomeCallable AssociateDelegateToResourceCallable(const AssociateDelegateToResourceRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::AssociateDelegateToResource, request);
        }
 
        template<typename AssociateDelegateToResourceRequestT = Model::AssociateDelegateToResourceRequest>
        void AssociateDelegateToResourceAsync(const AssociateDelegateToResourceRequestT& request, const AssociateDelegateToResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::AssociateDelegateToResource, request, handler, context);
        }
 
        virtual Model::AssociateMemberToGroupOutcome AssociateMemberToGroup(const Model::AssociateMemberToGroupRequest& request) const;
 
        template<typename AssociateMemberToGroupRequestT = Model::AssociateMemberToGroupRequest>
        Model::AssociateMemberToGroupOutcomeCallable AssociateMemberToGroupCallable(const AssociateMemberToGroupRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::AssociateMemberToGroup, request);
        }
 
        template<typename AssociateMemberToGroupRequestT = Model::AssociateMemberToGroupRequest>
        void AssociateMemberToGroupAsync(const AssociateMemberToGroupRequestT& request, const AssociateMemberToGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::AssociateMemberToGroup, request, handler, context);
        }
 
        virtual Model::AssumeImpersonationRoleOutcome AssumeImpersonationRole(const Model::AssumeImpersonationRoleRequest& request) const;
 
        template<typename AssumeImpersonationRoleRequestT = Model::AssumeImpersonationRoleRequest>
        Model::AssumeImpersonationRoleOutcomeCallable AssumeImpersonationRoleCallable(const AssumeImpersonationRoleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::AssumeImpersonationRole, request);
        }
 
        template<typename AssumeImpersonationRoleRequestT = Model::AssumeImpersonationRoleRequest>
        void AssumeImpersonationRoleAsync(const AssumeImpersonationRoleRequestT& request, const AssumeImpersonationRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::AssumeImpersonationRole, request, handler, context);
        }
 
        virtual Model::CancelMailboxExportJobOutcome CancelMailboxExportJob(const Model::CancelMailboxExportJobRequest& request) const;
 
        template<typename CancelMailboxExportJobRequestT = Model::CancelMailboxExportJobRequest>
        Model::CancelMailboxExportJobOutcomeCallable CancelMailboxExportJobCallable(const CancelMailboxExportJobRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CancelMailboxExportJob, request);
        }
 
        template<typename CancelMailboxExportJobRequestT = Model::CancelMailboxExportJobRequest>
        void CancelMailboxExportJobAsync(const CancelMailboxExportJobRequestT& request, const CancelMailboxExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CancelMailboxExportJob, request, handler, context);
        }
 
        virtual Model::CreateAliasOutcome CreateAlias(const Model::CreateAliasRequest& request) const;
 
        template<typename CreateAliasRequestT = Model::CreateAliasRequest>
        Model::CreateAliasOutcomeCallable CreateAliasCallable(const CreateAliasRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateAlias, request);
        }
 
        template<typename CreateAliasRequestT = Model::CreateAliasRequest>
        void CreateAliasAsync(const CreateAliasRequestT& request, const CreateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateAlias, request, handler, context);
        }
 
        virtual Model::CreateAvailabilityConfigurationOutcome CreateAvailabilityConfiguration(const Model::CreateAvailabilityConfigurationRequest& request) const;
 
        template<typename CreateAvailabilityConfigurationRequestT = Model::CreateAvailabilityConfigurationRequest>
        Model::CreateAvailabilityConfigurationOutcomeCallable CreateAvailabilityConfigurationCallable(const CreateAvailabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateAvailabilityConfiguration, request);
        }
 
        template<typename CreateAvailabilityConfigurationRequestT = Model::CreateAvailabilityConfigurationRequest>
        void CreateAvailabilityConfigurationAsync(const CreateAvailabilityConfigurationRequestT& request, const CreateAvailabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateAvailabilityConfiguration, request, handler, context);
        }
 
        virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateGroup, request);
        }
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateGroup, request, handler, context);
        }
 
        virtual Model::CreateIdentityCenterApplicationOutcome CreateIdentityCenterApplication(const Model::CreateIdentityCenterApplicationRequest& request) const;
 
        template<typename CreateIdentityCenterApplicationRequestT = Model::CreateIdentityCenterApplicationRequest>
        Model::CreateIdentityCenterApplicationOutcomeCallable CreateIdentityCenterApplicationCallable(const CreateIdentityCenterApplicationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateIdentityCenterApplication, request);
        }
 
        template<typename CreateIdentityCenterApplicationRequestT = Model::CreateIdentityCenterApplicationRequest>
        void CreateIdentityCenterApplicationAsync(const CreateIdentityCenterApplicationRequestT& request, const CreateIdentityCenterApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateIdentityCenterApplication, request, handler, context);
        }
 
        virtual Model::CreateImpersonationRoleOutcome CreateImpersonationRole(const Model::CreateImpersonationRoleRequest& request) const;
 
        template<typename CreateImpersonationRoleRequestT = Model::CreateImpersonationRoleRequest>
        Model::CreateImpersonationRoleOutcomeCallable CreateImpersonationRoleCallable(const CreateImpersonationRoleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateImpersonationRole, request);
        }
 
        template<typename CreateImpersonationRoleRequestT = Model::CreateImpersonationRoleRequest>
        void CreateImpersonationRoleAsync(const CreateImpersonationRoleRequestT& request, const CreateImpersonationRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateImpersonationRole, request, handler, context);
        }
 
        virtual Model::CreateMobileDeviceAccessRuleOutcome CreateMobileDeviceAccessRule(const Model::CreateMobileDeviceAccessRuleRequest& request) const;
 
        template<typename CreateMobileDeviceAccessRuleRequestT = Model::CreateMobileDeviceAccessRuleRequest>
        Model::CreateMobileDeviceAccessRuleOutcomeCallable CreateMobileDeviceAccessRuleCallable(const CreateMobileDeviceAccessRuleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateMobileDeviceAccessRule, request);
        }
 
        template<typename CreateMobileDeviceAccessRuleRequestT = Model::CreateMobileDeviceAccessRuleRequest>
        void CreateMobileDeviceAccessRuleAsync(const CreateMobileDeviceAccessRuleRequestT& request, const CreateMobileDeviceAccessRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateMobileDeviceAccessRule, request, handler, context);
        }
 
        virtual Model::CreateOrganizationOutcome CreateOrganization(const Model::CreateOrganizationRequest& request) const;
 
        template<typename CreateOrganizationRequestT = Model::CreateOrganizationRequest>
        Model::CreateOrganizationOutcomeCallable CreateOrganizationCallable(const CreateOrganizationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateOrganization, request);
        }
 
        template<typename CreateOrganizationRequestT = Model::CreateOrganizationRequest>
        void CreateOrganizationAsync(const CreateOrganizationRequestT& request, const CreateOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateOrganization, request, handler, context);
        }
 
        virtual Model::CreateResourceOutcome CreateResource(const Model::CreateResourceRequest& request) const;
 
        template<typename CreateResourceRequestT = Model::CreateResourceRequest>
        Model::CreateResourceOutcomeCallable CreateResourceCallable(const CreateResourceRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateResource, request);
        }
 
        template<typename CreateResourceRequestT = Model::CreateResourceRequest>
        void CreateResourceAsync(const CreateResourceRequestT& request, const CreateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateResource, request, handler, context);
        }
 
        virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::CreateUser, request);
        }
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::CreateUser, request, handler, context);
        }
 
        virtual Model::DeleteAccessControlRuleOutcome DeleteAccessControlRule(const Model::DeleteAccessControlRuleRequest& request) const;
 
        template<typename DeleteAccessControlRuleRequestT = Model::DeleteAccessControlRuleRequest>
        Model::DeleteAccessControlRuleOutcomeCallable DeleteAccessControlRuleCallable(const DeleteAccessControlRuleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteAccessControlRule, request);
        }
 
        template<typename DeleteAccessControlRuleRequestT = Model::DeleteAccessControlRuleRequest>
        void DeleteAccessControlRuleAsync(const DeleteAccessControlRuleRequestT& request, const DeleteAccessControlRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteAccessControlRule, request, handler, context);
        }
 
        virtual Model::DeleteAliasOutcome DeleteAlias(const Model::DeleteAliasRequest& request) const;
 
        template<typename DeleteAliasRequestT = Model::DeleteAliasRequest>
        Model::DeleteAliasOutcomeCallable DeleteAliasCallable(const DeleteAliasRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteAlias, request);
        }
 
        template<typename DeleteAliasRequestT = Model::DeleteAliasRequest>
        void DeleteAliasAsync(const DeleteAliasRequestT& request, const DeleteAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteAlias, request, handler, context);
        }
 
        virtual Model::DeleteAvailabilityConfigurationOutcome DeleteAvailabilityConfiguration(const Model::DeleteAvailabilityConfigurationRequest& request) const;
 
        template<typename DeleteAvailabilityConfigurationRequestT = Model::DeleteAvailabilityConfigurationRequest>
        Model::DeleteAvailabilityConfigurationOutcomeCallable DeleteAvailabilityConfigurationCallable(const DeleteAvailabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteAvailabilityConfiguration, request);
        }
 
        template<typename DeleteAvailabilityConfigurationRequestT = Model::DeleteAvailabilityConfigurationRequest>
        void DeleteAvailabilityConfigurationAsync(const DeleteAvailabilityConfigurationRequestT& request, const DeleteAvailabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteAvailabilityConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteEmailMonitoringConfigurationOutcome DeleteEmailMonitoringConfiguration(const Model::DeleteEmailMonitoringConfigurationRequest& request) const;
 
        template<typename DeleteEmailMonitoringConfigurationRequestT = Model::DeleteEmailMonitoringConfigurationRequest>
        Model::DeleteEmailMonitoringConfigurationOutcomeCallable DeleteEmailMonitoringConfigurationCallable(const DeleteEmailMonitoringConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteEmailMonitoringConfiguration, request);
        }
 
        template<typename DeleteEmailMonitoringConfigurationRequestT = Model::DeleteEmailMonitoringConfigurationRequest>
        void DeleteEmailMonitoringConfigurationAsync(const DeleteEmailMonitoringConfigurationRequestT& request, const DeleteEmailMonitoringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteEmailMonitoringConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const;
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteGroup, request);
        }
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        void DeleteGroupAsync(const DeleteGroupRequestT& request, const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteGroup, request, handler, context);
        }
 
        virtual Model::DeleteIdentityCenterApplicationOutcome DeleteIdentityCenterApplication(const Model::DeleteIdentityCenterApplicationRequest& request) const;
 
        template<typename DeleteIdentityCenterApplicationRequestT = Model::DeleteIdentityCenterApplicationRequest>
        Model::DeleteIdentityCenterApplicationOutcomeCallable DeleteIdentityCenterApplicationCallable(const DeleteIdentityCenterApplicationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteIdentityCenterApplication, request);
        }
 
        template<typename DeleteIdentityCenterApplicationRequestT = Model::DeleteIdentityCenterApplicationRequest>
        void DeleteIdentityCenterApplicationAsync(const DeleteIdentityCenterApplicationRequestT& request, const DeleteIdentityCenterApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteIdentityCenterApplication, request, handler, context);
        }
 
        virtual Model::DeleteIdentityProviderConfigurationOutcome DeleteIdentityProviderConfiguration(const Model::DeleteIdentityProviderConfigurationRequest& request) const;
 
        template<typename DeleteIdentityProviderConfigurationRequestT = Model::DeleteIdentityProviderConfigurationRequest>
        Model::DeleteIdentityProviderConfigurationOutcomeCallable DeleteIdentityProviderConfigurationCallable(const DeleteIdentityProviderConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteIdentityProviderConfiguration, request);
        }
 
        template<typename DeleteIdentityProviderConfigurationRequestT = Model::DeleteIdentityProviderConfigurationRequest>
        void DeleteIdentityProviderConfigurationAsync(const DeleteIdentityProviderConfigurationRequestT& request, const DeleteIdentityProviderConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteIdentityProviderConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteImpersonationRoleOutcome DeleteImpersonationRole(const Model::DeleteImpersonationRoleRequest& request) const;
 
        template<typename DeleteImpersonationRoleRequestT = Model::DeleteImpersonationRoleRequest>
        Model::DeleteImpersonationRoleOutcomeCallable DeleteImpersonationRoleCallable(const DeleteImpersonationRoleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteImpersonationRole, request);
        }
 
        template<typename DeleteImpersonationRoleRequestT = Model::DeleteImpersonationRoleRequest>
        void DeleteImpersonationRoleAsync(const DeleteImpersonationRoleRequestT& request, const DeleteImpersonationRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteImpersonationRole, request, handler, context);
        }
 
        virtual Model::DeleteMailboxPermissionsOutcome DeleteMailboxPermissions(const Model::DeleteMailboxPermissionsRequest& request) const;
 
        template<typename DeleteMailboxPermissionsRequestT = Model::DeleteMailboxPermissionsRequest>
        Model::DeleteMailboxPermissionsOutcomeCallable DeleteMailboxPermissionsCallable(const DeleteMailboxPermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteMailboxPermissions, request);
        }
 
        template<typename DeleteMailboxPermissionsRequestT = Model::DeleteMailboxPermissionsRequest>
        void DeleteMailboxPermissionsAsync(const DeleteMailboxPermissionsRequestT& request, const DeleteMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteMailboxPermissions, request, handler, context);
        }
 
        virtual Model::DeleteMobileDeviceAccessOverrideOutcome DeleteMobileDeviceAccessOverride(const Model::DeleteMobileDeviceAccessOverrideRequest& request) const;
 
        template<typename DeleteMobileDeviceAccessOverrideRequestT = Model::DeleteMobileDeviceAccessOverrideRequest>
        Model::DeleteMobileDeviceAccessOverrideOutcomeCallable DeleteMobileDeviceAccessOverrideCallable(const DeleteMobileDeviceAccessOverrideRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteMobileDeviceAccessOverride, request);
        }
 
        template<typename DeleteMobileDeviceAccessOverrideRequestT = Model::DeleteMobileDeviceAccessOverrideRequest>
        void DeleteMobileDeviceAccessOverrideAsync(const DeleteMobileDeviceAccessOverrideRequestT& request, const DeleteMobileDeviceAccessOverrideResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteMobileDeviceAccessOverride, request, handler, context);
        }
 
        virtual Model::DeleteMobileDeviceAccessRuleOutcome DeleteMobileDeviceAccessRule(const Model::DeleteMobileDeviceAccessRuleRequest& request) const;
 
        template<typename DeleteMobileDeviceAccessRuleRequestT = Model::DeleteMobileDeviceAccessRuleRequest>
        Model::DeleteMobileDeviceAccessRuleOutcomeCallable DeleteMobileDeviceAccessRuleCallable(const DeleteMobileDeviceAccessRuleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteMobileDeviceAccessRule, request);
        }
 
        template<typename DeleteMobileDeviceAccessRuleRequestT = Model::DeleteMobileDeviceAccessRuleRequest>
        void DeleteMobileDeviceAccessRuleAsync(const DeleteMobileDeviceAccessRuleRequestT& request, const DeleteMobileDeviceAccessRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteMobileDeviceAccessRule, request, handler, context);
        }
 
        virtual Model::DeleteOrganizationOutcome DeleteOrganization(const Model::DeleteOrganizationRequest& request) const;
 
        template<typename DeleteOrganizationRequestT = Model::DeleteOrganizationRequest>
        Model::DeleteOrganizationOutcomeCallable DeleteOrganizationCallable(const DeleteOrganizationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteOrganization, request);
        }
 
        template<typename DeleteOrganizationRequestT = Model::DeleteOrganizationRequest>
        void DeleteOrganizationAsync(const DeleteOrganizationRequestT& request, const DeleteOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteOrganization, request, handler, context);
        }
 
        virtual Model::DeletePersonalAccessTokenOutcome DeletePersonalAccessToken(const Model::DeletePersonalAccessTokenRequest& request) const;
 
        template<typename DeletePersonalAccessTokenRequestT = Model::DeletePersonalAccessTokenRequest>
        Model::DeletePersonalAccessTokenOutcomeCallable DeletePersonalAccessTokenCallable(const DeletePersonalAccessTokenRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeletePersonalAccessToken, request);
        }
 
        template<typename DeletePersonalAccessTokenRequestT = Model::DeletePersonalAccessTokenRequest>
        void DeletePersonalAccessTokenAsync(const DeletePersonalAccessTokenRequestT& request, const DeletePersonalAccessTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeletePersonalAccessToken, request, handler, context);
        }
 
        virtual Model::DeleteResourceOutcome DeleteResource(const Model::DeleteResourceRequest& request) const;
 
        template<typename DeleteResourceRequestT = Model::DeleteResourceRequest>
        Model::DeleteResourceOutcomeCallable DeleteResourceCallable(const DeleteResourceRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteResource, request);
        }
 
        template<typename DeleteResourceRequestT = Model::DeleteResourceRequest>
        void DeleteResourceAsync(const DeleteResourceRequestT& request, const DeleteResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteResource, request, handler, context);
        }
 
        virtual Model::DeleteRetentionPolicyOutcome DeleteRetentionPolicy(const Model::DeleteRetentionPolicyRequest& request) const;
 
        template<typename DeleteRetentionPolicyRequestT = Model::DeleteRetentionPolicyRequest>
        Model::DeleteRetentionPolicyOutcomeCallable DeleteRetentionPolicyCallable(const DeleteRetentionPolicyRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteRetentionPolicy, request);
        }
 
        template<typename DeleteRetentionPolicyRequestT = Model::DeleteRetentionPolicyRequest>
        void DeleteRetentionPolicyAsync(const DeleteRetentionPolicyRequestT& request, const DeleteRetentionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteRetentionPolicy, request, handler, context);
        }
 
        virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeleteUser, request);
        }
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeleteUser, request, handler, context);
        }
 
        virtual Model::DeregisterFromWorkMailOutcome DeregisterFromWorkMail(const Model::DeregisterFromWorkMailRequest& request) const;
 
        template<typename DeregisterFromWorkMailRequestT = Model::DeregisterFromWorkMailRequest>
        Model::DeregisterFromWorkMailOutcomeCallable DeregisterFromWorkMailCallable(const DeregisterFromWorkMailRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeregisterFromWorkMail, request);
        }
 
        template<typename DeregisterFromWorkMailRequestT = Model::DeregisterFromWorkMailRequest>
        void DeregisterFromWorkMailAsync(const DeregisterFromWorkMailRequestT& request, const DeregisterFromWorkMailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeregisterFromWorkMail, request, handler, context);
        }
 
        virtual Model::DeregisterMailDomainOutcome DeregisterMailDomain(const Model::DeregisterMailDomainRequest& request) const;
 
        template<typename DeregisterMailDomainRequestT = Model::DeregisterMailDomainRequest>
        Model::DeregisterMailDomainOutcomeCallable DeregisterMailDomainCallable(const DeregisterMailDomainRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DeregisterMailDomain, request);
        }
 
        template<typename DeregisterMailDomainRequestT = Model::DeregisterMailDomainRequest>
        void DeregisterMailDomainAsync(const DeregisterMailDomainRequestT& request, const DeregisterMailDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DeregisterMailDomain, request, handler, context);
        }
 
        virtual Model::DescribeEmailMonitoringConfigurationOutcome DescribeEmailMonitoringConfiguration(const Model::DescribeEmailMonitoringConfigurationRequest& request) const;
 
        template<typename DescribeEmailMonitoringConfigurationRequestT = Model::DescribeEmailMonitoringConfigurationRequest>
        Model::DescribeEmailMonitoringConfigurationOutcomeCallable DescribeEmailMonitoringConfigurationCallable(const DescribeEmailMonitoringConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DescribeEmailMonitoringConfiguration, request);
        }
 
        template<typename DescribeEmailMonitoringConfigurationRequestT = Model::DescribeEmailMonitoringConfigurationRequest>
        void DescribeEmailMonitoringConfigurationAsync(const DescribeEmailMonitoringConfigurationRequestT& request, const DescribeEmailMonitoringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DescribeEmailMonitoringConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeEntityOutcome DescribeEntity(const Model::DescribeEntityRequest& request) const;
 
        template<typename DescribeEntityRequestT = Model::DescribeEntityRequest>
        Model::DescribeEntityOutcomeCallable DescribeEntityCallable(const DescribeEntityRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DescribeEntity, request);
        }
 
        template<typename DescribeEntityRequestT = Model::DescribeEntityRequest>
        void DescribeEntityAsync(const DescribeEntityRequestT& request, const DescribeEntityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DescribeEntity, request, handler, context);
        }
 
        virtual Model::DescribeGroupOutcome DescribeGroup(const Model::DescribeGroupRequest& request) const;
 
        template<typename DescribeGroupRequestT = Model::DescribeGroupRequest>
        Model::DescribeGroupOutcomeCallable DescribeGroupCallable(const DescribeGroupRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DescribeGroup, request);
        }
 
        template<typename DescribeGroupRequestT = Model::DescribeGroupRequest>
        void DescribeGroupAsync(const DescribeGroupRequestT& request, const DescribeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DescribeGroup, request, handler, context);
        }
 
        virtual Model::DescribeIdentityProviderConfigurationOutcome DescribeIdentityProviderConfiguration(const Model::DescribeIdentityProviderConfigurationRequest& request) const;
 
        template<typename DescribeIdentityProviderConfigurationRequestT = Model::DescribeIdentityProviderConfigurationRequest>
        Model::DescribeIdentityProviderConfigurationOutcomeCallable DescribeIdentityProviderConfigurationCallable(const DescribeIdentityProviderConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DescribeIdentityProviderConfiguration, request);
        }
 
        template<typename DescribeIdentityProviderConfigurationRequestT = Model::DescribeIdentityProviderConfigurationRequest>
        void DescribeIdentityProviderConfigurationAsync(const DescribeIdentityProviderConfigurationRequestT& request, const DescribeIdentityProviderConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DescribeIdentityProviderConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeInboundDmarcSettingsOutcome DescribeInboundDmarcSettings(const Model::DescribeInboundDmarcSettingsRequest& request) const;
 
        template<typename DescribeInboundDmarcSettingsRequestT = Model::DescribeInboundDmarcSettingsRequest>
        Model::DescribeInboundDmarcSettingsOutcomeCallable DescribeInboundDmarcSettingsCallable(const DescribeInboundDmarcSettingsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DescribeInboundDmarcSettings, request);
        }
 
        template<typename DescribeInboundDmarcSettingsRequestT = Model::DescribeInboundDmarcSettingsRequest>
        void DescribeInboundDmarcSettingsAsync(const DescribeInboundDmarcSettingsRequestT& request, const DescribeInboundDmarcSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DescribeInboundDmarcSettings, request, handler, context);
        }
 
        virtual Model::DescribeMailboxExportJobOutcome DescribeMailboxExportJob(const Model::DescribeMailboxExportJobRequest& request) const;
 
        template<typename DescribeMailboxExportJobRequestT = Model::DescribeMailboxExportJobRequest>
        Model::DescribeMailboxExportJobOutcomeCallable DescribeMailboxExportJobCallable(const DescribeMailboxExportJobRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DescribeMailboxExportJob, request);
        }
 
        template<typename DescribeMailboxExportJobRequestT = Model::DescribeMailboxExportJobRequest>
        void DescribeMailboxExportJobAsync(const DescribeMailboxExportJobRequestT& request, const DescribeMailboxExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DescribeMailboxExportJob, request, handler, context);
        }
 
        virtual Model::DescribeOrganizationOutcome DescribeOrganization(const Model::DescribeOrganizationRequest& request) const;
 
        template<typename DescribeOrganizationRequestT = Model::DescribeOrganizationRequest>
        Model::DescribeOrganizationOutcomeCallable DescribeOrganizationCallable(const DescribeOrganizationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DescribeOrganization, request);
        }
 
        template<typename DescribeOrganizationRequestT = Model::DescribeOrganizationRequest>
        void DescribeOrganizationAsync(const DescribeOrganizationRequestT& request, const DescribeOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DescribeOrganization, 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(&WorkMailClient::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(&WorkMailClient::DescribeResource, request, handler, context);
        }
 
        virtual Model::DescribeUserOutcome DescribeUser(const Model::DescribeUserRequest& request) const;
 
        template<typename DescribeUserRequestT = Model::DescribeUserRequest>
        Model::DescribeUserOutcomeCallable DescribeUserCallable(const DescribeUserRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DescribeUser, request);
        }
 
        template<typename DescribeUserRequestT = Model::DescribeUserRequest>
        void DescribeUserAsync(const DescribeUserRequestT& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DescribeUser, request, handler, context);
        }
 
        virtual Model::DisassociateDelegateFromResourceOutcome DisassociateDelegateFromResource(const Model::DisassociateDelegateFromResourceRequest& request) const;
 
        template<typename DisassociateDelegateFromResourceRequestT = Model::DisassociateDelegateFromResourceRequest>
        Model::DisassociateDelegateFromResourceOutcomeCallable DisassociateDelegateFromResourceCallable(const DisassociateDelegateFromResourceRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DisassociateDelegateFromResource, request);
        }
 
        template<typename DisassociateDelegateFromResourceRequestT = Model::DisassociateDelegateFromResourceRequest>
        void DisassociateDelegateFromResourceAsync(const DisassociateDelegateFromResourceRequestT& request, const DisassociateDelegateFromResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DisassociateDelegateFromResource, request, handler, context);
        }
 
        virtual Model::DisassociateMemberFromGroupOutcome DisassociateMemberFromGroup(const Model::DisassociateMemberFromGroupRequest& request) const;
 
        template<typename DisassociateMemberFromGroupRequestT = Model::DisassociateMemberFromGroupRequest>
        Model::DisassociateMemberFromGroupOutcomeCallable DisassociateMemberFromGroupCallable(const DisassociateMemberFromGroupRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::DisassociateMemberFromGroup, request);
        }
 
        template<typename DisassociateMemberFromGroupRequestT = Model::DisassociateMemberFromGroupRequest>
        void DisassociateMemberFromGroupAsync(const DisassociateMemberFromGroupRequestT& request, const DisassociateMemberFromGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::DisassociateMemberFromGroup, request, handler, context);
        }
 
        virtual Model::GetAccessControlEffectOutcome GetAccessControlEffect(const Model::GetAccessControlEffectRequest& request) const;
 
        template<typename GetAccessControlEffectRequestT = Model::GetAccessControlEffectRequest>
        Model::GetAccessControlEffectOutcomeCallable GetAccessControlEffectCallable(const GetAccessControlEffectRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetAccessControlEffect, request);
        }
 
        template<typename GetAccessControlEffectRequestT = Model::GetAccessControlEffectRequest>
        void GetAccessControlEffectAsync(const GetAccessControlEffectRequestT& request, const GetAccessControlEffectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetAccessControlEffect, request, handler, context);
        }
 
        virtual Model::GetDefaultRetentionPolicyOutcome GetDefaultRetentionPolicy(const Model::GetDefaultRetentionPolicyRequest& request) const;
 
        template<typename GetDefaultRetentionPolicyRequestT = Model::GetDefaultRetentionPolicyRequest>
        Model::GetDefaultRetentionPolicyOutcomeCallable GetDefaultRetentionPolicyCallable(const GetDefaultRetentionPolicyRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetDefaultRetentionPolicy, request);
        }
 
        template<typename GetDefaultRetentionPolicyRequestT = Model::GetDefaultRetentionPolicyRequest>
        void GetDefaultRetentionPolicyAsync(const GetDefaultRetentionPolicyRequestT& request, const GetDefaultRetentionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetDefaultRetentionPolicy, request, handler, context);
        }
 
        virtual Model::GetImpersonationRoleOutcome GetImpersonationRole(const Model::GetImpersonationRoleRequest& request) const;
 
        template<typename GetImpersonationRoleRequestT = Model::GetImpersonationRoleRequest>
        Model::GetImpersonationRoleOutcomeCallable GetImpersonationRoleCallable(const GetImpersonationRoleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetImpersonationRole, request);
        }
 
        template<typename GetImpersonationRoleRequestT = Model::GetImpersonationRoleRequest>
        void GetImpersonationRoleAsync(const GetImpersonationRoleRequestT& request, const GetImpersonationRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetImpersonationRole, request, handler, context);
        }
 
        virtual Model::GetImpersonationRoleEffectOutcome GetImpersonationRoleEffect(const Model::GetImpersonationRoleEffectRequest& request) const;
 
        template<typename GetImpersonationRoleEffectRequestT = Model::GetImpersonationRoleEffectRequest>
        Model::GetImpersonationRoleEffectOutcomeCallable GetImpersonationRoleEffectCallable(const GetImpersonationRoleEffectRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetImpersonationRoleEffect, request);
        }
 
        template<typename GetImpersonationRoleEffectRequestT = Model::GetImpersonationRoleEffectRequest>
        void GetImpersonationRoleEffectAsync(const GetImpersonationRoleEffectRequestT& request, const GetImpersonationRoleEffectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetImpersonationRoleEffect, request, handler, context);
        }
 
        virtual Model::GetMailDomainOutcome GetMailDomain(const Model::GetMailDomainRequest& request) const;
 
        template<typename GetMailDomainRequestT = Model::GetMailDomainRequest>
        Model::GetMailDomainOutcomeCallable GetMailDomainCallable(const GetMailDomainRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetMailDomain, request);
        }
 
        template<typename GetMailDomainRequestT = Model::GetMailDomainRequest>
        void GetMailDomainAsync(const GetMailDomainRequestT& request, const GetMailDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetMailDomain, request, handler, context);
        }
 
        virtual Model::GetMailboxDetailsOutcome GetMailboxDetails(const Model::GetMailboxDetailsRequest& request) const;
 
        template<typename GetMailboxDetailsRequestT = Model::GetMailboxDetailsRequest>
        Model::GetMailboxDetailsOutcomeCallable GetMailboxDetailsCallable(const GetMailboxDetailsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetMailboxDetails, request);
        }
 
        template<typename GetMailboxDetailsRequestT = Model::GetMailboxDetailsRequest>
        void GetMailboxDetailsAsync(const GetMailboxDetailsRequestT& request, const GetMailboxDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetMailboxDetails, request, handler, context);
        }
 
        virtual Model::GetMobileDeviceAccessEffectOutcome GetMobileDeviceAccessEffect(const Model::GetMobileDeviceAccessEffectRequest& request) const;
 
        template<typename GetMobileDeviceAccessEffectRequestT = Model::GetMobileDeviceAccessEffectRequest>
        Model::GetMobileDeviceAccessEffectOutcomeCallable GetMobileDeviceAccessEffectCallable(const GetMobileDeviceAccessEffectRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetMobileDeviceAccessEffect, request);
        }
 
        template<typename GetMobileDeviceAccessEffectRequestT = Model::GetMobileDeviceAccessEffectRequest>
        void GetMobileDeviceAccessEffectAsync(const GetMobileDeviceAccessEffectRequestT& request, const GetMobileDeviceAccessEffectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetMobileDeviceAccessEffect, request, handler, context);
        }
 
        virtual Model::GetMobileDeviceAccessOverrideOutcome GetMobileDeviceAccessOverride(const Model::GetMobileDeviceAccessOverrideRequest& request) const;
 
        template<typename GetMobileDeviceAccessOverrideRequestT = Model::GetMobileDeviceAccessOverrideRequest>
        Model::GetMobileDeviceAccessOverrideOutcomeCallable GetMobileDeviceAccessOverrideCallable(const GetMobileDeviceAccessOverrideRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetMobileDeviceAccessOverride, request);
        }
 
        template<typename GetMobileDeviceAccessOverrideRequestT = Model::GetMobileDeviceAccessOverrideRequest>
        void GetMobileDeviceAccessOverrideAsync(const GetMobileDeviceAccessOverrideRequestT& request, const GetMobileDeviceAccessOverrideResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetMobileDeviceAccessOverride, request, handler, context);
        }
 
        virtual Model::GetPersonalAccessTokenMetadataOutcome GetPersonalAccessTokenMetadata(const Model::GetPersonalAccessTokenMetadataRequest& request) const;
 
        template<typename GetPersonalAccessTokenMetadataRequestT = Model::GetPersonalAccessTokenMetadataRequest>
        Model::GetPersonalAccessTokenMetadataOutcomeCallable GetPersonalAccessTokenMetadataCallable(const GetPersonalAccessTokenMetadataRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::GetPersonalAccessTokenMetadata, request);
        }
 
        template<typename GetPersonalAccessTokenMetadataRequestT = Model::GetPersonalAccessTokenMetadataRequest>
        void GetPersonalAccessTokenMetadataAsync(const GetPersonalAccessTokenMetadataRequestT& request, const GetPersonalAccessTokenMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::GetPersonalAccessTokenMetadata, request, handler, context);
        }
 
        virtual Model::ListAccessControlRulesOutcome ListAccessControlRules(const Model::ListAccessControlRulesRequest& request) const;
 
        template<typename ListAccessControlRulesRequestT = Model::ListAccessControlRulesRequest>
        Model::ListAccessControlRulesOutcomeCallable ListAccessControlRulesCallable(const ListAccessControlRulesRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListAccessControlRules, request);
        }
 
        template<typename ListAccessControlRulesRequestT = Model::ListAccessControlRulesRequest>
        void ListAccessControlRulesAsync(const ListAccessControlRulesRequestT& request, const ListAccessControlRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListAccessControlRules, request, handler, context);
        }
 
        virtual Model::ListAliasesOutcome ListAliases(const Model::ListAliasesRequest& request) const;
 
        template<typename ListAliasesRequestT = Model::ListAliasesRequest>
        Model::ListAliasesOutcomeCallable ListAliasesCallable(const ListAliasesRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListAliases, request);
        }
 
        template<typename ListAliasesRequestT = Model::ListAliasesRequest>
        void ListAliasesAsync(const ListAliasesRequestT& request, const ListAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListAliases, request, handler, context);
        }
 
        virtual Model::ListAvailabilityConfigurationsOutcome ListAvailabilityConfigurations(const Model::ListAvailabilityConfigurationsRequest& request) const;
 
        template<typename ListAvailabilityConfigurationsRequestT = Model::ListAvailabilityConfigurationsRequest>
        Model::ListAvailabilityConfigurationsOutcomeCallable ListAvailabilityConfigurationsCallable(const ListAvailabilityConfigurationsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListAvailabilityConfigurations, request);
        }
 
        template<typename ListAvailabilityConfigurationsRequestT = Model::ListAvailabilityConfigurationsRequest>
        void ListAvailabilityConfigurationsAsync(const ListAvailabilityConfigurationsRequestT& request, const ListAvailabilityConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListAvailabilityConfigurations, request, handler, context);
        }
 
        virtual Model::ListGroupMembersOutcome ListGroupMembers(const Model::ListGroupMembersRequest& request) const;
 
        template<typename ListGroupMembersRequestT = Model::ListGroupMembersRequest>
        Model::ListGroupMembersOutcomeCallable ListGroupMembersCallable(const ListGroupMembersRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListGroupMembers, request);
        }
 
        template<typename ListGroupMembersRequestT = Model::ListGroupMembersRequest>
        void ListGroupMembersAsync(const ListGroupMembersRequestT& request, const ListGroupMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListGroupMembers, request, handler, context);
        }
 
        virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request) const;
 
        template<typename ListGroupsRequestT = Model::ListGroupsRequest>
        Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListGroups, request);
        }
 
        template<typename ListGroupsRequestT = Model::ListGroupsRequest>
        void ListGroupsAsync(const ListGroupsRequestT& request, const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListGroups, request, handler, context);
        }
 
        virtual Model::ListGroupsForEntityOutcome ListGroupsForEntity(const Model::ListGroupsForEntityRequest& request) const;
 
        template<typename ListGroupsForEntityRequestT = Model::ListGroupsForEntityRequest>
        Model::ListGroupsForEntityOutcomeCallable ListGroupsForEntityCallable(const ListGroupsForEntityRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListGroupsForEntity, request);
        }
 
        template<typename ListGroupsForEntityRequestT = Model::ListGroupsForEntityRequest>
        void ListGroupsForEntityAsync(const ListGroupsForEntityRequestT& request, const ListGroupsForEntityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListGroupsForEntity, request, handler, context);
        }
 
        virtual Model::ListImpersonationRolesOutcome ListImpersonationRoles(const Model::ListImpersonationRolesRequest& request) const;
 
        template<typename ListImpersonationRolesRequestT = Model::ListImpersonationRolesRequest>
        Model::ListImpersonationRolesOutcomeCallable ListImpersonationRolesCallable(const ListImpersonationRolesRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListImpersonationRoles, request);
        }
 
        template<typename ListImpersonationRolesRequestT = Model::ListImpersonationRolesRequest>
        void ListImpersonationRolesAsync(const ListImpersonationRolesRequestT& request, const ListImpersonationRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListImpersonationRoles, request, handler, context);
        }
 
        virtual Model::ListMailDomainsOutcome ListMailDomains(const Model::ListMailDomainsRequest& request) const;
 
        template<typename ListMailDomainsRequestT = Model::ListMailDomainsRequest>
        Model::ListMailDomainsOutcomeCallable ListMailDomainsCallable(const ListMailDomainsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListMailDomains, request);
        }
 
        template<typename ListMailDomainsRequestT = Model::ListMailDomainsRequest>
        void ListMailDomainsAsync(const ListMailDomainsRequestT& request, const ListMailDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListMailDomains, request, handler, context);
        }
 
        virtual Model::ListMailboxExportJobsOutcome ListMailboxExportJobs(const Model::ListMailboxExportJobsRequest& request) const;
 
        template<typename ListMailboxExportJobsRequestT = Model::ListMailboxExportJobsRequest>
        Model::ListMailboxExportJobsOutcomeCallable ListMailboxExportJobsCallable(const ListMailboxExportJobsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListMailboxExportJobs, request);
        }
 
        template<typename ListMailboxExportJobsRequestT = Model::ListMailboxExportJobsRequest>
        void ListMailboxExportJobsAsync(const ListMailboxExportJobsRequestT& request, const ListMailboxExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListMailboxExportJobs, request, handler, context);
        }
 
        virtual Model::ListMailboxPermissionsOutcome ListMailboxPermissions(const Model::ListMailboxPermissionsRequest& request) const;
 
        template<typename ListMailboxPermissionsRequestT = Model::ListMailboxPermissionsRequest>
        Model::ListMailboxPermissionsOutcomeCallable ListMailboxPermissionsCallable(const ListMailboxPermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListMailboxPermissions, request);
        }
 
        template<typename ListMailboxPermissionsRequestT = Model::ListMailboxPermissionsRequest>
        void ListMailboxPermissionsAsync(const ListMailboxPermissionsRequestT& request, const ListMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListMailboxPermissions, request, handler, context);
        }
 
        virtual Model::ListMobileDeviceAccessOverridesOutcome ListMobileDeviceAccessOverrides(const Model::ListMobileDeviceAccessOverridesRequest& request) const;
 
        template<typename ListMobileDeviceAccessOverridesRequestT = Model::ListMobileDeviceAccessOverridesRequest>
        Model::ListMobileDeviceAccessOverridesOutcomeCallable ListMobileDeviceAccessOverridesCallable(const ListMobileDeviceAccessOverridesRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListMobileDeviceAccessOverrides, request);
        }
 
        template<typename ListMobileDeviceAccessOverridesRequestT = Model::ListMobileDeviceAccessOverridesRequest>
        void ListMobileDeviceAccessOverridesAsync(const ListMobileDeviceAccessOverridesRequestT& request, const ListMobileDeviceAccessOverridesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListMobileDeviceAccessOverrides, request, handler, context);
        }
 
        virtual Model::ListMobileDeviceAccessRulesOutcome ListMobileDeviceAccessRules(const Model::ListMobileDeviceAccessRulesRequest& request) const;
 
        template<typename ListMobileDeviceAccessRulesRequestT = Model::ListMobileDeviceAccessRulesRequest>
        Model::ListMobileDeviceAccessRulesOutcomeCallable ListMobileDeviceAccessRulesCallable(const ListMobileDeviceAccessRulesRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListMobileDeviceAccessRules, request);
        }
 
        template<typename ListMobileDeviceAccessRulesRequestT = Model::ListMobileDeviceAccessRulesRequest>
        void ListMobileDeviceAccessRulesAsync(const ListMobileDeviceAccessRulesRequestT& request, const ListMobileDeviceAccessRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListMobileDeviceAccessRules, request, handler, context);
        }
 
        virtual Model::ListOrganizationsOutcome ListOrganizations(const Model::ListOrganizationsRequest& request = {}) const;
 
        template<typename ListOrganizationsRequestT = Model::ListOrganizationsRequest>
        Model::ListOrganizationsOutcomeCallable ListOrganizationsCallable(const ListOrganizationsRequestT& request = {}) const
        {
            return SubmitCallable(&WorkMailClient::ListOrganizations, request);
        }
 
        template<typename ListOrganizationsRequestT = Model::ListOrganizationsRequest>
        void ListOrganizationsAsync(const ListOrganizationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOrganizationsRequestT& request = {}) const
        {
            return SubmitAsync(&WorkMailClient::ListOrganizations, request, handler, context);
        }
 
        virtual Model::ListPersonalAccessTokensOutcome ListPersonalAccessTokens(const Model::ListPersonalAccessTokensRequest& request) const;
 
        template<typename ListPersonalAccessTokensRequestT = Model::ListPersonalAccessTokensRequest>
        Model::ListPersonalAccessTokensOutcomeCallable ListPersonalAccessTokensCallable(const ListPersonalAccessTokensRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListPersonalAccessTokens, request);
        }
 
        template<typename ListPersonalAccessTokensRequestT = Model::ListPersonalAccessTokensRequest>
        void ListPersonalAccessTokensAsync(const ListPersonalAccessTokensRequestT& request, const ListPersonalAccessTokensResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListPersonalAccessTokens, request, handler, context);
        }
 
        virtual Model::ListResourceDelegatesOutcome ListResourceDelegates(const Model::ListResourceDelegatesRequest& request) const;
 
        template<typename ListResourceDelegatesRequestT = Model::ListResourceDelegatesRequest>
        Model::ListResourceDelegatesOutcomeCallable ListResourceDelegatesCallable(const ListResourceDelegatesRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListResourceDelegates, request);
        }
 
        template<typename ListResourceDelegatesRequestT = Model::ListResourceDelegatesRequest>
        void ListResourceDelegatesAsync(const ListResourceDelegatesRequestT& request, const ListResourceDelegatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListResourceDelegates, 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(&WorkMailClient::ListResources, request);
        }
 
        template<typename ListResourcesRequestT = Model::ListResourcesRequest>
        void ListResourcesAsync(const ListResourcesRequestT& request, const ListResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListResources, 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(&WorkMailClient::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(&WorkMailClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;
 
        template<typename ListUsersRequestT = Model::ListUsersRequest>
        Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ListUsers, request);
        }
 
        template<typename ListUsersRequestT = Model::ListUsersRequest>
        void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ListUsers, request, handler, context);
        }
 
        virtual Model::PutAccessControlRuleOutcome PutAccessControlRule(const Model::PutAccessControlRuleRequest& request) const;
 
        template<typename PutAccessControlRuleRequestT = Model::PutAccessControlRuleRequest>
        Model::PutAccessControlRuleOutcomeCallable PutAccessControlRuleCallable(const PutAccessControlRuleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::PutAccessControlRule, request);
        }
 
        template<typename PutAccessControlRuleRequestT = Model::PutAccessControlRuleRequest>
        void PutAccessControlRuleAsync(const PutAccessControlRuleRequestT& request, const PutAccessControlRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::PutAccessControlRule, request, handler, context);
        }
 
        virtual Model::PutEmailMonitoringConfigurationOutcome PutEmailMonitoringConfiguration(const Model::PutEmailMonitoringConfigurationRequest& request) const;
 
        template<typename PutEmailMonitoringConfigurationRequestT = Model::PutEmailMonitoringConfigurationRequest>
        Model::PutEmailMonitoringConfigurationOutcomeCallable PutEmailMonitoringConfigurationCallable(const PutEmailMonitoringConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::PutEmailMonitoringConfiguration, request);
        }
 
        template<typename PutEmailMonitoringConfigurationRequestT = Model::PutEmailMonitoringConfigurationRequest>
        void PutEmailMonitoringConfigurationAsync(const PutEmailMonitoringConfigurationRequestT& request, const PutEmailMonitoringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::PutEmailMonitoringConfiguration, request, handler, context);
        }
 
        virtual Model::PutIdentityProviderConfigurationOutcome PutIdentityProviderConfiguration(const Model::PutIdentityProviderConfigurationRequest& request) const;
 
        template<typename PutIdentityProviderConfigurationRequestT = Model::PutIdentityProviderConfigurationRequest>
        Model::PutIdentityProviderConfigurationOutcomeCallable PutIdentityProviderConfigurationCallable(const PutIdentityProviderConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::PutIdentityProviderConfiguration, request);
        }
 
        template<typename PutIdentityProviderConfigurationRequestT = Model::PutIdentityProviderConfigurationRequest>
        void PutIdentityProviderConfigurationAsync(const PutIdentityProviderConfigurationRequestT& request, const PutIdentityProviderConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::PutIdentityProviderConfiguration, request, handler, context);
        }
 
        virtual Model::PutInboundDmarcSettingsOutcome PutInboundDmarcSettings(const Model::PutInboundDmarcSettingsRequest& request) const;
 
        template<typename PutInboundDmarcSettingsRequestT = Model::PutInboundDmarcSettingsRequest>
        Model::PutInboundDmarcSettingsOutcomeCallable PutInboundDmarcSettingsCallable(const PutInboundDmarcSettingsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::PutInboundDmarcSettings, request);
        }
 
        template<typename PutInboundDmarcSettingsRequestT = Model::PutInboundDmarcSettingsRequest>
        void PutInboundDmarcSettingsAsync(const PutInboundDmarcSettingsRequestT& request, const PutInboundDmarcSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::PutInboundDmarcSettings, request, handler, context);
        }
 
        virtual Model::PutMailboxPermissionsOutcome PutMailboxPermissions(const Model::PutMailboxPermissionsRequest& request) const;
 
        template<typename PutMailboxPermissionsRequestT = Model::PutMailboxPermissionsRequest>
        Model::PutMailboxPermissionsOutcomeCallable PutMailboxPermissionsCallable(const PutMailboxPermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::PutMailboxPermissions, request);
        }
 
        template<typename PutMailboxPermissionsRequestT = Model::PutMailboxPermissionsRequest>
        void PutMailboxPermissionsAsync(const PutMailboxPermissionsRequestT& request, const PutMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::PutMailboxPermissions, request, handler, context);
        }
 
        virtual Model::PutMobileDeviceAccessOverrideOutcome PutMobileDeviceAccessOverride(const Model::PutMobileDeviceAccessOverrideRequest& request) const;
 
        template<typename PutMobileDeviceAccessOverrideRequestT = Model::PutMobileDeviceAccessOverrideRequest>
        Model::PutMobileDeviceAccessOverrideOutcomeCallable PutMobileDeviceAccessOverrideCallable(const PutMobileDeviceAccessOverrideRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::PutMobileDeviceAccessOverride, request);
        }
 
        template<typename PutMobileDeviceAccessOverrideRequestT = Model::PutMobileDeviceAccessOverrideRequest>
        void PutMobileDeviceAccessOverrideAsync(const PutMobileDeviceAccessOverrideRequestT& request, const PutMobileDeviceAccessOverrideResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::PutMobileDeviceAccessOverride, request, handler, context);
        }
 
        virtual Model::PutRetentionPolicyOutcome PutRetentionPolicy(const Model::PutRetentionPolicyRequest& request) const;
 
        template<typename PutRetentionPolicyRequestT = Model::PutRetentionPolicyRequest>
        Model::PutRetentionPolicyOutcomeCallable PutRetentionPolicyCallable(const PutRetentionPolicyRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::PutRetentionPolicy, request);
        }
 
        template<typename PutRetentionPolicyRequestT = Model::PutRetentionPolicyRequest>
        void PutRetentionPolicyAsync(const PutRetentionPolicyRequestT& request, const PutRetentionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::PutRetentionPolicy, request, handler, context);
        }
 
        virtual Model::RegisterMailDomainOutcome RegisterMailDomain(const Model::RegisterMailDomainRequest& request) const;
 
        template<typename RegisterMailDomainRequestT = Model::RegisterMailDomainRequest>
        Model::RegisterMailDomainOutcomeCallable RegisterMailDomainCallable(const RegisterMailDomainRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::RegisterMailDomain, request);
        }
 
        template<typename RegisterMailDomainRequestT = Model::RegisterMailDomainRequest>
        void RegisterMailDomainAsync(const RegisterMailDomainRequestT& request, const RegisterMailDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::RegisterMailDomain, request, handler, context);
        }
 
        virtual Model::RegisterToWorkMailOutcome RegisterToWorkMail(const Model::RegisterToWorkMailRequest& request) const;
 
        template<typename RegisterToWorkMailRequestT = Model::RegisterToWorkMailRequest>
        Model::RegisterToWorkMailOutcomeCallable RegisterToWorkMailCallable(const RegisterToWorkMailRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::RegisterToWorkMail, request);
        }
 
        template<typename RegisterToWorkMailRequestT = Model::RegisterToWorkMailRequest>
        void RegisterToWorkMailAsync(const RegisterToWorkMailRequestT& request, const RegisterToWorkMailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::RegisterToWorkMail, request, handler, context);
        }
 
        virtual Model::ResetPasswordOutcome ResetPassword(const Model::ResetPasswordRequest& request) const;
 
        template<typename ResetPasswordRequestT = Model::ResetPasswordRequest>
        Model::ResetPasswordOutcomeCallable ResetPasswordCallable(const ResetPasswordRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::ResetPassword, request);
        }
 
        template<typename ResetPasswordRequestT = Model::ResetPasswordRequest>
        void ResetPasswordAsync(const ResetPasswordRequestT& request, const ResetPasswordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::ResetPassword, request, handler, context);
        }
 
        virtual Model::StartMailboxExportJobOutcome StartMailboxExportJob(const Model::StartMailboxExportJobRequest& request) const;
 
        template<typename StartMailboxExportJobRequestT = Model::StartMailboxExportJobRequest>
        Model::StartMailboxExportJobOutcomeCallable StartMailboxExportJobCallable(const StartMailboxExportJobRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::StartMailboxExportJob, request);
        }
 
        template<typename StartMailboxExportJobRequestT = Model::StartMailboxExportJobRequest>
        void StartMailboxExportJobAsync(const StartMailboxExportJobRequestT& request, const StartMailboxExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::StartMailboxExportJob, 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(&WorkMailClient::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(&WorkMailClient::TagResource, request, handler, context);
        }
 
        virtual Model::TestAvailabilityConfigurationOutcome TestAvailabilityConfiguration(const Model::TestAvailabilityConfigurationRequest& request) const;
 
        template<typename TestAvailabilityConfigurationRequestT = Model::TestAvailabilityConfigurationRequest>
        Model::TestAvailabilityConfigurationOutcomeCallable TestAvailabilityConfigurationCallable(const TestAvailabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::TestAvailabilityConfiguration, request);
        }
 
        template<typename TestAvailabilityConfigurationRequestT = Model::TestAvailabilityConfigurationRequest>
        void TestAvailabilityConfigurationAsync(const TestAvailabilityConfigurationRequestT& request, const TestAvailabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::TestAvailabilityConfiguration, 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(&WorkMailClient::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(&WorkMailClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAvailabilityConfigurationOutcome UpdateAvailabilityConfiguration(const Model::UpdateAvailabilityConfigurationRequest& request) const;
 
        template<typename UpdateAvailabilityConfigurationRequestT = Model::UpdateAvailabilityConfigurationRequest>
        Model::UpdateAvailabilityConfigurationOutcomeCallable UpdateAvailabilityConfigurationCallable(const UpdateAvailabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::UpdateAvailabilityConfiguration, request);
        }
 
        template<typename UpdateAvailabilityConfigurationRequestT = Model::UpdateAvailabilityConfigurationRequest>
        void UpdateAvailabilityConfigurationAsync(const UpdateAvailabilityConfigurationRequestT& request, const UpdateAvailabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::UpdateAvailabilityConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateDefaultMailDomainOutcome UpdateDefaultMailDomain(const Model::UpdateDefaultMailDomainRequest& request) const;
 
        template<typename UpdateDefaultMailDomainRequestT = Model::UpdateDefaultMailDomainRequest>
        Model::UpdateDefaultMailDomainOutcomeCallable UpdateDefaultMailDomainCallable(const UpdateDefaultMailDomainRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::UpdateDefaultMailDomain, request);
        }
 
        template<typename UpdateDefaultMailDomainRequestT = Model::UpdateDefaultMailDomainRequest>
        void UpdateDefaultMailDomainAsync(const UpdateDefaultMailDomainRequestT& request, const UpdateDefaultMailDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::UpdateDefaultMailDomain, request, handler, context);
        }
 
        virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request) const;
 
        template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
        Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::UpdateGroup, request);
        }
 
        template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
        void UpdateGroupAsync(const UpdateGroupRequestT& request, const UpdateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::UpdateGroup, request, handler, context);
        }
 
        virtual Model::UpdateImpersonationRoleOutcome UpdateImpersonationRole(const Model::UpdateImpersonationRoleRequest& request) const;
 
        template<typename UpdateImpersonationRoleRequestT = Model::UpdateImpersonationRoleRequest>
        Model::UpdateImpersonationRoleOutcomeCallable UpdateImpersonationRoleCallable(const UpdateImpersonationRoleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::UpdateImpersonationRole, request);
        }
 
        template<typename UpdateImpersonationRoleRequestT = Model::UpdateImpersonationRoleRequest>
        void UpdateImpersonationRoleAsync(const UpdateImpersonationRoleRequestT& request, const UpdateImpersonationRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::UpdateImpersonationRole, request, handler, context);
        }
 
        virtual Model::UpdateMailboxQuotaOutcome UpdateMailboxQuota(const Model::UpdateMailboxQuotaRequest& request) const;
 
        template<typename UpdateMailboxQuotaRequestT = Model::UpdateMailboxQuotaRequest>
        Model::UpdateMailboxQuotaOutcomeCallable UpdateMailboxQuotaCallable(const UpdateMailboxQuotaRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::UpdateMailboxQuota, request);
        }
 
        template<typename UpdateMailboxQuotaRequestT = Model::UpdateMailboxQuotaRequest>
        void UpdateMailboxQuotaAsync(const UpdateMailboxQuotaRequestT& request, const UpdateMailboxQuotaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::UpdateMailboxQuota, request, handler, context);
        }
 
        virtual Model::UpdateMobileDeviceAccessRuleOutcome UpdateMobileDeviceAccessRule(const Model::UpdateMobileDeviceAccessRuleRequest& request) const;
 
        template<typename UpdateMobileDeviceAccessRuleRequestT = Model::UpdateMobileDeviceAccessRuleRequest>
        Model::UpdateMobileDeviceAccessRuleOutcomeCallable UpdateMobileDeviceAccessRuleCallable(const UpdateMobileDeviceAccessRuleRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::UpdateMobileDeviceAccessRule, request);
        }
 
        template<typename UpdateMobileDeviceAccessRuleRequestT = Model::UpdateMobileDeviceAccessRuleRequest>
        void UpdateMobileDeviceAccessRuleAsync(const UpdateMobileDeviceAccessRuleRequestT& request, const UpdateMobileDeviceAccessRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::UpdateMobileDeviceAccessRule, request, handler, context);
        }
 
        virtual Model::UpdatePrimaryEmailAddressOutcome UpdatePrimaryEmailAddress(const Model::UpdatePrimaryEmailAddressRequest& request) const;
 
        template<typename UpdatePrimaryEmailAddressRequestT = Model::UpdatePrimaryEmailAddressRequest>
        Model::UpdatePrimaryEmailAddressOutcomeCallable UpdatePrimaryEmailAddressCallable(const UpdatePrimaryEmailAddressRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::UpdatePrimaryEmailAddress, request);
        }
 
        template<typename UpdatePrimaryEmailAddressRequestT = Model::UpdatePrimaryEmailAddressRequest>
        void UpdatePrimaryEmailAddressAsync(const UpdatePrimaryEmailAddressRequestT& request, const UpdatePrimaryEmailAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::UpdatePrimaryEmailAddress, 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(&WorkMailClient::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(&WorkMailClient::UpdateResource, request, handler, context);
        }
 
        virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const;
 
        template<typename UpdateUserRequestT = Model::UpdateUserRequest>
        Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const
        {
            return SubmitCallable(&WorkMailClient::UpdateUser, request);
        }
 
        template<typename UpdateUserRequestT = Model::UpdateUserRequest>
        void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkMailClient::UpdateUser, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<WorkMailEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<WorkMailClient>;
      void init(const WorkMailClientConfiguration& clientConfiguration);
 
      WorkMailClientConfiguration m_clientConfiguration;
      std::shared_ptr<WorkMailEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace WorkMail
} // namespace Aws