IdentityStoreClient.h

 
#pragma once
#include <aws/identitystore/IdentityStore_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/identitystore/IdentityStoreServiceClientModel.h>
 
namespace Aws
{
namespace IdentityStore
{
  class AWS_IDENTITYSTORE_API IdentityStoreClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IdentityStoreClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IdentityStoreClientConfiguration ClientConfigurationType;
      typedef IdentityStoreEndpointProvider EndpointProviderType;
 
        IdentityStoreClient(const Aws::IdentityStore::IdentityStoreClientConfiguration& clientConfiguration = Aws::IdentityStore::IdentityStoreClientConfiguration(),
                            std::shared_ptr<IdentityStoreEndpointProviderBase> endpointProvider = nullptr);
 
        IdentityStoreClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<IdentityStoreEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::IdentityStore::IdentityStoreClientConfiguration& clientConfiguration = Aws::IdentityStore::IdentityStoreClientConfiguration());
 
        IdentityStoreClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<IdentityStoreEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::IdentityStore::IdentityStoreClientConfiguration& clientConfiguration = Aws::IdentityStore::IdentityStoreClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IdentityStoreClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IdentityStoreClient(const Aws::Auth::AWSCredentials& credentials,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IdentityStoreClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IdentityStoreClient();
 
        virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::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(&IdentityStoreClient::CreateGroup, request, handler, context);
        }
 
        virtual Model::CreateGroupMembershipOutcome CreateGroupMembership(const Model::CreateGroupMembershipRequest& request) const;
 
