Interface DevopsAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    DevopsAsyncClient

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20210630")
    public interface DevopsAsync
    extends AutoCloseable
    Use the DevOps API to create DevOps projects, configure code repositories, add artifacts to deploy, build and test software applications, configure target deployment environments, and deploy software applications.

    For more information, see DevOps.

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

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

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

        void setRegion​(Region region)
        Sets the region to call (ex, Region.US_PHOENIX_1).

        Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.

        Parameters:
        region - The region of the service.
      • setRegion

        void setRegion​(String regionId)
        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 setRegion.

        If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.

        Parameters:
        regionId - The public region ID.
      • useRealmSpecificEndpointTemplate

        void useRealmSpecificEndpointTemplate​(boolean realmSpecificEndpointTemplateEnabled)
        Determines whether realm specific endpoint should be used or not.

        Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”

        Parameters:
        realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template
      • approveDeployment

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

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

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

        Future<ChangeProjectCompartmentResponse> changeProjectCompartment​(ChangeProjectCompartmentRequest request,
                                                                          AsyncHandler<ChangeProjectCompartmentRequest,​ChangeProjectCompartmentResponse> handler)
        Moves a project resource from one compartment OCID to another.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createBuildPipeline

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

        Future<CreateBuildRunResponse> createBuildRun​(CreateBuildRunRequest request,
                                                      AsyncHandler<CreateBuildRunRequest,​CreateBuildRunResponse> handler)
        Starts a build pipeline run for a predefined build pipeline.

        Please ensure the completion of any work request for creation/updation of Build Pipeline before starting a Build Run.

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

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

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

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

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

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

        Future<CreateOrUpdateGitRefResponse> createOrUpdateGitRef​(CreateOrUpdateGitRefRequest request,
                                                                  AsyncHandler<CreateOrUpdateGitRefRequest,​CreateOrUpdateGitRefResponse> handler)
        Creates a new reference or updates an existing one.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createProject

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

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

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

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

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

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

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

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

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

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

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

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

        Future<DeleteGitRefResponse> deleteGitRef​(DeleteGitRefRequest request,
                                                  AsyncHandler<DeleteGitRefRequest,​DeleteGitRefResponse> handler)
        Deletes a Repository’s Ref by its name.

        Returns an error if the name is ambiguous. Can be disambiguated by using full names like "heads/" or "tags/".

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

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

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

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

        Future<DeleteRefResponse> deleteRef​(DeleteRefRequest request,
                                            AsyncHandler<DeleteRefRequest,​DeleteRefResponse> handler)
        Deletes a Repository’s Ref by its name.

        Returns an error if the name is ambiguous. Can be disambiguated by using full names like "heads/" or "tags/". This API will be deprecated on Wed, 12 June 2024 01:00:00 GMT as it does not get recognized when refName has ‘/’. This will be replaced by "/repositories/{repositoryId}/actions/deleteGitRef".

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

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

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

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

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

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

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

        Future<GetCommitDiffResponse> getCommitDiff​(GetCommitDiffRequest request,
                                                    AsyncHandler<GetCommitDiffRequest,​GetCommitDiffResponse> handler)
        Compares two revisions for their differences.

        Supports comparison between two references or commits.

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

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

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

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

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

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

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

        Future<GetFileDiffResponse> getFileDiff​(GetFileDiffRequest request,
                                                AsyncHandler<GetFileDiffRequest,​GetFileDiffResponse> handler)
        Gets the line-by-line difference between file on different commits.

        This API will be deprecated on Wed, 29 Mar 2023 01:00:00 GMT as it does not get recognized when filePath has ‘/’. This will be replaced by "/repositories/{repositoryId}/file/diffs"

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

        Future<GetMirrorRecordResponse> getMirrorRecord​(GetMirrorRecordRequest request,
                                                        AsyncHandler<GetMirrorRecordRequest,​GetMirrorRecordResponse> handler)
        Returns either current mirror record or last successful mirror record for a specific mirror repository.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getObject

        Future<GetObjectResponse> getObject​(GetObjectRequest request,
                                            AsyncHandler<GetObjectRequest,​GetObjectResponse> handler)
        Retrieves blob of specific branch name/commit ID and file path.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getObjectContent

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

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

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

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

        Future<GetRefResponse> getRef​(GetRefRequest request,
                                      AsyncHandler<GetRefRequest,​GetRefResponse> handler)
        This API will be deprecated on Wed, 12 June 2024 01:00:00 GMT as it does not get recognized when refName has ‘/’.

        This will be replaced by "/repositories/{repositoryId}/refs". Retrieves a repository’s reference by its name with preference for branches over tags if the name is ambiguous. This can be disambiguated by using full names like "heads/" or "tags/".

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

        Future<GetRepoFileDiffResponse> getRepoFileDiff​(GetRepoFileDiffRequest request,
                                                        AsyncHandler<GetRepoFileDiffRequest,​GetRepoFileDiffResponse> handler)
        Gets the line-by-line difference between file on different commits.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getRepoFileLines

        Future<GetRepoFileLinesResponse> getRepoFileLines​(GetRepoFileLinesRequest request,
                                                          AsyncHandler<GetRepoFileLinesRequest,​GetRepoFileLinesResponse> handler)
        Retrieve lines of a specified file.

        Supports starting line number and limit.

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

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

        Future<GetRepositoryFileLinesResponse> getRepositoryFileLines​(GetRepositoryFileLinesRequest request,
                                                                      AsyncHandler<GetRepositoryFileLinesRequest,​GetRepositoryFileLinesResponse> handler)
        Retrieve lines of a specified file.

        Supports starting line number and limit. This API will be deprecated on Wed, 29 Mar 2023 01:00:00 GMT as it does not get recognized when filePath has ‘/’. This will be replaced by "/repositories/{repositoryId}/file/lines"

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

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

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

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

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

        Future<ListBuildPipelineStagesResponse> listBuildPipelineStages​(ListBuildPipelineStagesRequest request,
                                                                        AsyncHandler<ListBuildPipelineStagesRequest,​ListBuildPipelineStagesResponse> handler)
        Returns a list of all stages in a compartment or build pipeline.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listBuildPipelines

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

        Future<ListBuildRunSnapshotsResponse> listBuildRunSnapshots​(ListBuildRunSnapshotsRequest request,
                                                                    AsyncHandler<ListBuildRunSnapshotsRequest,​ListBuildRunSnapshotsResponse> handler)
        Returns a list of build run snapshots for a given commit or the latest commit on a pull request if no commit is provided.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listBuildRuns

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

        Future<ListCommitDiffsResponse> listCommitDiffs​(ListCommitDiffsRequest request,
                                                        AsyncHandler<ListCommitDiffsRequest,​ListCommitDiffsResponse> handler)
        Compares two revisions and lists the differences.

        Supports comparison between two references or commits.

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

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

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

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

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

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

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

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

        Future<ListForkSyncStatusesResponse> listForkSyncStatuses​(ListForkSyncStatusesRequest request,
                                                                  AsyncHandler<ListForkSyncStatusesRequest,​ListForkSyncStatusesResponse> handler)
        LIST operation that returns a collection of fork sync status objects.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMirrorRecords

        Future<ListMirrorRecordsResponse> listMirrorRecords​(ListMirrorRecordsRequest request,
                                                            AsyncHandler<ListMirrorRecordsRequest,​ListMirrorRecordsResponse> handler)
        Returns a list of mirror entry in history within 30 days.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listPaths

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

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

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

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

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

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

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

        Future<ListRepositoriesResponse> listRepositories​(ListRepositoriesRequest request,
                                                          AsyncHandler<ListRepositoriesRequest,​ListRepositoriesResponse> handler)
        Returns a list of repositories given a compartment ID or a project ID.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listTriggers

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

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

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

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

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

        Future<MirrorRepositoryResponse> mirrorRepository​(MirrorRepositoryRequest request,
                                                          AsyncHandler<MirrorRepositoryRequest,​MirrorRepositoryResponse> handler)
        Synchronize a mirrored repository to the latest version from external providers.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • patchPullRequest

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

        Future<PutRepositoryRefResponse> putRepositoryRef​(PutRepositoryRefRequest request,
                                                          AsyncHandler<PutRepositoryRefRequest,​PutRepositoryRefResponse> handler)
        Creates a new reference or updates an existing one.

        This API will be deprecated on Wed, 12 June 2024 01:00:00 GMT as it does not get recognized when refName has ‘/’. This will be replaced by "/repositories/{repositoryId}/actions/createOrUpdateGitRef".

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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