RAMClient.h

 
#pragma once
#include <aws/ram/RAM_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/ram/RAMServiceClientModel.h>
 
namespace Aws
{
namespace RAM
{
  class AWS_RAM_API RAMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<RAMClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef RAMClientConfiguration ClientConfigurationType;
      typedef RAMEndpointProvider EndpointProviderType;
 
        RAMClient(const Aws::RAM::RAMClientConfiguration& clientConfiguration = Aws::RAM::RAMClientConfiguration(),
                  std::shared_ptr<RAMEndpointProviderBase> endpointProvider = nullptr);
 
        RAMClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<RAMEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::RAM::RAMClientConfiguration& clientConfiguration = Aws::RAM::RAMClientConfiguration());
 
        RAMClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<RAMEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::RAM::RAMClientConfiguration& clientConfiguration = Aws::RAM::RAMClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        RAMClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        RAMClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        RAMClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~RAMClient();
 
        virtual Model::AcceptResourceShareInvitationOutcome AcceptResourceShareInvitation(const Model::AcceptResourceShareInvitationRequest& request) const;
 
        template<typename AcceptResourceShareInvitationRequestT = Model::AcceptResourceShareInvitationRequest>
        Model::AcceptResourceShareInvitationOutcomeCallable AcceptResourceShareInvitationCallable(const AcceptResourceShareInvitationRequestT& request) const
        {
            return SubmitCallable(&RAMClient::AcceptResourceShareInvitation, request);
        }
 
