Package software.amazon.awssdk.services.iotroborunner

Interface IotRoboRunnerAsyncClient

    • Method Detail

      • createDestination

        default CompletableFuture<CreateDestinationResponse> createDestination​(CreateDestinationRequest createDestinationRequest)

        Grants permission to create a destination

        Parameters:
        createDestinationRequest -
        Returns:
        A Java Future containing the result of the CreateDestination operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • ServiceQuotaExceededException Exception thrown if the user's AWS account has reached a service limit and the operation cannot proceed.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createDestination

        default CompletableFuture<CreateDestinationResponse> createDestination​(Consumer<CreateDestinationRequest.Builder> createDestinationRequest)

        Grants permission to create a destination


        This is a convenience which creates an instance of the CreateDestinationRequest.Builder avoiding the need to create one manually via CreateDestinationRequest.builder()

        Parameters:
        createDestinationRequest - A Consumer that will call methods on CreateDestinationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateDestination operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • ServiceQuotaExceededException Exception thrown if the user's AWS account has reached a service limit and the operation cannot proceed.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createSite

        default CompletableFuture<CreateSiteResponse> createSite​(CreateSiteRequest createSiteRequest)

        Grants permission to create a site

        Parameters:
        createSiteRequest -
        Returns:
        A Java Future containing the result of the CreateSite operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • ServiceQuotaExceededException Exception thrown if the user's AWS account has reached a service limit and the operation cannot proceed.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createSite

        default CompletableFuture<CreateSiteResponse> createSite​(Consumer<CreateSiteRequest.Builder> createSiteRequest)

        Grants permission to create a site


        This is a convenience which creates an instance of the CreateSiteRequest.Builder avoiding the need to create one manually via CreateSiteRequest.builder()

        Parameters:
        createSiteRequest - A Consumer that will call methods on CreateSiteRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateSite operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • ServiceQuotaExceededException Exception thrown if the user's AWS account has reached a service limit and the operation cannot proceed.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createWorker

        default CompletableFuture<CreateWorkerResponse> createWorker​(CreateWorkerRequest createWorkerRequest)

        Grants permission to create a worker

        Parameters:
        createWorkerRequest -
        Returns:
        A Java Future containing the result of the CreateWorker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • ServiceQuotaExceededException Exception thrown if the user's AWS account has reached a service limit and the operation cannot proceed.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createWorker

        default CompletableFuture<CreateWorkerResponse> createWorker​(Consumer<CreateWorkerRequest.Builder> createWorkerRequest)

        Grants permission to create a worker


        This is a convenience which creates an instance of the CreateWorkerRequest.Builder avoiding the need to create one manually via CreateWorkerRequest.builder()

        Parameters:
        createWorkerRequest - A Consumer that will call methods on CreateWorkerRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateWorker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • ServiceQuotaExceededException Exception thrown if the user's AWS account has reached a service limit and the operation cannot proceed.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createWorkerFleet

        default CompletableFuture<CreateWorkerFleetResponse> createWorkerFleet​(CreateWorkerFleetRequest createWorkerFleetRequest)

        Grants permission to create a worker fleet

        Parameters:
        createWorkerFleetRequest -
        Returns:
        A Java Future containing the result of the CreateWorkerFleet operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • ServiceQuotaExceededException Exception thrown if the user's AWS account has reached a service limit and the operation cannot proceed.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createWorkerFleet

        default CompletableFuture<CreateWorkerFleetResponse> createWorkerFleet​(Consumer<CreateWorkerFleetRequest.Builder> createWorkerFleetRequest)

        Grants permission to create a worker fleet


        This is a convenience which creates an instance of the CreateWorkerFleetRequest.Builder avoiding the need to create one manually via CreateWorkerFleetRequest.builder()

        Parameters:
        createWorkerFleetRequest - A Consumer that will call methods on CreateWorkerFleetRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateWorkerFleet operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • ServiceQuotaExceededException Exception thrown if the user's AWS account has reached a service limit and the operation cannot proceed.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteDestination

        default CompletableFuture<DeleteDestinationResponse> deleteDestination​(DeleteDestinationRequest deleteDestinationRequest)

        Grants permission to delete a destination

        Parameters:
        deleteDestinationRequest -
        Returns:
        A Java Future containing the result of the DeleteDestination operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteDestination

        default CompletableFuture<DeleteDestinationResponse> deleteDestination​(Consumer<DeleteDestinationRequest.Builder> deleteDestinationRequest)

        Grants permission to delete a destination


        This is a convenience which creates an instance of the DeleteDestinationRequest.Builder avoiding the need to create one manually via DeleteDestinationRequest.builder()

        Parameters:
        deleteDestinationRequest - A Consumer that will call methods on DeleteDestinationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteDestination operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteSite

        default CompletableFuture<DeleteSiteResponse> deleteSite​(DeleteSiteRequest deleteSiteRequest)

        Grants permission to delete a site

        Parameters:
        deleteSiteRequest -
        Returns:
        A Java Future containing the result of the DeleteSite operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteSite

        default CompletableFuture<DeleteSiteResponse> deleteSite​(Consumer<DeleteSiteRequest.Builder> deleteSiteRequest)

        Grants permission to delete a site


        This is a convenience which creates an instance of the DeleteSiteRequest.Builder avoiding the need to create one manually via DeleteSiteRequest.builder()

        Parameters:
        deleteSiteRequest - A Consumer that will call methods on DeleteSiteRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteSite operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteWorker

        default CompletableFuture<DeleteWorkerResponse> deleteWorker​(DeleteWorkerRequest deleteWorkerRequest)

        Grants permission to delete a worker

        Parameters:
        deleteWorkerRequest -
        Returns:
        A Java Future containing the result of the DeleteWorker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteWorker

        default CompletableFuture<DeleteWorkerResponse> deleteWorker​(Consumer<DeleteWorkerRequest.Builder> deleteWorkerRequest)

        Grants permission to delete a worker


        This is a convenience which creates an instance of the DeleteWorkerRequest.Builder avoiding the need to create one manually via DeleteWorkerRequest.builder()

        Parameters:
        deleteWorkerRequest - A Consumer that will call methods on DeleteWorkerRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteWorker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteWorkerFleet

        default CompletableFuture<DeleteWorkerFleetResponse> deleteWorkerFleet​(DeleteWorkerFleetRequest deleteWorkerFleetRequest)

        Grants permission to delete a worker fleet

        Parameters:
        deleteWorkerFleetRequest -
        Returns:
        A Java Future containing the result of the DeleteWorkerFleet operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteWorkerFleet

        default CompletableFuture<DeleteWorkerFleetResponse> deleteWorkerFleet​(Consumer<DeleteWorkerFleetRequest.Builder> deleteWorkerFleetRequest)

        Grants permission to delete a worker fleet


        This is a convenience which creates an instance of the DeleteWorkerFleetRequest.Builder avoiding the need to create one manually via DeleteWorkerFleetRequest.builder()

        Parameters:
        deleteWorkerFleetRequest - A Consumer that will call methods on DeleteWorkerFleetRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteWorkerFleet operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • ConflictException Exception thrown if a resource in a create request already exists.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getDestination

        default CompletableFuture<GetDestinationResponse> getDestination​(GetDestinationRequest getDestinationRequest)

        Grants permission to get a destination

        Parameters:
        getDestinationRequest -
        Returns:
        A Java Future containing the result of the GetDestination operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getDestination

        default CompletableFuture<GetDestinationResponse> getDestination​(Consumer<GetDestinationRequest.Builder> getDestinationRequest)

        Grants permission to get a destination


        This is a convenience which creates an instance of the GetDestinationRequest.Builder avoiding the need to create one manually via GetDestinationRequest.builder()

        Parameters:
        getDestinationRequest - A Consumer that will call methods on GetDestinationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetDestination operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getSite

        default CompletableFuture<GetSiteResponse> getSite​(GetSiteRequest getSiteRequest)

        Grants permission to get a site

        Parameters:
        getSiteRequest -
        Returns:
        A Java Future containing the result of the GetSite operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getSite

        default CompletableFuture<GetSiteResponse> getSite​(Consumer<GetSiteRequest.Builder> getSiteRequest)

        Grants permission to get a site


        This is a convenience which creates an instance of the GetSiteRequest.Builder avoiding the need to create one manually via GetSiteRequest.builder()

        Parameters:
        getSiteRequest - A Consumer that will call methods on GetSiteRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetSite operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getWorker

        default CompletableFuture<GetWorkerResponse> getWorker​(GetWorkerRequest getWorkerRequest)

        Grants permission to get a worker

        Parameters:
        getWorkerRequest -
        Returns:
        A Java Future containing the result of the GetWorker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getWorker

        default CompletableFuture<GetWorkerResponse> getWorker​(Consumer<GetWorkerRequest.Builder> getWorkerRequest)

        Grants permission to get a worker


        This is a convenience which creates an instance of the GetWorkerRequest.Builder avoiding the need to create one manually via GetWorkerRequest.builder()

        Parameters:
        getWorkerRequest - A Consumer that will call methods on GetWorkerRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetWorker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getWorkerFleet

        default CompletableFuture<GetWorkerFleetResponse> getWorkerFleet​(GetWorkerFleetRequest getWorkerFleetRequest)

        Grants permission to get a worker fleet

        Parameters:
        getWorkerFleetRequest -
        Returns:
        A Java Future containing the result of the GetWorkerFleet operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getWorkerFleet

        default CompletableFuture<GetWorkerFleetResponse> getWorkerFleet​(Consumer<GetWorkerFleetRequest.Builder> getWorkerFleetRequest)

        Grants permission to get a worker fleet


        This is a convenience which creates an instance of the GetWorkerFleetRequest.Builder avoiding the need to create one manually via GetWorkerFleetRequest.builder()

        Parameters:
        getWorkerFleetRequest - A Consumer that will call methods on GetWorkerFleetRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetWorkerFleet operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listDestinations

        default CompletableFuture<ListDestinationsResponse> listDestinations​(ListDestinationsRequest listDestinationsRequest)

        Grants permission to list destinations

        Parameters:
        listDestinationsRequest -
        Returns:
        A Java Future containing the result of the ListDestinations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listDestinations

        default CompletableFuture<ListDestinationsResponse> listDestinations​(Consumer<ListDestinationsRequest.Builder> listDestinationsRequest)

        Grants permission to list destinations


        This is a convenience which creates an instance of the ListDestinationsRequest.Builder avoiding the need to create one manually via ListDestinationsRequest.builder()

        Parameters:
        listDestinationsRequest - A Consumer that will call methods on ListDestinationsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListDestinations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listDestinationsPaginator

        default ListDestinationsPublisher listDestinationsPaginator​(ListDestinationsRequest listDestinationsRequest)

        This is a variant of listDestinations(software.amazon.awssdk.services.iotroborunner.model.ListDestinationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListDestinationsPublisher publisher = client.listDestinationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListDestinationsPublisher publisher = client.listDestinationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotroborunner.model.ListDestinationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotroborunner.model.ListDestinationsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listDestinations(software.amazon.awssdk.services.iotroborunner.model.ListDestinationsRequest) operation.

        Parameters:
        listDestinationsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listDestinationsPaginator

        default ListDestinationsPublisher listDestinationsPaginator​(Consumer<ListDestinationsRequest.Builder> listDestinationsRequest)

        This is a variant of listDestinations(software.amazon.awssdk.services.iotroborunner.model.ListDestinationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListDestinationsPublisher publisher = client.listDestinationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListDestinationsPublisher publisher = client.listDestinationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotroborunner.model.ListDestinationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotroborunner.model.ListDestinationsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listDestinations(software.amazon.awssdk.services.iotroborunner.model.ListDestinationsRequest) operation.


        This is a convenience which creates an instance of the ListDestinationsRequest.Builder avoiding the need to create one manually via ListDestinationsRequest.builder()

        Parameters:
        listDestinationsRequest - A Consumer that will call methods on ListDestinationsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listSites

        default CompletableFuture<ListSitesResponse> listSites​(ListSitesRequest listSitesRequest)

        Grants permission to list sites

        Parameters:
        listSitesRequest -
        Returns:
        A Java Future containing the result of the ListSites operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listSites

        default CompletableFuture<ListSitesResponse> listSites​(Consumer<ListSitesRequest.Builder> listSitesRequest)

        Grants permission to list sites


        This is a convenience which creates an instance of the ListSitesRequest.Builder avoiding the need to create one manually via ListSitesRequest.builder()

        Parameters:
        listSitesRequest - A Consumer that will call methods on ListSitesRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListSites operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listSitesPaginator

        default ListSitesPublisher listSitesPaginator​(ListSitesRequest listSitesRequest)

        This is a variant of listSites(software.amazon.awssdk.services.iotroborunner.model.ListSitesRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListSitesPublisher publisher = client.listSitesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListSitesPublisher publisher = client.listSitesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotroborunner.model.ListSitesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotroborunner.model.ListSitesResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listSites(software.amazon.awssdk.services.iotroborunner.model.ListSitesRequest) operation.

        Parameters:
        listSitesRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listSitesPaginator

        default ListSitesPublisher listSitesPaginator​(Consumer<ListSitesRequest.Builder> listSitesRequest)

        This is a variant of listSites(software.amazon.awssdk.services.iotroborunner.model.ListSitesRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListSitesPublisher publisher = client.listSitesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListSitesPublisher publisher = client.listSitesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotroborunner.model.ListSitesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotroborunner.model.ListSitesResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listSites(software.amazon.awssdk.services.iotroborunner.model.ListSitesRequest) operation.


        This is a convenience which creates an instance of the ListSitesRequest.Builder avoiding the need to create one manually via ListSitesRequest.builder()

        Parameters:
        listSitesRequest - A Consumer that will call methods on ListSitesRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listWorkerFleets

        default CompletableFuture<ListWorkerFleetsResponse> listWorkerFleets​(ListWorkerFleetsRequest listWorkerFleetsRequest)

        Grants permission to list worker fleets

        Parameters:
        listWorkerFleetsRequest -
        Returns:
        A Java Future containing the result of the ListWorkerFleets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listWorkerFleets

        default CompletableFuture<ListWorkerFleetsResponse> listWorkerFleets​(Consumer<ListWorkerFleetsRequest.Builder> listWorkerFleetsRequest)

        Grants permission to list worker fleets


        This is a convenience which creates an instance of the ListWorkerFleetsRequest.Builder avoiding the need to create one manually via ListWorkerFleetsRequest.builder()

        Parameters:
        listWorkerFleetsRequest - A Consumer that will call methods on ListWorkerFleetsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListWorkerFleets operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listWorkerFleetsPaginator

        default ListWorkerFleetsPublisher listWorkerFleetsPaginator​(ListWorkerFleetsRequest listWorkerFleetsRequest)

        This is a variant of listWorkerFleets(software.amazon.awssdk.services.iotroborunner.model.ListWorkerFleetsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListWorkerFleetsPublisher publisher = client.listWorkerFleetsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListWorkerFleetsPublisher publisher = client.listWorkerFleetsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotroborunner.model.ListWorkerFleetsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotroborunner.model.ListWorkerFleetsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listWorkerFleets(software.amazon.awssdk.services.iotroborunner.model.ListWorkerFleetsRequest) operation.

        Parameters:
        listWorkerFleetsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listWorkerFleetsPaginator

        default ListWorkerFleetsPublisher listWorkerFleetsPaginator​(Consumer<ListWorkerFleetsRequest.Builder> listWorkerFleetsRequest)

        This is a variant of listWorkerFleets(software.amazon.awssdk.services.iotroborunner.model.ListWorkerFleetsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListWorkerFleetsPublisher publisher = client.listWorkerFleetsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListWorkerFleetsPublisher publisher = client.listWorkerFleetsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotroborunner.model.ListWorkerFleetsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotroborunner.model.ListWorkerFleetsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listWorkerFleets(software.amazon.awssdk.services.iotroborunner.model.ListWorkerFleetsRequest) operation.


        This is a convenience which creates an instance of the ListWorkerFleetsRequest.Builder avoiding the need to create one manually via ListWorkerFleetsRequest.builder()

        Parameters:
        listWorkerFleetsRequest - A Consumer that will call methods on ListWorkerFleetsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listWorkers

        default CompletableFuture<ListWorkersResponse> listWorkers​(ListWorkersRequest listWorkersRequest)

        Grants permission to list workers

        Parameters:
        listWorkersRequest -
        Returns:
        A Java Future containing the result of the ListWorkers operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listWorkers

        default CompletableFuture<ListWorkersResponse> listWorkers​(Consumer<ListWorkersRequest.Builder> listWorkersRequest)

        Grants permission to list workers


        This is a convenience which creates an instance of the ListWorkersRequest.Builder avoiding the need to create one manually via ListWorkersRequest.builder()

        Parameters:
        listWorkersRequest - A Consumer that will call methods on ListWorkersRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListWorkers operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listWorkersPaginator

        default ListWorkersPublisher listWorkersPaginator​(ListWorkersRequest listWorkersRequest)

        This is a variant of listWorkers(software.amazon.awssdk.services.iotroborunner.model.ListWorkersRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListWorkersPublisher publisher = client.listWorkersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListWorkersPublisher publisher = client.listWorkersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotroborunner.model.ListWorkersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotroborunner.model.ListWorkersResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listWorkers(software.amazon.awssdk.services.iotroborunner.model.ListWorkersRequest) operation.

        Parameters:
        listWorkersRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listWorkersPaginator

        default ListWorkersPublisher listWorkersPaginator​(Consumer<ListWorkersRequest.Builder> listWorkersRequest)

        This is a variant of listWorkers(software.amazon.awssdk.services.iotroborunner.model.ListWorkersRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListWorkersPublisher publisher = client.listWorkersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.iotroborunner.paginators.ListWorkersPublisher publisher = client.listWorkersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotroborunner.model.ListWorkersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotroborunner.model.ListWorkersResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listWorkers(software.amazon.awssdk.services.iotroborunner.model.ListWorkersRequest) operation.


        This is a convenience which creates an instance of the ListWorkersRequest.Builder avoiding the need to create one manually via ListWorkersRequest.builder()

        Parameters:
        listWorkersRequest - A Consumer that will call methods on ListWorkersRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateDestination

        default CompletableFuture<UpdateDestinationResponse> updateDestination​(UpdateDestinationRequest updateDestinationRequest)

        Grants permission to update a destination

        Parameters:
        updateDestinationRequest -
        Returns:
        A Java Future containing the result of the UpdateDestination operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateDestination

        default CompletableFuture<UpdateDestinationResponse> updateDestination​(Consumer<UpdateDestinationRequest.Builder> updateDestinationRequest)

        Grants permission to update a destination


        This is a convenience which creates an instance of the UpdateDestinationRequest.Builder avoiding the need to create one manually via UpdateDestinationRequest.builder()

        Parameters:
        updateDestinationRequest - A Consumer that will call methods on UpdateDestinationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateDestination operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateSite

        default CompletableFuture<UpdateSiteResponse> updateSite​(UpdateSiteRequest updateSiteRequest)

        Grants permission to update a site

        Parameters:
        updateSiteRequest -
        Returns:
        A Java Future containing the result of the UpdateSite operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateSite

        default CompletableFuture<UpdateSiteResponse> updateSite​(Consumer<UpdateSiteRequest.Builder> updateSiteRequest)

        Grants permission to update a site


        This is a convenience which creates an instance of the UpdateSiteRequest.Builder avoiding the need to create one manually via UpdateSiteRequest.builder()

        Parameters:
        updateSiteRequest - A Consumer that will call methods on UpdateSiteRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateSite operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateWorker

        default CompletableFuture<UpdateWorkerResponse> updateWorker​(UpdateWorkerRequest updateWorkerRequest)

        Grants permission to update a worker

        Parameters:
        updateWorkerRequest -
        Returns:
        A Java Future containing the result of the UpdateWorker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateWorker

        default CompletableFuture<UpdateWorkerResponse> updateWorker​(Consumer<UpdateWorkerRequest.Builder> updateWorkerRequest)

        Grants permission to update a worker


        This is a convenience which creates an instance of the UpdateWorkerRequest.Builder avoiding the need to create one manually via UpdateWorkerRequest.builder()

        Parameters:
        updateWorkerRequest - A Consumer that will call methods on UpdateWorkerRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateWorker operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateWorkerFleet

        default CompletableFuture<UpdateWorkerFleetResponse> updateWorkerFleet​(UpdateWorkerFleetRequest updateWorkerFleetRequest)

        Grants permission to update a worker fleet

        Parameters:
        updateWorkerFleetRequest -
        Returns:
        A Java Future containing the result of the UpdateWorkerFleet operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateWorkerFleet

        default CompletableFuture<UpdateWorkerFleetResponse> updateWorkerFleet​(Consumer<UpdateWorkerFleetRequest.Builder> updateWorkerFleetRequest)

        Grants permission to update a worker fleet


        This is a convenience which creates an instance of the UpdateWorkerFleetRequest.Builder avoiding the need to create one manually via UpdateWorkerFleetRequest.builder()

        Parameters:
        updateWorkerFleetRequest - A Consumer that will call methods on UpdateWorkerFleetRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateWorkerFleet operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException Exception thrown if an invalid parameter is provided to an API.
        • ResourceNotFoundException Exception thrown if a resource referenced in the request doesn't exist.
        • ThrottlingException Exception thrown if the api has been called too quickly be the client.
        • InternalServerException Exception thrown if something goes wrong within the service.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • IotRoboRunnerException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation