Package com.oracle.bmc.marketplacepublisher

Interface MarketplacePublisherAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    MarketplacePublisherAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20241201")
public interface MarketplacePublisherAsync
extends AutoCloseable
    Use the Marketplace Publisher API to manage the publishing of applications in Oracle Cloud Infrastructure Marketplace.

    • 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

      • activateTermVersion

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

      • cancelWorkRequest

        Future<CancelWorkRequestResponse> cancelWorkRequest​(CancelWorkRequestRequest request,
                                                    AsyncHandler<CancelWorkRequestRequest,​CancelWorkRequestResponse> handler)
        Cancels 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.

      • cascadingDeleteListing

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

      • changeArtifactCompartment

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

      • changeTermCompartment

        Future<ChangeTermCompartmentResponse> changeTermCompartment​(ChangeTermCompartmentRequest request,
                                                            AsyncHandler<ChangeTermCompartmentRequest,​ChangeTermCompartmentResponse> handler)
        Moves a term from one compartment 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.

      • cloneListingRevision

        Future<CloneListingRevisionResponse> cloneListingRevision​(CloneListingRevisionRequest request,
                                                          AsyncHandler<CloneListingRevisionRequest,​CloneListingRevisionResponse> handler)
        Clone the published/withdrawn Listing Revision identified by the 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.

      • createArtifact

        Future<CreateArtifactResponse> createArtifact​(CreateArtifactRequest request,
                                              AsyncHandler<CreateArtifactRequest,​CreateArtifactResponse> handler)
        Creates a new artifact in your compartment.

        You must specify your compartment ID in the request object.

        You must also specify a *name* for the artifact(although it can be an empty string). It does not have to be unique, and you can change it anytime with updateArtifact..

        You must also specify a *artifactType* for the artifact. Allowed values are CONTAINER_IMAGE and HELM_CHART

        You must also provide the container or helm chart registry details for the corresponding images. Oracle container registry details (Registry/Concepts/registryoverview.htm).

        After you send your request, the new object's `status` will temporarily be IN_PROGRESS and `lifecycleState` will be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE and the status has changed to \u2018AVAILABLE\u2019 for the new 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.

      • createListing

        Future<CreateListingResponse> createListing​(CreateListingRequest request,
                                            AsyncHandler<CreateListingRequest,​CreateListingResponse> handler)
        Creates a new listing in your compartment.

        You must specify your compartment ID in the request object.

        You must also specify a *name* for the listing and cannot be updated later.

        You must also specify a *packageType* for the listing. Allowed values are CONTAINER_IMAGE and HELM_CHART

        After you send your request, the new object's `lifecycleState` will be CREATING. Before using the object, first make sure its `lifecycleState` has changed to ACTIVE.

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

      • createListingRevision

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

      • createTerm

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

      • createTermVersion

        Future<CreateTermVersionResponse> createTermVersion​(CreateTermVersionRequest request,
                                                    AsyncHandler<CreateTermVersionRequest,​CreateTermVersionResponse> handler)
        Creates a new Term 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.

      • deleteArtifact

        Future<DeleteArtifactResponse> deleteArtifact​(DeleteArtifactRequest request,
                                              AsyncHandler<DeleteArtifactRequest,​DeleteArtifactResponse> handler)
        Deletes the specified 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.

      • deleteListing

        Future<DeleteListingResponse> deleteListing​(DeleteListingRequest request,
                                            AsyncHandler<DeleteListingRequest,​DeleteListingResponse> handler)
        Deletes a listing by the 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.

      • deleteListingRevision

        Future<DeleteListingRevisionResponse> deleteListingRevision​(DeleteListingRevisionRequest request,
                                                            AsyncHandler<DeleteListingRevisionRequest,​DeleteListingRevisionResponse> handler)
        Deletes a listing by the 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.

      • deleteTerm

        Future<DeleteTermResponse> deleteTerm​(DeleteTermRequest request,
                                      AsyncHandler<DeleteTermRequest,​DeleteTermResponse> handler)
        Deletes a Term by the 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.

      • deleteTermVersion

        Future<DeleteTermVersionResponse> deleteTermVersion​(DeleteTermVersionRequest request,
                                                    AsyncHandler<DeleteTermVersionRequest,​DeleteTermVersionResponse> handler)
        Deletes a Term by the 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.

      • getArtifact

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

      • getCategory

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

      • getLead

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

      • getListing

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

      • getListingRevision

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

      • getListingRevisionNote

        Future<GetListingRevisionNoteResponse> getListingRevisionNote​(GetListingRevisionNoteRequest request,
                                                              AsyncHandler<GetListingRevisionNoteRequest,​GetListingRevisionNoteResponse> handler)
        Get note details by the 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.

      • getMarket

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

      • getProduct

        Future<GetProductResponse> getProduct​(GetProductRequest request,
                                      AsyncHandler<GetProductRequest,​GetProductResponse> handler)
        Gets a Product by code 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.

      • getPublisher

        Future<GetPublisherResponse> getPublisher​(GetPublisherRequest request,
                                          AsyncHandler<GetPublisherRequest,​GetPublisherResponse> handler)
        Gets a Publisher 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.

      • getSupportDoc

        Future<GetSupportDocResponse> getSupportDoc​(GetSupportDocRequest request,
                                            AsyncHandler<GetSupportDocRequest,​GetSupportDocResponse> handler)
        Gets a SupportDoc by code 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.

      • getSupportDocContent

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

      • getTerm

        Future<GetTermResponse> getTerm​(GetTermRequest request,
                                AsyncHandler<GetTermRequest,​GetTermResponse> handler)
        Gets a Term 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.

      • getTermVersion

        Future<GetTermVersionResponse> getTermVersion​(GetTermVersionRequest request,
                                              AsyncHandler<GetTermVersionRequest,​GetTermVersionResponse> handler)
        Gets a Term Version by the 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.

      • getTermVersionContent

        Future<GetTermVersionContentResponse> getTermVersionContent​(GetTermVersionContentRequest request,
                                                            AsyncHandler<GetTermVersionContentRequest,​GetTermVersionContentResponse> handler)
        Gets a Term Version content by the 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)
        Gets details 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.

      • listArtifacts

        Future<ListArtifactsResponse> listArtifacts​(ListArtifactsRequest request,
                                            AsyncHandler<ListArtifactsRequest,​ListArtifactsResponse> handler)
        Lists the artifacts in your compartment.

        You must specify your compartment’s OCID as the value for the compartment ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listAvailableServices

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

      • listCategories

        Future<ListCategoriesResponse> listCategories​(ListCategoriesRequest request,
                                              AsyncHandler<ListCategoriesRequest,​ListCategoriesResponse> handler)
        Lists the categories in your compartment.

        You must specify your compartment’s OCID as the value for the compartment ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listLeads

        Future<ListLeadsResponse> listLeads​(ListLeadsRequest request,
                                    AsyncHandler<ListLeadsRequest,​ListLeadsResponse> handler)
        Lists the leads in your compartment that belong to a listing.

        You must specify your listing’s OCID as the value for the listing ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listListingRevisions

        Future<ListListingRevisionsResponse> listListingRevisions​(ListListingRevisionsRequest request,
                                                          AsyncHandler<ListListingRevisionsRequest,​ListListingRevisionsResponse> handler)
        Lists the list of listing revisions for a specific listing ID, compartment ID or listing revision status.

        You can specify your compartment's OCID as the value for the compartment ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listListings

        Future<ListListingsResponse> listListings​(ListListingsRequest request,
                                          AsyncHandler<ListListingsRequest,​ListListingsResponse> handler)
        Lists the listings in your compartment.

        You must specify your compartment’s OCID as the value for the compartment ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listMarkets

        Future<ListMarketsResponse> listMarkets​(ListMarketsRequest request,
                                        AsyncHandler<ListMarketsRequest,​ListMarketsResponse> handler)
        Lists the markets in your compartment.

        You must specify your compartment’s OCID as the value for the compartment ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listProducts

        Future<ListProductsResponse> listProducts​(ListProductsRequest request,
                                          AsyncHandler<ListProductsRequest,​ListProductsResponse> handler)
        Lists the products in your compartment.

        You must specify your compartment’s OCID as the value for the compartment ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listPublishers

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

      • listSupportDocs

        Future<ListSupportDocsResponse> listSupportDocs​(ListSupportDocsRequest request,
                                                AsyncHandler<ListSupportDocsRequest,​ListSupportDocsResponse> handler)
        Lists the supportDocs in your compartment.

        You must specify your compartment’s OCID as the value for the compartment ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listSupportedCurrencies

        Future<ListSupportedCurrenciesResponse> listSupportedCurrencies​(ListSupportedCurrenciesRequest request,
                                                                AsyncHandler<ListSupportedCurrenciesRequest,​ListSupportedCurrenciesResponse> handler)
        Lists the currencies supported by the Marketplace Publisher Service.

        You must specify your compartment’s OCID as the value for the compartment ID. For information about OCIDs, see Resource Identifiers (Content/General/Concepts/identifiers.htm).

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

      • listSupportedShapes

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

      • listTermVersions

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

      • listTerms

        Future<ListTermsResponse> listTerms​(ListTermsRequest request,
                                    AsyncHandler<ListTermsRequest,​ListTermsResponse> handler)
        Returns a list of the publisher terms.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of 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 (paginated) list of errors for 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.

      • listWorkRequestLogs

        Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                        AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Returns a (paginated) list of logs for 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.

      • 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.

      • publishListingRevision

        Future<PublishListingRevisionResponse> publishListingRevision​(PublishListingRevisionRequest request,
                                                              AsyncHandler<PublishListingRevisionRequest,​PublishListingRevisionResponse> handler)
        Publish the Listing revision identified 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.

      • updateArtifact

        Future<UpdateArtifactResponse> updateArtifact​(UpdateArtifactRequest request,
                                              AsyncHandler<UpdateArtifactRequest,​UpdateArtifactResponse> handler)
        Updates the specified artifact identified by the 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.

      • updateListing

        Future<UpdateListingResponse> updateListing​(UpdateListingRequest request,
                                            AsyncHandler<UpdateListingRequest,​UpdateListingResponse> handler)
        Updates the specified Listing identified by the 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.

      • updateListingRevision

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

      • updateTerm

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

      • updateTermVersion

        Future<UpdateTermVersionResponse> updateTermVersion​(UpdateTermVersionRequest request,
                                                    AsyncHandler<UpdateTermVersionRequest,​UpdateTermVersionResponse> handler)
        Updates the Term 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.

      • withdrawListingRevision

        Future<WithdrawListingRevisionResponse> withdrawListingRevision​(WithdrawListingRevisionRequest request,
                                                                AsyncHandler<WithdrawListingRevisionRequest,​WithdrawListingRevisionResponse> handler)
        Update the Listing Revision identified by the id as Withdraw/UnPublished.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.