Class IdentityAsyncClient
- java.lang.Object
- 
- com.oracle.bmc.http.internal.BaseAsyncClient
- 
- com.oracle.bmc.identity.IdentityAsyncClient
 
 
- 
- All Implemented Interfaces:
- IdentityAsync,- AutoCloseable
 
 @Generated(value="OracleSDKGenerator", comments="API Version: 20160918") public class IdentityAsyncClient extends BaseAsyncClient implements IdentityAsyncAsync client implementation for Identity service.
 There are two ways to use async client: 1. Use AsyncHandler: using AsyncHandler, if the response to the call is anInputStream, like getObject Api in object storage service, developers need to process the stream in AsyncHandler, and not anywhere else, because the stream will be closed right after the AsyncHandler is invoked.
 2. Use Java Future: using Java Future, developers need to close the stream after they are done with the Java Future.
 Accessing the result should be done in a mutually exclusive manner, either through the Future or the AsyncHandler, but not both. If the Future is used, the caller should pass in null as the AsyncHandler. If the AsyncHandler is used, it is still safe to use the Future to determine whether or not the request was completed via Future.isDone/isCancelled.
 Please refer to https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/ResteasyClientWithObjectStorageExample.java
- 
- 
Nested Class SummaryNested Classes Modifier and Type Class Description static classIdentityAsyncClient.BuilderBuilder class for this client.
 - 
Field SummaryFields Modifier and Type Field Description StringclientCommonLibraryVersionCompatible SDK version, provided by the codegen.Optional<String>minimumClientCommonLibraryVersionFromClientMinimum compatible SDK version, maybe provided by the codegen.static ServiceSERVICEService instance for Identity.
 - 
Constructor SummaryConstructors Constructor Description IdentityAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory)Deprecated.Use thebuilderinstead.IdentityAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, List<ClientConfigurator> additionalClientConfigurators)Deprecated.Use thebuilderinstead.IdentityAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, List<ClientConfigurator> additionalClientConfigurators, String endpoint)Deprecated.Use thebuilderinstead.IdentityAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, Map<SigningStrategy,RequestSignerFactory> signingStrategyRequestSignerFactories, List<ClientConfigurator> additionalClientConfigurators, String endpoint)Deprecated.Use thebuilderinstead.IdentityAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider)Deprecated.Use thebuilderinstead.IdentityAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration)Deprecated.Use thebuilderinstead.IdentityAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator)Deprecated.Use thebuilderinstead.
 - 
Method Summary- 
Methods inherited from class java.lang.Objectclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 - 
Methods inherited from interface java.lang.AutoCloseableclose
 - 
Methods inherited from interface com.oracle.bmc.identity.IdentityAsyncgetEndpoint, refreshClient, setEndpoint, useRealmSpecificEndpointTemplate
 
- 
 
