Interface IdentityDomainsAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    IdentityDomainsAsyncClient

    @Generated(value="OracleSDKGenerator",
               comments="API Version: v1")
    public interface IdentityDomainsAsync
    extends AutoCloseable
    Use the Identity Domains API to manage resources within an identity domain, for example, users, dynamic resource groups, groups, and identity providers.

    For information about managing resources within identity domains, see Identity and Access Management (with identity domains). Use this pattern to construct endpoints for identity domains: https:///admin/v1/. See Finding an Identity Domain URL to locate the domain URL you need. Use the table of contents and search tool to explore the Identity Domains API.

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

        void setEndpoint​(String endpoint)
        Sets the endpoint to call (ex, https://www.example.com).
        Parameters:
        endpoint - The endpoint of the serice.
      • getEndpoint

        String getEndpoint()
        Gets the set endpoint for REST call (ex, https://www.example.com)
      • createApiKey

        Future<CreateApiKeyResponse> createApiKey​(CreateApiKeyRequest request,
                                                  AsyncHandler<CreateApiKeyRequest,​CreateApiKeyResponse> handler)
        Create a user’s API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createApp

        Future<CreateAppResponse> createApp​(CreateAppRequest request,
                                            AsyncHandler<CreateAppRequest,​CreateAppResponse> handler)
        Create an App
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createAppRole

        Future<CreateAppRoleResponse> createAppRole​(CreateAppRoleRequest request,
                                                    AsyncHandler<CreateAppRoleRequest,​CreateAppRoleResponse> handler)
        Create an AppRole
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createAuthToken

        Future<CreateAuthTokenResponse> createAuthToken​(CreateAuthTokenRequest request,
                                                        AsyncHandler<CreateAuthTokenRequest,​CreateAuthTokenResponse> handler)
        Create a user’s Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createCloudGate

        Future<CreateCloudGateResponse> createCloudGate​(CreateCloudGateRequest request,
                                                        AsyncHandler<CreateCloudGateRequest,​CreateCloudGateResponse> handler)
        Create a Cloud Gate
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createCloudGateServer

        Future<CreateCloudGateServerResponse> createCloudGateServer​(CreateCloudGateServerRequest request,
                                                                    AsyncHandler<CreateCloudGateServerRequest,​CreateCloudGateServerResponse> handler)
        Create a Cloud Gate server
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createCondition

        Future<CreateConditionResponse> createCondition​(CreateConditionRequest request,
                                                        AsyncHandler<CreateConditionRequest,​CreateConditionResponse> handler)
        Create a condition
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createGrant

        Future<CreateGrantResponse> createGrant​(CreateGrantRequest request,
                                                AsyncHandler<CreateGrantRequest,​CreateGrantResponse> handler)
        Add a Grantee to an AppRole
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createGroup

        Future<CreateGroupResponse> createGroup​(CreateGroupRequest request,
                                                AsyncHandler<CreateGroupRequest,​CreateGroupResponse> handler)
        Create a group.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createMe

        Future<CreateMeResponse> createMe​(CreateMeRequest request,
                                          AsyncHandler<CreateMeRequest,​CreateMeResponse> handler)
        Self register a user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createMyApiKey

        Future<CreateMyApiKeyResponse> createMyApiKey​(CreateMyApiKeyRequest request,
                                                      AsyncHandler<CreateMyApiKeyRequest,​CreateMyApiKeyResponse> handler)
        Add a user’s own API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createMyAuthToken

        Future<CreateMyAuthTokenResponse> createMyAuthToken​(CreateMyAuthTokenRequest request,
                                                            AsyncHandler<CreateMyAuthTokenRequest,​CreateMyAuthTokenResponse> handler)
        Create a user’s own Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createMyRequest

        Future<CreateMyRequestResponse> createMyRequest​(CreateMyRequestRequest request,
                                                        AsyncHandler<CreateMyRequestRequest,​CreateMyRequestResponse> handler)
        Create a Request
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createMySmtpCredential

        Future<CreateMySmtpCredentialResponse> createMySmtpCredential​(CreateMySmtpCredentialRequest request,
                                                                      AsyncHandler<CreateMySmtpCredentialRequest,​CreateMySmtpCredentialResponse> handler)
        Create a user’s own SMTP credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createMySupportAccount

        Future<CreateMySupportAccountResponse> createMySupportAccount​(CreateMySupportAccountRequest request,
                                                                      AsyncHandler<CreateMySupportAccountRequest,​CreateMySupportAccountResponse> handler)
        Create a user’s own support account.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createPasswordPolicy

        Future<CreatePasswordPolicyResponse> createPasswordPolicy​(CreatePasswordPolicyRequest request,
                                                                  AsyncHandler<CreatePasswordPolicyRequest,​CreatePasswordPolicyResponse> handler)
        Create a password policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createPolicy

        Future<CreatePolicyResponse> createPolicy​(CreatePolicyRequest request,
                                                  AsyncHandler<CreatePolicyRequest,​CreatePolicyResponse> handler)
        Create a Policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createRule

        Future<CreateRuleResponse> createRule​(CreateRuleRequest request,
                                              AsyncHandler<CreateRuleRequest,​CreateRuleResponse> handler)
        Create a Rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createSmtpCredential

        Future<CreateSmtpCredentialResponse> createSmtpCredential​(CreateSmtpCredentialRequest request,
                                                                  AsyncHandler<CreateSmtpCredentialRequest,​CreateSmtpCredentialResponse> handler)
        Create a user’s SMTP credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createUser

        Future<CreateUserResponse> createUser​(CreateUserRequest request,
                                              AsyncHandler<CreateUserRequest,​CreateUserResponse> handler)
        Create a user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createUserDbCredential

        Future<CreateUserDbCredentialResponse> createUserDbCredential​(CreateUserDbCredentialRequest request,
                                                                      AsyncHandler<CreateUserDbCredentialRequest,​CreateUserDbCredentialResponse> handler)
        Create a user’s database (DB) credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteApiKey

        Future<DeleteApiKeyResponse> deleteApiKey​(DeleteApiKeyRequest request,
                                                  AsyncHandler<DeleteApiKeyRequest,​DeleteApiKeyResponse> handler)
        Delete a user’s API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteApp

        Future<DeleteAppResponse> deleteApp​(DeleteAppRequest request,
                                            AsyncHandler<DeleteAppRequest,​DeleteAppResponse> handler)
        Delete an App
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteAppRole

        Future<DeleteAppRoleResponse> deleteAppRole​(DeleteAppRoleRequest request,
                                                    AsyncHandler<DeleteAppRoleRequest,​DeleteAppRoleResponse> handler)
        Delete an AppRole
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteAuthToken

        Future<DeleteAuthTokenResponse> deleteAuthToken​(DeleteAuthTokenRequest request,
                                                        AsyncHandler<DeleteAuthTokenRequest,​DeleteAuthTokenResponse> handler)
        Delete a user’s Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteCloudGate

        Future<DeleteCloudGateResponse> deleteCloudGate​(DeleteCloudGateRequest request,
                                                        AsyncHandler<DeleteCloudGateRequest,​DeleteCloudGateResponse> handler)
        Delete a Cloud Gate
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteCloudGateServer

        Future<DeleteCloudGateServerResponse> deleteCloudGateServer​(DeleteCloudGateServerRequest request,
                                                                    AsyncHandler<DeleteCloudGateServerRequest,​DeleteCloudGateServerResponse> handler)
        Delete a Cloud Gate server
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteCondition

        Future<DeleteConditionResponse> deleteCondition​(DeleteConditionRequest request,
                                                        AsyncHandler<DeleteConditionRequest,​DeleteConditionResponse> handler)
        Delete a condition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteGrant

        Future<DeleteGrantResponse> deleteGrant​(DeleteGrantRequest request,
                                                AsyncHandler<DeleteGrantRequest,​DeleteGrantResponse> handler)
        Remove a Grantee from an AppRole
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteGroup

        Future<DeleteGroupResponse> deleteGroup​(DeleteGroupRequest request,
                                                AsyncHandler<DeleteGroupRequest,​DeleteGroupResponse> handler)
        Delete a group.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteMyApiKey

        Future<DeleteMyApiKeyResponse> deleteMyApiKey​(DeleteMyApiKeyRequest request,
                                                      AsyncHandler<DeleteMyApiKeyRequest,​DeleteMyApiKeyResponse> handler)
        Delete a user’s own API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteMyAuthToken

        Future<DeleteMyAuthTokenResponse> deleteMyAuthToken​(DeleteMyAuthTokenRequest request,
                                                            AsyncHandler<DeleteMyAuthTokenRequest,​DeleteMyAuthTokenResponse> handler)
        Delete a user’s own Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteMyDevice

        Future<DeleteMyDeviceResponse> deleteMyDevice​(DeleteMyDeviceRequest request,
                                                      AsyncHandler<DeleteMyDeviceRequest,​DeleteMyDeviceResponse> handler)
        Delete a Device
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteMySmtpCredential

        Future<DeleteMySmtpCredentialResponse> deleteMySmtpCredential​(DeleteMySmtpCredentialRequest request,
                                                                      AsyncHandler<DeleteMySmtpCredentialRequest,​DeleteMySmtpCredentialResponse> handler)
        Delete a user’s own SMTP credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteMySupportAccount

        Future<DeleteMySupportAccountResponse> deleteMySupportAccount​(DeleteMySupportAccountRequest request,
                                                                      AsyncHandler<DeleteMySupportAccountRequest,​DeleteMySupportAccountResponse> handler)
        Delete a user’s own support account.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deletePasswordPolicy

        Future<DeletePasswordPolicyResponse> deletePasswordPolicy​(DeletePasswordPolicyRequest request,
                                                                  AsyncHandler<DeletePasswordPolicyRequest,​DeletePasswordPolicyResponse> handler)
        Delete a password policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deletePolicy

        Future<DeletePolicyResponse> deletePolicy​(DeletePolicyRequest request,
                                                  AsyncHandler<DeletePolicyRequest,​DeletePolicyResponse> handler)
        Delete a Policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteRule

        Future<DeleteRuleResponse> deleteRule​(DeleteRuleRequest request,
                                              AsyncHandler<DeleteRuleRequest,​DeleteRuleResponse> handler)
        Delete a Rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteSmtpCredential

        Future<DeleteSmtpCredentialResponse> deleteSmtpCredential​(DeleteSmtpCredentialRequest request,
                                                                  AsyncHandler<DeleteSmtpCredentialRequest,​DeleteSmtpCredentialResponse> handler)
        Delete a user’s SMTP credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteUser

        Future<DeleteUserResponse> deleteUser​(DeleteUserRequest request,
                                              AsyncHandler<DeleteUserRequest,​DeleteUserResponse> handler)
        Delete a user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteUserDbCredential

        Future<DeleteUserDbCredentialResponse> deleteUserDbCredential​(DeleteUserDbCredentialRequest request,
                                                                      AsyncHandler<DeleteUserDbCredentialRequest,​DeleteUserDbCredentialResponse> handler)
        Delete a user’s database (DB) credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getAccountMgmtInfo

        Future<GetAccountMgmtInfoResponse> getAccountMgmtInfo​(GetAccountMgmtInfoRequest request,
                                                              AsyncHandler<GetAccountMgmtInfoRequest,​GetAccountMgmtInfoResponse> handler)
        Get Account Mgmt Info
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getApiKey

        Future<GetApiKeyResponse> getApiKey​(GetApiKeyRequest request,
                                            AsyncHandler<GetApiKeyRequest,​GetApiKeyResponse> handler)
        Get a user’s API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getApp

        Future<GetAppResponse> getApp​(GetAppRequest request,
                                      AsyncHandler<GetAppRequest,​GetAppResponse> handler)
        Get an App
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getAppRole

        Future<GetAppRoleResponse> getAppRole​(GetAppRoleRequest request,
                                              AsyncHandler<GetAppRoleRequest,​GetAppRoleResponse> handler)
        Get an AppRole
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getApprovalWorkflow

        Future<GetApprovalWorkflowResponse> getApprovalWorkflow​(GetApprovalWorkflowRequest request,
                                                                AsyncHandler<GetApprovalWorkflowRequest,​GetApprovalWorkflowResponse> handler)
        Get ApprovalWorkflow
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getAuthToken

        Future<GetAuthTokenResponse> getAuthToken​(GetAuthTokenRequest request,
                                                  AsyncHandler<GetAuthTokenRequest,​GetAuthTokenResponse> handler)
        Get a user’s Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getBrandingSetting

        Future<GetBrandingSettingResponse> getBrandingSetting​(GetBrandingSettingRequest request,
                                                              AsyncHandler<GetBrandingSettingRequest,​GetBrandingSettingResponse> handler)
        Get Branding Settings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getCloudGate

        Future<GetCloudGateResponse> getCloudGate​(GetCloudGateRequest request,
                                                  AsyncHandler<GetCloudGateRequest,​GetCloudGateResponse> handler)
        Get a Cloud Gate
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getCloudGateMapping

        Future<GetCloudGateMappingResponse> getCloudGateMapping​(GetCloudGateMappingRequest request,
                                                                AsyncHandler<GetCloudGateMappingRequest,​GetCloudGateMappingResponse> handler)
        Get a Cloud Gate mapping
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getCloudGateServer

        Future<GetCloudGateServerResponse> getCloudGateServer​(GetCloudGateServerRequest request,
                                                              AsyncHandler<GetCloudGateServerRequest,​GetCloudGateServerResponse> handler)
        Get a Cloud Gate server
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getCondition

        Future<GetConditionResponse> getCondition​(GetConditionRequest request,
                                                  AsyncHandler<GetConditionRequest,​GetConditionResponse> handler)
        Get a condition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getCustomerSecretKey

        Future<GetCustomerSecretKeyResponse> getCustomerSecretKey​(GetCustomerSecretKeyRequest request,
                                                                  AsyncHandler<GetCustomerSecretKeyRequest,​GetCustomerSecretKeyResponse> handler)
        Get a user’s customer secret key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getGrant

        Future<GetGrantResponse> getGrant​(GetGrantRequest request,
                                          AsyncHandler<GetGrantRequest,​GetGrantResponse> handler)
        Get a Grant
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getGroup

        Future<GetGroupResponse> getGroup​(GetGroupRequest request,
                                          AsyncHandler<GetGroupRequest,​GetGroupResponse> handler)
        Get a group.

        Important: The Group SEARCH and GET operations on users and members will throw an exception if the response has more than 10,000 members. To avoid the exception, use the pagination filter to GET or SEARCH group members.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getIdentityProvider

        Future<GetIdentityProviderResponse> getIdentityProvider​(GetIdentityProviderRequest request,
                                                                AsyncHandler<GetIdentityProviderRequest,​GetIdentityProviderResponse> handler)
        Get an Identity Provider
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getIdentitySetting

        Future<GetIdentitySettingResponse> getIdentitySetting​(GetIdentitySettingRequest request,
                                                              AsyncHandler<GetIdentitySettingRequest,​GetIdentitySettingResponse> handler)
        Get an Identity setting.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getKmsiSetting

        Future<GetKmsiSettingResponse> getKmsiSetting​(GetKmsiSettingRequest request,
                                                      AsyncHandler<GetKmsiSettingRequest,​GetKmsiSettingResponse> handler)
        Get KmsiSettings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMe

        Future<GetMeResponse> getMe​(GetMeRequest request,
                                    AsyncHandler<GetMeRequest,​GetMeResponse> handler)
        Get a user’s own information.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMyApiKey

        Future<GetMyApiKeyResponse> getMyApiKey​(GetMyApiKeyRequest request,
                                                AsyncHandler<GetMyApiKeyRequest,​GetMyApiKeyResponse> handler)
        Get a user’s own API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMyAuthToken

        Future<GetMyAuthTokenResponse> getMyAuthToken​(GetMyAuthTokenRequest request,
                                                      AsyncHandler<GetMyAuthTokenRequest,​GetMyAuthTokenResponse> handler)
        Get a user’s own Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMyCustomerSecretKey

        Future<GetMyCustomerSecretKeyResponse> getMyCustomerSecretKey​(GetMyCustomerSecretKeyRequest request,
                                                                      AsyncHandler<GetMyCustomerSecretKeyRequest,​GetMyCustomerSecretKeyResponse> handler)
        Get a user’s own customer secret key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMyDevice

        Future<GetMyDeviceResponse> getMyDevice​(GetMyDeviceRequest request,
                                                AsyncHandler<GetMyDeviceRequest,​GetMyDeviceResponse> handler)
        Get a Device
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMyPendingApproval

        Future<GetMyPendingApprovalResponse> getMyPendingApproval​(GetMyPendingApprovalRequest request,
                                                                  AsyncHandler<GetMyPendingApprovalRequest,​GetMyPendingApprovalResponse> handler)
        Get My MyPendingApproval
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMyRequest

        Future<GetMyRequestResponse> getMyRequest​(GetMyRequestRequest request,
                                                  AsyncHandler<GetMyRequestRequest,​GetMyRequestResponse> handler)
        Get My Requests
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMySmtpCredential

        Future<GetMySmtpCredentialResponse> getMySmtpCredential​(GetMySmtpCredentialRequest request,
                                                                AsyncHandler<GetMySmtpCredentialRequest,​GetMySmtpCredentialResponse> handler)
        Get a user’s own SMTP credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMySupportAccount

        Future<GetMySupportAccountResponse> getMySupportAccount​(GetMySupportAccountRequest request,
                                                                AsyncHandler<GetMySupportAccountRequest,​GetMySupportAccountResponse> handler)
        Get a user’s own support account.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMyTrustedUserAgent

        Future<GetMyTrustedUserAgentResponse> getMyTrustedUserAgent​(GetMyTrustedUserAgentRequest request,
                                                                    AsyncHandler<GetMyTrustedUserAgentRequest,​GetMyTrustedUserAgentResponse> handler)
        Get a Trusted User Agent
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMyUserDbCredential

        Future<GetMyUserDbCredentialResponse> getMyUserDbCredential​(GetMyUserDbCredentialRequest request,
                                                                    AsyncHandler<GetMyUserDbCredentialRequest,​GetMyUserDbCredentialResponse> handler)
        Get a user’s own database (DB) credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getNetworkPerimeter

        Future<GetNetworkPerimeterResponse> getNetworkPerimeter​(GetNetworkPerimeterRequest request,
                                                                AsyncHandler<GetNetworkPerimeterRequest,​GetNetworkPerimeterResponse> handler)
        Get a NetworkPerimeter
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getPasswordPolicy

        Future<GetPasswordPolicyResponse> getPasswordPolicy​(GetPasswordPolicyRequest request,
                                                            AsyncHandler<GetPasswordPolicyRequest,​GetPasswordPolicyResponse> handler)
        Get a password policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getPolicy

        Future<GetPolicyResponse> getPolicy​(GetPolicyRequest request,
                                            AsyncHandler<GetPolicyRequest,​GetPolicyResponse> handler)
        Get a Policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getRule

        Future<GetRuleResponse> getRule​(GetRuleRequest request,
                                        AsyncHandler<GetRuleRequest,​GetRuleResponse> handler)
        Get a Rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSchema

        Future<GetSchemaResponse> getSchema​(GetSchemaRequest request,
                                            AsyncHandler<GetSchemaRequest,​GetSchemaResponse> handler)
        Get a Schema
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSecurityQuestion

        Future<GetSecurityQuestionResponse> getSecurityQuestion​(GetSecurityQuestionRequest request,
                                                                AsyncHandler<GetSecurityQuestionRequest,​GetSecurityQuestionResponse> handler)
        Get a security question.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSetting

        Future<GetSettingResponse> getSetting​(GetSettingRequest request,
                                              AsyncHandler<GetSettingRequest,​GetSettingResponse> handler)
        Get Settings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSmtpCredential

        Future<GetSmtpCredentialResponse> getSmtpCredential​(GetSmtpCredentialRequest request,
                                                            AsyncHandler<GetSmtpCredentialRequest,​GetSmtpCredentialResponse> handler)
        Get a user’s SMTP credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getUser

        Future<GetUserResponse> getUser​(GetUserRequest request,
                                        AsyncHandler<GetUserRequest,​GetUserResponse> handler)
        Get a user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getUserDbCredential

        Future<GetUserDbCredentialResponse> getUserDbCredential​(GetUserDbCredentialRequest request,
                                                                AsyncHandler<GetUserDbCredentialRequest,​GetUserDbCredentialResponse> handler)
        Get a user’s database (DB) credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listAccountMgmtInfos

        Future<ListAccountMgmtInfosResponse> listAccountMgmtInfos​(ListAccountMgmtInfosRequest request,
                                                                  AsyncHandler<ListAccountMgmtInfosRequest,​ListAccountMgmtInfosResponse> handler)
        Search Account Mgmt Info
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listApiKeys

        Future<ListApiKeysResponse> listApiKeys​(ListApiKeysRequest request,
                                                AsyncHandler<ListApiKeysRequest,​ListApiKeysResponse> handler)
        Search API keys.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listAppRoles

        Future<ListAppRolesResponse> listAppRoles​(ListAppRolesRequest request,
                                                  AsyncHandler<ListAppRolesRequest,​ListAppRolesResponse> handler)
        Search AppRoles
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listApprovalWorkflows

        Future<ListApprovalWorkflowsResponse> listApprovalWorkflows​(ListApprovalWorkflowsRequest request,
                                                                    AsyncHandler<ListApprovalWorkflowsRequest,​ListApprovalWorkflowsResponse> handler)
        Search ApprovalWorkflow
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listApps

        Future<ListAppsResponse> listApps​(ListAppsRequest request,
                                          AsyncHandler<ListAppsRequest,​ListAppsResponse> handler)
        Search Apps
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listAuthTokens

        Future<ListAuthTokensResponse> listAuthTokens​(ListAuthTokensRequest request,
                                                      AsyncHandler<ListAuthTokensRequest,​ListAuthTokensResponse> handler)
        Search for Auth tokens.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listBrandingSettings

        Future<ListBrandingSettingsResponse> listBrandingSettings​(ListBrandingSettingsRequest request,
                                                                  AsyncHandler<ListBrandingSettingsRequest,​ListBrandingSettingsResponse> handler)
        Search Branding Settings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listCloudGateMappings

        Future<ListCloudGateMappingsResponse> listCloudGateMappings​(ListCloudGateMappingsRequest request,
                                                                    AsyncHandler<ListCloudGateMappingsRequest,​ListCloudGateMappingsResponse> handler)
        Search Cloud Gate mappings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listCloudGateServers

        Future<ListCloudGateServersResponse> listCloudGateServers​(ListCloudGateServersRequest request,
                                                                  AsyncHandler<ListCloudGateServersRequest,​ListCloudGateServersResponse> handler)
        Search Cloud Gate servers
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listCloudGates

        Future<ListCloudGatesResponse> listCloudGates​(ListCloudGatesRequest request,
                                                      AsyncHandler<ListCloudGatesRequest,​ListCloudGatesResponse> handler)
        Search Cloud Gates
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listConditions

        Future<ListConditionsResponse> listConditions​(ListConditionsRequest request,
                                                      AsyncHandler<ListConditionsRequest,​ListConditionsResponse> handler)
        Search conditions.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listCustomerSecretKeys

        Future<ListCustomerSecretKeysResponse> listCustomerSecretKeys​(ListCustomerSecretKeysRequest request,
                                                                      AsyncHandler<ListCustomerSecretKeysRequest,​ListCustomerSecretKeysResponse> handler)
        Search for a user’s customer secret keys.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listGrants

        Future<ListGrantsResponse> listGrants​(ListGrantsRequest request,
                                              AsyncHandler<ListGrantsRequest,​ListGrantsResponse> handler)
        Search Grants
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listGroups

        Future<ListGroupsResponse> listGroups​(ListGroupsRequest request,
                                              AsyncHandler<ListGroupsRequest,​ListGroupsResponse> handler)
        Search for groups.

        Important: The Group SEARCH and GET operations on users and members will throw an exception if the response has more than 10,000 members. To avoid the exception, use the pagination filter to GET or SEARCH group members.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listIdentityProviders

        Future<ListIdentityProvidersResponse> listIdentityProviders​(ListIdentityProvidersRequest request,
                                                                    AsyncHandler<ListIdentityProvidersRequest,​ListIdentityProvidersResponse> handler)
        Search Identity Providers
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listIdentitySettings

        Future<ListIdentitySettingsResponse> listIdentitySettings​(ListIdentitySettingsRequest request,
                                                                  AsyncHandler<ListIdentitySettingsRequest,​ListIdentitySettingsResponse> handler)
        Search for Identity settings.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listKmsiSettings

        Future<ListKmsiSettingsResponse> listKmsiSettings​(ListKmsiSettingsRequest request,
                                                          AsyncHandler<ListKmsiSettingsRequest,​ListKmsiSettingsResponse> handler)
        Search KmsiSettings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMyApiKeys

        Future<ListMyApiKeysResponse> listMyApiKeys​(ListMyApiKeysRequest request,
                                                    AsyncHandler<ListMyApiKeysRequest,​ListMyApiKeysResponse> handler)
        Search for a user’s own API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMyApps

        Future<ListMyAppsResponse> listMyApps​(ListMyAppsRequest request,
                                              AsyncHandler<ListMyAppsRequest,​ListMyAppsResponse> handler)
        Search My Apps
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMyAuthTokens

        Future<ListMyAuthTokensResponse> listMyAuthTokens​(ListMyAuthTokensRequest request,
                                                          AsyncHandler<ListMyAuthTokensRequest,​ListMyAuthTokensResponse> handler)
        Search for a user’s own Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMyDevices

        Future<ListMyDevicesResponse> listMyDevices​(ListMyDevicesRequest request,
                                                    AsyncHandler<ListMyDevicesRequest,​ListMyDevicesResponse> handler)
        Search Devices
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMyGroups

        Future<ListMyGroupsResponse> listMyGroups​(ListMyGroupsRequest request,
                                                  AsyncHandler<ListMyGroupsRequest,​ListMyGroupsResponse> handler)
        Search for ‘My Groups’.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMyRequests

        Future<ListMyRequestsResponse> listMyRequests​(ListMyRequestsRequest request,
                                                      AsyncHandler<ListMyRequestsRequest,​ListMyRequestsResponse> handler)
        Search My Requests
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMySmtpCredentials

        Future<ListMySmtpCredentialsResponse> listMySmtpCredentials​(ListMySmtpCredentialsRequest request,
                                                                    AsyncHandler<ListMySmtpCredentialsRequest,​ListMySmtpCredentialsResponse> handler)
        Search for a user’s own SMTP credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMySupportAccounts

        Future<ListMySupportAccountsResponse> listMySupportAccounts​(ListMySupportAccountsRequest request,
                                                                    AsyncHandler<ListMySupportAccountsRequest,​ListMySupportAccountsResponse> handler)
        Search for a user’s own support account.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMyUserDbCredentials

        Future<ListMyUserDbCredentialsResponse> listMyUserDbCredentials​(ListMyUserDbCredentialsRequest request,
                                                                        AsyncHandler<ListMyUserDbCredentialsRequest,​ListMyUserDbCredentialsResponse> handler)
        Search for a user’s own database (DB) credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listNetworkPerimeters

        Future<ListNetworkPerimetersResponse> listNetworkPerimeters​(ListNetworkPerimetersRequest request,
                                                                    AsyncHandler<ListNetworkPerimetersRequest,​ListNetworkPerimetersResponse> handler)
        Search NetworkPerimeters
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listPasswordPolicies

        Future<ListPasswordPoliciesResponse> listPasswordPolicies​(ListPasswordPoliciesRequest request,
                                                                  AsyncHandler<ListPasswordPoliciesRequest,​ListPasswordPoliciesResponse> handler)
        Search for password policies.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listPolicies

        Future<ListPoliciesResponse> listPolicies​(ListPoliciesRequest request,
                                                  AsyncHandler<ListPoliciesRequest,​ListPoliciesResponse> handler)
        Search Policies.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listRules

        Future<ListRulesResponse> listRules​(ListRulesRequest request,
                                            AsyncHandler<ListRulesRequest,​ListRulesResponse> handler)
        Search Rules.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSchemas

        Future<ListSchemasResponse> listSchemas​(ListSchemasRequest request,
                                                AsyncHandler<ListSchemasRequest,​ListSchemasResponse> handler)
        Search Schemas
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSecurityQuestions

        Future<ListSecurityQuestionsResponse> listSecurityQuestions​(ListSecurityQuestionsRequest request,
                                                                    AsyncHandler<ListSecurityQuestionsRequest,​ListSecurityQuestionsResponse> handler)
        Search for security questions.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSettings

        Future<ListSettingsResponse> listSettings​(ListSettingsRequest request,
                                                  AsyncHandler<ListSettingsRequest,​ListSettingsResponse> handler)
        Search Settings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSmtpCredentials

        Future<ListSmtpCredentialsResponse> listSmtpCredentials​(ListSmtpCredentialsRequest request,
                                                                AsyncHandler<ListSmtpCredentialsRequest,​ListSmtpCredentialsResponse> handler)
        Search for SMTP credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listUserDbCredentials

        Future<ListUserDbCredentialsResponse> listUserDbCredentials​(ListUserDbCredentialsRequest request,
                                                                    AsyncHandler<ListUserDbCredentialsRequest,​ListUserDbCredentialsResponse> handler)
        Search for a user’s database (DB) credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listUsers

        Future<ListUsersResponse> listUsers​(ListUsersRequest request,
                                            AsyncHandler<ListUsersRequest,​ListUsersResponse> handler)
        Search for users.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchApiKey

        Future<PatchApiKeyResponse> patchApiKey​(PatchApiKeyRequest request,
                                                AsyncHandler<PatchApiKeyRequest,​PatchApiKeyResponse> handler)
        Update a user’s API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchApp

        Future<PatchAppResponse> patchApp​(PatchAppRequest request,
                                          AsyncHandler<PatchAppRequest,​PatchAppResponse> handler)
        Update an App
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchAppRole

        Future<PatchAppRoleResponse> patchAppRole​(PatchAppRoleRequest request,
                                                  AsyncHandler<PatchAppRoleRequest,​PatchAppRoleResponse> handler)
        Update an AppRole
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchApprovalWorkflow

        Future<PatchApprovalWorkflowResponse> patchApprovalWorkflow​(PatchApprovalWorkflowRequest request,
                                                                    AsyncHandler<PatchApprovalWorkflowRequest,​PatchApprovalWorkflowResponse> handler)
        Update ApprovalWorkflow
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchAuthToken

        Future<PatchAuthTokenResponse> patchAuthToken​(PatchAuthTokenRequest request,
                                                      AsyncHandler<PatchAuthTokenRequest,​PatchAuthTokenResponse> handler)
        Update a user’s Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchCloudGate

        Future<PatchCloudGateResponse> patchCloudGate​(PatchCloudGateRequest request,
                                                      AsyncHandler<PatchCloudGateRequest,​PatchCloudGateResponse> handler)
        Update a Cloud Gate
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchCloudGateMapping

        Future<PatchCloudGateMappingResponse> patchCloudGateMapping​(PatchCloudGateMappingRequest request,
                                                                    AsyncHandler<PatchCloudGateMappingRequest,​PatchCloudGateMappingResponse> handler)
        Update a Cloud Gate mapping
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchCloudGateServer

        Future<PatchCloudGateServerResponse> patchCloudGateServer​(PatchCloudGateServerRequest request,
                                                                  AsyncHandler<PatchCloudGateServerRequest,​PatchCloudGateServerResponse> handler)
        Update a Cloud Gate server
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchCondition

        Future<PatchConditionResponse> patchCondition​(PatchConditionRequest request,
                                                      AsyncHandler<PatchConditionRequest,​PatchConditionResponse> handler)
        Update a condition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchCustomerSecretKey

        Future<PatchCustomerSecretKeyResponse> patchCustomerSecretKey​(PatchCustomerSecretKeyRequest request,
                                                                      AsyncHandler<PatchCustomerSecretKeyRequest,​PatchCustomerSecretKeyResponse> handler)
        Update a user’s customer secret key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchGrant

        Future<PatchGrantResponse> patchGrant​(PatchGrantRequest request,
                                              AsyncHandler<PatchGrantRequest,​PatchGrantResponse> handler)
        Update a Grant
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchGroup

        Future<PatchGroupResponse> patchGroup​(PatchGroupRequest request,
                                              AsyncHandler<PatchGroupRequest,​PatchGroupResponse> handler)
        Update a group.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchIdentityProvider

        Future<PatchIdentityProviderResponse> patchIdentityProvider​(PatchIdentityProviderRequest request,
                                                                    AsyncHandler<PatchIdentityProviderRequest,​PatchIdentityProviderResponse> handler)
        Update an Identity Provider
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchIdentitySetting

        Future<PatchIdentitySettingResponse> patchIdentitySetting​(PatchIdentitySettingRequest request,
                                                                  AsyncHandler<PatchIdentitySettingRequest,​PatchIdentitySettingResponse> handler)
        Update an Identity setting.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchKmsiSetting

        Future<PatchKmsiSettingResponse> patchKmsiSetting​(PatchKmsiSettingRequest request,
                                                          AsyncHandler<PatchKmsiSettingRequest,​PatchKmsiSettingResponse> handler)
        Update a Setting
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchMe

        Future<PatchMeResponse> patchMe​(PatchMeRequest request,
                                        AsyncHandler<PatchMeRequest,​PatchMeResponse> handler)
        Update a user’s own information.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchMyApiKey

        Future<PatchMyApiKeyResponse> patchMyApiKey​(PatchMyApiKeyRequest request,
                                                    AsyncHandler<PatchMyApiKeyRequest,​PatchMyApiKeyResponse> handler)
        Update a user’s own API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchMyAuthToken

        Future<PatchMyAuthTokenResponse> patchMyAuthToken​(PatchMyAuthTokenRequest request,
                                                          AsyncHandler<PatchMyAuthTokenRequest,​PatchMyAuthTokenResponse> handler)
        Update a user’s own Auth token.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchMyDevice

        Future<PatchMyDeviceResponse> patchMyDevice​(PatchMyDeviceRequest request,
                                                    AsyncHandler<PatchMyDeviceRequest,​PatchMyDeviceResponse> handler)
        Update a Device
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchMyRequest

        Future<PatchMyRequestResponse> patchMyRequest​(PatchMyRequestRequest request,
                                                      AsyncHandler<PatchMyRequestRequest,​PatchMyRequestResponse> handler)
        Update My Requests
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchMySmtpCredential

        Future<PatchMySmtpCredentialResponse> patchMySmtpCredential​(PatchMySmtpCredentialRequest request,
                                                                    AsyncHandler<PatchMySmtpCredentialRequest,​PatchMySmtpCredentialResponse> handler)
        Update a user’s own SMTP credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchNetworkPerimeter

        Future<PatchNetworkPerimeterResponse> patchNetworkPerimeter​(PatchNetworkPerimeterRequest request,
                                                                    AsyncHandler<PatchNetworkPerimeterRequest,​PatchNetworkPerimeterResponse> handler)
        Update a NetworkPerimeter
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchPasswordPolicy

        Future<PatchPasswordPolicyResponse> patchPasswordPolicy​(PatchPasswordPolicyRequest request,
                                                                AsyncHandler<PatchPasswordPolicyRequest,​PatchPasswordPolicyResponse> handler)
        Update a password policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchPolicy

        Future<PatchPolicyResponse> patchPolicy​(PatchPolicyRequest request,
                                                AsyncHandler<PatchPolicyRequest,​PatchPolicyResponse> handler)
        Update a Policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchRule

        Future<PatchRuleResponse> patchRule​(PatchRuleRequest request,
                                            AsyncHandler<PatchRuleRequest,​PatchRuleResponse> handler)
        Update a Rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchSchema

        Future<PatchSchemaResponse> patchSchema​(PatchSchemaRequest request,
                                                AsyncHandler<PatchSchemaRequest,​PatchSchemaResponse> handler)
        Update a Schema Def
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchSecurityQuestion

        Future<PatchSecurityQuestionResponse> patchSecurityQuestion​(PatchSecurityQuestionRequest request,
                                                                    AsyncHandler<PatchSecurityQuestionRequest,​PatchSecurityQuestionResponse> handler)
        Update a security question.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchSetting

        Future<PatchSettingResponse> patchSetting​(PatchSettingRequest request,
                                                  AsyncHandler<PatchSettingRequest,​PatchSettingResponse> handler)
        Update a Setting
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchSmtpCredential

        Future<PatchSmtpCredentialResponse> patchSmtpCredential​(PatchSmtpCredentialRequest request,
                                                                AsyncHandler<PatchSmtpCredentialRequest,​PatchSmtpCredentialResponse> handler)
        Update a user’s SMTP credentials.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchUser

        Future<PatchUserResponse> patchUser​(PatchUserRequest request,
                                            AsyncHandler<PatchUserRequest,​PatchUserResponse> handler)
        Update a user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putApp

        Future<PutAppResponse> putApp​(PutAppRequest request,
                                      AsyncHandler<PutAppRequest,​PutAppResponse> handler)
        Replace an App
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putAppStatusChanger

        Future<PutAppStatusChangerResponse> putAppStatusChanger​(PutAppStatusChangerRequest request,
                                                                AsyncHandler<PutAppStatusChangerRequest,​PutAppStatusChangerResponse> handler)
        Activate/Deactivate an App
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putApprovalWorkflow

        Future<PutApprovalWorkflowResponse> putApprovalWorkflow​(PutApprovalWorkflowRequest request,
                                                                AsyncHandler<PutApprovalWorkflowRequest,​PutApprovalWorkflowResponse> handler)
        Replace ApprovalWorkflow
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putCloudGate

        Future<PutCloudGateResponse> putCloudGate​(PutCloudGateRequest request,
                                                  AsyncHandler<PutCloudGateRequest,​PutCloudGateResponse> handler)
        Replace a Cloud Gate
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putCloudGateMapping

        Future<PutCloudGateMappingResponse> putCloudGateMapping​(PutCloudGateMappingRequest request,
                                                                AsyncHandler<PutCloudGateMappingRequest,​PutCloudGateMappingResponse> handler)
        Replace a Cloud Gate mapping
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putCloudGateServer

        Future<PutCloudGateServerResponse> putCloudGateServer​(PutCloudGateServerRequest request,
                                                              AsyncHandler<PutCloudGateServerRequest,​PutCloudGateServerResponse> handler)
        Replace a Cloud Gate server
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putCondition

        Future<PutConditionResponse> putCondition​(PutConditionRequest request,
                                                  AsyncHandler<PutConditionRequest,​PutConditionResponse> handler)
        Replace a condition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putGroup

        Future<PutGroupResponse> putGroup​(PutGroupRequest request,
                                          AsyncHandler<PutGroupRequest,​PutGroupResponse> handler)
        Replace a group.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putIdentityProvider

        Future<PutIdentityProviderResponse> putIdentityProvider​(PutIdentityProviderRequest request,
                                                                AsyncHandler<PutIdentityProviderRequest,​PutIdentityProviderResponse> handler)
        Replace an Identity Provider
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putIdentitySetting

        Future<PutIdentitySettingResponse> putIdentitySetting​(PutIdentitySettingRequest request,
                                                              AsyncHandler<PutIdentitySettingRequest,​PutIdentitySettingResponse> handler)
        Replace an Identity setting.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putKmsiSetting

        Future<PutKmsiSettingResponse> putKmsiSetting​(PutKmsiSettingRequest request,
                                                      AsyncHandler<PutKmsiSettingRequest,​PutKmsiSettingResponse> handler)
        Replace KmsiSettings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putMe

        Future<PutMeResponse> putMe​(PutMeRequest request,
                                    AsyncHandler<PutMeRequest,​PutMeResponse> handler)
        Replace a user’s own information.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putMePasswordChanger

        Future<PutMePasswordChangerResponse> putMePasswordChanger​(PutMePasswordChangerRequest request,
                                                                  AsyncHandler<PutMePasswordChangerRequest,​PutMePasswordChangerResponse> handler)
        Update a user’s own password.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putNetworkPerimeter

        Future<PutNetworkPerimeterResponse> putNetworkPerimeter​(PutNetworkPerimeterRequest request,
                                                                AsyncHandler<PutNetworkPerimeterRequest,​PutNetworkPerimeterResponse> handler)
        Replace a NetworkPerimeter
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putNotificationSetting

        Future<PutNotificationSettingResponse> putNotificationSetting​(PutNotificationSettingRequest request,
                                                                      AsyncHandler<PutNotificationSettingRequest,​PutNotificationSettingResponse> handler)
        Replace Notification Settings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putPasswordPolicy

        Future<PutPasswordPolicyResponse> putPasswordPolicy​(PutPasswordPolicyRequest request,
                                                            AsyncHandler<PutPasswordPolicyRequest,​PutPasswordPolicyResponse> handler)
        Replace a password policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putPolicy

        Future<PutPolicyResponse> putPolicy​(PutPolicyRequest request,
                                            AsyncHandler<PutPolicyRequest,​PutPolicyResponse> handler)
        Replace a Policy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putRule

        Future<PutRuleResponse> putRule​(PutRuleRequest request,
                                        AsyncHandler<PutRuleRequest,​PutRuleResponse> handler)
        Replace a Rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putSchema

        Future<PutSchemaResponse> putSchema​(PutSchemaRequest request,
                                            AsyncHandler<PutSchemaRequest,​PutSchemaResponse> handler)
        Replace a Schema Def
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putSetting

        Future<PutSettingResponse> putSetting​(PutSettingRequest request,
                                              AsyncHandler<PutSettingRequest,​PutSettingResponse> handler)
        Replace Settings
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putUser

        Future<PutUserResponse> putUser​(PutUserRequest request,
                                        AsyncHandler<PutUserRequest,​PutUserResponse> handler)
        Replace a user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putUserPasswordChanger

        Future<PutUserPasswordChangerResponse> putUserPasswordChanger​(PutUserPasswordChangerRequest request,
                                                                      AsyncHandler<PutUserPasswordChangerRequest,​PutUserPasswordChangerResponse> handler)
        Change a user’s password to a known value.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putUserPasswordResetter

        Future<PutUserPasswordResetterResponse> putUserPasswordResetter​(PutUserPasswordResetterRequest request,
                                                                        AsyncHandler<PutUserPasswordResetterRequest,​PutUserPasswordResetterResponse> handler)
        Reset a user’s password to a randomly-generated value.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putUserStatusChanger

        Future<PutUserStatusChangerResponse> putUserStatusChanger​(PutUserStatusChangerRequest request,
                                                                  AsyncHandler<PutUserStatusChangerRequest,​PutUserStatusChangerResponse> handler)
        Change a user’s status.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchAccountMgmtInfos

        Future<SearchAccountMgmtInfosResponse> searchAccountMgmtInfos​(SearchAccountMgmtInfosRequest request,
                                                                      AsyncHandler<SearchAccountMgmtInfosRequest,​SearchAccountMgmtInfosResponse> handler)
        Search Account Mgmt Info Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchApiKeys

        Future<SearchApiKeysResponse> searchApiKeys​(SearchApiKeysRequest request,
                                                    AsyncHandler<SearchApiKeysRequest,​SearchApiKeysResponse> handler)
        Search for API keys using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchAppRoles

        Future<SearchAppRolesResponse> searchAppRoles​(SearchAppRolesRequest request,
                                                      AsyncHandler<SearchAppRolesRequest,​SearchAppRolesResponse> handler)
        Search AppRoles Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchApps

        Future<SearchAppsResponse> searchApps​(SearchAppsRequest request,
                                              AsyncHandler<SearchAppsRequest,​SearchAppsResponse> handler)
        Search Apps Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchAuthTokens

        Future<SearchAuthTokensResponse> searchAuthTokens​(SearchAuthTokensRequest request,
                                                          AsyncHandler<SearchAuthTokensRequest,​SearchAuthTokensResponse> handler)
        Search for Auth tokens using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchCloudGateServers

        Future<SearchCloudGateServersResponse> searchCloudGateServers​(SearchCloudGateServersRequest request,
                                                                      AsyncHandler<SearchCloudGateServersRequest,​SearchCloudGateServersResponse> handler)
        Search Cloud Gate servers Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchCloudGates

        Future<SearchCloudGatesResponse> searchCloudGates​(SearchCloudGatesRequest request,
                                                          AsyncHandler<SearchCloudGatesRequest,​SearchCloudGatesResponse> handler)
        Search Cloud Gates Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchConditions

        Future<SearchConditionsResponse> searchConditions​(SearchConditionsRequest request,
                                                          AsyncHandler<SearchConditionsRequest,​SearchConditionsResponse> handler)
        Search Conditions Using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchGrants

        Future<SearchGrantsResponse> searchGrants​(SearchGrantsRequest request,
                                                  AsyncHandler<SearchGrantsRequest,​SearchGrantsResponse> handler)
        Search Grants Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchGroups

        Future<SearchGroupsResponse> searchGroups​(SearchGroupsRequest request,
                                                  AsyncHandler<SearchGroupsRequest,​SearchGroupsResponse> handler)
        Search for groups using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchIdentitySettings

        Future<SearchIdentitySettingsResponse> searchIdentitySettings​(SearchIdentitySettingsRequest request,
                                                                      AsyncHandler<SearchIdentitySettingsRequest,​SearchIdentitySettingsResponse> handler)
        Search for Identity settings using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchKmsiSettings

        Future<SearchKmsiSettingsResponse> searchKmsiSettings​(SearchKmsiSettingsRequest request,
                                                              AsyncHandler<SearchKmsiSettingsRequest,​SearchKmsiSettingsResponse> handler)
        Search KmsiSettings Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchMyApps

        Future<SearchMyAppsResponse> searchMyApps​(SearchMyAppsRequest request,
                                                  AsyncHandler<SearchMyAppsRequest,​SearchMyAppsResponse> handler)
        Search My Apps Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchMyGroups

        Future<SearchMyGroupsResponse> searchMyGroups​(SearchMyGroupsRequest request,
                                                      AsyncHandler<SearchMyGroupsRequest,​SearchMyGroupsResponse> handler)
        Search for ‘My Groups’ using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchMyRequests

        Future<SearchMyRequestsResponse> searchMyRequests​(SearchMyRequestsRequest request,
                                                          AsyncHandler<SearchMyRequestsRequest,​SearchMyRequestsResponse> handler)
        Search My Requests Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchPasswordPolicies

        Future<SearchPasswordPoliciesResponse> searchPasswordPolicies​(SearchPasswordPoliciesRequest request,
                                                                      AsyncHandler<SearchPasswordPoliciesRequest,​SearchPasswordPoliciesResponse> handler)
        Search for password policies using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchPolicies

        Future<SearchPoliciesResponse> searchPolicies​(SearchPoliciesRequest request,
                                                      AsyncHandler<SearchPoliciesRequest,​SearchPoliciesResponse> handler)
        Search Policies Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchRules

        Future<SearchRulesResponse> searchRules​(SearchRulesRequest request,
                                                AsyncHandler<SearchRulesRequest,​SearchRulesResponse> handler)
        Search Rules Using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchSchemas

        Future<SearchSchemasResponse> searchSchemas​(SearchSchemasRequest request,
                                                    AsyncHandler<SearchSchemasRequest,​SearchSchemasResponse> handler)
        Search Schemas Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchSettings

        Future<SearchSettingsResponse> searchSettings​(SearchSettingsRequest request,
                                                      AsyncHandler<SearchSettingsRequest,​SearchSettingsResponse> handler)
        Search Settings Using POST
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchSmtpCredentials

        Future<SearchSmtpCredentialsResponse> searchSmtpCredentials​(SearchSmtpCredentialsRequest request,
                                                                    AsyncHandler<SearchSmtpCredentialsRequest,​SearchSmtpCredentialsResponse> handler)
        Search for SMTP credentials using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchUserDbCredentials

        Future<SearchUserDbCredentialsResponse> searchUserDbCredentials​(SearchUserDbCredentialsRequest request,
                                                                        AsyncHandler<SearchUserDbCredentialsRequest,​SearchUserDbCredentialsResponse> handler)
        Search for a user’s database (DB) credentials using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchUsers

        Future<SearchUsersResponse> searchUsers​(SearchUsersRequest request,
                                                AsyncHandler<SearchUsersRequest,​SearchUsersResponse> handler)
        Search for users using POST.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.