Package com.oracle.bmc.apigateway

Interface ApiGatewayAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    ApiGatewayAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20190501")
public interface ApiGatewayAsync
extends AutoCloseable
    API for the API Gateway service.

    Use this API to manage gateways, deployments, and related items. For more information, see Overview of API Gateway.

    • 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

      • addApiLock

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

      • addCertificateLock

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

      • addSdkLock

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

      • changeApiCompartment

        Future<ChangeApiCompartmentResponse> changeApiCompartment​(ChangeApiCompartmentRequest request,
                                                          AsyncHandler<ChangeApiCompartmentRequest,​ChangeApiCompartmentResponse> handler)
        Changes the API 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.

      • createApi

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

      • createCertificate

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

      • createSdk

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

      • deleteApi

        Future<DeleteApiResponse> deleteApi​(DeleteApiRequest request,
                                    AsyncHandler<DeleteApiRequest,​DeleteApiResponse> handler)
        Deletes the API with the given 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.

      • deleteCertificate

        Future<DeleteCertificateResponse> deleteCertificate​(DeleteCertificateRequest request,
                                                    AsyncHandler<DeleteCertificateRequest,​DeleteCertificateResponse> handler)
        Deletes the certificate with the given 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.

      • deleteSdk

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

      • getApi

        Future<GetApiResponse> getApi​(GetApiRequest request,
                              AsyncHandler<GetApiRequest,​GetApiResponse> handler)
        Gets an API 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.

      • getApiContent

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

      • getApiValidations

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

      • getCertificate

        Future<GetCertificateResponse> getCertificate​(GetCertificateRequest request,
                                              AsyncHandler<GetCertificateRequest,​GetCertificateResponse> handler)
        Gets a certificate 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.

      • getSdk

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

      • listApis

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

      • listCertificates

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

      • listSdkLanguageTypes

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

      • listSdks

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

      • removeApiLock

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

      • removeCertificateLock

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

      • removeSdkLock

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

      • updateApi

        Future<UpdateApiResponse> updateApi​(UpdateApiRequest request,
                                    AsyncHandler<UpdateApiRequest,​UpdateApiResponse> handler)
        Updates the API with the given 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.

      • updateCertificate

        Future<UpdateCertificateResponse> updateCertificate​(UpdateCertificateRequest request,
                                                    AsyncHandler<UpdateCertificateRequest,​UpdateCertificateResponse> handler)
        Updates a certificate with the given 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.

      • updateSdk

        Future<UpdateSdkResponse> updateSdk​(UpdateSdkRequest request,
                                    AsyncHandler<UpdateSdkRequest,​UpdateSdkResponse> handler)
        Updates the SDK with the given 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.