com.oracle.bmc.identity.IdentityAsync Maven / Gradle / Ivy
/**
* Copyright (c) 2016, 2021, Oracle and/or its affiliates. All rights reserved.
* This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
*/
package com.oracle.bmc.identity;
import com.oracle.bmc.identity.requests.*;
import com.oracle.bmc.identity.responses.*;
/**
* APIs for managing users, groups, compartments, and policies.
*/
@javax.annotation.Generated(value = "OracleSDKGenerator", comments = "API Version: 20160918")
public interface IdentityAsync extends AutoCloseable {
/**
* Sets the endpoint to call (ex, https://www.example.com).
* @param endpoint The endpoint of the serice.
*/
void setEndpoint(String endpoint);
/**
* Gets the set endpoint for REST call (ex, https://www.example.com)
*/
String getEndpoint();
/**
* Sets the region to call (ex, Region.US_PHOENIX_1).
*
* Note, this will call {@link #setEndpoint(String) setEndpoint} after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.
* @param region The region of the service.
*/
void setRegion(com.oracle.bmc.Region region);
/**
* Sets the region to call (ex, 'us-phoenix-1').
*
* Note, this will first try to map the region ID to a known Region and call
* {@link #setRegion(Region) setRegion}.
*
* If no known Region could be determined, it will create an endpoint based on the
* default endpoint format ({@link com.oracle.bmc.Region#formatDefaultRegionEndpoint(Service, String)}
* and then call {@link #setEndpoint(String) setEndpoint}.
* @param regionId The public region ID.
*/
void setRegion(String regionId);
/**
* Activates the specified MFA TOTP device for the user. Activation requires manual interaction with the Console.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future activateMfaTotpDevice(
ActivateMfaTotpDeviceRequest request,
com.oracle.bmc.responses.AsyncHandler<
ActivateMfaTotpDeviceRequest, ActivateMfaTotpDeviceResponse>
handler);
/**
* Adds the specified user to the specified group and returns a `UserGroupMembership` object 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future addUserToGroup(
AddUserToGroupRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Assembles 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future assembleEffectiveTagSet(
AssembleEffectiveTagSetRequest request,
com.oracle.bmc.responses.AsyncHandler<
AssembleEffectiveTagSetRequest, AssembleEffectiveTagSetResponse>
handler);
/**
* Deletes 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](https://docs.cloud.oracle.com/Content/Identity/Tasks/managingregions.htm#Home). This operation creates a
* {@link WorkRequest}. Use the {@link #getWorkRequest(GetWorkRequestRequest, Consumer, Consumer) getWorkRequest}
* API to monitor the status of the bulk action.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future bulkDeleteResources(
BulkDeleteResourcesRequest request,
com.oracle.bmc.responses.AsyncHandler<
BulkDeleteResourcesRequest, BulkDeleteResourcesResponse>
handler);
/**
* Deletes 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:
* \u00A0
* * 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 {@link #deleteTag(DeleteTagRequest, Consumer, Consumer) deleteTag} or the {@link #cascadeDeleteTagNamespace(CascadeDeleteTagNamespaceRequest, Consumer, Consumer) cascadeDeleteTagNamespace} operation until this process completes.
*
* In order to delete tags, you must first retire the tags. Use {@link #updateTag(UpdateTagRequest, Consumer, Consumer) updateTag}
* to retire a tag.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future bulkDeleteTags(
BulkDeleteTagsRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Edits 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 {@link #bulkEditOperationDetails(BulkEditOperationDetailsRequest, Consumer, Consumer) bulkEditOperationDetails} for 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future bulkEditTags(
BulkEditTagsRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Moves 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](https://docs.cloud.oracle.com/Content/Identity/Tasks/managingregions.htm#Home).
* To move resources, you must have the appropriate permissions to move the resource in both the source and target
* compartments. This operation creates a {@link WorkRequest}.
* Use the {@link #getWorkRequest(GetWorkRequestRequest, Consumer, Consumer) getWorkRequest} API to monitor the status of the bulk action.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future bulkMoveResources(
BulkMoveResourcesRequest request,
com.oracle.bmc.responses.AsyncHandler<
BulkMoveResourcesRequest, BulkMoveResourcesResponse>
handler);
/**
* Deletes 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 {@link #deleteTag(DeleteTagRequest, Consumer, Consumer) deleteTag} or the {@link #bulkDeleteTags(BulkDeleteTagsRequest, Consumer, Consumer) bulkDeleteTags} operation until this process completes.
*
* To delete a tag namespace, you must first retire it. Use {@link #updateTagNamespace(UpdateTagNamespaceRequest, Consumer, Consumer) updateTagNamespace}
* to retire a tag namespace.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future cascadeDeleteTagNamespace(
CascadeDeleteTagNamespaceRequest request,
com.oracle.bmc.responses.AsyncHandler<
CascadeDeleteTagNamespaceRequest, CascadeDeleteTagNamespaceResponse>
handler);
/**
* Moves 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.cloud.oracle.com/Content/Identity/Reference/iampolicyreference.htm).
*
* Moving a tag namespace moves all the tag key definitions contained in the tag namespace.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future
changeTagNamespaceCompartment(
ChangeTagNamespaceCompartmentRequest request,
com.oracle.bmc.responses.AsyncHandler<
ChangeTagNamespaceCompartmentRequest,
ChangeTagNamespaceCompartmentResponse>
handler);
/**
* Creates a new auth token for the specified user. For information about what auth tokens are for, see
* [Managing User Credentials](https://docs.cloud.oracle.com/Content/Identity/Tasks/managingcredentials.htm).
*
* 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
* {@link #updateAuthToken(UpdateAuthTokenRequest, Consumer, Consumer) 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createAuthToken(
CreateAuthTokenRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Creates a new compartment in the specified compartment.
*
**Important:** Compartments cannot be deleted.
*
* 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.cloud.oracle.com/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.cloud.oracle.com/Content/Identity/Concepts/policies.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
* {@link #updateCompartment(UpdateCompartmentRequest, Consumer, Consumer) 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createCompartment(
CreateCompartmentRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateCompartmentRequest, CreateCompartmentResponse>
handler);
/**
* Creates 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](https://docs.cloud.oracle.com/Content/Identity/Tasks/managingcredentials.htm).
*
* 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
* {@link #updateCustomerSecretKey(UpdateCustomerSecretKeyRequest, Consumer, Consumer) 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createCustomerSecretKey(
CreateCustomerSecretKeyRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateCustomerSecretKeyRequest, CreateCustomerSecretKeyResponse>
handler);
/**
* Creates 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.cloud.oracle.com/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.cloud.oracle.com/Content/Identity/Concepts/policies.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 {@link #updateDynamicGroup(UpdateDynamicGroupRequest, Consumer, Consumer) 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createDynamicGroup(
CreateDynamicGroupRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateDynamicGroupRequest, CreateDynamicGroupResponse>
handler);
/**
* Creates 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.cloud.oracle.com/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.cloud.oracle.com/Content/Identity/Concepts/policies.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 {@link #updateGroup(UpdateGroupRequest, Consumer, Consumer) 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 {@link #addUserToGroup(AddUserToGroupRequest, Consumer, Consumer) addUserToGroup} and
* {@link #createPolicy(CreatePolicyRequest, Consumer, Consumer) createPolicy}.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createGroup(
CreateGroupRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Creates a new identity provider in your tenancy. For more information, see
* [Identity Providers and Federation](https://docs.cloud.oracle.com/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.cloud.oracle.com/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
* {@link #updateIdentityProvider(UpdateIdentityProviderRequest, Consumer, Consumer) 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createIdentityProvider(
CreateIdentityProviderRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateIdentityProviderRequest, CreateIdentityProviderResponse>
handler);
/**
* Creates a single mapping between an IdP group and an IAM Service
* {@link Group}.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createIdpGroupMapping(
CreateIdpGroupMappingRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateIdpGroupMappingRequest, CreateIdpGroupMappingResponse>
handler);
/**
* Creates a new MFA TOTP device for the user. A user can have one MFA TOTP device.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createMfaTotpDevice(
CreateMfaTotpDeviceRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateMfaTotpDeviceRequest, CreateMfaTotpDeviceResponse>
handler);
/**
* Creates 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.cloud.oracle.com/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.cloud.oracle.com/Content/Identity/Concepts/policies.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 {@link #updateNetworkSource(UpdateNetworkSourceRequest, Consumer, Consumer) 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.cloud.oracle.com/Content/Identity/Tasks/managingnetworksources.htm).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createNetworkSource(
CreateNetworkSourceRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateNetworkSourceRequest, CreateNetworkSourceResponse>
handler);
/**
* Creates Oauth token for the user
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createOAuthClientCredential(
CreateOAuthClientCredentialRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateOAuthClientCredentialRequest, CreateOAuthClientCredentialResponse>
handler);
/**
* Creates a new Console one-time password for the specified user. For more information about user
* credentials, see [User Credentials](https://docs.cloud.oracle.com/Content/Identity/Concepts/usercredentials.htm).
*
* 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.
*
**Note:** The user's Console login is the unique name you specified when you created the user
* (see {@link #createUser(CreateUserRequest, Consumer, Consumer) createUser}).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createOrResetUIPassword(
CreateOrResetUIPasswordRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateOrResetUIPasswordRequest, CreateOrResetUIPasswordResponse>
handler);
/**
* Creates a new policy in the specified compartment (either the tenancy or another of your compartments).
* If you're new to policies, see [Getting Started with Policies](https://docs.cloud.oracle.com/Content/Identity/Concepts/policygetstarted.htm).
*
* 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 {@link #updatePolicy(UpdatePolicyRequest, Consumer, Consumer) updatePolicy}.
*
* You must specify one or more policy statements in the statements array. For information about writing
* policies, see [How Policies Work](https://docs.cloud.oracle.com/Content/Identity/Concepts/policies.htm) and
* [Common Policies](https://docs.cloud.oracle.com/Content/Identity/Concepts/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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createPolicy(
CreatePolicyRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Creates a subscription to a region for a tenancy.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createRegionSubscription(
CreateRegionSubscriptionRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateRegionSubscriptionRequest, CreateRegionSubscriptionResponse>
handler);
/**
* Creates 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
* {@link #updateSmtpCredential(UpdateSmtpCredentialRequest, Consumer, Consumer) updateSmtpCredential}.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createSmtpCredential(
CreateSmtpCredentialRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateSmtpCredentialRequest, CreateSmtpCredentialResponse>
handler);
/**
* **Deprecated. Use {@link #createAuthToken(CreateAuthTokenRequest, Consumer, Consumer) createAuthToken} instead.**
*
* Creates a new Swift password for the specified user. For information about what Swift passwords are for, see
* [Managing User Credentials](https://docs.cloud.oracle.com/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
* {@link #updateSwiftPassword(UpdateSwiftPasswordRequest, Consumer, Consumer) 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createSwiftPassword(
CreateSwiftPasswordRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateSwiftPasswordRequest, CreateSwiftPasswordResponse>
handler);
/**
* Creates 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
* {@link #updateTag(UpdateTagRequest, Consumer, Consumer) 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 {@link #enumTagDefinitionValidator(EnumTagDefinitionValidatorRequest, Consumer, Consumer) enumTagDefinitionValidator}.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createTag(
CreateTagRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Creates 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createTagDefault(
CreateTagDefaultRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Creates 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
* {@link #updateTagNamespace(UpdateTagNamespaceRequest, Consumer, Consumer) updateTagNamespace}.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createTagNamespace(
CreateTagNamespaceRequest request,
com.oracle.bmc.responses.AsyncHandler<
CreateTagNamespaceRequest, CreateTagNamespaceResponse>
handler);
/**
* Creates a new user in your tenancy. For conceptual information about users, your tenancy, and other
* IAM Service components, see [Overview of the IAM Service](https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.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). 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.cloud.oracle.com/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
* {@link #updateUser(UpdateUserRequest, Consumer, Consumer) 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
* {@link #addUserToGroup(AddUserToGroupRequest, Consumer, Consumer) addUserToGroup}). If the user needs to
* access the Console, you need to provide the user a password (see
* {@link #createOrResetUIPassword(CreateOrResetUIPasswordRequest, Consumer, Consumer) createOrResetUIPassword}).
* 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.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm) and also
* {@link #uploadApiKey(UploadApiKeyRequest, Consumer, Consumer) uploadApiKey}).
*
**Important:** Make sure to inform the new user which compartment(s) they have access to.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future createUser(
CreateUserRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Deletes 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteApiKey(
DeleteApiKeyRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Deletes the specified auth token for the specified user.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteAuthToken(
DeleteAuthTokenRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Deletes the specified compartment. The compartment must be empty.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteCompartment(
DeleteCompartmentRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteCompartmentRequest, DeleteCompartmentResponse>
handler);
/**
* Deletes the specified secret key for the specified user.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteCustomerSecretKey(
DeleteCustomerSecretKeyRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteCustomerSecretKeyRequest, DeleteCustomerSecretKeyResponse>
handler);
/**
* Deletes the specified dynamic group.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteDynamicGroup(
DeleteDynamicGroupRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteDynamicGroupRequest, DeleteDynamicGroupResponse>
handler);
/**
* Deletes the specified group. The group must be empty.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteGroup(
DeleteGroupRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Deletes the specified identity provider. The identity provider must not have
* any group mappings (see {@link IdpGroupMapping}).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteIdentityProvider(
DeleteIdentityProviderRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteIdentityProviderRequest, DeleteIdentityProviderResponse>
handler);
/**
* Deletes the specified group mapping.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteIdpGroupMapping(
DeleteIdpGroupMappingRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteIdpGroupMappingRequest, DeleteIdpGroupMappingResponse>
handler);
/**
* Deletes the specified MFA TOTP device for the specified user.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteMfaTotpDevice(
DeleteMfaTotpDeviceRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteMfaTotpDeviceRequest, DeleteMfaTotpDeviceResponse>
handler);
/**
* Deletes the specified network source
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteNetworkSource(
DeleteNetworkSourceRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteNetworkSourceRequest, DeleteNetworkSourceResponse>
handler);
/**
* Delete Oauth token for the user
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteOAuthClientCredential(
DeleteOAuthClientCredentialRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteOAuthClientCredentialRequest, DeleteOAuthClientCredentialResponse>
handler);
/**
* Deletes the specified policy. The deletion takes effect typically within 10 seconds.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deletePolicy(
DeletePolicyRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Deletes the specified SMTP credential for the specified user.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteSmtpCredential(
DeleteSmtpCredentialRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteSmtpCredentialRequest, DeleteSmtpCredentialResponse>
handler);
/**
* **Deprecated. Use {@link #deleteAuthToken(DeleteAuthTokenRequest, Consumer, Consumer) deleteAuthToken} instead.**
*
* Deletes the specified Swift password for the specified user.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteSwiftPassword(
DeleteSwiftPasswordRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteSwiftPasswordRequest, DeleteSwiftPasswordResponse>
handler);
/**
* Deletes the specified tag definition. This operation triggers a process that removes the
* tag from all resources in your tenancy.
*
* These things happen immediately:
* \u00A0
* * 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 {@link #bulkDeleteTags(BulkDeleteTagsRequest, Consumer, Consumer) bulkDeleteTags} or the {@link #cascadeDeleteTagNamespace(CascadeDeleteTagNamespaceRequest, Consumer, Consumer) cascadeDeleteTagNamespace} operation until this process completes.
*
* To delete a tag, you must first retire it. Use {@link #updateTag(UpdateTagRequest, Consumer, Consumer) updateTag}
* to retire a tag.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteTag(
DeleteTagRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Deletes the the specified tag default.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteTagDefault(
DeleteTagDefaultRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Deletes 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 {@link #cascadeDeleteTagNamespace(CascadeDeleteTagNamespaceRequest, Consumer, Consumer) cascadeDeleteTagNamespace} to delete a tag namespace along with all of
* the tag definitions contained within that namespace.
*
* Use {@link #deleteTag(DeleteTagRequest, Consumer, Consumer) deleteTag} to delete a tag definition.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteTagNamespace(
DeleteTagNamespaceRequest request,
com.oracle.bmc.responses.AsyncHandler<
DeleteTagNamespaceRequest, DeleteTagNamespaceResponse>
handler);
/**
* Deletes the specified user. The user must not be in any groups.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future deleteUser(
DeleteUserRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Generate seed for the MFA TOTP device.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future generateTotpSeed(
GenerateTotpSeedRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Gets the authentication policy for the given tenancy. You must specify your tenant\u2019s OCID as the value for
* the compartment ID (remember that the tenancy is simply the root compartment).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getAuthenticationPolicy(
GetAuthenticationPolicyRequest request,
com.oracle.bmc.responses.AsyncHandler<
GetAuthenticationPolicyRequest, GetAuthenticationPolicyResponse>
handler);
/**
* Gets 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 {@link #listInstances(ListInstancesRequest, Consumer, Consumer) listInstances} operation in the Cloud Compute
* Service or the {@link #listVolumes(ListVolumesRequest, Consumer, Consumer) listVolumes} operation in Cloud Block Storage.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getCompartment(
GetCompartmentRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Gets the specified dynamic group's information.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getDynamicGroup(
GetDynamicGroupRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Gets the specified group's information.
*
* This operation does not return a list of all the users in the group. To do that, use
* {@link #listUserGroupMemberships(ListUserGroupMembershipsRequest, Consumer, Consumer) listUserGroupMemberships} and
* provide the group's OCID as a query parameter in the request.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getGroup(
GetGroupRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Gets the specified identity provider's information.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getIdentityProvider(
GetIdentityProviderRequest request,
com.oracle.bmc.responses.AsyncHandler<
GetIdentityProviderRequest, GetIdentityProviderResponse>
handler);
/**
* Gets the specified group mapping.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getIdpGroupMapping(
GetIdpGroupMappingRequest request,
com.oracle.bmc.responses.AsyncHandler<
GetIdpGroupMappingRequest, GetIdpGroupMappingResponse>
handler);
/**
* Get the specified MFA TOTP device for the specified user.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getMfaTotpDevice(
GetMfaTotpDeviceRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Gets the specified network source's information.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getNetworkSource(
GetNetworkSourceRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Gets the specified policy's information.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getPolicy(
GetPolicyRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Gets the specified tag's information.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getTag(
GetTagRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Retrieves the specified tag default.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getTagDefault(
GetTagDefaultRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Gets the specified tag namespace's information.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getTagNamespace(
GetTagNamespaceRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Gets details on a specified work request. The workRequestID is returned in the opc-workrequest-id header
* for any asynchronous operation in the Identity and Access Management service.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getTaggingWorkRequest(
GetTaggingWorkRequestRequest request,
com.oracle.bmc.responses.AsyncHandler<
GetTaggingWorkRequestRequest, GetTaggingWorkRequestResponse>
handler);
/**
* Get the specified tenancy's information.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getTenancy(
GetTenancyRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Gets the specified user's information.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getUser(
GetUserRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Gets the specified UserGroupMembership's information.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getUserGroupMembership(
GetUserGroupMembershipRequest request,
com.oracle.bmc.responses.AsyncHandler<
GetUserGroupMembershipRequest, GetUserGroupMembershipResponse>
handler);
/**
* Gets 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getUserUIPasswordInformation(
GetUserUIPasswordInformationRequest request,
com.oracle.bmc.responses.AsyncHandler<
GetUserUIPasswordInformationRequest,
GetUserUIPasswordInformationResponse>
handler);
/**
* Gets details on a specified work request. The workRequestID is returned in the opc-workrequest-id header
* for any asynchronous operation in the Identity and Access Management service.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future getWorkRequest(
GetWorkRequestRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Lists 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listApiKeys(
ListApiKeysRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Lists 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listAuthTokens(
ListAuthTokensRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Lists 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](https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
* 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listAvailabilityDomains(
ListAvailabilityDomainsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListAvailabilityDomainsRequest, ListAvailabilityDomainsResponse>
handler);
/**
* Lists the resource-types supported by compartment bulk actions. Use this API to help you provide the correct
* resource-type information to the {@link #bulkDeleteResources(BulkDeleteResourcesRequest, Consumer, Consumer) bulkDeleteResources}
* and {@link #bulkMoveResources(BulkMoveResourcesRequest, Consumer, Consumer) bulkMoveResources} operations. 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](https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) to identify a specific resource, but some resource-types,
* such as buckets, require you to provide other identifying information.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listBulkActionResourceTypes(
ListBulkActionResourceTypesRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListBulkActionResourceTypesRequest, ListBulkActionResourceTypesResponse>
handler);
/**
* Lists the resource types that support bulk tag editing.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future
listBulkEditTagsResourceTypes(
ListBulkEditTagsResourceTypesRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListBulkEditTagsResourceTypesRequest,
ListBulkEditTagsResourceTypesResponse>
handler);
/**
* Lists 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.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listCompartments(
ListCompartmentsRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Lists all the tags enabled for cost-tracking in the specified tenancy. For information about
* cost-tracking tags, see [Using Cost-tracking Tags](https://docs.cloud.oracle.com/Content/Identity/Concepts/taggingoverview.htm#costs).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listCostTrackingTags(
ListCostTrackingTagsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListCostTrackingTagsRequest, ListCostTrackingTagsResponse>
handler);
/**
* Lists 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listCustomerSecretKeys(
ListCustomerSecretKeysRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListCustomerSecretKeysRequest, ListCustomerSecretKeysResponse>
handler);
/**
* Lists 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](https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listDynamicGroups(
ListDynamicGroupsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListDynamicGroupsRequest, ListDynamicGroupsResponse>
handler);
/**
* Lists 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](https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listFaultDomains(
ListFaultDomainsRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Lists 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](https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listGroups(
ListGroupsRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Lists the identity provider groups.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listIdentityProviderGroups(
ListIdentityProviderGroupsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListIdentityProviderGroupsRequest, ListIdentityProviderGroupsResponse>
handler);
/**
* 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.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listIdentityProviders(
ListIdentityProvidersRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListIdentityProvidersRequest, ListIdentityProvidersResponse>
handler);
/**
* Lists the group mappings for the specified identity provider.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listIdpGroupMappings(
ListIdpGroupMappingsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListIdpGroupMappingsRequest, ListIdpGroupMappingsResponse>
handler);
/**
* Lists 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listMfaTotpDevices(
ListMfaTotpDevicesRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListMfaTotpDevicesRequest, ListMfaTotpDevicesResponse>
handler);
/**
* Lists 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](https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listNetworkSources(
ListNetworkSourcesRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListNetworkSourcesRequest, ListNetworkSourcesResponse>
handler);
/**
* List of Oauth tokens for the user
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listOAuthClientCredentials(
ListOAuthClientCredentialsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListOAuthClientCredentialsRequest, ListOAuthClientCredentialsResponse>
handler);
/**
* Lists 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](https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
*
* 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listPolicies(
ListPoliciesRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Lists the region subscriptions for the specified tenancy.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listRegionSubscriptions(
ListRegionSubscriptionsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListRegionSubscriptionsRequest, ListRegionSubscriptionsResponse>
handler);
/**
* Lists all the regions offered by Oracle Cloud Infrastructure.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listRegions(
ListRegionsRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Lists 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listSmtpCredentials(
ListSmtpCredentialsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListSmtpCredentialsRequest, ListSmtpCredentialsResponse>
handler);
/**
* **Deprecated. Use {@link #listAuthTokens(ListAuthTokensRequest, Consumer, Consumer) listAuthTokens} instead.**
*
* 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listSwiftPasswords(
ListSwiftPasswordsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListSwiftPasswordsRequest, ListSwiftPasswordsResponse>
handler);
/**
* Lists the tag defaults for tag definitions in the specified compartment.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listTagDefaults(
ListTagDefaultsRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Lists the tag namespaces in the specified compartment.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listTagNamespaces(
ListTagNamespacesRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListTagNamespacesRequest, ListTagNamespacesResponse>
handler);
/**
* Gets the errors for a work request.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listTaggingWorkRequestErrors(
ListTaggingWorkRequestErrorsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListTaggingWorkRequestErrorsRequest,
ListTaggingWorkRequestErrorsResponse>
handler);
/**
* Gets the logs for a work request.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listTaggingWorkRequestLogs(
ListTaggingWorkRequestLogsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListTaggingWorkRequestLogsRequest, ListTaggingWorkRequestLogsResponse>
handler);
/**
* Lists the tagging work requests in compartment.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listTaggingWorkRequests(
ListTaggingWorkRequestsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListTaggingWorkRequestsRequest, ListTaggingWorkRequestsResponse>
handler);
/**
* Lists the tag definitions in the specified tag namespace.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listTags(
ListTagsRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Lists the `UserGroupMembership` objects 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](https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five)).
* 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listUserGroupMemberships(
ListUserGroupMembershipsRequest request,
com.oracle.bmc.responses.AsyncHandler<
ListUserGroupMembershipsRequest, ListUserGroupMembershipsResponse>
handler);
/**
* Lists 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](https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listUsers(
ListUsersRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Lists the work requests in compartment.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future listWorkRequests(
ListWorkRequestsRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Move 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 `CompartmentId` that 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.cloud.oracle.com/Content/Identity/Tasks/managingcompartments.htm#MoveCompartment).
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future moveCompartment(
MoveCompartmentRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Recover the compartment from DELETED state to ACTIVE state.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future recoverCompartment(
RecoverCompartmentRequest request,
com.oracle.bmc.responses.AsyncHandler<
RecoverCompartmentRequest, RecoverCompartmentResponse>
handler);
/**
* Removes a user from a group by deleting the corresponding `UserGroupMembership`.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future removeUserFromGroup(
RemoveUserFromGroupRequest request,
com.oracle.bmc.responses.AsyncHandler<
RemoveUserFromGroupRequest, RemoveUserFromGroupResponse>
handler);
/**
* Resets the OAuth2 client credentials for the SCIM client associated with this identity provider.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future resetIdpScimClient(
ResetIdpScimClientRequest request,
com.oracle.bmc.responses.AsyncHandler<
ResetIdpScimClientRequest, ResetIdpScimClientResponse>
handler);
/**
* Updates the specified auth token's description.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateAuthToken(
UpdateAuthTokenRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Updates authentication policy for the specified tenancy
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateAuthenticationPolicy(
UpdateAuthenticationPolicyRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateAuthenticationPolicyRequest, UpdateAuthenticationPolicyResponse>
handler);
/**
* Updates the specified compartment's description or name. You can't update the root compartment.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateCompartment(
UpdateCompartmentRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateCompartmentRequest, UpdateCompartmentResponse>
handler);
/**
* Updates the specified secret key's description.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateCustomerSecretKey(
UpdateCustomerSecretKeyRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateCustomerSecretKeyRequest, UpdateCustomerSecretKeyResponse>
handler);
/**
* Updates the specified dynamic group.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateDynamicGroup(
UpdateDynamicGroupRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateDynamicGroupRequest, UpdateDynamicGroupResponse>
handler);
/**
* Updates the specified group.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateGroup(
UpdateGroupRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Updates the specified identity provider.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateIdentityProvider(
UpdateIdentityProviderRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateIdentityProviderRequest, UpdateIdentityProviderResponse>
handler);
/**
* Updates the specified group mapping.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateIdpGroupMapping(
UpdateIdpGroupMappingRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateIdpGroupMappingRequest, UpdateIdpGroupMappingResponse>
handler);
/**
* Updates the specified network source.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateNetworkSource(
UpdateNetworkSourceRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateNetworkSourceRequest, UpdateNetworkSourceResponse>
handler);
/**
* Updates Oauth token for the user
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateOAuthClientCredential(
UpdateOAuthClientCredentialRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateOAuthClientCredentialRequest, UpdateOAuthClientCredentialResponse>
handler);
/**
* Updates the specified policy. You can update the description or the policy statements themselves.
*
* Policy changes take effect typically within 10 seconds.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updatePolicy(
UpdatePolicyRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Updates the specified SMTP credential's description.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateSmtpCredential(
UpdateSmtpCredentialRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateSmtpCredentialRequest, UpdateSmtpCredentialResponse>
handler);
/**
* **Deprecated. Use {@link #updateAuthToken(UpdateAuthTokenRequest, Consumer, Consumer) updateAuthToken} instead.**
*
* Updates the specified Swift password's description.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateSwiftPassword(
UpdateSwiftPasswordRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateSwiftPasswordRequest, UpdateSwiftPasswordResponse>
handler);
/**
* Updates 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateTag(
UpdateTagRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Updates 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateTagDefault(
UpdateTagDefaultRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Updates 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 {@link #updateTag(UpdateTagRequest, Consumer, Consumer) updateTag}. For more information about retiring tag namespaces, see
* [Retiring Key Definitions and Namespace Definitions](https://docs.cloud.oracle.com/Content/Identity/Concepts/taggingoverview.htm#Retiring).
*
* You can't add a namespace with the same name as a retired namespace in the same tenancy.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateTagNamespace(
UpdateTagNamespaceRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateTagNamespaceRequest, UpdateTagNamespaceResponse>
handler);
/**
* Updates the description of the specified user.
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateUser(
UpdateUserRequest request,
com.oracle.bmc.responses.AsyncHandler handler);
/**
* Updates the capabilities of the specified user.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateUserCapabilities(
UpdateUserCapabilitiesRequest request,
com.oracle.bmc.responses.AsyncHandler<
UpdateUserCapabilitiesRequest, UpdateUserCapabilitiesResponse>
handler);
/**
* Updates the state of the specified user.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future updateUserState(
UpdateUserStateRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
/**
* Uploads 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.
*
*
* @param request The request object containing the details to send
* @param handler The request handler to invoke upon completion, may be null.
* @return A Future that can be used to get the response if no AsyncHandler was
* provided. Note, if you provide an AsyncHandler and use the Future, some
* types of responses (like java.io.InputStream) may not be able to be read in
* both places as the underlying stream may only be consumed once.
*/
java.util.concurrent.Future uploadApiKey(
UploadApiKeyRequest request,
com.oracle.bmc.responses.AsyncHandler
handler);
}