        template<typename CreateGroupMembershipRequestT = Model::CreateGroupMembershipRequest>
        Model::CreateGroupMembershipOutcomeCallable CreateGroupMembershipCallable(const CreateGroupMembershipRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::CreateGroupMembership, request);
        }
 
        template<typename CreateGroupMembershipRequestT = Model::CreateGroupMembershipRequest>
        void CreateGroupMembershipAsync(const CreateGroupMembershipRequestT& request, const CreateGroupMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::CreateGroupMembership, 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(&IdentityStoreClient::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(&IdentityStoreClient::CreateUser, 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(&IdentityStoreClient::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(&IdentityStoreClient::DeleteGroup, request, handler, context);
        }
 
        virtual Model::DeleteGroupMembershipOutcome DeleteGroupMembership(const Model::DeleteGroupMembershipRequest& request) const;
 
        template<typename DeleteGroupMembershipRequestT = Model::DeleteGroupMembershipRequest>
        Model::DeleteGroupMembershipOutcomeCallable DeleteGroupMembershipCallable(const DeleteGroupMembershipRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::DeleteGroupMembership, request);
        }
 
        template<typename DeleteGroupMembershipRequestT = Model::DeleteGroupMembershipRequest>
        void DeleteGroupMembershipAsync(const DeleteGroupMembershipRequestT& request, const DeleteGroupMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::DeleteGroupMembership, 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(&IdentityStoreClient::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(&IdentityStoreClient::DeleteUser, 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(&IdentityStoreClient::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(&IdentityStoreClient::DescribeGroup, request, handler, context);
        }
 
        virtual Model::DescribeGroupMembershipOutcome DescribeGroupMembership(const Model::DescribeGroupMembershipRequest& request) const;
 
        template<typename DescribeGroupMembershipRequestT = Model::DescribeGroupMembershipRequest>
        Model::DescribeGroupMembershipOutcomeCallable DescribeGroupMembershipCallable(const DescribeGroupMembershipRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::DescribeGroupMembership, request);
        }
 
        template<typename DescribeGroupMembershipRequestT = Model::DescribeGroupMembershipRequest>
        void DescribeGroupMembershipAsync(const DescribeGroupMembershipRequestT& request, const DescribeGroupMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::DescribeGroupMembership, 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(&IdentityStoreClient::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(&IdentityStoreClient::DescribeUser, request, handler, context);
        }
 
        virtual Model::GetGroupIdOutcome GetGroupId(const Model::GetGroupIdRequest& request) const;
 
        template<typename GetGroupIdRequestT = Model::GetGroupIdRequest>
        Model::GetGroupIdOutcomeCallable GetGroupIdCallable(const GetGroupIdRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::GetGroupId, request);
        }
 
        template<typename GetGroupIdRequestT = Model::GetGroupIdRequest>
        void GetGroupIdAsync(const GetGroupIdRequestT& request, const GetGroupIdResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::GetGroupId, request, handler, context);
        }
 
        virtual Model::GetGroupMembershipIdOutcome GetGroupMembershipId(const Model::GetGroupMembershipIdRequest& request) const;
 
        template<typename GetGroupMembershipIdRequestT = Model::GetGroupMembershipIdRequest>
        Model::GetGroupMembershipIdOutcomeCallable GetGroupMembershipIdCallable(const GetGroupMembershipIdRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::GetGroupMembershipId, request);
        }
 
        template<typename GetGroupMembershipIdRequestT = Model::GetGroupMembershipIdRequest>
        void GetGroupMembershipIdAsync(const GetGroupMembershipIdRequestT& request, const GetGroupMembershipIdResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::GetGroupMembershipId, request, handler, context);
        }
 
        virtual Model::GetUserIdOutcome GetUserId(const Model::GetUserIdRequest& request) const;
 
        template<typename GetUserIdRequestT = Model::GetUserIdRequest>
        Model::GetUserIdOutcomeCallable GetUserIdCallable(const GetUserIdRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::GetUserId, request);
        }
 
        template<typename GetUserIdRequestT = Model::GetUserIdRequest>
        void GetUserIdAsync(const GetUserIdRequestT& request, const GetUserIdResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::GetUserId, request, handler, context);
        }
 
        virtual Model::IsMemberInGroupsOutcome IsMemberInGroups(const Model::IsMemberInGroupsRequest& request) const;
 
        template<typename IsMemberInGroupsRequestT = Model::IsMemberInGroupsRequest>
        Model::IsMemberInGroupsOutcomeCallable IsMemberInGroupsCallable(const IsMemberInGroupsRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::IsMemberInGroups, request);
        }
 
        template<typename IsMemberInGroupsRequestT = Model::IsMemberInGroupsRequest>
        void IsMemberInGroupsAsync(const IsMemberInGroupsRequestT& request, const IsMemberInGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::IsMemberInGroups, request, handler, context);
        }
 
        virtual Model::ListGroupMembershipsOutcome ListGroupMemberships(const Model::ListGroupMembershipsRequest& request) const;
 
        template<typename ListGroupMembershipsRequestT = Model::ListGroupMembershipsRequest>
        Model::ListGroupMembershipsOutcomeCallable ListGroupMembershipsCallable(const ListGroupMembershipsRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::ListGroupMemberships, request);
        }
 
        template<typename ListGroupMembershipsRequestT = Model::ListGroupMembershipsRequest>
        void ListGroupMembershipsAsync(const ListGroupMembershipsRequestT& request, const ListGroupMembershipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::ListGroupMemberships, request, handler, context);
        }
 
        virtual Model::ListGroupMembershipsForMemberOutcome ListGroupMembershipsForMember(const Model::ListGroupMembershipsForMemberRequest& request) const;
 
        template<typename ListGroupMembershipsForMemberRequestT = Model::ListGroupMembershipsForMemberRequest>
        Model::ListGroupMembershipsForMemberOutcomeCallable ListGroupMembershipsForMemberCallable(const ListGroupMembershipsForMemberRequestT& request) const
        {
            return SubmitCallable(&IdentityStoreClient::ListGroupMembershipsForMember, request);
        }
 
        template<typename ListGroupMembershipsForMemberRequestT = Model::ListGroupMembershipsForMemberRequest>
        void ListGroupMembershipsForMemberAsync(const ListGroupMembershipsForMemberRequestT& request, const ListGroupMembershipsForMemberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IdentityStoreClient::ListGroupMembershipsForMember, 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(&IdentityStoreClient::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(&IdentityStoreClient::ListGroups, 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(&IdentityStoreClient::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(&IdentityStoreClient::ListUsers, 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(&IdentityStoreClient::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(&IdentityStoreClient::UpdateGroup, 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(&IdentityStoreClient::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(&IdentityStoreClient::UpdateUser, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IdentityStoreEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IdentityStoreClient>;
      void init(const IdentityStoreClientConfiguration& clientConfiguration);
 
      IdentityStoreClientConfiguration m_clientConfiguration;
      std::shared_ptr<IdentityStoreEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IdentityStore
} // namespace Aws