        template<typename AcceptResourceShareInvitationRequestT = Model::AcceptResourceShareInvitationRequest>
        void AcceptResourceShareInvitationAsync(const AcceptResourceShareInvitationRequestT& request, const AcceptResourceShareInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::AcceptResourceShareInvitation, request, handler, context);
        }
 
        virtual Model::AssociateResourceShareOutcome AssociateResourceShare(const Model::AssociateResourceShareRequest& request) const;
 
        template<typename AssociateResourceShareRequestT = Model::AssociateResourceShareRequest>
        Model::AssociateResourceShareOutcomeCallable AssociateResourceShareCallable(const AssociateResourceShareRequestT& request) const
        {
            return SubmitCallable(&RAMClient::AssociateResourceShare, request);
        }
 
        template<typename AssociateResourceShareRequestT = Model::AssociateResourceShareRequest>
        void AssociateResourceShareAsync(const AssociateResourceShareRequestT& request, const AssociateResourceShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::AssociateResourceShare, request, handler, context);
        }
 
        virtual Model::AssociateResourceSharePermissionOutcome AssociateResourceSharePermission(const Model::AssociateResourceSharePermissionRequest& request) const;
 
        template<typename AssociateResourceSharePermissionRequestT = Model::AssociateResourceSharePermissionRequest>
        Model::AssociateResourceSharePermissionOutcomeCallable AssociateResourceSharePermissionCallable(const AssociateResourceSharePermissionRequestT& request) const
        {
            return SubmitCallable(&RAMClient::AssociateResourceSharePermission, request);
        }
 
        template<typename AssociateResourceSharePermissionRequestT = Model::AssociateResourceSharePermissionRequest>
        void AssociateResourceSharePermissionAsync(const AssociateResourceSharePermissionRequestT& request, const AssociateResourceSharePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::AssociateResourceSharePermission, request, handler, context);
        }
 
        virtual Model::CreatePermissionOutcome CreatePermission(const Model::CreatePermissionRequest& request) const;
 
        template<typename CreatePermissionRequestT = Model::CreatePermissionRequest>
        Model::CreatePermissionOutcomeCallable CreatePermissionCallable(const CreatePermissionRequestT& request) const
        {
            return SubmitCallable(&RAMClient::CreatePermission, request);
        }
 
        template<typename CreatePermissionRequestT = Model::CreatePermissionRequest>
        void CreatePermissionAsync(const CreatePermissionRequestT& request, const CreatePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::CreatePermission, request, handler, context);
        }
 
        virtual Model::CreatePermissionVersionOutcome CreatePermissionVersion(const Model::CreatePermissionVersionRequest& request) const;
 
        template<typename CreatePermissionVersionRequestT = Model::CreatePermissionVersionRequest>
        Model::CreatePermissionVersionOutcomeCallable CreatePermissionVersionCallable(const CreatePermissionVersionRequestT& request) const
        {
            return SubmitCallable(&RAMClient::CreatePermissionVersion, request);
        }
 
        template<typename CreatePermissionVersionRequestT = Model::CreatePermissionVersionRequest>
        void CreatePermissionVersionAsync(const CreatePermissionVersionRequestT& request, const CreatePermissionVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::CreatePermissionVersion, request, handler, context);
        }
 
        virtual Model::CreateResourceShareOutcome CreateResourceShare(const Model::CreateResourceShareRequest& request) const;
 
        template<typename CreateResourceShareRequestT = Model::CreateResourceShareRequest>
        Model::CreateResourceShareOutcomeCallable CreateResourceShareCallable(const CreateResourceShareRequestT& request) const
        {
            return SubmitCallable(&RAMClient::CreateResourceShare, request);
        }
 
        template<typename CreateResourceShareRequestT = Model::CreateResourceShareRequest>
        void CreateResourceShareAsync(const CreateResourceShareRequestT& request, const CreateResourceShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::CreateResourceShare, request, handler, context);
        }
 
        virtual Model::DeletePermissionOutcome DeletePermission(const Model::DeletePermissionRequest& request) const;
 
        template<typename DeletePermissionRequestT = Model::DeletePermissionRequest>
        Model::DeletePermissionOutcomeCallable DeletePermissionCallable(const DeletePermissionRequestT& request) const
        {
            return SubmitCallable(&RAMClient::DeletePermission, request);
        }
 
        template<typename DeletePermissionRequestT = Model::DeletePermissionRequest>
        void DeletePermissionAsync(const DeletePermissionRequestT& request, const DeletePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::DeletePermission, request, handler, context);
        }
 
        virtual Model::DeletePermissionVersionOutcome DeletePermissionVersion(const Model::DeletePermissionVersionRequest& request) const;
 
        template<typename DeletePermissionVersionRequestT = Model::DeletePermissionVersionRequest>
        Model::DeletePermissionVersionOutcomeCallable DeletePermissionVersionCallable(const DeletePermissionVersionRequestT& request) const
        {
            return SubmitCallable(&RAMClient::DeletePermissionVersion, request);
        }
 
        template<typename DeletePermissionVersionRequestT = Model::DeletePermissionVersionRequest>
        void DeletePermissionVersionAsync(const DeletePermissionVersionRequestT& request, const DeletePermissionVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::DeletePermissionVersion, request, handler, context);
        }
 
        virtual Model::DeleteResourceShareOutcome DeleteResourceShare(const Model::DeleteResourceShareRequest& request) const;
 
        template<typename DeleteResourceShareRequestT = Model::DeleteResourceShareRequest>
        Model::DeleteResourceShareOutcomeCallable DeleteResourceShareCallable(const DeleteResourceShareRequestT& request) const
        {
            return SubmitCallable(&RAMClient::DeleteResourceShare, request);
        }
 
        template<typename DeleteResourceShareRequestT = Model::DeleteResourceShareRequest>
        void DeleteResourceShareAsync(const DeleteResourceShareRequestT& request, const DeleteResourceShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::DeleteResourceShare, request, handler, context);
        }
 
        virtual Model::DisassociateResourceShareOutcome DisassociateResourceShare(const Model::DisassociateResourceShareRequest& request) const;
 
        template<typename DisassociateResourceShareRequestT = Model::DisassociateResourceShareRequest>
        Model::DisassociateResourceShareOutcomeCallable DisassociateResourceShareCallable(const DisassociateResourceShareRequestT& request) const
        {
            return SubmitCallable(&RAMClient::DisassociateResourceShare, request);
        }
 
        template<typename DisassociateResourceShareRequestT = Model::DisassociateResourceShareRequest>
        void DisassociateResourceShareAsync(const DisassociateResourceShareRequestT& request, const DisassociateResourceShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::DisassociateResourceShare, request, handler, context);
        }
 
        virtual Model::DisassociateResourceSharePermissionOutcome DisassociateResourceSharePermission(const Model::DisassociateResourceSharePermissionRequest& request) const;
 
        template<typename DisassociateResourceSharePermissionRequestT = Model::DisassociateResourceSharePermissionRequest>
        Model::DisassociateResourceSharePermissionOutcomeCallable DisassociateResourceSharePermissionCallable(const DisassociateResourceSharePermissionRequestT& request) const
        {
            return SubmitCallable(&RAMClient::DisassociateResourceSharePermission, request);
        }
 
        template<typename DisassociateResourceSharePermissionRequestT = Model::DisassociateResourceSharePermissionRequest>
        void DisassociateResourceSharePermissionAsync(const DisassociateResourceSharePermissionRequestT& request, const DisassociateResourceSharePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::DisassociateResourceSharePermission, request, handler, context);
        }
 
        virtual Model::EnableSharingWithAwsOrganizationOutcome EnableSharingWithAwsOrganization(const Model::EnableSharingWithAwsOrganizationRequest& request = {}) const;
 
        template<typename EnableSharingWithAwsOrganizationRequestT = Model::EnableSharingWithAwsOrganizationRequest>
        Model::EnableSharingWithAwsOrganizationOutcomeCallable EnableSharingWithAwsOrganizationCallable(const EnableSharingWithAwsOrganizationRequestT& request = {}) const
        {
            return SubmitCallable(&RAMClient::EnableSharingWithAwsOrganization, request);
        }
 
        template<typename EnableSharingWithAwsOrganizationRequestT = Model::EnableSharingWithAwsOrganizationRequest>
        void EnableSharingWithAwsOrganizationAsync(const EnableSharingWithAwsOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const EnableSharingWithAwsOrganizationRequestT& request = {}) const
        {
            return SubmitAsync(&RAMClient::EnableSharingWithAwsOrganization, request, handler, context);
        }
 
        virtual Model::GetPermissionOutcome GetPermission(const Model::GetPermissionRequest& request) const;
 
        template<typename GetPermissionRequestT = Model::GetPermissionRequest>
        Model::GetPermissionOutcomeCallable GetPermissionCallable(const GetPermissionRequestT& request) const
        {
            return SubmitCallable(&RAMClient::GetPermission, request);
        }
 
        template<typename GetPermissionRequestT = Model::GetPermissionRequest>
        void GetPermissionAsync(const GetPermissionRequestT& request, const GetPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::GetPermission, request, handler, context);
        }
 
        virtual Model::GetResourcePoliciesOutcome GetResourcePolicies(const Model::GetResourcePoliciesRequest& request) const;
 
        template<typename GetResourcePoliciesRequestT = Model::GetResourcePoliciesRequest>
        Model::GetResourcePoliciesOutcomeCallable GetResourcePoliciesCallable(const GetResourcePoliciesRequestT& request) const
        {
            return SubmitCallable(&RAMClient::GetResourcePolicies, request);
        }
 
        template<typename GetResourcePoliciesRequestT = Model::GetResourcePoliciesRequest>
        void GetResourcePoliciesAsync(const GetResourcePoliciesRequestT& request, const GetResourcePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::GetResourcePolicies, request, handler, context);
        }
 
        virtual Model::GetResourceShareAssociationsOutcome GetResourceShareAssociations(const Model::GetResourceShareAssociationsRequest& request) const;
 
        template<typename GetResourceShareAssociationsRequestT = Model::GetResourceShareAssociationsRequest>
        Model::GetResourceShareAssociationsOutcomeCallable GetResourceShareAssociationsCallable(const GetResourceShareAssociationsRequestT& request) const
        {
            return SubmitCallable(&RAMClient::GetResourceShareAssociations, request);
        }
 
        template<typename GetResourceShareAssociationsRequestT = Model::GetResourceShareAssociationsRequest>
        void GetResourceShareAssociationsAsync(const GetResourceShareAssociationsRequestT& request, const GetResourceShareAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::GetResourceShareAssociations, request, handler, context);
        }
 
        virtual Model::GetResourceShareInvitationsOutcome GetResourceShareInvitations(const Model::GetResourceShareInvitationsRequest& request = {}) const;
 
        template<typename GetResourceShareInvitationsRequestT = Model::GetResourceShareInvitationsRequest>
        Model::GetResourceShareInvitationsOutcomeCallable GetResourceShareInvitationsCallable(const GetResourceShareInvitationsRequestT& request = {}) const
        {
            return SubmitCallable(&RAMClient::GetResourceShareInvitations, request);
        }
 
        template<typename GetResourceShareInvitationsRequestT = Model::GetResourceShareInvitationsRequest>
        void GetResourceShareInvitationsAsync(const GetResourceShareInvitationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetResourceShareInvitationsRequestT& request = {}) const
        {
            return SubmitAsync(&RAMClient::GetResourceShareInvitations, request, handler, context);
        }
 
        virtual Model::GetResourceSharesOutcome GetResourceShares(const Model::GetResourceSharesRequest& request) const;
 
        template<typename GetResourceSharesRequestT = Model::GetResourceSharesRequest>
        Model::GetResourceSharesOutcomeCallable GetResourceSharesCallable(const GetResourceSharesRequestT& request) const
        {
            return SubmitCallable(&RAMClient::GetResourceShares, request);
        }
 
        template<typename GetResourceSharesRequestT = Model::GetResourceSharesRequest>
        void GetResourceSharesAsync(const GetResourceSharesRequestT& request, const GetResourceSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::GetResourceShares, request, handler, context);
        }
 
        virtual Model::ListPendingInvitationResourcesOutcome ListPendingInvitationResources(const Model::ListPendingInvitationResourcesRequest& request) const;
 
        template<typename ListPendingInvitationResourcesRequestT = Model::ListPendingInvitationResourcesRequest>
        Model::ListPendingInvitationResourcesOutcomeCallable ListPendingInvitationResourcesCallable(const ListPendingInvitationResourcesRequestT& request) const
        {
            return SubmitCallable(&RAMClient::ListPendingInvitationResources, request);
        }
 
        template<typename ListPendingInvitationResourcesRequestT = Model::ListPendingInvitationResourcesRequest>
        void ListPendingInvitationResourcesAsync(const ListPendingInvitationResourcesRequestT& request, const ListPendingInvitationResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::ListPendingInvitationResources, request, handler, context);
        }
 
        virtual Model::ListPermissionAssociationsOutcome ListPermissionAssociations(const Model::ListPermissionAssociationsRequest& request = {}) const;
 
        template<typename ListPermissionAssociationsRequestT = Model::ListPermissionAssociationsRequest>
        Model::ListPermissionAssociationsOutcomeCallable ListPermissionAssociationsCallable(const ListPermissionAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&RAMClient::ListPermissionAssociations, request);
        }
 
        template<typename ListPermissionAssociationsRequestT = Model::ListPermissionAssociationsRequest>
        void ListPermissionAssociationsAsync(const ListPermissionAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPermissionAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&RAMClient::ListPermissionAssociations, request, handler, context);
        }
 
        virtual Model::ListPermissionVersionsOutcome ListPermissionVersions(const Model::ListPermissionVersionsRequest& request) const;
 
        template<typename ListPermissionVersionsRequestT = Model::ListPermissionVersionsRequest>
        Model::ListPermissionVersionsOutcomeCallable ListPermissionVersionsCallable(const ListPermissionVersionsRequestT& request) const
        {
            return SubmitCallable(&RAMClient::ListPermissionVersions, request);
        }
 
        template<typename ListPermissionVersionsRequestT = Model::ListPermissionVersionsRequest>
        void ListPermissionVersionsAsync(const ListPermissionVersionsRequestT& request, const ListPermissionVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::ListPermissionVersions, request, handler, context);
        }
 
        virtual Model::ListPermissionsOutcome ListPermissions(const Model::ListPermissionsRequest& request = {}) const;
 
        template<typename ListPermissionsRequestT = Model::ListPermissionsRequest>
        Model::ListPermissionsOutcomeCallable ListPermissionsCallable(const ListPermissionsRequestT& request = {}) const
        {
            return SubmitCallable(&RAMClient::ListPermissions, request);
        }
 
        template<typename ListPermissionsRequestT = Model::ListPermissionsRequest>
        void ListPermissionsAsync(const ListPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPermissionsRequestT& request = {}) const
        {
            return SubmitAsync(&RAMClient::ListPermissions, request, handler, context);
        }
 
        virtual Model::ListPrincipalsOutcome ListPrincipals(const Model::ListPrincipalsRequest& request) const;
 
        template<typename ListPrincipalsRequestT = Model::ListPrincipalsRequest>
        Model::ListPrincipalsOutcomeCallable ListPrincipalsCallable(const ListPrincipalsRequestT& request) const
        {
            return SubmitCallable(&RAMClient::ListPrincipals, request);
        }
 
        template<typename ListPrincipalsRequestT = Model::ListPrincipalsRequest>
        void ListPrincipalsAsync(const ListPrincipalsRequestT& request, const ListPrincipalsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::ListPrincipals, request, handler, context);
        }
 
        virtual Model::ListReplacePermissionAssociationsWorkOutcome ListReplacePermissionAssociationsWork(const Model::ListReplacePermissionAssociationsWorkRequest& request = {}) const;
 
        template<typename ListReplacePermissionAssociationsWorkRequestT = Model::ListReplacePermissionAssociationsWorkRequest>
        Model::ListReplacePermissionAssociationsWorkOutcomeCallable ListReplacePermissionAssociationsWorkCallable(const ListReplacePermissionAssociationsWorkRequestT& request = {}) const
        {
            return SubmitCallable(&RAMClient::ListReplacePermissionAssociationsWork, request);
        }
 
        template<typename ListReplacePermissionAssociationsWorkRequestT = Model::ListReplacePermissionAssociationsWorkRequest>
        void ListReplacePermissionAssociationsWorkAsync(const ListReplacePermissionAssociationsWorkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReplacePermissionAssociationsWorkRequestT& request = {}) const
        {
            return SubmitAsync(&RAMClient::ListReplacePermissionAssociationsWork, request, handler, context);
        }
 
        virtual Model::ListResourceSharePermissionsOutcome ListResourceSharePermissions(const Model::ListResourceSharePermissionsRequest& request) const;
 
        template<typename ListResourceSharePermissionsRequestT = Model::ListResourceSharePermissionsRequest>
        Model::ListResourceSharePermissionsOutcomeCallable ListResourceSharePermissionsCallable(const ListResourceSharePermissionsRequestT& request) const
        {
            return SubmitCallable(&RAMClient::ListResourceSharePermissions, request);
        }
 
        template<typename ListResourceSharePermissionsRequestT = Model::ListResourceSharePermissionsRequest>
        void ListResourceSharePermissionsAsync(const ListResourceSharePermissionsRequestT& request, const ListResourceSharePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::ListResourceSharePermissions, request, handler, context);
        }
 
        virtual Model::ListResourceTypesOutcome ListResourceTypes(const Model::ListResourceTypesRequest& request = {}) const;
 
        template<typename ListResourceTypesRequestT = Model::ListResourceTypesRequest>
        Model::ListResourceTypesOutcomeCallable ListResourceTypesCallable(const ListResourceTypesRequestT& request = {}) const
        {
            return SubmitCallable(&RAMClient::ListResourceTypes, request);
        }
 
        template<typename ListResourceTypesRequestT = Model::ListResourceTypesRequest>
        void ListResourceTypesAsync(const ListResourceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourceTypesRequestT& request = {}) const
        {
            return SubmitAsync(&RAMClient::ListResourceTypes, 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(&RAMClient::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(&RAMClient::ListResources, request, handler, context);
        }
 
        virtual Model::PromotePermissionCreatedFromPolicyOutcome PromotePermissionCreatedFromPolicy(const Model::PromotePermissionCreatedFromPolicyRequest& request) const;
 
        template<typename PromotePermissionCreatedFromPolicyRequestT = Model::PromotePermissionCreatedFromPolicyRequest>
        Model::PromotePermissionCreatedFromPolicyOutcomeCallable PromotePermissionCreatedFromPolicyCallable(const PromotePermissionCreatedFromPolicyRequestT& request) const
        {
            return SubmitCallable(&RAMClient::PromotePermissionCreatedFromPolicy, request);
        }
 
        template<typename PromotePermissionCreatedFromPolicyRequestT = Model::PromotePermissionCreatedFromPolicyRequest>
        void PromotePermissionCreatedFromPolicyAsync(const PromotePermissionCreatedFromPolicyRequestT& request, const PromotePermissionCreatedFromPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::PromotePermissionCreatedFromPolicy, request, handler, context);
        }
 
        virtual Model::PromoteResourceShareCreatedFromPolicyOutcome PromoteResourceShareCreatedFromPolicy(const Model::PromoteResourceShareCreatedFromPolicyRequest& request) const;
 
        template<typename PromoteResourceShareCreatedFromPolicyRequestT = Model::PromoteResourceShareCreatedFromPolicyRequest>
        Model::PromoteResourceShareCreatedFromPolicyOutcomeCallable PromoteResourceShareCreatedFromPolicyCallable(const PromoteResourceShareCreatedFromPolicyRequestT& request) const
        {
            return SubmitCallable(&RAMClient::PromoteResourceShareCreatedFromPolicy, request);
        }
 
        template<typename PromoteResourceShareCreatedFromPolicyRequestT = Model::PromoteResourceShareCreatedFromPolicyRequest>
        void PromoteResourceShareCreatedFromPolicyAsync(const PromoteResourceShareCreatedFromPolicyRequestT& request, const PromoteResourceShareCreatedFromPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::PromoteResourceShareCreatedFromPolicy, request, handler, context);
        }
 
        virtual Model::RejectResourceShareInvitationOutcome RejectResourceShareInvitation(const Model::RejectResourceShareInvitationRequest& request) const;
 
        template<typename RejectResourceShareInvitationRequestT = Model::RejectResourceShareInvitationRequest>
        Model::RejectResourceShareInvitationOutcomeCallable RejectResourceShareInvitationCallable(const RejectResourceShareInvitationRequestT& request) const
        {
            return SubmitCallable(&RAMClient::RejectResourceShareInvitation, request);
        }
 
        template<typename RejectResourceShareInvitationRequestT = Model::RejectResourceShareInvitationRequest>
        void RejectResourceShareInvitationAsync(const RejectResourceShareInvitationRequestT& request, const RejectResourceShareInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::RejectResourceShareInvitation, request, handler, context);
        }
 
        virtual Model::ReplacePermissionAssociationsOutcome ReplacePermissionAssociations(const Model::ReplacePermissionAssociationsRequest& request) const;
 
        template<typename ReplacePermissionAssociationsRequestT = Model::ReplacePermissionAssociationsRequest>
        Model::ReplacePermissionAssociationsOutcomeCallable ReplacePermissionAssociationsCallable(const ReplacePermissionAssociationsRequestT& request) const
        {
            return SubmitCallable(&RAMClient::ReplacePermissionAssociations, request);
        }
 
        template<typename ReplacePermissionAssociationsRequestT = Model::ReplacePermissionAssociationsRequest>
        void ReplacePermissionAssociationsAsync(const ReplacePermissionAssociationsRequestT& request, const ReplacePermissionAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::ReplacePermissionAssociations, request, handler, context);
        }
 
        virtual Model::SetDefaultPermissionVersionOutcome SetDefaultPermissionVersion(const Model::SetDefaultPermissionVersionRequest& request) const;
 
        template<typename SetDefaultPermissionVersionRequestT = Model::SetDefaultPermissionVersionRequest>
        Model::SetDefaultPermissionVersionOutcomeCallable SetDefaultPermissionVersionCallable(const SetDefaultPermissionVersionRequestT& request) const
        {
            return SubmitCallable(&RAMClient::SetDefaultPermissionVersion, request);
        }
 
        template<typename SetDefaultPermissionVersionRequestT = Model::SetDefaultPermissionVersionRequest>
        void SetDefaultPermissionVersionAsync(const SetDefaultPermissionVersionRequestT& request, const SetDefaultPermissionVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::SetDefaultPermissionVersion, 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(&RAMClient::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(&RAMClient::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(&RAMClient::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(&RAMClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateResourceShareOutcome UpdateResourceShare(const Model::UpdateResourceShareRequest& request) const;
 
        template<typename UpdateResourceShareRequestT = Model::UpdateResourceShareRequest>
        Model::UpdateResourceShareOutcomeCallable UpdateResourceShareCallable(const UpdateResourceShareRequestT& request) const
        {
            return SubmitCallable(&RAMClient::UpdateResourceShare, request);
        }
 
        template<typename UpdateResourceShareRequestT = Model::UpdateResourceShareRequest>
        void UpdateResourceShareAsync(const UpdateResourceShareRequestT& request, const UpdateResourceShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RAMClient::UpdateResourceShare, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<RAMEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<RAMClient>;
      void init(const RAMClientConfiguration& clientConfiguration);
 
      RAMClientConfiguration m_clientConfiguration;
      std::shared_ptr<RAMEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace RAM
} // namespace Aws