RAMClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ram/RAMPaginationBase.h>
#include <aws/ram/RAMServiceClientModel.h>
#include <aws/ram/RAMWaiter.h>
#include <aws/ram/RAM_EXPORTS.h>
 
namespace Aws {
namespace RAM {
class AWS_RAM_API RAMClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<RAMClient>,
                              public RAMPaginationBase<RAMClient>,
                              public RAMWaiter<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::ListSourceAssociationsOutcome ListSourceAssociations(const Model::ListSourceAssociationsRequest& request = {}) const;
 
  template <typename ListSourceAssociationsRequestT = Model::ListSourceAssociationsRequest>
  Model::ListSourceAssociationsOutcomeCallable ListSourceAssociationsCallable(const ListSourceAssociationsRequestT& request = {}) const {
    return SubmitCallable(&RAMClient::ListSourceAssociations, request);
  }
 
  template <typename ListSourceAssociationsRequestT = Model::ListSourceAssociationsRequest>
  void ListSourceAssociationsAsync(const ListSourceAssociationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListSourceAssociationsRequestT& request = {}) const {
    return SubmitAsync(&RAMClient::ListSourceAssociations, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<RAMEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<RAMClient>;
  void init(const RAMClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, RAMError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  RAMClientConfiguration m_clientConfiguration;
  std::shared_ptr<RAMEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace RAM
}  // namespace Aws