- 
- 
- 
Constructor Detail- 
IdentityAsyncClient@Deprecated public IdentityAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider) Deprecated.Use thebuilderinstead.Create a new client instance.- Parameters:
- authenticationDetailsProvider- The authentication details (see- IdentityAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
 
 - 
IdentityAsyncClient@Deprecated public IdentityAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration) Deprecated.Use thebuilderinstead.Create a new client instance.- Parameters:
- authenticationDetailsProvider- The authentication details (see- IdentityAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
- configuration-- ClientBuilderBase.configuration
 
 - 
IdentityAsyncClient@Deprecated public IdentityAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator) Deprecated.Use thebuilderinstead.Create a new client instance.- Parameters:
- authenticationDetailsProvider- The authentication details (see- IdentityAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
- configuration-- ClientBuilderBase.configuration
- clientConfigurator-- ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
 
 - 
IdentityAsyncClient@Deprecated public IdentityAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory) Deprecated.Use thebuilderinstead.Create a new client instance.- Parameters:
- authenticationDetailsProvider- The authentication details (see- IdentityAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
- configuration-- ClientBuilderBase.configuration
- clientConfigurator-- ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
- defaultRequestSignerFactory-- ClientBuilderBase.requestSignerFactory
 
 - 
IdentityAsyncClient@Deprecated public IdentityAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, List<ClientConfigurator> additionalClientConfigurators) Deprecated.Use thebuilderinstead.Create a new client instance.- Parameters:
- authenticationDetailsProvider- The authentication details (see- IdentityAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
- configuration-- ClientBuilderBase.configuration
- clientConfigurator-- ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
- defaultRequestSignerFactory-- ClientBuilderBase.requestSignerFactory
- additionalClientConfigurators-- ClientBuilderBase.additionalClientConfigurators
 
 - 
IdentityAsyncClient@Deprecated public IdentityAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, List<ClientConfigurator> additionalClientConfigurators, String endpoint) Deprecated.Use thebuilderinstead.Create a new client instance.- Parameters:
- authenticationDetailsProvider- The authentication details (see- IdentityAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
- configuration-- ClientBuilderBase.configuration
- clientConfigurator-- ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
- defaultRequestSignerFactory-- ClientBuilderBase.requestSignerFactory
- additionalClientConfigurators-- ClientBuilderBase.additionalClientConfigurators
- endpoint-- ClientBuilderBase.endpoint(java.lang.String)
 
 - 
IdentityAsyncClient@Deprecated public IdentityAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, Map<SigningStrategy,RequestSignerFactory> signingStrategyRequestSignerFactories, List<ClientConfigurator> additionalClientConfigurators, String endpoint) Deprecated.Use thebuilderinstead.Create a new client instance.- Parameters:
- authenticationDetailsProvider- The authentication details (see- IdentityAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
- configuration-- ClientBuilderBase.configuration
- clientConfigurator-- ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
- defaultRequestSignerFactory-- ClientBuilderBase.requestSignerFactory
- additionalClientConfigurators-- ClientBuilderBase.additionalClientConfigurators
- endpoint-- ClientBuilderBase.endpoint(java.lang.String)
- signingStrategyRequestSignerFactories-- ClientBuilderBase.signingStrategyRequestSignerFactories
 
 
- 
 - 
Method Detail- 
builderpublic static IdentityAsyncClient.Builder builder() Create a builder for this client.- Returns:
- builder
 
 - 
setRegionpublic void setRegion(Region region) Description copied from interface:IdentityAsyncSets the region to call (ex, Region.US_PHOENIX_1).Note, this will call setEndpointafter resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.- Specified by:
- setRegionin interface- IdentityAsync
- Parameters:
- region- The region of the service.
 
 - 
setRegionpublic void setRegion(String regionId) Description copied from interface:IdentityAsyncSets the region to call (ex, ‘us-phoenix-1’).Note, this will first try to map the region ID to a known Region and call setRegion.If no known Region could be determined, it will create an endpoint based on the default endpoint format ( Region.formatDefaultRegionEndpoint(Service, String)and then callsetEndpoint.- Specified by:
- setRegionin interface- IdentityAsync
- Parameters:
- regionId- The public region ID.
 
 - 
activateDomainpublic Future<ActivateDomainResponse> activateDomain(ActivateDomainRequest request, AsyncHandler<ActivateDomainRequest,ActivateDomainResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Activates a deactivated identity domain.You can only activate identity domains that your user account is not a part of. After you send the request, the `lifecycleDetails` of the identity domain is set to ACTIVATING. When the operation completes, the `lifecycleDetails` is set to null and the `lifecycleState` of the identity domain is set to ACTIVE. To track the progress of the request, submitting an HTTP GET on the /iamWorkRequests/{iamWorkRequestsId} endpoint retrieves the operation's status. - Specified by:
- activateDomainin interface- IdentityAsync
- 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.
 
 - 
activateMfaTotpDevicepublic Future<ActivateMfaTotpDeviceResponse> activateMfaTotpDevice(ActivateMfaTotpDeviceRequest request, AsyncHandler<ActivateMfaTotpDeviceRequest,ActivateMfaTotpDeviceResponse> handler) Description copied from interface:IdentityAsyncActivates the specified MFA TOTP device for the user.Activation requires manual interaction with the Console. - Specified by:
- activateMfaTotpDevicein interface- IdentityAsync
- 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.
 
 - 
addTagDefaultLockpublic Future<AddTagDefaultLockResponse> addTagDefaultLock(AddTagDefaultLockRequest request, AsyncHandler<AddTagDefaultLockRequest,AddTagDefaultLockResponse> handler) Description copied from interface:IdentityAsyncAdd a resource lock to a tag default.- Specified by:
- addTagDefaultLockin interface- IdentityAsync
- 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.
 
 - 
addTagNamespaceLockpublic Future<AddTagNamespaceLockResponse> addTagNamespaceLock(AddTagNamespaceLockRequest request, AsyncHandler<AddTagNamespaceLockRequest,AddTagNamespaceLockResponse> handler) Description copied from interface:IdentityAsyncAdd a resource lock to a tag namespace.- Specified by:
- addTagNamespaceLockin interface- IdentityAsync
- 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.
 
 - 
addUserToGrouppublic Future<AddUserToGroupResponse> addUserToGroup(AddUserToGroupRequest request, AsyncHandler<AddUserToGroupRequest,AddUserToGroupResponse> handler) Description copied from interface:IdentityAsyncAdds the specified user to the specified group and returns aUserGroupMembershipobject with its own OCID.After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. - Specified by:
- addUserToGroupin interface- IdentityAsync
- 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.
 
 - 
assembleEffectiveTagSetpublic Future<AssembleEffectiveTagSetResponse> assembleEffectiveTagSet(AssembleEffectiveTagSetRequest request, AsyncHandler<AssembleEffectiveTagSetRequest,AssembleEffectiveTagSetResponse> handler) Description copied from interface:IdentityAsyncAssembles tag defaults in the specified compartment and any parent compartments to determine the tags to apply.Tag defaults from parent compartments do not override tag defaults referencing the same tag in a compartment lower down the hierarchy. This set of tag defaults includes all tag defaults from the current compartment back to the root compartment. - Specified by:
- assembleEffectiveTagSetin interface- IdentityAsync
- 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.
 
 - 
bulkDeleteResourcespublic Future<BulkDeleteResourcesResponse> bulkDeleteResources(BulkDeleteResourcesRequest request, AsyncHandler<BulkDeleteResourcesRequest,BulkDeleteResourcesResponse> handler) Description copied from interface:IdentityAsyncDeletes multiple resources in the compartment.All resources must be in the same compartment. You must have the appropriate permissions to delete the resources in the request. This API can only be invoked from the tenancy’s home region. This operation creates a WorkRequest. Use thegetWorkRequestAPI to monitor the status of the bulk action.- Specified by:
- bulkDeleteResourcesin interface- IdentityAsync
- 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.
 
 - 
bulkDeleteTagspublic Future<BulkDeleteTagsResponse> bulkDeleteTags(BulkDeleteTagsRequest request, AsyncHandler<BulkDeleteTagsRequest,BulkDeleteTagsResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified tag key definitions.This operation triggers a process that removes the tags from all resources in your tenancy. The tag key definitions must be within the same tag namespace. The following actions happen immediately: If the tag is a cost-tracking tag, the tag no longer counts against your 10 cost-tracking tags limit, even if you do not disable the tag before running this operation. * If the tag is used with dynamic groups, the rules that contain the tag are no longer evaluated against the tag. After you start this operation, the state of the tag changes to DELETING, and tag removal from resources begins. This process can take up to 48 hours depending on the number of resources that are tagged and the regions in which those resources reside. When all tags have been removed, the state changes to DELETED. You cannot restore a deleted tag. After the tag state changes to DELETED, you can use the same tag name again. After you start this operation, you cannot start either the deleteTagor thecascadeDeleteTagNamespaceoperation until this process completes.In order to delete tags, you must first retire the tags. Use updateTagto retire a tag.- Specified by:
- bulkDeleteTagsin interface- IdentityAsync
- 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.
 
 - 
bulkEditTagspublic Future<BulkEditTagsResponse> bulkEditTags(BulkEditTagsRequest request, AsyncHandler<BulkEditTagsRequest,BulkEditTagsResponse> handler) Description copied from interface:IdentityAsyncEdits the specified list of tag key definitions for the selected resources.This operation triggers a process that edits the tags on all selected resources. The possible actions are: Add a defined tag when the tag does not already exist on the resource. * Update the value for a defined tag when the tag is present on the resource. * Add a defined tag when it does not already exist on the resource or update the value for a defined tag when the tag is present on the resource. * Remove a defined tag from a resource. The tag is removed from the resource regardless of the tag value. See bulkEditOperationDetailsfor more information.The edits can include a combination of operations and tag sets. However, multiple operations cannot apply to one key definition in the same request. For example, if one request adds `tag set-1` to a resource and sets a tag value to `tag set-2`, `tag set-1` and `tag set-2` cannot have any common tag definitions. - Specified by:
- bulkEditTagsin interface- IdentityAsync
- 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.
 
 - 
bulkMoveResourcespublic Future<BulkMoveResourcesResponse> bulkMoveResources(BulkMoveResourcesRequest request, AsyncHandler<BulkMoveResourcesRequest,BulkMoveResourcesResponse> handler) Description copied from interface:IdentityAsyncMoves multiple resources from one compartment to another.All resources must be in the same compartment. This API can only be invoked from the tenancy’s home region. To move resources, you must have the appropriate permissions to move the resource in both the source and target compartments. This operation creates a WorkRequest. Use thegetWorkRequestAPI to monitor the status of the bulk action.- Specified by:
- bulkMoveResourcesin interface- IdentityAsync
- 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.
 
 - 
cascadeDeleteTagNamespacepublic Future<CascadeDeleteTagNamespaceResponse> cascadeDeleteTagNamespace(CascadeDeleteTagNamespaceRequest request, AsyncHandler<CascadeDeleteTagNamespaceRequest,CascadeDeleteTagNamespaceResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified tag namespace.This operation triggers a process that removes all of the tags defined in the specified tag namespace from all resources in your tenancy and then deletes the tag namespace. After you start the delete operation: New tag key definitions cannot be created under the namespace. * The state of the tag namespace changes to DELETING. * Tag removal from the resources begins. This process can take up to 48 hours depending on the number of tag definitions in the namespace, the number of resources that are tagged, and the locations of the regions in which those resources reside. After all tags are removed, the state changes to DELETED. You cannot restore a deleted tag namespace. After the deleted tag namespace changes its state to DELETED, you can use the name of the deleted tag namespace again. After you start this operation, you cannot start either the deleteTagor thebulkDeleteTagsoperation until this process completes.To delete a tag namespace, you must first retire it. Use updateTagNamespaceto retire a tag namespace.- Specified by:
- cascadeDeleteTagNamespacein interface- IdentityAsync
- 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.
 
 - 
changeDomainCompartmentpublic Future<ChangeDomainCompartmentResponse> changeDomainCompartment(ChangeDomainCompartmentRequest request, AsyncHandler<ChangeDomainCompartmentRequest,ChangeDomainCompartmentResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Moves the identity domain to a different compartment in the tenancy.To track the progress of the request, submitting an HTTP GET on the /iamWorkRequests/{iamWorkRequestsId} endpoint retrieves the operation's status. - Specified by:
- changeDomainCompartmentin interface- IdentityAsync
- 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.
 
 - 
changeDomainLicenseTypepublic Future<ChangeDomainLicenseTypeResponse> changeDomainLicenseType(ChangeDomainLicenseTypeRequest request, AsyncHandler<ChangeDomainLicenseTypeRequest,ChangeDomainLicenseTypeResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Changes the license type of the given identity domain.The identity domain’s lifecycleStatemust be set to ACTIVE and the requestedlicenseTypemust be allowed. To retrieve the allowedlicenseTypefor the identity domain, uselistAllowedDomainLicenseTypes.After you send your request, the `lifecycleDetails` of this identity domain is set to UPDATING. When the update of the identity domain completes, then the `lifecycleDetails` is set to null. To track the progress of the request, submitting an HTTP GET on the /iamWorkRequests/{iamWorkRequestsId} endpoint retrieves the operation's status. - Specified by:
- changeDomainLicenseTypein interface- IdentityAsync
- 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.
 
 - 
changeTagNamespaceCompartmentpublic Future<ChangeTagNamespaceCompartmentResponse> changeTagNamespaceCompartment(ChangeTagNamespaceCompartmentRequest request, AsyncHandler<ChangeTagNamespaceCompartmentRequest,ChangeTagNamespaceCompartmentResponse> handler) Description copied from interface:IdentityAsyncMoves the specified tag namespace to the specified compartment within the same tenancy.To move the tag namespace, you must have the manage tag-namespaces permission on both compartments. For more information about IAM policies, see [Details for IAM](https://docs.oracle.com/iaas/Content/Identity/policyreference/iampolicyreference.htm). Moving a tag namespace moves all the tag key definitions contained in the tag namespace. - Specified by:
- changeTagNamespaceCompartmentin interface- IdentityAsync
- 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.
 
 - 
createAuthTokenpublic Future<CreateAuthTokenResponse> createAuthToken(CreateAuthTokenRequest request, AsyncHandler<CreateAuthTokenRequest,CreateAuthTokenResponse> handler) Description copied from interface:IdentityAsyncCreates a new auth token for the specified user.For information about what auth tokens are for, see Managing User Credentials. You must specify a *description* for the auth token (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateAuthToken.Every user has permission to create an auth token for *their own user ID*. An administrator in your organization does not need to write a policy to give users this ability. To compare, administrators who have permission to the tenancy can use this operation to create an auth token for any user, including themselves. - Specified by:
- createAuthTokenin interface- IdentityAsync
- 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.
 
 - 
createCompartmentpublic Future<CreateCompartmentResponse> createCompartment(CreateCompartmentRequest request, AsyncHandler<CreateCompartmentRequest,CreateCompartmentResponse> handler) Description copied from interface:IdentityAsyncCreates a new compartment in the specified compartment.Specify the parent compartment's OCID as the compartment ID in the request object. Remember that the tenancy is simply the root compartment. For information about OCIDs, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm). You must also specify a *name* for the compartment, which must be unique across all compartments in your tenancy. You can use this name or the OCID when writing policies that apply to the compartment. For more information about policies, see [How Policies Work](https://docs.oracle.com/iaas/Content/Identity/policieshow/how-policies-work.htm). You must also specify a *description* for the compartment (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateCompartment.After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. - Specified by:
- createCompartmentin interface- IdentityAsync
- 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.
 
 - 
createCustomerSecretKeypublic Future<CreateCustomerSecretKeyResponse> createCustomerSecretKey(CreateCustomerSecretKeyRequest request, AsyncHandler<CreateCustomerSecretKeyRequest,CreateCustomerSecretKeyResponse> handler) Description copied from interface:IdentityAsyncCreates a new secret key for the specified user.Secret keys are used for authentication with the Object Storage Service’s Amazon S3 compatible API. The secret key consists of an Access Key/Secret Key pair. For information, see Managing User Credentials. You must specify a *description* for the secret key (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateCustomerSecretKey.Every user has permission to create a secret key for *their own user ID*. An administrator in your organization does not need to write a policy to give users this ability. To compare, administrators who have permission to the tenancy can use this operation to create a secret key for any user, including themselves. - Specified by:
- createCustomerSecretKeyin interface- IdentityAsync
- 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.
 
 - 
createDbCredentialpublic Future<CreateDbCredentialResponse> createDbCredential(CreateDbCredentialRequest request, AsyncHandler<CreateDbCredentialRequest,CreateDbCredentialResponse> handler) Description copied from interface:IdentityAsyncCreates a new DB credential for the specified user.- Specified by:
- createDbCredentialin interface- IdentityAsync
- 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.
 
 - 
createDomainpublic Future<CreateDomainResponse> createDomain(CreateDomainRequest request, AsyncHandler<CreateDomainRequest,CreateDomainResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Creates a new identity domain in the tenancy with the identity domain home inhomeRegion.After you send your request, the temporary lifecycleStateof this identity domain is set to CREATING andlifecycleDetailsto UPDATING. When creation of the identity domain completes, this identity domain’slifecycleStateis set to ACTIVE andlifecycleDetailsto null.To track the progress of the request, submitting an HTTP GET on the /iamWorkRequests/{iamWorkRequestsId} endpoint retrieves the operation's status. After creating an `identity domain`, first make sure its `lifecycleState` changes from CREATING to ACTIVE before you use it. - Specified by:
- createDomainin interface- IdentityAsync
- 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.
 
 - 
createDynamicGrouppublic Future<CreateDynamicGroupResponse> createDynamicGroup(CreateDynamicGroupRequest request, AsyncHandler<CreateDynamicGroupRequest,CreateDynamicGroupResponse> handler) Description copied from interface:IdentityAsyncCreates a new dynamic group in your tenancy.You must specify your tenancy's OCID as the compartment ID in the request object (remember that the tenancy is simply the root compartment). Notice that IAM resources (users, groups, compartments, and some policies) reside within the tenancy itself, unlike cloud resources such as compute instances, which typically reside within compartments inside the tenancy. For information about OCIDs, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm). You must also specify a *name* for the dynamic group, which must be unique across all dynamic groups in your tenancy, and cannot be changed. Note that this name has to be also unique across all groups in your tenancy. You can use this name or the OCID when writing policies that apply to the dynamic group. For more information about policies, see [How Policies Work](https://docs.oracle.com/iaas/Content/Identity/policieshow/how-policies-work.htm). You must also specify a *description* for the dynamic group (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateDynamicGroup.After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. - Specified by:
- createDynamicGroupin interface- IdentityAsync
- 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.
 
 - 
createGrouppublic Future<CreateGroupResponse> createGroup(CreateGroupRequest request, AsyncHandler<CreateGroupRequest,CreateGroupResponse> handler) Description copied from interface:IdentityAsyncCreates a new group in your tenancy.You must specify your tenancy's OCID as the compartment ID in the request object (remember that the tenancy is simply the root compartment). Notice that IAM resources (users, groups, compartments, and some policies) reside within the tenancy itself, unlike cloud resources such as compute instances, which typically reside within compartments inside the tenancy. For information about OCIDs, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm). You must also specify a *name* for the group, which must be unique across all groups in your tenancy and cannot be changed. You can use this name or the OCID when writing policies that apply to the group. For more information about policies, see [How Policies Work](https://docs.oracle.com/iaas/Content/Identity/policieshow/how-policies-work.htm). You must also specify a *description* for the group (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateGroup.After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. After creating the group, you need to put users in it and write policies for it. See addUserToGroupandcreatePolicy.- Specified by:
- createGroupin interface- IdentityAsync
- 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.
 
 - 
createIdentityProviderpublic Future<CreateIdentityProviderResponse> createIdentityProvider(CreateIdentityProviderRequest request, AsyncHandler<CreateIdentityProviderRequest,CreateIdentityProviderResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Creates a new identity provider in your tenancy. For more information, see [Identity Providers and Federation](https://docs.oracle.com/iaas/Content/Identity/Concepts/federation.htm). You must specify your tenancy's OCID as the compartment ID in the request object. Remember that the tenancy is simply the root compartment. For information about OCIDs, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm). You must also specify a *name* for the `IdentityProvider`, which must be unique across all `IdentityProvider` objects in your tenancy and cannot be changed. You must also specify a *description* for the `IdentityProvider` (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateIdentityProvider.After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. - Specified by:
- createIdentityProviderin interface- IdentityAsync
- 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.
 
 - 
createIdpGroupMappingpublic Future<CreateIdpGroupMappingResponse> createIdpGroupMapping(CreateIdpGroupMappingRequest request, AsyncHandler<CreateIdpGroupMappingRequest,CreateIdpGroupMappingResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Creates a single mapping between an IdP group and an IAM Service Group.- Specified by:
- createIdpGroupMappingin interface- IdentityAsync
- 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.
 
 - 
createMfaTotpDevicepublic Future<CreateMfaTotpDeviceResponse> createMfaTotpDevice(CreateMfaTotpDeviceRequest request, AsyncHandler<CreateMfaTotpDeviceRequest,CreateMfaTotpDeviceResponse> handler) Description copied from interface:IdentityAsyncCreates a new MFA TOTP device for the user.A user can have one MFA TOTP device. - Specified by:
- createMfaTotpDevicein interface- IdentityAsync
- 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.
 
 - 
createNetworkSourcepublic Future<CreateNetworkSourceResponse> createNetworkSource(CreateNetworkSourceRequest request, AsyncHandler<CreateNetworkSourceRequest,CreateNetworkSourceResponse> handler) Description copied from interface:IdentityAsyncCreates a new network source in your tenancy.You must specify your tenancy's OCID as the compartment ID in the request object (remember that the tenancy is simply the root compartment). Notice that IAM resources (users, groups, compartments, and some policies) reside within the tenancy itself, unlike cloud resources such as compute instances, which typically reside within compartments inside the tenancy. For information about OCIDs, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm). You must also specify a *name* for the network source, which must be unique across all network sources in your tenancy, and cannot be changed. You can use this name or the OCID when writing policies that apply to the network source. For more information about policies, see [How Policies Work](https://docs.oracle.com/iaas/Content/Identity/policieshow/how-policies-work.htm). You must also specify a *description* for the network source (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateNetworkSource.After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. After your network resource is created, you can use it in policy to restrict access to only requests made from an allowed IP address specified in your network source. For more information, see [Managing Network Sources](https://docs.oracle.com/iaas/Content/Identity/Tasks/managingnetworksources.htm). - Specified by:
- createNetworkSourcein interface- IdentityAsync
- 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.
 
 - 
createOAuthClientCredentialpublic Future<CreateOAuthClientCredentialResponse> createOAuthClientCredential(CreateOAuthClientCredentialRequest request, AsyncHandler<CreateOAuthClientCredentialRequest,CreateOAuthClientCredentialResponse> handler) Description copied from interface:IdentityAsyncCreates Oauth token for the user- Specified by:
- createOAuthClientCredentialin interface- IdentityAsync
- 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.
 
 - 
createOrResetUIPasswordpublic Future<CreateOrResetUIPasswordResponse> createOrResetUIPassword(CreateOrResetUIPasswordRequest request, AsyncHandler<CreateOrResetUIPasswordRequest,CreateOrResetUIPasswordResponse> handler) Description copied from interface:IdentityAsyncCreates a new Console one-time password for the specified user.For more information about user credentials, see User Credentials. Use this operation after creating a new user, or if a user forgets their password. The new one-time password is returned to you in the response, and you must securely deliver it to the user. They'll be prompted to change this password the next time they sign in to the Console. If they don't change it within 7 days, the password will expire and you'll need to create a new one-time password for the user. (For tenancies that support identity domains) Resetting a user's password generates a reset password email with a link that the user must follow to reset their password. If the user does not reset their password before the link expires, you'll need to reset the user's password again. *Note:** The user's Console login is the unique name you specified when you created the user (see createUser).- Specified by:
- createOrResetUIPasswordin interface- IdentityAsync
- 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.
 
 - 
createPolicypublic Future<CreatePolicyResponse> createPolicy(CreatePolicyRequest request, AsyncHandler<CreatePolicyRequest,CreatePolicyResponse> handler) Description copied from interface:IdentityAsyncCreates a new policy in the specified compartment (either the tenancy or another of your compartments).If you’re new to policies, see Get Started with Policies. You must specify a *name* for the policy, which must be unique across all policies in your tenancy and cannot be changed. You must also specify a *description* for the policy (although it can be an empty string). It does not have to be unique, and you can change it anytime with updatePolicy.You must specify one or more policy statements in the statements array. For information about writing policies, see [How Policies Work](https://docs.oracle.com/iaas/Content/Identity/policieshow/how-policies-work.htm) and [Common Policies](https://docs.oracle.com/iaas/Content/Identity/policiescommon/commonpolicies.htm). After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. New policies take effect typically within 10 seconds. - Specified by:
- createPolicyin interface- IdentityAsync
- 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.
 
 - 
createRegionSubscriptionpublic Future<CreateRegionSubscriptionResponse> createRegionSubscription(CreateRegionSubscriptionRequest request, AsyncHandler<CreateRegionSubscriptionRequest,CreateRegionSubscriptionResponse> handler) Description copied from interface:IdentityAsyncCreates a subscription to a region for a tenancy.- Specified by:
- createRegionSubscriptionin interface- IdentityAsync
- 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.
 
 - 
createSmtpCredentialpublic Future<CreateSmtpCredentialResponse> createSmtpCredential(CreateSmtpCredentialRequest request, AsyncHandler<CreateSmtpCredentialRequest,CreateSmtpCredentialResponse> handler) Description copied from interface:IdentityAsyncCreates a new SMTP credential for the specified user.An SMTP credential has an SMTP user name and an SMTP password. You must specify a description for the SMTP credential (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateSmtpCredential.- Specified by:
- createSmtpCredentialin interface- IdentityAsync
- 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.
 
 - 
createSwiftPasswordpublic Future<CreateSwiftPasswordResponse> createSwiftPassword(CreateSwiftPasswordRequest request, AsyncHandler<CreateSwiftPasswordRequest,CreateSwiftPasswordResponse> handler) Description copied from interface:IdentityAsync**Deprecated.Use createAuthTokeninstead.**Creates a new Swift password for the specified user. For information about what Swift passwords are for, see [Managing User Credentials](https://docs.oracle.com/iaas/Content/Identity/Tasks/managingcredentials.htm). You must specify a *description* for the Swift password (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateSwiftPassword.Every user has permission to create a Swift password for *their own user ID*. An administrator in your organization does not need to write a policy to give users this ability. To compare, administrators who have permission to the tenancy can use this operation to create a Swift password for any user, including themselves. - Specified by:
- createSwiftPasswordin interface- IdentityAsync
- 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.
 
 - 
createTagpublic Future<CreateTagResponse> createTag(CreateTagRequest request, AsyncHandler<CreateTagRequest,CreateTagResponse> handler) Description copied from interface:IdentityAsyncCreates a new tag in the specified tag namespace.The tag requires either the OCID or the name of the tag namespace that will contain this tag definition. You must specify a *name* for the tag, which must be unique across all tags in the tag namespace and cannot be changed. The name can contain any ASCII character except the space (_) or period (.) characters. Names are case insensitive. That means, for example, \"myTag\" and \"mytag\" are not allowed in the same namespace. If you specify a name that's already in use in the tag namespace, a 409 error is returned. The tag must have a *description*. It does not have to be unique, and you can change it with updateTag.The tag must have a value type, which is specified with a validator. Tags can use either a static value or a list of possible values. Static values are entered by a user applying the tag to a resource. Lists are created by you and the user must apply a value from the list. Lists are validiated. If no `validator` is set, the user applying the tag to a resource can type in a static value or leave the tag value empty. * If a `validator` is set, the user applying the tag to a resource must select from a list of values that you supply with enumTagDefinitionValidator.- Specified by:
- createTagin interface- IdentityAsync
- 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.
 
 - 
createTagDefaultpublic Future<CreateTagDefaultResponse> createTagDefault(CreateTagDefaultRequest request, AsyncHandler<CreateTagDefaultRequest,CreateTagDefaultResponse> handler) Description copied from interface:IdentityAsyncCreates a new tag default in the specified compartment for the specified tag definition.If you specify that a value is required, a value is set during resource creation (either by the user creating the resource or another tag defualt). If no value is set, resource creation is blocked. If the `isRequired` flag is set to \"true\", the value is set during resource creation. * If the `isRequired` flag is set to \"false\", the value you enter is set during resource creation. - Specified by:
- createTagDefaultin interface- IdentityAsync
- 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.
 
 - 
createTagNamespacepublic Future<CreateTagNamespaceResponse> createTagNamespace(CreateTagNamespaceRequest request, AsyncHandler<CreateTagNamespaceRequest,CreateTagNamespaceResponse> handler) Description copied from interface:IdentityAsyncCreates a new tag namespace in the specified compartment.You must specify the compartment ID in the request object (remember that the tenancy is simply the root compartment). You must also specify a *name* for the namespace, which must be unique across all namespaces in your tenancy and cannot be changed. The name can contain any ASCII character except the space (_) or period (.). Names are case insensitive. That means, for example, \"myNamespace\" and \"mynamespace\" are not allowed in the same tenancy. Once you created a namespace, you cannot change the name. If you specify a name that's already in use in the tenancy, a 409 error is returned. You must also specify a *description* for the namespace. It does not have to be unique, and you can change it with updateTagNamespace.- Specified by:
- createTagNamespacein interface- IdentityAsync
- 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.
 
 - 
createUserpublic Future<CreateUserResponse> createUser(CreateUserRequest request, AsyncHandler<CreateUserRequest,CreateUserResponse> handler) Description copied from interface:IdentityAsyncCreates a new user in your tenancy.For conceptual information about users, your tenancy, and other IAM Service components, see Overview of IAM. You must specify your tenancy's OCID as the compartment ID in the request object (remember that the tenancy is simply the root compartment). Notice that IAM resources (users, groups, compartments, and some policies) reside within the tenancy itself, unlike cloud resources such as compute instances, which typically reside within compartments inside the tenancy. For information about OCIDs, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm). You must also specify a *name* for the user, which must be unique across all users in your tenancy and cannot be changed. Allowed characters: No spaces. Only letters, numerals, hyphens, periods, underscores, +, and @. If you specify a name that's already in use, you'll get a 409 error. This name will be the user's login to the Console. You might want to pick a name that your company's own identity system (e.g., Active Directory, LDAP, etc.) already uses. If you delete a user and then create a new user with the same name, they'll be considered different users because they have different OCIDs. You must also specify a *description* for the user (although it can be an empty string). It does not have to be unique, and you can change it anytime with updateUser. You can use the field to provide the user's full name, a description, a nickname, or other information to generally identify the user.After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. A new user has no permissions until you place the user in one or more groups (see addUserToGroup). If the user needs to access the Console, you need to provide the user a password (seecreateOrResetUIPassword). If the user needs to access the Oracle Cloud Infrastructure REST API, you need to upload a public API signing key for that user (see [Required Keys and OCIDs](https://docs.oracle.com/iaas/Content/API/Concepts/apisigningkey.htm) and alsouploadApiKey).*Important:** Make sure to inform the new user which compartment(s) they have access to. - Specified by:
- createUserin interface- IdentityAsync
- 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.
 
 - 
deactivateDomainpublic Future<DeactivateDomainResponse> deactivateDomain(DeactivateDomainRequest request, AsyncHandler<DeactivateDomainRequest,DeactivateDomainResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Deactivates the specified identity domain.Identity domains must be in an ACTIVE lifecycleStateand have no active apps present in the domain or underlying Identity Cloud Service stripe. You cannot deactivate the default identity domain.After you send your request, the `lifecycleDetails` of this identity domain is set to DEACTIVATING. When the operation completes, then the `lifecycleDetails` is set to null and the `lifecycleState` is set to INACTIVE. To track the progress of the request, submitting an HTTP GET on the /iamWorkRequests/{iamWorkRequestsId} endpoint retrieves the operation's status. - Specified by:
- deactivateDomainin interface- IdentityAsync
- 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.
 
 - 
deleteApiKeypublic Future<DeleteApiKeyResponse> deleteApiKey(DeleteApiKeyRequest request, AsyncHandler<DeleteApiKeyRequest,DeleteApiKeyResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified API signing key for the specified user.Every user has permission to use this operation to delete a key for *their own user ID*. An administrator in your organization does not need to write a policy to give users this ability. To compare, administrators who have permission to the tenancy can use this operation to delete a key for any user, including themselves. - Specified by:
- deleteApiKeyin interface- IdentityAsync
- 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.
 
 - 
deleteAuthTokenpublic Future<DeleteAuthTokenResponse> deleteAuthToken(DeleteAuthTokenRequest request, AsyncHandler<DeleteAuthTokenRequest,DeleteAuthTokenResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified auth token for the specified user.- Specified by:
- deleteAuthTokenin interface- IdentityAsync
- 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.
 
 - 
deleteCompartmentpublic Future<DeleteCompartmentResponse> deleteCompartment(DeleteCompartmentRequest request, AsyncHandler<DeleteCompartmentRequest,DeleteCompartmentResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified compartment.The compartment must be empty. - Specified by:
- deleteCompartmentin interface- IdentityAsync
- 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.
 
 - 
deleteCustomerSecretKeypublic Future<DeleteCustomerSecretKeyResponse> deleteCustomerSecretKey(DeleteCustomerSecretKeyRequest request, AsyncHandler<DeleteCustomerSecretKeyRequest,DeleteCustomerSecretKeyResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified secret key for the specified user.- Specified by:
- deleteCustomerSecretKeyin interface- IdentityAsync
- 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.
 
 - 
deleteDbCredentialpublic Future<DeleteDbCredentialResponse> deleteDbCredential(DeleteDbCredentialRequest request, AsyncHandler<DeleteDbCredentialRequest,DeleteDbCredentialResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified DB credential for the specified user.- Specified by:
- deleteDbCredentialin interface- IdentityAsync
- 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.
 
 - 
deleteDomainpublic Future<DeleteDomainResponse> deleteDomain(DeleteDomainRequest request, AsyncHandler<DeleteDomainRequest,DeleteDomainResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Deletes an identity domain.The identity domain must have no active apps present in the underlying IDCS stripe. You must also deactivate the identity domain, rendering the lifecycleStateof the identity domain INACTIVE. Furthermore, as the authenticated user performing the operation, you cannot be a member of the identity domain you are deleting. Lastly, you cannot delete the default identity domain. A tenancy must always have at least the default identity domain.To track the progress of the request, submitting an HTTP GET on the /iamWorkRequests/{iamWorkRequestsId} endpoint retrieves the operation's status. - Specified by:
- deleteDomainin interface- IdentityAsync
- 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.
 
 - 
deleteDynamicGrouppublic Future<DeleteDynamicGroupResponse> deleteDynamicGroup(DeleteDynamicGroupRequest request, AsyncHandler<DeleteDynamicGroupRequest,DeleteDynamicGroupResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified dynamic group.- Specified by:
- deleteDynamicGroupin interface- IdentityAsync
- 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.
 
 - 
deleteGrouppublic Future<DeleteGroupResponse> deleteGroup(DeleteGroupRequest request, AsyncHandler<DeleteGroupRequest,DeleteGroupResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified group.The group must be empty. - Specified by:
- deleteGroupin interface- IdentityAsync
- 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.
 
 - 
deleteIdentityProviderpublic Future<DeleteIdentityProviderResponse> deleteIdentityProvider(DeleteIdentityProviderRequest request, AsyncHandler<DeleteIdentityProviderRequest,DeleteIdentityProviderResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Deletes the specified identity provider. The identity provider must not have any group mappings (see IdpGroupMapping).- Specified by:
- deleteIdentityProviderin interface- IdentityAsync
- 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.
 
 - 
deleteIdpGroupMappingpublic Future<DeleteIdpGroupMappingResponse> deleteIdpGroupMapping(DeleteIdpGroupMappingRequest request, AsyncHandler<DeleteIdpGroupMappingRequest,DeleteIdpGroupMappingResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Deletes the specified group mapping. - Specified by:
- deleteIdpGroupMappingin interface- IdentityAsync
- 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.
 
 - 
deleteMfaTotpDevicepublic Future<DeleteMfaTotpDeviceResponse> deleteMfaTotpDevice(DeleteMfaTotpDeviceRequest request, AsyncHandler<DeleteMfaTotpDeviceRequest,DeleteMfaTotpDeviceResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified MFA TOTP device for the specified user.- Specified by:
- deleteMfaTotpDevicein interface- IdentityAsync
- 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.
 
 - 
deleteNetworkSourcepublic Future<DeleteNetworkSourceResponse> deleteNetworkSource(DeleteNetworkSourceRequest request, AsyncHandler<DeleteNetworkSourceRequest,DeleteNetworkSourceResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified network source.- Specified by:
- deleteNetworkSourcein interface- IdentityAsync
- 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.
 
 - 
deleteOAuthClientCredentialpublic Future<DeleteOAuthClientCredentialResponse> deleteOAuthClientCredential(DeleteOAuthClientCredentialRequest request, AsyncHandler<DeleteOAuthClientCredentialRequest,DeleteOAuthClientCredentialResponse> handler) Description copied from interface:IdentityAsyncDelete Oauth token for the user- Specified by:
- deleteOAuthClientCredentialin interface- IdentityAsync
- 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.
 
 - 
deletePolicypublic Future<DeletePolicyResponse> deletePolicy(DeletePolicyRequest request, AsyncHandler<DeletePolicyRequest,DeletePolicyResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified policy.The deletion takes effect typically within 10 seconds. - Specified by:
- deletePolicyin interface- IdentityAsync
- 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.
 
 - 
deleteSmtpCredentialpublic Future<DeleteSmtpCredentialResponse> deleteSmtpCredential(DeleteSmtpCredentialRequest request, AsyncHandler<DeleteSmtpCredentialRequest,DeleteSmtpCredentialResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified SMTP credential for the specified user.- Specified by:
- deleteSmtpCredentialin interface- IdentityAsync
- 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.
 
 - 
deleteSwiftPasswordpublic Future<DeleteSwiftPasswordResponse> deleteSwiftPassword(DeleteSwiftPasswordRequest request, AsyncHandler<DeleteSwiftPasswordRequest,DeleteSwiftPasswordResponse> handler) Description copied from interface:IdentityAsync**Deprecated.Use deleteAuthTokeninstead.**Deletes the specified Swift password for the specified user. - Specified by:
- deleteSwiftPasswordin interface- IdentityAsync
- 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.
 
 - 
deleteTagpublic Future<DeleteTagResponse> deleteTag(DeleteTagRequest request, AsyncHandler<DeleteTagRequest,DeleteTagResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified tag definition.This operation triggers a process that removes the tag from all resources in your tenancy. These things happen immediately: * If the tag was a cost-tracking tag, it no longer counts against your 10 cost-tracking tags limit, whether you first disabled it or not. * If the tag was used with dynamic groups, none of the rules that contain the tag will be evaluated against the tag. When you start the delete operation, the state of the tag changes to DELETING and tag removal from resources begins. This can take up to 48 hours depending on the number of resources that were tagged as well as the regions in which those resources reside. When all tags have been removed, the state changes to DELETED. You cannot restore a deleted tag. Once the deleted tag changes its state to DELETED, you can use the same tag name again. After you start this operation, you cannot start either the bulkDeleteTagsor thecascadeDeleteTagNamespaceoperation until this process completes.To delete a tag, you must first retire it. Use updateTagto retire a tag.- Specified by:
- deleteTagin interface- IdentityAsync
- 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.
 
 - 
deleteTagDefaultpublic Future<DeleteTagDefaultResponse> deleteTagDefault(DeleteTagDefaultRequest request, AsyncHandler<DeleteTagDefaultRequest,DeleteTagDefaultResponse> handler) Description copied from interface:IdentityAsyncDeletes the the specified tag default.- Specified by:
- deleteTagDefaultin interface- IdentityAsync
- 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.
 
 - 
deleteTagNamespacepublic Future<DeleteTagNamespaceResponse> deleteTagNamespace(DeleteTagNamespaceRequest request, AsyncHandler<DeleteTagNamespaceRequest,DeleteTagNamespaceResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified tag namespace.Only an empty tag namespace can be deleted with this operation. To use this operation to delete a tag namespace that contains tag definitions, first delete all of its tag definitions. Use cascadeDeleteTagNamespaceto delete a tag namespace along with all of the tag definitions contained within that namespace.Use deleteTagto delete a tag definition.- Specified by:
- deleteTagNamespacein interface- IdentityAsync
- 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.
 
 - 
deleteUserpublic Future<DeleteUserResponse> deleteUser(DeleteUserRequest request, AsyncHandler<DeleteUserRequest,DeleteUserResponse> handler) Description copied from interface:IdentityAsyncDeletes the specified user.The user must not be in any groups. - Specified by:
- deleteUserin interface- IdentityAsync
- 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.
 
 - 
enableReplicationToRegionpublic Future<EnableReplicationToRegionResponse> enableReplicationToRegion(EnableReplicationToRegionRequest request, AsyncHandler<EnableReplicationToRegionRequest,EnableReplicationToRegionResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Replicates the identity domain to a new region (provided that the region is the tenancy home region or other region that the tenancy subscribes to).You can only replicate identity domains that are in an ACTIVE lifecycleStateand not currently updating or already replicating. You also can only trigger the replication of secondary identity domains. The default identity domain is automatically replicated to all regions that the tenancy subscribes to.After you send the request, the `state` of the identity domain in the replica region is set to ENABLING_REPLICATION. When the operation completes, the `state` is set to REPLICATION_ENABLED. To track the progress of the request, submitting an HTTP GET on the /iamWorkRequests/{iamWorkRequestsId} endpoint retrieves the operation's status. - Specified by:
- enableReplicationToRegionin interface- IdentityAsync
- 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.
 
 - 
generateTotpSeedpublic Future<GenerateTotpSeedResponse> generateTotpSeed(GenerateTotpSeedRequest request, AsyncHandler<GenerateTotpSeedRequest,GenerateTotpSeedResponse> handler) Description copied from interface:IdentityAsyncGenerate seed for the MFA TOTP device.- Specified by:
- generateTotpSeedin interface- IdentityAsync
- 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.
 
 - 
getAuthenticationPolicypublic Future<GetAuthenticationPolicyResponse> getAuthenticationPolicy(GetAuthenticationPolicyRequest request, AsyncHandler<GetAuthenticationPolicyRequest,GetAuthenticationPolicyResponse> handler) Description copied from interface:IdentityAsyncGets the authentication policy for the given tenancy.You must specify your tenant’s OCID as the value for the compartment ID (remember that the tenancy is simply the root compartment). - Specified by:
- getAuthenticationPolicyin interface- IdentityAsync
- 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.
 
 - 
getCompartmentpublic Future<GetCompartmentResponse> getCompartment(GetCompartmentRequest request, AsyncHandler<GetCompartmentRequest,GetCompartmentResponse> handler) Description copied from interface:IdentityAsyncGets the specified compartment’s information.This operation does not return a list of all the resources inside the compartment. There is no single API operation that does that. Compartments can contain multiple types of resources (instances, block storage volumes, etc.). To find out what's in a compartment, you must call the \"List\" operation for each resource type and specify the compartment's OCID as a query parameter in the request. For example, call the listInstancesoperation in the Cloud Compute Service or thelistVolumesoperation in Cloud Block Storage.- Specified by:
- getCompartmentin interface- IdentityAsync
- 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.
 
 - 
getDomainpublic Future<GetDomainResponse> getDomain(GetDomainRequest request, AsyncHandler<GetDomainRequest,GetDomainResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Gets the specified identity domain’s information.- Specified by:
- getDomainin interface- IdentityAsync
- 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.
 
 - 
getDynamicGrouppublic Future<GetDynamicGroupResponse> getDynamicGroup(GetDynamicGroupRequest request, AsyncHandler<GetDynamicGroupRequest,GetDynamicGroupResponse> handler) Description copied from interface:IdentityAsyncGets the specified dynamic group’s information.- Specified by:
- getDynamicGroupin interface- IdentityAsync
- 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.
 
 - 
getGrouppublic Future<GetGroupResponse> getGroup(GetGroupRequest request, AsyncHandler<GetGroupRequest,GetGroupResponse> handler) Description copied from interface:IdentityAsyncGets the specified group’s information.This operation does not return a list of all the users in the group. To do that, use listUserGroupMembershipsand provide the group's OCID as a query parameter in the request.- Specified by:
- getGroupin interface- IdentityAsync
- 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.
 
 - 
getIamWorkRequestpublic Future<GetIamWorkRequestResponse> getIamWorkRequest(GetIamWorkRequestRequest request, AsyncHandler<GetIamWorkRequestRequest,GetIamWorkRequestResponse> handler) Description copied from interface:IdentityAsyncGets the details of a specified IAM work request.The workRequestID is returned in the opc-workrequest-id header for any asynchronous operation in the Identity and Access Management service. - Specified by:
- getIamWorkRequestin interface- IdentityAsync
- 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.
 
 - 
getIdentityProviderpublic Future<GetIdentityProviderResponse> getIdentityProvider(GetIdentityProviderRequest request, AsyncHandler<GetIdentityProviderRequest,GetIdentityProviderResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Gets the specified identity provider's information. - Specified by:
- getIdentityProviderin interface- IdentityAsync
- 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.
 
 - 
getIdpGroupMappingpublic Future<GetIdpGroupMappingResponse> getIdpGroupMapping(GetIdpGroupMappingRequest request, AsyncHandler<GetIdpGroupMappingRequest,GetIdpGroupMappingResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Gets the specified group mapping. - Specified by:
- getIdpGroupMappingin interface- IdentityAsync
- 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.
 
 - 
getMfaTotpDevicepublic Future<GetMfaTotpDeviceResponse> getMfaTotpDevice(GetMfaTotpDeviceRequest request, AsyncHandler<GetMfaTotpDeviceRequest,GetMfaTotpDeviceResponse> handler) Description copied from interface:IdentityAsyncGet the specified MFA TOTP device for the specified user.- Specified by:
- getMfaTotpDevicein interface- IdentityAsync
- 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.
 
 - 
getNetworkSourcepublic Future<GetNetworkSourceResponse> getNetworkSource(GetNetworkSourceRequest request, AsyncHandler<GetNetworkSourceRequest,GetNetworkSourceResponse> handler) Description copied from interface:IdentityAsyncGets the specified network source’s information.- Specified by:
- getNetworkSourcein interface- IdentityAsync
- 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.
 
 - 
getPolicypublic Future<GetPolicyResponse> getPolicy(GetPolicyRequest request, AsyncHandler<GetPolicyRequest,GetPolicyResponse> handler) Description copied from interface:IdentityAsyncGets the specified policy’s information.- Specified by:
- getPolicyin interface- IdentityAsync
- 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.
 
 - 
getStandardTagTemplatepublic Future<GetStandardTagTemplateResponse> getStandardTagTemplate(GetStandardTagTemplateRequest request, AsyncHandler<GetStandardTagTemplateRequest,GetStandardTagTemplateResponse> handler) Description copied from interface:IdentityAsyncRetrieve the standard tag namespace template given the standard tag namespace name.- Specified by:
- getStandardTagTemplatein interface- IdentityAsync
- 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.
 
 - 
getTagpublic Future<GetTagResponse> getTag(GetTagRequest request, AsyncHandler<GetTagRequest,GetTagResponse> handler) Description copied from interface:IdentityAsyncGets the specified tag’s information.- Specified by:
- getTagin interface- IdentityAsync
- 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.
 
 - 
getTagDefaultpublic Future<GetTagDefaultResponse> getTagDefault(GetTagDefaultRequest request, AsyncHandler<GetTagDefaultRequest,GetTagDefaultResponse> handler) Description copied from interface:IdentityAsyncRetrieves the specified tag default.- Specified by:
- getTagDefaultin interface- IdentityAsync
- 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.
 
 - 
getTagNamespacepublic Future<GetTagNamespaceResponse> getTagNamespace(GetTagNamespaceRequest request, AsyncHandler<GetTagNamespaceRequest,GetTagNamespaceResponse> handler) Description copied from interface:IdentityAsyncGets the specified tag namespace’s information.- Specified by:
- getTagNamespacein interface- IdentityAsync
- 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.
 
 - 
getTaggingWorkRequestpublic Future<GetTaggingWorkRequestResponse> getTaggingWorkRequest(GetTaggingWorkRequestRequest request, AsyncHandler<GetTaggingWorkRequestRequest,GetTaggingWorkRequestResponse> handler) Description copied from interface:IdentityAsyncGets details on a specified work request.The workRequestID is returned in the opc-workrequest-id header for any asynchronous operation in tagging service. - Specified by:
- getTaggingWorkRequestin interface- IdentityAsync
- 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.
 
 - 
getTenancypublic Future<GetTenancyResponse> getTenancy(GetTenancyRequest request, AsyncHandler<GetTenancyRequest,GetTenancyResponse> handler) Description copied from interface:IdentityAsyncGet the specified tenancy’s information.- Specified by:
- getTenancyin interface- IdentityAsync
- 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.
 
 - 
getUserpublic Future<GetUserResponse> getUser(GetUserRequest request, AsyncHandler<GetUserRequest,GetUserResponse> handler) Description copied from interface:IdentityAsyncGets the specified user’s information.- Specified by:
- getUserin interface- IdentityAsync
- 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.
 
 - 
getUserGroupMembershippublic Future<GetUserGroupMembershipResponse> getUserGroupMembership(GetUserGroupMembershipRequest request, AsyncHandler<GetUserGroupMembershipRequest,GetUserGroupMembershipResponse> handler) Description copied from interface:IdentityAsyncGets the specified UserGroupMembership’s information.- Specified by:
- getUserGroupMembershipin interface- IdentityAsync
- 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.
 
 - 
getUserUIPasswordInformationpublic Future<GetUserUIPasswordInformationResponse> getUserUIPasswordInformation(GetUserUIPasswordInformationRequest request, AsyncHandler<GetUserUIPasswordInformationRequest,GetUserUIPasswordInformationResponse> handler) Description copied from interface:IdentityAsyncGets the specified user’s console password information.The returned object contains the user’s OCID, but not the password itself. The actual password is returned only when created or reset. - Specified by:
- getUserUIPasswordInformationin interface- IdentityAsync
- 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.
 
 - 
getWorkRequestpublic Future<GetWorkRequestResponse> getWorkRequest(GetWorkRequestRequest request, AsyncHandler<GetWorkRequestRequest,GetWorkRequestResponse> handler) Description copied from interface:IdentityAsyncGets details on a specified work request.The workRequestID is returned in the opc-workrequest-id header for any asynchronous operation in the compartment service. - Specified by:
- getWorkRequestin interface- IdentityAsync
- 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.
 
 - 
importStandardTagspublic Future<ImportStandardTagsResponse> importStandardTags(ImportStandardTagsRequest request, AsyncHandler<ImportStandardTagsRequest,ImportStandardTagsResponse> handler) Description copied from interface:IdentityAsyncOCI will release Tag Namespaces that our customers can import.These Tag Namespaces will provide Tags for our customers and Partners to provide consistency and enable data reporting. - Specified by:
- importStandardTagsin interface- IdentityAsync
- 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.
 
 - 
listAllowedDomainLicenseTypespublic Future<ListAllowedDomainLicenseTypesResponse> listAllowedDomainLicenseTypes(ListAllowedDomainLicenseTypesRequest request, AsyncHandler<ListAllowedDomainLicenseTypesRequest,ListAllowedDomainLicenseTypesResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Lists the license types for identity domains supported by Oracle Cloud Infrastructure.(License types are also referred to as domain types.) If `currentLicenseTypeName` is provided, then the request returns license types that the identity domain with the specified license type name can change to. Otherwise, the request returns all valid license types currently supported. - Specified by:
- listAllowedDomainLicenseTypesin interface- IdentityAsync
- 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.
 
 - 
listApiKeyspublic Future<ListApiKeysResponse> listApiKeys(ListApiKeysRequest request, AsyncHandler<ListApiKeysRequest,ListApiKeysResponse> handler) Description copied from interface:IdentityAsyncLists the API signing keys for the specified user.A user can have a maximum of three keys. Every user has permission to use this API call for *their own user ID*. An administrator in your organization does not need to write a policy to give users this ability. - Specified by:
- listApiKeysin interface- IdentityAsync
- 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.
 
 - 
listAuthTokenspublic Future<ListAuthTokensResponse> listAuthTokens(ListAuthTokensRequest request, AsyncHandler<ListAuthTokensRequest,ListAuthTokensResponse> handler) Description copied from interface:IdentityAsyncLists the auth tokens for the specified user.The returned object contains the token’s OCID, but not the token itself. The actual token is returned only upon creation. - Specified by:
- listAuthTokensin interface- IdentityAsync
- 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.
 
 - 
listAvailabilityDomainspublic Future<ListAvailabilityDomainsResponse> listAvailabilityDomains(ListAvailabilityDomainsRequest request, AsyncHandler<ListAvailabilityDomainsRequest,ListAvailabilityDomainsResponse> handler) Description copied from interface:IdentityAsyncLists the availability domains in your tenancy.Specify the OCID of either the tenancy or another of your compartments as the value for the compartment ID (remember that the tenancy is simply the root compartment). See Where to Get the Tenancy’s OCID and User’s OCID. Note that the order of the results returned can change if availability domains are added or removed; therefore, do not create a dependency on the list order. - Specified by:
- listAvailabilityDomainsin interface- IdentityAsync
- 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.
 
 - 
listBulkActionResourceTypespublic Future<ListBulkActionResourceTypesResponse> listBulkActionResourceTypes(ListBulkActionResourceTypesRequest request, AsyncHandler<ListBulkActionResourceTypesRequest,ListBulkActionResourceTypesResponse> handler) Description copied from interface:IdentityAsyncLists the resource-types supported by compartment bulk actions.Use this API to help you provide the correct resource-type information to the bulkDeleteResourcesandbulkMoveResourcesoperations. The returned list of resource-types provides the appropriate resource-type names to use with the bulk action operations along with the type of identifying information you’ll need to provide for each resource-type. Most resource-types just require an OCID to identify a specific resource, but some resource-types, such as buckets, require you to provide other identifying information.- Specified by:
- listBulkActionResourceTypesin interface- IdentityAsync
- 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.
 
 - 
listBulkEditTagsResourceTypespublic Future<ListBulkEditTagsResourceTypesResponse> listBulkEditTagsResourceTypes(ListBulkEditTagsResourceTypesRequest request, AsyncHandler<ListBulkEditTagsResourceTypesRequest,ListBulkEditTagsResourceTypesResponse> handler) Description copied from interface:IdentityAsyncLists the resource types that support bulk tag editing.- Specified by:
- listBulkEditTagsResourceTypesin interface- IdentityAsync
- 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.
 
 - 
listCompartmentspublic Future<ListCompartmentsResponse> listCompartments(ListCompartmentsRequest request, AsyncHandler<ListCompartmentsRequest,ListCompartmentsResponse> handler) Description copied from interface:IdentityAsyncLists the compartments in a specified compartment.The members of the list returned depends on the values set for several parameters. With the exception of the tenancy (root compartment), the ListCompartments operation returns only the first-level child compartments in the parent compartment specified in `compartmentId`. The list does not include any subcompartments of the child compartments (grandchildren). The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (the resource can be in a subcompartment). The parameter `compartmentIdInSubtree` applies only when you perform ListCompartments on the tenancy (root compartment). When set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ANY. See [Where to Get the Tenancy's OCID and User's OCID](https://docs.oracle.com/iaas/Content/API/Concepts/apisigningkey.htm#five). - Specified by:
- listCompartmentsin interface- IdentityAsync
- 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.
 
 - 
listCostTrackingTagspublic Future<ListCostTrackingTagsResponse> listCostTrackingTags(ListCostTrackingTagsRequest request, AsyncHandler<ListCostTrackingTagsRequest,ListCostTrackingTagsResponse> handler) Description copied from interface:IdentityAsyncLists all the tags enabled for cost-tracking in the specified tenancy.For information about cost-tracking tags, see Using Cost-tracking Tags. - Specified by:
- listCostTrackingTagsin interface- IdentityAsync
- 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.
 
 - 
listCustomerSecretKeyspublic Future<ListCustomerSecretKeysResponse> listCustomerSecretKeys(ListCustomerSecretKeysRequest request, AsyncHandler<ListCustomerSecretKeysRequest,ListCustomerSecretKeysResponse> handler) Description copied from interface:IdentityAsyncLists the secret keys for the specified user.The returned object contains the secret key’s OCID, but not the secret key itself. The actual secret key is returned only upon creation. - Specified by:
- listCustomerSecretKeysin interface- IdentityAsync
- 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.
 
 - 
listDbCredentialspublic Future<ListDbCredentialsResponse> listDbCredentials(ListDbCredentialsRequest request, AsyncHandler<ListDbCredentialsRequest,ListDbCredentialsResponse> handler) Description copied from interface:IdentityAsyncLists the DB credentials for the specified user.The returned object contains the credential’s OCID - Specified by:
- listDbCredentialsin interface- IdentityAsync
- 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.
 
 - 
listDomainspublic Future<ListDomainsResponse> listDomains(ListDomainsRequest request, AsyncHandler<ListDomainsRequest,ListDomainsResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Lists all identity domains within a tenancy.- Specified by:
- listDomainsin interface- IdentityAsync
- 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.
 
 - 
listDynamicGroupspublic Future<ListDynamicGroupsResponse> listDynamicGroups(ListDynamicGroupsRequest request, AsyncHandler<ListDynamicGroupsRequest,ListDynamicGroupsResponse> handler) Description copied from interface:IdentityAsyncLists the dynamic groups in your tenancy.You must specify your tenancy’s OCID as the value for the compartment ID (remember that the tenancy is simply the root compartment). See Where to Get the Tenancy’s OCID and User’s OCID. - Specified by:
- listDynamicGroupsin interface- IdentityAsync
- 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.
 
 - 
listFaultDomainspublic Future<ListFaultDomainsResponse> listFaultDomains(ListFaultDomainsRequest request, AsyncHandler<ListFaultDomainsRequest,ListFaultDomainsResponse> handler) Description copied from interface:IdentityAsyncLists the Fault Domains in your tenancy.Specify the OCID of either the tenancy or another of your compartments as the value for the compartment ID (remember that the tenancy is simply the root compartment). See Where to Get the Tenancy’s OCID and User’s OCID. - Specified by:
- listFaultDomainsin interface- IdentityAsync
- 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.
 
 - 
listGroupspublic Future<ListGroupsResponse> listGroups(ListGroupsRequest request, AsyncHandler<ListGroupsRequest,ListGroupsResponse> handler) Description copied from interface:IdentityAsyncLists the groups in your tenancy.You must specify your tenancy’s OCID as the value for the compartment ID (remember that the tenancy is simply the root compartment). See Where to Get the Tenancy’s OCID and User’s OCID. - Specified by:
- listGroupsin interface- IdentityAsync
- 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.
 
 - 
listIamWorkRequestErrorspublic Future<ListIamWorkRequestErrorsResponse> listIamWorkRequestErrors(ListIamWorkRequestErrorsRequest request, AsyncHandler<ListIamWorkRequestErrorsRequest,ListIamWorkRequestErrorsResponse> handler) Description copied from interface:IdentityAsyncGets error details for a specified IAM work request.The workRequestID is returned in the opc-workrequest-id header for any asynchronous operation in the Identity and Access Management service. - Specified by:
- listIamWorkRequestErrorsin interface- IdentityAsync
- 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.
 
 - 
listIamWorkRequestLogspublic Future<ListIamWorkRequestLogsResponse> listIamWorkRequestLogs(ListIamWorkRequestLogsRequest request, AsyncHandler<ListIamWorkRequestLogsRequest,ListIamWorkRequestLogsResponse> handler) Description copied from interface:IdentityAsyncGets logs for a specified IAM work request.The workRequestID is returned in the opc-workrequest-id header for any asynchronous operation in the Identity and Access Management service. - Specified by:
- listIamWorkRequestLogsin interface- IdentityAsync
- 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.
 
 - 
listIamWorkRequestspublic Future<ListIamWorkRequestsResponse> listIamWorkRequests(ListIamWorkRequestsRequest request, AsyncHandler<ListIamWorkRequestsRequest,ListIamWorkRequestsResponse> handler) Description copied from interface:IdentityAsyncLists the IAM work requests in compartment.The workRequestID is returned in the opc-workrequest-id header for any asynchronous operation in the Identity and Access Management service. - Specified by:
- listIamWorkRequestsin interface- IdentityAsync
- 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.
 
 - 
listIdentityProviderGroupspublic Future<ListIdentityProviderGroupsResponse> listIdentityProviderGroups(ListIdentityProviderGroupsRequest request, AsyncHandler<ListIdentityProviderGroupsRequest,ListIdentityProviderGroupsResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Lists the identity provider groups. - Specified by:
- listIdentityProviderGroupsin interface- IdentityAsync
- 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.
 
 - 
listIdentityProviderspublic Future<ListIdentityProvidersResponse> listIdentityProviders(ListIdentityProvidersRequest request, AsyncHandler<ListIdentityProvidersRequest,ListIdentityProvidersResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Lists all the identity providers in your tenancy. You must specify the identity provider type (e.g., `SAML2` for identity providers using the SAML2.0 protocol). You must specify your tenancy's OCID as the value for the compartment ID (remember that the tenancy is simply the root compartment). See [Where to Get the Tenancy's OCID and User's OCID](https://docs.oracle.com/iaas/Content/API/Concepts/apisigningkey.htm#five). - Specified by:
- listIdentityProvidersin interface- IdentityAsync
- 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.
 
 - 
listIdpGroupMappingspublic Future<ListIdpGroupMappingsResponse> listIdpGroupMappings(ListIdpGroupMappingsRequest request, AsyncHandler<ListIdpGroupMappingsRequest,ListIdpGroupMappingsResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Lists the group mappings for the specified identity provider. - Specified by:
- listIdpGroupMappingsin interface- IdentityAsync
- 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.
 
 - 
listMfaTotpDevicespublic Future<ListMfaTotpDevicesResponse> listMfaTotpDevices(ListMfaTotpDevicesRequest request, AsyncHandler<ListMfaTotpDevicesRequest,ListMfaTotpDevicesResponse> handler) Description copied from interface:IdentityAsyncLists the MFA TOTP devices for the specified user.The returned object contains the device’s OCID, but not the seed. The seed is returned only upon creation or when the IAM service regenerates the MFA seed for the device. - Specified by:
- listMfaTotpDevicesin interface- IdentityAsync
- 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.
 
 - 
listNetworkSourcespublic Future<ListNetworkSourcesResponse> listNetworkSources(ListNetworkSourcesRequest request, AsyncHandler<ListNetworkSourcesRequest,ListNetworkSourcesResponse> handler) Description copied from interface:IdentityAsyncLists the network sources in your tenancy.You must specify your tenancy’s OCID as the value for the compartment ID (remember that the tenancy is simply the root compartment). See Where to Get the Tenancy’s OCID and User’s OCID. - Specified by:
- listNetworkSourcesin interface- IdentityAsync
- 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.
 
 - 
listOAuthClientCredentialspublic Future<ListOAuthClientCredentialsResponse> listOAuthClientCredentials(ListOAuthClientCredentialsRequest request, AsyncHandler<ListOAuthClientCredentialsRequest,ListOAuthClientCredentialsResponse> handler) Description copied from interface:IdentityAsyncList of Oauth tokens for the user- Specified by:
- listOAuthClientCredentialsin interface- IdentityAsync
- 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.
 
 - 
listPoliciespublic Future<ListPoliciesResponse> listPolicies(ListPoliciesRequest request, AsyncHandler<ListPoliciesRequest,ListPoliciesResponse> handler) Description copied from interface:IdentityAsyncLists the policies in the specified compartment (either the tenancy or another of your compartments).See Where to Get the Tenancy’s OCID and User’s OCID. To determine which policies apply to a particular group or compartment, you must view the individual statements inside all your policies. There isn't a way to automatically obtain that information via the API. - Specified by:
- listPoliciesin interface- IdentityAsync
- 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.
 
 - 
listRegionSubscriptionspublic Future<ListRegionSubscriptionsResponse> listRegionSubscriptions(ListRegionSubscriptionsRequest request, AsyncHandler<ListRegionSubscriptionsRequest,ListRegionSubscriptionsResponse> handler) Description copied from interface:IdentityAsyncLists the region subscriptions for the specified tenancy.- Specified by:
- listRegionSubscriptionsin interface- IdentityAsync
- 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.
 
 - 
listRegionspublic Future<ListRegionsResponse> listRegions(ListRegionsRequest request, AsyncHandler<ListRegionsRequest,ListRegionsResponse> handler) Description copied from interface:IdentityAsyncLists all the regions offered by Oracle Cloud Infrastructure.- Specified by:
- listRegionsin interface- IdentityAsync
- 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.
 
 - 
listSmtpCredentialspublic Future<ListSmtpCredentialsResponse> listSmtpCredentials(ListSmtpCredentialsRequest request, AsyncHandler<ListSmtpCredentialsRequest,ListSmtpCredentialsResponse> handler) Description copied from interface:IdentityAsyncLists the SMTP credentials for the specified user.The returned object contains the credential’s OCID, the SMTP user name but not the SMTP password. The SMTP password is returned only upon creation. - Specified by:
- listSmtpCredentialsin interface- IdentityAsync
- 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.
 
 - 
listStandardTagNamespacespublic Future<ListStandardTagNamespacesResponse> listStandardTagNamespaces(ListStandardTagNamespacesRequest request, AsyncHandler<ListStandardTagNamespacesRequest,ListStandardTagNamespacesResponse> handler) Description copied from interface:IdentityAsyncLists available standard tag namespaces that users can create.- Specified by:
- listStandardTagNamespacesin interface- IdentityAsync
- 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.
 
 - 
listSwiftPasswordspublic Future<ListSwiftPasswordsResponse> listSwiftPasswords(ListSwiftPasswordsRequest request, AsyncHandler<ListSwiftPasswordsRequest,ListSwiftPasswordsResponse> handler) Description copied from interface:IdentityAsync**Deprecated.Use listAuthTokensinstead.**Lists the Swift passwords for the specified user. The returned object contains the password's OCID, but not the password itself. The actual password is returned only upon creation. - Specified by:
- listSwiftPasswordsin interface- IdentityAsync
- 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.
 
 - 
listTagDefaultspublic Future<ListTagDefaultsResponse> listTagDefaults(ListTagDefaultsRequest request, AsyncHandler<ListTagDefaultsRequest,ListTagDefaultsResponse> handler) Description copied from interface:IdentityAsyncLists the tag defaults for tag definitions in the specified compartment.- Specified by:
- listTagDefaultsin interface- IdentityAsync
- 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.
 
 - 
listTagNamespacespublic Future<ListTagNamespacesResponse> listTagNamespaces(ListTagNamespacesRequest request, AsyncHandler<ListTagNamespacesRequest,ListTagNamespacesResponse> handler) Description copied from interface:IdentityAsyncLists the tag namespaces in the specified compartment.- Specified by:
- listTagNamespacesin interface- IdentityAsync
- 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.
 
 - 
listTaggingWorkRequestErrorspublic Future<ListTaggingWorkRequestErrorsResponse> listTaggingWorkRequestErrors(ListTaggingWorkRequestErrorsRequest request, AsyncHandler<ListTaggingWorkRequestErrorsRequest,ListTaggingWorkRequestErrorsResponse> handler) Description copied from interface:IdentityAsyncGets the errors for a work request.- Specified by:
- listTaggingWorkRequestErrorsin interface- IdentityAsync
- 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.
 
 - 
listTaggingWorkRequestLogspublic Future<ListTaggingWorkRequestLogsResponse> listTaggingWorkRequestLogs(ListTaggingWorkRequestLogsRequest request, AsyncHandler<ListTaggingWorkRequestLogsRequest,ListTaggingWorkRequestLogsResponse> handler) Description copied from interface:IdentityAsyncGets the logs for a work request.- Specified by:
- listTaggingWorkRequestLogsin interface- IdentityAsync
- 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.
 
 - 
listTaggingWorkRequestspublic Future<ListTaggingWorkRequestsResponse> listTaggingWorkRequests(ListTaggingWorkRequestsRequest request, AsyncHandler<ListTaggingWorkRequestsRequest,ListTaggingWorkRequestsResponse> handler) Description copied from interface:IdentityAsyncLists the tagging work requests in compartment.- Specified by:
- listTaggingWorkRequestsin interface- IdentityAsync
- 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.
 
 - 
listTagspublic Future<ListTagsResponse> listTags(ListTagsRequest request, AsyncHandler<ListTagsRequest,ListTagsResponse> handler) Description copied from interface:IdentityAsyncLists the tag definitions in the specified tag namespace.- Specified by:
- listTagsin interface- IdentityAsync
- 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.
 
 - 
listUserGroupMembershipspublic Future<ListUserGroupMembershipsResponse> listUserGroupMemberships(ListUserGroupMembershipsRequest request, AsyncHandler<ListUserGroupMembershipsRequest,ListUserGroupMembershipsResponse> handler) Description copied from interface:IdentityAsyncLists theUserGroupMembershipobjects in your tenancy.You must specify your tenancy’s OCID as the value for the compartment ID (see Where to Get the Tenancy’s OCID and User’s OCID). You must also then filter the list in one of these ways: - You can limit the results to just the memberships for a given user by specifying a `userId`. - Similarly, you can limit the results to just the memberships for a given group by specifying a `groupId`. - You can set both the `userId` and `groupId` to determine if the specified user is in the specified group. If the answer is no, the response is an empty list. - Although`userId` and `groupId` are not individually required, you must set one of them. - Specified by:
- listUserGroupMembershipsin interface- IdentityAsync
- 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.
 
 - 
listUserspublic Future<ListUsersResponse> listUsers(ListUsersRequest request, AsyncHandler<ListUsersRequest,ListUsersResponse> handler) Description copied from interface:IdentityAsyncLists the users in your tenancy.You must specify your tenancy’s OCID as the value for the compartment ID (remember that the tenancy is simply the root compartment). See Where to Get the Tenancy’s OCID and User’s OCID. - Specified by:
- listUsersin interface- IdentityAsync
- 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.
 
 - 
listWorkRequestspublic Future<ListWorkRequestsResponse> listWorkRequests(ListWorkRequestsRequest request, AsyncHandler<ListWorkRequestsRequest,ListWorkRequestsResponse> handler) Description copied from interface:IdentityAsyncLists the work requests in compartment.- Specified by:
- listWorkRequestsin interface- IdentityAsync
- 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.
 
 - 
moveCompartmentpublic Future<MoveCompartmentResponse> moveCompartment(MoveCompartmentRequest request, AsyncHandler<MoveCompartmentRequest,MoveCompartmentResponse> handler) Description copied from interface:IdentityAsyncMove the compartment to a different parent compartment in the same tenancy.When you move a compartment, all its contents (subcompartments and resources) are moved with it. Note that the CompartmentIdthat you specify in the path is the compartment that you want to move.*IMPORTANT**: After you move a compartment to a new parent compartment, the access policies of the new parent take effect and the policies of the previous parent no longer apply. Ensure that you are aware of the implications for the compartment contents before you move it. For more information, see [Moving a Compartment](https://docs.oracle.com/iaas/Content/Identity/compartments/managingcompartments.htm#MoveCompartment). - Specified by:
- moveCompartmentin interface- IdentityAsync
- 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.
 
 - 
recoverCompartmentpublic Future<RecoverCompartmentResponse> recoverCompartment(RecoverCompartmentRequest request, AsyncHandler<RecoverCompartmentRequest,RecoverCompartmentResponse> handler) Description copied from interface:IdentityAsyncRecover the compartment from DELETED state to ACTIVE state.- Specified by:
- recoverCompartmentin interface- IdentityAsync
- 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.
 
 - 
removeTagDefaultLockpublic Future<RemoveTagDefaultLockResponse> removeTagDefaultLock(RemoveTagDefaultLockRequest request, AsyncHandler<RemoveTagDefaultLockRequest,RemoveTagDefaultLockResponse> handler) Description copied from interface:IdentityAsyncRemove a resource lock from a tag default.- Specified by:
- removeTagDefaultLockin interface- IdentityAsync
- 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.
 
 - 
removeTagNamespaceLockpublic Future<RemoveTagNamespaceLockResponse> removeTagNamespaceLock(RemoveTagNamespaceLockRequest request, AsyncHandler<RemoveTagNamespaceLockRequest,RemoveTagNamespaceLockResponse> handler) Description copied from interface:IdentityAsyncRemove a resource lock from a tag namespace.- Specified by:
- removeTagNamespaceLockin interface- IdentityAsync
- 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.
 
 - 
removeUserFromGrouppublic Future<RemoveUserFromGroupResponse> removeUserFromGroup(RemoveUserFromGroupRequest request, AsyncHandler<RemoveUserFromGroupRequest,RemoveUserFromGroupResponse> handler) Description copied from interface:IdentityAsyncRemoves a user from a group by deleting the correspondingUserGroupMembership.- Specified by:
- removeUserFromGroupin interface- IdentityAsync
- 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.
 
 - 
resetIdpScimClientpublic Future<ResetIdpScimClientResponse> resetIdpScimClient(ResetIdpScimClientRequest request, AsyncHandler<ResetIdpScimClientRequest,ResetIdpScimClientResponse> handler) Description copied from interface:IdentityAsyncResets the OAuth2 client credentials for the SCIM client associated with this identity provider.- Specified by:
- resetIdpScimClientin interface- IdentityAsync
- 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.
 
 - 
updateAuthTokenpublic Future<UpdateAuthTokenResponse> updateAuthToken(UpdateAuthTokenRequest request, AsyncHandler<UpdateAuthTokenRequest,UpdateAuthTokenResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified auth token’s description.- Specified by:
- updateAuthTokenin interface- IdentityAsync
- 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.
 
 - 
updateAuthenticationPolicypublic Future<UpdateAuthenticationPolicyResponse> updateAuthenticationPolicy(UpdateAuthenticationPolicyRequest request, AsyncHandler<UpdateAuthenticationPolicyRequest,UpdateAuthenticationPolicyResponse> handler) Description copied from interface:IdentityAsyncUpdates authentication policy for the specified tenancy.- Specified by:
- updateAuthenticationPolicyin interface- IdentityAsync
- 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.
 
 - 
updateCompartmentpublic Future<UpdateCompartmentResponse> updateCompartment(UpdateCompartmentRequest request, AsyncHandler<UpdateCompartmentRequest,UpdateCompartmentResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified compartment’s description or name.You can’t update the root compartment. - Specified by:
- updateCompartmentin interface- IdentityAsync
- 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.
 
 - 
updateCustomerSecretKeypublic Future<UpdateCustomerSecretKeyResponse> updateCustomerSecretKey(UpdateCustomerSecretKeyRequest request, AsyncHandler<UpdateCustomerSecretKeyRequest,UpdateCustomerSecretKeyResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified secret key’s description.- Specified by:
- updateCustomerSecretKeyin interface- IdentityAsync
- 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.
 
 - 
updateDomainpublic Future<UpdateDomainResponse> updateDomain(UpdateDomainRequest request, AsyncHandler<UpdateDomainRequest,UpdateDomainResponse> handler) Description copied from interface:IdentityAsync(For tenancies that support identity domains) Updates identity domain information and the associated Identity Cloud Service (IDCS) stripe.To track the progress of the request, submitting an HTTP GET on the /iamWorkRequests/{iamWorkRequestsId} endpoint retrieves the operation's status. - Specified by:
- updateDomainin interface- IdentityAsync
- 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.
 
 - 
updateDynamicGrouppublic Future<UpdateDynamicGroupResponse> updateDynamicGroup(UpdateDynamicGroupRequest request, AsyncHandler<UpdateDynamicGroupRequest,UpdateDynamicGroupResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified dynamic group.- Specified by:
- updateDynamicGroupin interface- IdentityAsync
- 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.
 
 - 
updateGrouppublic Future<UpdateGroupResponse> updateGroup(UpdateGroupRequest request, AsyncHandler<UpdateGroupRequest,UpdateGroupResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified group.- Specified by:
- updateGroupin interface- IdentityAsync
- 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.
 
 - 
updateIdentityProviderpublic Future<UpdateIdentityProviderResponse> updateIdentityProvider(UpdateIdentityProviderRequest request, AsyncHandler<UpdateIdentityProviderRequest,UpdateIdentityProviderResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Updates the specified identity provider. - Specified by:
- updateIdentityProviderin interface- IdentityAsync
- 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.
 
 - 
updateIdpGroupMappingpublic Future<UpdateIdpGroupMappingResponse> updateIdpGroupMapping(UpdateIdpGroupMappingRequest request, AsyncHandler<UpdateIdpGroupMappingRequest,UpdateIdpGroupMappingResponse> handler) Description copied from interface:IdentityAsyncDeprecated. For more information, see Deprecated IAM Service APIs.Updates the specified group mapping. - Specified by:
- updateIdpGroupMappingin interface- IdentityAsync
- 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.
 
 - 
updateNetworkSourcepublic Future<UpdateNetworkSourceResponse> updateNetworkSource(UpdateNetworkSourceRequest request, AsyncHandler<UpdateNetworkSourceRequest,UpdateNetworkSourceResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified network source.- Specified by:
- updateNetworkSourcein interface- IdentityAsync
- 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.
 
 - 
updateOAuthClientCredentialpublic Future<UpdateOAuthClientCredentialResponse> updateOAuthClientCredential(UpdateOAuthClientCredentialRequest request, AsyncHandler<UpdateOAuthClientCredentialRequest,UpdateOAuthClientCredentialResponse> handler) Description copied from interface:IdentityAsyncUpdates Oauth token for the user- Specified by:
- updateOAuthClientCredentialin interface- IdentityAsync
- 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.
 
 - 
updatePolicypublic Future<UpdatePolicyResponse> updatePolicy(UpdatePolicyRequest request, AsyncHandler<UpdatePolicyRequest,UpdatePolicyResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified policy.You can update the description or the policy statements themselves. Policy changes take effect typically within 10 seconds. - Specified by:
- updatePolicyin interface- IdentityAsync
- 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.
 
 - 
updateSmtpCredentialpublic Future<UpdateSmtpCredentialResponse> updateSmtpCredential(UpdateSmtpCredentialRequest request, AsyncHandler<UpdateSmtpCredentialRequest,UpdateSmtpCredentialResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified SMTP credential’s description.- Specified by:
- updateSmtpCredentialin interface- IdentityAsync
- 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.
 
 - 
updateSwiftPasswordpublic Future<UpdateSwiftPasswordResponse> updateSwiftPassword(UpdateSwiftPasswordRequest request, AsyncHandler<UpdateSwiftPasswordRequest,UpdateSwiftPasswordResponse> handler) Description copied from interface:IdentityAsync**Deprecated.Use updateAuthTokeninstead.**Updates the specified Swift password's description. - Specified by:
- updateSwiftPasswordin interface- IdentityAsync
- 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.
 
 - 
updateTagpublic Future<UpdateTagResponse> updateTag(UpdateTagRequest request, AsyncHandler<UpdateTagRequest,UpdateTagResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified tag definition.Setting `validator` determines the value type. Tags can use either a static value or a list of possible values. Static values are entered by a user applying the tag to a resource. Lists are created by you and the user must apply a value from the list. On update, any values in a list that were previously set do not change, but new values must pass validation. Values already applied to a resource do not change. You cannot remove list values that appear in a TagDefault. To remove a list value that appears in a TagDefault, first update the TagDefault to use a different value. - Specified by:
- updateTagin interface- IdentityAsync
- 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.
 
 - 
updateTagDefaultpublic Future<UpdateTagDefaultResponse> updateTagDefault(UpdateTagDefaultRequest request, AsyncHandler<UpdateTagDefaultRequest,UpdateTagDefaultResponse> handler) Description copied from interface:IdentityAsyncUpdates the specified tag default.If you specify that a value is required, a value is set during resource creation (either by the user creating the resource or another tag defualt). If no value is set, resource creation is blocked. If the `isRequired` flag is set to \"true\", the value is set during resource creation. * If the `isRequired` flag is set to \"false\", the value you enter is set during resource creation. - Specified by:
- updateTagDefaultin interface- IdentityAsync
- 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.
 
 - 
updateTagNamespacepublic Future<UpdateTagNamespaceResponse> updateTagNamespace(UpdateTagNamespaceRequest request, AsyncHandler<UpdateTagNamespaceRequest,UpdateTagNamespaceResponse> handler) Description copied from interface:IdentityAsyncUpdates the the specified tag namespace.You can’t update the namespace name. Updating `isRetired` to 'true' retires the namespace and all the tag definitions in the namespace. Reactivating a namespace (changing `isRetired` from 'true' to 'false') does not reactivate tag definitions. To reactivate the tag definitions, you must reactivate each one individually *after* you reactivate the namespace, using updateTag. For more information about retiring tag namespaces, see [Retiring Key Definitions and Namespace Definitions](https://docs.oracle.com/iaas/Content/Tagging/Tasks/managingtagsandtagnamespaces.htm#retiringkeys).You can't add a namespace with the same name as a retired namespace in the same tenancy. - Specified by:
- updateTagNamespacein interface- IdentityAsync
- 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.
 
 - 
updateUserpublic Future<UpdateUserResponse> updateUser(UpdateUserRequest request, AsyncHandler<UpdateUserRequest,UpdateUserResponse> handler) Description copied from interface:IdentityAsyncUpdates the description of the specified user.- Specified by:
- updateUserin interface- IdentityAsync
- 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.
 
 - 
updateUserCapabilitiespublic Future<UpdateUserCapabilitiesResponse> updateUserCapabilities(UpdateUserCapabilitiesRequest request, AsyncHandler<UpdateUserCapabilitiesRequest,UpdateUserCapabilitiesResponse> handler) Description copied from interface:IdentityAsyncUpdates the capabilities of the specified user.- Specified by:
- updateUserCapabilitiesin interface- IdentityAsync
- 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.
 
 - 
updateUserStatepublic Future<UpdateUserStateResponse> updateUserState(UpdateUserStateRequest request, AsyncHandler<UpdateUserStateRequest,UpdateUserStateResponse> handler) Description copied from interface:IdentityAsyncUpdates the state of the specified user.- Specified by:
- updateUserStatein interface- IdentityAsync
- 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.
 
 - 
uploadApiKeypublic Future<UploadApiKeyResponse> uploadApiKey(UploadApiKeyRequest request, AsyncHandler<UploadApiKeyRequest,UploadApiKeyResponse> handler) Description copied from interface:IdentityAsyncUploads an API signing key for the specified user.Every user has permission to use this operation to upload a key for *their own user ID*. An administrator in your organization does not need to write a policy to give users this ability. To compare, administrators who have permission to the tenancy can use this operation to upload a key for any user, including themselves. *Important:** Even though you have permission to upload an API key, you might not yet have permission to do much else. If you try calling an operation unrelated to your own credential management (e.g., `ListUsers`, `LaunchInstance`) and receive an \"unauthorized\" error, check with an administrator to confirm which IAM Service group(s) you're in and what access you have. Also confirm you're working in the correct compartment. After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE. - Specified by:
- uploadApiKeyin interface- IdentityAsync
- 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.
 
 - 
getDefaultConfiguratorprotected ClientConfigurator getDefaultConfigurator() 
 - 
useRealmSpecificEndpointTemplatepublic void useRealmSpecificEndpointTemplate(boolean useOfRealmSpecificEndpointTemplateEnabled) This method should be used to enable or disable the use of realm-specific endpoint template.The default value is null. To enable the use of endpoint template defined for the realm in use, set the flag to true To disable the use of endpoint template defined for the realm in use, set the flag to false - Parameters:
- useOfRealmSpecificEndpointTemplateEnabled- This flag can be set to true or false to enable or disable the use of realm-specific endpoint template respectively
 
 - 
populateServiceParametersInEndpointpublic final void populateServiceParametersInEndpoint(String endpoint, Map<String,Object> requiredParametersMap) Populate the parameters in the endpoint with its corresponding value and update the base endpoint.The value will be populated iff the parameter in endpoint is a required request path parameter or a required request query parameter. If not, the parameter in the endpoint will be ignored and left blank. - Parameters:
- endpoint- The endpoint template in use
- requiredParametersMap- Map of parameter name as key and value set in request path or query parameter as value
 
 - 
updateBaseEndpointpublic final void updateBaseEndpoint(String endpoint) This method should be used for parameterized endpoint templates only.This does not include {region} and {secondLevelDomain} parameters. - Parameters:
- endpoint- The updated endpoint to use
 
 - 
setEndpointpublic final void setEndpoint(String endpoint) 
 - 
getEndpointpublic final String getEndpoint() 
 - 
refreshClientpublic final void refreshClient() Rebuild the backingHttpClient.This will call ClientConfigurators again, and can be used to e.g. refresh the SSL certificate.
 - 
closepublic final void close() - Specified by:
- closein interface- AutoCloseable
 
 - 
getClientCommonLibraryVersionpublic String getClientCommonLibraryVersion() 
 - 
getMinimumClientCommonLibraryVersionFromClientpublic Optional<String> getMinimumClientCommonLibraryVersionFromClient() 
 - 
clientCallprotected <REQ extends BmcRequest<?>,RESP extends BmcResponse,RESP_BUILDER extends BmcResponse.Builder<RESP>> ClientCall<REQ,RESP,RESP_BUILDER> clientCall(REQ request, Supplier<RESP_BUILDER> responseBuilder) 
 
- 
 
-