Interface IotManagedIntegrationsAsyncClient

All Superinterfaces:
AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
@Generated("software.amazon.awssdk:codegen") @ThreadSafe public interface IotManagedIntegrationsAsyncClient extends AwsClient
Service client for accessing Managed integrations for AWS IoT Device Management asynchronously. This can be created using the static builder() method.The asynchronous client performs non-blocking I/O when configured with any SdkAsyncHttpClient supported in the SDK. However, full non-blocking is not guaranteed as the async client may perform blocking calls in some cases such as credentials retrieval and endpoint discovery as part of the async API call.

Managed integrations is a feature of AWS IoT Device Management that enables developers to quickly build innovative IoT solutions. Customers can use managed integrations to automate device setup workflows and support interoperability across many devices, regardless of device vendor or connectivity protocol. This allows developers to use a single user-interface to control, manage, and operate a range of devices.

  • Field Details

  • Method Details

    • createCredentialLocker

      default CompletableFuture<CreateCredentialLockerResponse> createCredentialLocker(CreateCredentialLockerRequest createCredentialLockerRequest)

      Create a product credential locker. This operation will trigger the creation of all the manufacturing resources including the Wi-Fi setup key pair and device certificate.

      Parameters:
      createCredentialLockerRequest -
      Returns:
      A Java Future containing the result of the CreateCredentialLocker operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceQuotaExceededException The service quota has been exceeded for this request.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createCredentialLocker

      default CompletableFuture<CreateCredentialLockerResponse> createCredentialLocker(Consumer<CreateCredentialLockerRequest.Builder> createCredentialLockerRequest)

      Create a product credential locker. This operation will trigger the creation of all the manufacturing resources including the Wi-Fi setup key pair and device certificate.


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

      Parameters:
      createCredentialLockerRequest - A Consumer that will call methods on CreateCredentialLockerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateCredentialLocker operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceQuotaExceededException The service quota has been exceeded for this request.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createDestination

      default CompletableFuture<CreateDestinationResponse> createDestination(CreateDestinationRequest createDestinationRequest)

      Create a destination. IoT managed integrations uses the destination to determine where to deliver notifications for a device.

      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createDestination

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

      Create a destination. IoT managed integrations uses the destination to determine where to deliver notifications for a device.


      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createEventLogConfiguration

      default CompletableFuture<CreateEventLogConfigurationResponse> createEventLogConfiguration(CreateEventLogConfigurationRequest createEventLogConfigurationRequest)

      Set the event log configuration for the account, resource type, or specific resource.

      Parameters:
      createEventLogConfigurationRequest -
      Returns:
      A Java Future containing the result of the CreateEventLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceQuotaExceededException The service quota has been exceeded for this request.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createEventLogConfiguration

      default CompletableFuture<CreateEventLogConfigurationResponse> createEventLogConfiguration(Consumer<CreateEventLogConfigurationRequest.Builder> createEventLogConfigurationRequest)

      Set the event log configuration for the account, resource type, or specific resource.


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

      Parameters:
      createEventLogConfigurationRequest - A Consumer that will call methods on CreateEventLogConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateEventLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceQuotaExceededException The service quota has been exceeded for this request.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createManagedThing

      default CompletableFuture<CreateManagedThingResponse> createManagedThing(CreateManagedThingRequest createManagedThingRequest)

      Creates a managed thing. A managed thing contains the device identifier, protocol supported, and capabilities of the device in a protocol-specific format.

      Parameters:
      createManagedThingRequest -
      Returns:
      A Java Future containing the result of the CreateManagedThing operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createManagedThing

      default CompletableFuture<CreateManagedThingResponse> createManagedThing(Consumer<CreateManagedThingRequest.Builder> createManagedThingRequest)

      Creates a managed thing. A managed thing contains the device identifier, protocol supported, and capabilities of the device in a protocol-specific format.


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

      Parameters:
      createManagedThingRequest - A Consumer that will call methods on CreateManagedThingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateManagedThing operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createNotificationConfiguration

      default CompletableFuture<CreateNotificationConfigurationResponse> createNotificationConfiguration(CreateNotificationConfigurationRequest createNotificationConfigurationRequest)

      Creates a notification configuration. A configuration is a connection between an event type and a destination that you have already created.

      Parameters:
      createNotificationConfigurationRequest -
      Returns:
      A Java Future containing the result of the CreateNotificationConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createNotificationConfiguration

      default CompletableFuture<CreateNotificationConfigurationResponse> createNotificationConfiguration(Consumer<CreateNotificationConfigurationRequest.Builder> createNotificationConfigurationRequest)

      Creates a notification configuration. A configuration is a connection between an event type and a destination that you have already created.


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

      Parameters:
      createNotificationConfigurationRequest - A Consumer that will call methods on CreateNotificationConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateNotificationConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createOtaTask

      default CompletableFuture<CreateOtaTaskResponse> createOtaTask(CreateOtaTaskRequest createOtaTaskRequest)

      Create an over-the-air (OTA) task to update a device.

      Parameters:
      createOtaTaskRequest -
      Returns:
      A Java Future containing the result of the CreateOtaTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createOtaTask

      default CompletableFuture<CreateOtaTaskResponse> createOtaTask(Consumer<CreateOtaTaskRequest.Builder> createOtaTaskRequest)

      Create an over-the-air (OTA) task to update a device.


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

      Parameters:
      createOtaTaskRequest - A Consumer that will call methods on CreateOtaTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateOtaTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createOtaTaskConfiguration

      default CompletableFuture<CreateOtaTaskConfigurationResponse> createOtaTaskConfiguration(CreateOtaTaskConfigurationRequest createOtaTaskConfigurationRequest)

      Create a configuraiton for the over-the-air (OTA) task.

      Parameters:
      createOtaTaskConfigurationRequest -
      Returns:
      A Java Future containing the result of the CreateOtaTaskConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createOtaTaskConfiguration

      default CompletableFuture<CreateOtaTaskConfigurationResponse> createOtaTaskConfiguration(Consumer<CreateOtaTaskConfigurationRequest.Builder> createOtaTaskConfigurationRequest)

      Create a configuraiton for the over-the-air (OTA) task.


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

      Parameters:
      createOtaTaskConfigurationRequest - A Consumer that will call methods on CreateOtaTaskConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateOtaTaskConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createProvisioningProfile

      default CompletableFuture<CreateProvisioningProfileResponse> createProvisioningProfile(CreateProvisioningProfileRequest createProvisioningProfileRequest)

      Create a provisioning profile for a device to execute the provisioning flows using a provisioning template. The provisioning template is a document that defines the set of resources and policies applied to a device during the provisioning process.

      Parameters:
      createProvisioningProfileRequest -
      Returns:
      A Java Future containing the result of the CreateProvisioningProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createProvisioningProfile

      default CompletableFuture<CreateProvisioningProfileResponse> createProvisioningProfile(Consumer<CreateProvisioningProfileRequest.Builder> createProvisioningProfileRequest)

      Create a provisioning profile for a device to execute the provisioning flows using a provisioning template. The provisioning template is a document that defines the set of resources and policies applied to a device during the provisioning process.


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

      Parameters:
      createProvisioningProfileRequest - A Consumer that will call methods on CreateProvisioningProfileRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateProvisioningProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteCredentialLocker

      default CompletableFuture<DeleteCredentialLockerResponse> deleteCredentialLocker(DeleteCredentialLockerRequest deleteCredentialLockerRequest)

      Delete a credential locker.

      This operation can't be undone and any existing device won't be able to use IoT managed integrations.

      Parameters:
      deleteCredentialLockerRequest -
      Returns:
      A Java Future containing the result of the DeleteCredentialLocker operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteCredentialLocker

      default CompletableFuture<DeleteCredentialLockerResponse> deleteCredentialLocker(Consumer<DeleteCredentialLockerRequest.Builder> deleteCredentialLockerRequest)

      Delete a credential locker.

      This operation can't be undone and any existing device won't be able to use IoT managed integrations.


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

      Parameters:
      deleteCredentialLockerRequest - A Consumer that will call methods on DeleteCredentialLockerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteCredentialLocker operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteDestination

      default CompletableFuture<DeleteDestinationResponse> deleteDestination(DeleteDestinationRequest deleteDestinationRequest)

      Deletes a customer-managed destination specified by id.

      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteDestination

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

      Deletes a customer-managed destination specified by id.


      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteEventLogConfiguration

      default CompletableFuture<DeleteEventLogConfigurationResponse> deleteEventLogConfiguration(DeleteEventLogConfigurationRequest deleteEventLogConfigurationRequest)

      Delete an event log configuration.

      Parameters:
      deleteEventLogConfigurationRequest -
      Returns:
      A Java Future containing the result of the DeleteEventLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteEventLogConfiguration

      default CompletableFuture<DeleteEventLogConfigurationResponse> deleteEventLogConfiguration(Consumer<DeleteEventLogConfigurationRequest.Builder> deleteEventLogConfigurationRequest)

      Delete an event log configuration.


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

      Parameters:
      deleteEventLogConfigurationRequest - A Consumer that will call methods on DeleteEventLogConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteEventLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteManagedThing

      default CompletableFuture<DeleteManagedThingResponse> deleteManagedThing(DeleteManagedThingRequest deleteManagedThingRequest)

      Delete a managed thing. If a controller is deleted, all of the devices connected to it will have their status changed to PENDING. It is not possible to remove a cloud device.

      Parameters:
      deleteManagedThingRequest -
      Returns:
      A Java Future containing the result of the DeleteManagedThing operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteManagedThing

      default CompletableFuture<DeleteManagedThingResponse> deleteManagedThing(Consumer<DeleteManagedThingRequest.Builder> deleteManagedThingRequest)

      Delete a managed thing. If a controller is deleted, all of the devices connected to it will have their status changed to PENDING. It is not possible to remove a cloud device.


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

      Parameters:
      deleteManagedThingRequest - A Consumer that will call methods on DeleteManagedThingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteManagedThing operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteNotificationConfiguration

      default CompletableFuture<DeleteNotificationConfigurationResponse> deleteNotificationConfiguration(DeleteNotificationConfigurationRequest deleteNotificationConfigurationRequest)

      Deletes a notification configuration.

      Parameters:
      deleteNotificationConfigurationRequest -
      Returns:
      A Java Future containing the result of the DeleteNotificationConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteNotificationConfiguration

      default CompletableFuture<DeleteNotificationConfigurationResponse> deleteNotificationConfiguration(Consumer<DeleteNotificationConfigurationRequest.Builder> deleteNotificationConfigurationRequest)

      Deletes a notification configuration.


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

      Parameters:
      deleteNotificationConfigurationRequest - A Consumer that will call methods on DeleteNotificationConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteNotificationConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteOtaTask

      default CompletableFuture<DeleteOtaTaskResponse> deleteOtaTask(DeleteOtaTaskRequest deleteOtaTaskRequest)

      Delete the over-the-air (OTA) task.

      Parameters:
      deleteOtaTaskRequest -
      Returns:
      A Java Future containing the result of the DeleteOtaTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteOtaTask

      default CompletableFuture<DeleteOtaTaskResponse> deleteOtaTask(Consumer<DeleteOtaTaskRequest.Builder> deleteOtaTaskRequest)

      Delete the over-the-air (OTA) task.


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

      Parameters:
      deleteOtaTaskRequest - A Consumer that will call methods on DeleteOtaTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteOtaTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteOtaTaskConfiguration

      default CompletableFuture<DeleteOtaTaskConfigurationResponse> deleteOtaTaskConfiguration(DeleteOtaTaskConfigurationRequest deleteOtaTaskConfigurationRequest)

      Delete the over-the-air (OTA) task configuration.

      Parameters:
      deleteOtaTaskConfigurationRequest -
      Returns:
      A Java Future containing the result of the DeleteOtaTaskConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteOtaTaskConfiguration

      default CompletableFuture<DeleteOtaTaskConfigurationResponse> deleteOtaTaskConfiguration(Consumer<DeleteOtaTaskConfigurationRequest.Builder> deleteOtaTaskConfigurationRequest)

      Delete the over-the-air (OTA) task configuration.


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

      Parameters:
      deleteOtaTaskConfigurationRequest - A Consumer that will call methods on DeleteOtaTaskConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteOtaTaskConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteProvisioningProfile

      default CompletableFuture<DeleteProvisioningProfileResponse> deleteProvisioningProfile(DeleteProvisioningProfileRequest deleteProvisioningProfileRequest)

      Delete a provisioning profile.

      Parameters:
      deleteProvisioningProfileRequest -
      Returns:
      A Java Future containing the result of the DeleteProvisioningProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteProvisioningProfile

      default CompletableFuture<DeleteProvisioningProfileResponse> deleteProvisioningProfile(Consumer<DeleteProvisioningProfileRequest.Builder> deleteProvisioningProfileRequest)

      Delete a provisioning profile.


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

      Parameters:
      deleteProvisioningProfileRequest - A Consumer that will call methods on DeleteProvisioningProfileRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteProvisioningProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCredentialLocker

      default CompletableFuture<GetCredentialLockerResponse> getCredentialLocker(GetCredentialLockerRequest getCredentialLockerRequest)

      Get information on an existing credential locker

      Parameters:
      getCredentialLockerRequest -
      Returns:
      A Java Future containing the result of the GetCredentialLocker operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCredentialLocker

      default CompletableFuture<GetCredentialLockerResponse> getCredentialLocker(Consumer<GetCredentialLockerRequest.Builder> getCredentialLockerRequest)

      Get information on an existing credential locker


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

      Parameters:
      getCredentialLockerRequest - A Consumer that will call methods on GetCredentialLockerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetCredentialLocker operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCustomEndpoint

      default CompletableFuture<GetCustomEndpointResponse> getCustomEndpoint(GetCustomEndpointRequest getCustomEndpointRequest)

      Returns the IoT managed integrations custom endpoint.

      Parameters:
      getCustomEndpointRequest -
      Returns:
      A Java Future containing the result of the GetCustomEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCustomEndpoint

      default CompletableFuture<GetCustomEndpointResponse> getCustomEndpoint(Consumer<GetCustomEndpointRequest.Builder> getCustomEndpointRequest)

      Returns the IoT managed integrations custom endpoint.


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

      Parameters:
      getCustomEndpointRequest - A Consumer that will call methods on GetCustomEndpointRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetCustomEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getDefaultEncryptionConfiguration

      default CompletableFuture<GetDefaultEncryptionConfigurationResponse> getDefaultEncryptionConfiguration(GetDefaultEncryptionConfigurationRequest getDefaultEncryptionConfigurationRequest)

      Retrieves information about the default encryption configuration for the Amazon Web Services account in the default or specified region. For more information, see Key management in the AWS IoT SiteWise User Guide.

      Parameters:
      getDefaultEncryptionConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetDefaultEncryptionConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalFailureException An unexpected error has occurred.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getDefaultEncryptionConfiguration

      default CompletableFuture<GetDefaultEncryptionConfigurationResponse> getDefaultEncryptionConfiguration(Consumer<GetDefaultEncryptionConfigurationRequest.Builder> getDefaultEncryptionConfigurationRequest)

      Retrieves information about the default encryption configuration for the Amazon Web Services account in the default or specified region. For more information, see Key management in the AWS IoT SiteWise User Guide.


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

      Parameters:
      getDefaultEncryptionConfigurationRequest - A Consumer that will call methods on GetDefaultEncryptionConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetDefaultEncryptionConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalFailureException An unexpected error has occurred.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getDestination

      default CompletableFuture<GetDestinationResponse> getDestination(GetDestinationRequest getDestinationRequest)

      Gets a destination by ID.

      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getDestination

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

      Gets a destination by ID.


      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getDeviceDiscovery

      default CompletableFuture<GetDeviceDiscoveryResponse> getDeviceDiscovery(GetDeviceDiscoveryRequest getDeviceDiscoveryRequest)

      Get the current state of a device discovery.

      Parameters:
      getDeviceDiscoveryRequest -
      Returns:
      A Java Future containing the result of the GetDeviceDiscovery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getDeviceDiscovery

      default CompletableFuture<GetDeviceDiscoveryResponse> getDeviceDiscovery(Consumer<GetDeviceDiscoveryRequest.Builder> getDeviceDiscoveryRequest)

      Get the current state of a device discovery.


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

      Parameters:
      getDeviceDiscoveryRequest - A Consumer that will call methods on GetDeviceDiscoveryRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetDeviceDiscovery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEventLogConfiguration

      default CompletableFuture<GetEventLogConfigurationResponse> getEventLogConfiguration(GetEventLogConfigurationRequest getEventLogConfigurationRequest)

      Get an event log configuration.

      Parameters:
      getEventLogConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetEventLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEventLogConfiguration

      default CompletableFuture<GetEventLogConfigurationResponse> getEventLogConfiguration(Consumer<GetEventLogConfigurationRequest.Builder> getEventLogConfigurationRequest)

      Get an event log configuration.


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

      Parameters:
      getEventLogConfigurationRequest - A Consumer that will call methods on GetEventLogConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetEventLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getHubConfiguration

      default CompletableFuture<GetHubConfigurationResponse> getHubConfiguration(GetHubConfigurationRequest getHubConfigurationRequest)

      Get a hub configuration.

      Parameters:
      getHubConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetHubConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getHubConfiguration

      default CompletableFuture<GetHubConfigurationResponse> getHubConfiguration(Consumer<GetHubConfigurationRequest.Builder> getHubConfigurationRequest)

      Get a hub configuration.


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

      Parameters:
      getHubConfigurationRequest - A Consumer that will call methods on GetHubConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetHubConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThing

      default CompletableFuture<GetManagedThingResponse> getManagedThing(GetManagedThingRequest getManagedThingRequest)

      Get the attributes and capabilities associated with a managed thing.

      Parameters:
      getManagedThingRequest -
      Returns:
      A Java Future containing the result of the GetManagedThing operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThing

      default CompletableFuture<GetManagedThingResponse> getManagedThing(Consumer<GetManagedThingRequest.Builder> getManagedThingRequest)

      Get the attributes and capabilities associated with a managed thing.


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

      Parameters:
      getManagedThingRequest - A Consumer that will call methods on GetManagedThingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetManagedThing operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThingCapabilities

      default CompletableFuture<GetManagedThingCapabilitiesResponse> getManagedThingCapabilities(GetManagedThingCapabilitiesRequest getManagedThingCapabilitiesRequest)

      Get the capabilities for a managed thing using the device ID.

      Parameters:
      getManagedThingCapabilitiesRequest -
      Returns:
      A Java Future containing the result of the GetManagedThingCapabilities operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThingCapabilities

      default CompletableFuture<GetManagedThingCapabilitiesResponse> getManagedThingCapabilities(Consumer<GetManagedThingCapabilitiesRequest.Builder> getManagedThingCapabilitiesRequest)

      Get the capabilities for a managed thing using the device ID.


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

      Parameters:
      getManagedThingCapabilitiesRequest - A Consumer that will call methods on GetManagedThingCapabilitiesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetManagedThingCapabilities operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThingConnectivityData

      default CompletableFuture<GetManagedThingConnectivityDataResponse> getManagedThingConnectivityData(GetManagedThingConnectivityDataRequest getManagedThingConnectivityDataRequest)

      Get the connectivity status of a managed thing.

      Parameters:
      getManagedThingConnectivityDataRequest -
      Returns:
      A Java Future containing the result of the GetManagedThingConnectivityData operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThingConnectivityData

      default CompletableFuture<GetManagedThingConnectivityDataResponse> getManagedThingConnectivityData(Consumer<GetManagedThingConnectivityDataRequest.Builder> getManagedThingConnectivityDataRequest)

      Get the connectivity status of a managed thing.


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

      Parameters:
      getManagedThingConnectivityDataRequest - A Consumer that will call methods on GetManagedThingConnectivityDataRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetManagedThingConnectivityData operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThingMetaData

      default CompletableFuture<GetManagedThingMetaDataResponse> getManagedThingMetaData(GetManagedThingMetaDataRequest getManagedThingMetaDataRequest)

      Get the metadata information for a managed thing.

      Parameters:
      getManagedThingMetaDataRequest -
      Returns:
      A Java Future containing the result of the GetManagedThingMetaData operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThingMetaData

      default CompletableFuture<GetManagedThingMetaDataResponse> getManagedThingMetaData(Consumer<GetManagedThingMetaDataRequest.Builder> getManagedThingMetaDataRequest)

      Get the metadata information for a managed thing.


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

      Parameters:
      getManagedThingMetaDataRequest - A Consumer that will call methods on GetManagedThingMetaDataRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetManagedThingMetaData operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThingState

      default CompletableFuture<GetManagedThingStateResponse> getManagedThingState(GetManagedThingStateRequest getManagedThingStateRequest)

      Returns the managed thing state for the given device Id.

      Parameters:
      getManagedThingStateRequest -
      Returns:
      A Java Future containing the result of the GetManagedThingState operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalFailureException An unexpected error has occurred.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getManagedThingState

      default CompletableFuture<GetManagedThingStateResponse> getManagedThingState(Consumer<GetManagedThingStateRequest.Builder> getManagedThingStateRequest)

      Returns the managed thing state for the given device Id.


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

      Parameters:
      getManagedThingStateRequest - A Consumer that will call methods on GetManagedThingStateRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetManagedThingState operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalFailureException An unexpected error has occurred.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getNotificationConfiguration

      default CompletableFuture<GetNotificationConfigurationResponse> getNotificationConfiguration(GetNotificationConfigurationRequest getNotificationConfigurationRequest)

      Get a notification configuration.

      Parameters:
      getNotificationConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetNotificationConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getNotificationConfiguration

      default CompletableFuture<GetNotificationConfigurationResponse> getNotificationConfiguration(Consumer<GetNotificationConfigurationRequest.Builder> getNotificationConfigurationRequest)

      Get a notification configuration.


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

      Parameters:
      getNotificationConfigurationRequest - A Consumer that will call methods on GetNotificationConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetNotificationConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getOtaTask

      default CompletableFuture<GetOtaTaskResponse> getOtaTask(GetOtaTaskRequest getOtaTaskRequest)

      Get the over-the-air (OTA) task.

      Parameters:
      getOtaTaskRequest -
      Returns:
      A Java Future containing the result of the GetOtaTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getOtaTask

      default CompletableFuture<GetOtaTaskResponse> getOtaTask(Consumer<GetOtaTaskRequest.Builder> getOtaTaskRequest)

      Get the over-the-air (OTA) task.


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

      Parameters:
      getOtaTaskRequest - A Consumer that will call methods on GetOtaTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetOtaTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getOtaTaskConfiguration

      default CompletableFuture<GetOtaTaskConfigurationResponse> getOtaTaskConfiguration(GetOtaTaskConfigurationRequest getOtaTaskConfigurationRequest)

      Get a configuraiton for the over-the-air (OTA) task.

      Parameters:
      getOtaTaskConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetOtaTaskConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getOtaTaskConfiguration

      default CompletableFuture<GetOtaTaskConfigurationResponse> getOtaTaskConfiguration(Consumer<GetOtaTaskConfigurationRequest.Builder> getOtaTaskConfigurationRequest)

      Get a configuraiton for the over-the-air (OTA) task.


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

      Parameters:
      getOtaTaskConfigurationRequest - A Consumer that will call methods on GetOtaTaskConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetOtaTaskConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getProvisioningProfile

      default CompletableFuture<GetProvisioningProfileResponse> getProvisioningProfile(GetProvisioningProfileRequest getProvisioningProfileRequest)

      Get a provisioning profile by template name.

      Parameters:
      getProvisioningProfileRequest -
      Returns:
      A Java Future containing the result of the GetProvisioningProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getProvisioningProfile

      default CompletableFuture<GetProvisioningProfileResponse> getProvisioningProfile(Consumer<GetProvisioningProfileRequest.Builder> getProvisioningProfileRequest)

      Get a provisioning profile by template name.


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

      Parameters:
      getProvisioningProfileRequest - A Consumer that will call methods on GetProvisioningProfileRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetProvisioningProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getRuntimeLogConfiguration

      default CompletableFuture<GetRuntimeLogConfigurationResponse> getRuntimeLogConfiguration(GetRuntimeLogConfigurationRequest getRuntimeLogConfigurationRequest)

      Get the runtime log configuration for a specific managed thing or for all managed things as a group.

      Parameters:
      getRuntimeLogConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetRuntimeLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getRuntimeLogConfiguration

      default CompletableFuture<GetRuntimeLogConfigurationResponse> getRuntimeLogConfiguration(Consumer<GetRuntimeLogConfigurationRequest.Builder> getRuntimeLogConfigurationRequest)

      Get the runtime log configuration for a specific managed thing or for all managed things as a group.


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

      Parameters:
      getRuntimeLogConfigurationRequest - A Consumer that will call methods on GetRuntimeLogConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetRuntimeLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getSchemaVersion

      default CompletableFuture<GetSchemaVersionResponse> getSchemaVersion(GetSchemaVersionRequest getSchemaVersionRequest)

      Gets a schema version with the provided information.

      Parameters:
      getSchemaVersionRequest -
      Returns:
      A Java Future containing the result of the GetSchemaVersion operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getSchemaVersion

      default CompletableFuture<GetSchemaVersionResponse> getSchemaVersion(Consumer<GetSchemaVersionRequest.Builder> getSchemaVersionRequest)

      Gets a schema version with the provided information.


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

      Parameters:
      getSchemaVersionRequest - A Consumer that will call methods on GetSchemaVersionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetSchemaVersion operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCredentialLockers

      default CompletableFuture<ListCredentialLockersResponse> listCredentialLockers(ListCredentialLockersRequest listCredentialLockersRequest)

      List information on an existing credential locker.

      Parameters:
      listCredentialLockersRequest -
      Returns:
      A Java Future containing the result of the ListCredentialLockers operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCredentialLockers

      default CompletableFuture<ListCredentialLockersResponse> listCredentialLockers(Consumer<ListCredentialLockersRequest.Builder> listCredentialLockersRequest)

      List information on an existing credential locker.


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

      Parameters:
      listCredentialLockersRequest - A Consumer that will call methods on ListCredentialLockersRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListCredentialLockers operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCredentialLockersPaginator

      default ListCredentialLockersPublisher listCredentialLockersPaginator(ListCredentialLockersRequest listCredentialLockersRequest)

      This is a variant of listCredentialLockers(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCredentialLockersRequest) 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.iotmanagedintegrations.paginators.ListCredentialLockersPublisher publisher = client.listCredentialLockersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListCredentialLockersPublisher publisher = client.listCredentialLockersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListCredentialLockersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCredentialLockersResponse 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 listCredentialLockers(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCredentialLockersRequest) operation.

      Parameters:
      listCredentialLockersRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCredentialLockersPaginator

      default ListCredentialLockersPublisher listCredentialLockersPaginator(Consumer<ListCredentialLockersRequest.Builder> listCredentialLockersRequest)

      This is a variant of listCredentialLockers(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCredentialLockersRequest) 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.iotmanagedintegrations.paginators.ListCredentialLockersPublisher publisher = client.listCredentialLockersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListCredentialLockersPublisher publisher = client.listCredentialLockersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListCredentialLockersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCredentialLockersResponse 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 listCredentialLockers(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCredentialLockersRequest) operation.


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

      Parameters:
      listCredentialLockersRequest - A Consumer that will call methods on ListCredentialLockersRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listDestinations

      default CompletableFuture<ListDestinationsResponse> listDestinations(ListDestinationsRequest listDestinationsRequest)

      List all destination names under one Amazon Web Services account.

      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listDestinations

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

      List all destination names under one Amazon Web Services account.


      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listDestinationsPaginator

      default ListDestinationsPublisher listDestinationsPaginator(ListDestinationsRequest listDestinationsRequest)

      This is a variant of listDestinations(software.amazon.awssdk.services.iotmanagedintegrations.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.iotmanagedintegrations.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.iotmanagedintegrations.paginators.ListDestinationsPublisher publisher = client.listDestinationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListDestinationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.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.iotmanagedintegrations.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listDestinationsPaginator

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

      This is a variant of listDestinations(software.amazon.awssdk.services.iotmanagedintegrations.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.iotmanagedintegrations.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.iotmanagedintegrations.paginators.ListDestinationsPublisher publisher = client.listDestinationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListDestinationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.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.iotmanagedintegrations.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEventLogConfigurations

      default CompletableFuture<ListEventLogConfigurationsResponse> listEventLogConfigurations(ListEventLogConfigurationsRequest listEventLogConfigurationsRequest)

      List all event log configurations for an account.

      Parameters:
      listEventLogConfigurationsRequest -
      Returns:
      A Java Future containing the result of the ListEventLogConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEventLogConfigurations

      default CompletableFuture<ListEventLogConfigurationsResponse> listEventLogConfigurations(Consumer<ListEventLogConfigurationsRequest.Builder> listEventLogConfigurationsRequest)

      List all event log configurations for an account.


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

      Parameters:
      listEventLogConfigurationsRequest - A Consumer that will call methods on ListEventLogConfigurationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListEventLogConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEventLogConfigurationsPaginator

      default ListEventLogConfigurationsPublisher listEventLogConfigurationsPaginator(ListEventLogConfigurationsRequest listEventLogConfigurationsRequest)

      This is a variant of listEventLogConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListEventLogConfigurationsRequest) 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.iotmanagedintegrations.paginators.ListEventLogConfigurationsPublisher publisher = client.listEventLogConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListEventLogConfigurationsPublisher publisher = client.listEventLogConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListEventLogConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListEventLogConfigurationsResponse 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 listEventLogConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListEventLogConfigurationsRequest) operation.

      Parameters:
      listEventLogConfigurationsRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEventLogConfigurationsPaginator

      default ListEventLogConfigurationsPublisher listEventLogConfigurationsPaginator(Consumer<ListEventLogConfigurationsRequest.Builder> listEventLogConfigurationsRequest)

      This is a variant of listEventLogConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListEventLogConfigurationsRequest) 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.iotmanagedintegrations.paginators.ListEventLogConfigurationsPublisher publisher = client.listEventLogConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListEventLogConfigurationsPublisher publisher = client.listEventLogConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListEventLogConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListEventLogConfigurationsResponse 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 listEventLogConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListEventLogConfigurationsRequest) operation.


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

      Parameters:
      listEventLogConfigurationsRequest - A Consumer that will call methods on ListEventLogConfigurationsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedThingSchemas

      default CompletableFuture<ListManagedThingSchemasResponse> listManagedThingSchemas(ListManagedThingSchemasRequest listManagedThingSchemasRequest)

      List schemas associated with a managed thing.

      Parameters:
      listManagedThingSchemasRequest -
      Returns:
      A Java Future containing the result of the ListManagedThingSchemas operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedThingSchemas

      default CompletableFuture<ListManagedThingSchemasResponse> listManagedThingSchemas(Consumer<ListManagedThingSchemasRequest.Builder> listManagedThingSchemasRequest)

      List schemas associated with a managed thing.


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

      Parameters:
      listManagedThingSchemasRequest - A Consumer that will call methods on ListManagedThingSchemasRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListManagedThingSchemas operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedThingSchemasPaginator

      default ListManagedThingSchemasPublisher listManagedThingSchemasPaginator(ListManagedThingSchemasRequest listManagedThingSchemasRequest)

      This is a variant of listManagedThingSchemas(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingSchemasRequest) 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.iotmanagedintegrations.paginators.ListManagedThingSchemasPublisher publisher = client.listManagedThingSchemasPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListManagedThingSchemasPublisher publisher = client.listManagedThingSchemasPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingSchemasResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingSchemasResponse 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 listManagedThingSchemas(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingSchemasRequest) operation.

      Parameters:
      listManagedThingSchemasRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedThingSchemasPaginator

      default ListManagedThingSchemasPublisher listManagedThingSchemasPaginator(Consumer<ListManagedThingSchemasRequest.Builder> listManagedThingSchemasRequest)

      This is a variant of listManagedThingSchemas(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingSchemasRequest) 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.iotmanagedintegrations.paginators.ListManagedThingSchemasPublisher publisher = client.listManagedThingSchemasPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListManagedThingSchemasPublisher publisher = client.listManagedThingSchemasPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingSchemasResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingSchemasResponse 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 listManagedThingSchemas(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingSchemasRequest) operation.


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

      Parameters:
      listManagedThingSchemasRequest - A Consumer that will call methods on ListManagedThingSchemasRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedThings

      default CompletableFuture<ListManagedThingsResponse> listManagedThings(ListManagedThingsRequest listManagedThingsRequest)

      List all of the associations and statuses for a managed thing by its owner.

      Parameters:
      listManagedThingsRequest -
      Returns:
      A Java Future containing the result of the ListManagedThings operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedThings

      default CompletableFuture<ListManagedThingsResponse> listManagedThings(Consumer<ListManagedThingsRequest.Builder> listManagedThingsRequest)

      List all of the associations and statuses for a managed thing by its owner.


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

      Parameters:
      listManagedThingsRequest - A Consumer that will call methods on ListManagedThingsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListManagedThings operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedThingsPaginator

      default ListManagedThingsPublisher listManagedThingsPaginator(ListManagedThingsRequest listManagedThingsRequest)

      This is a variant of listManagedThings(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingsRequest) 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.iotmanagedintegrations.paginators.ListManagedThingsPublisher publisher = client.listManagedThingsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListManagedThingsPublisher publisher = client.listManagedThingsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingsResponse 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 listManagedThings(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingsRequest) operation.

      Parameters:
      listManagedThingsRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedThingsPaginator

      default ListManagedThingsPublisher listManagedThingsPaginator(Consumer<ListManagedThingsRequest.Builder> listManagedThingsRequest)

      This is a variant of listManagedThings(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingsRequest) 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.iotmanagedintegrations.paginators.ListManagedThingsPublisher publisher = client.listManagedThingsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListManagedThingsPublisher publisher = client.listManagedThingsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingsResponse 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 listManagedThings(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingsRequest) operation.


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

      Parameters:
      listManagedThingsRequest - A Consumer that will call methods on ListManagedThingsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listNotificationConfigurations

      default CompletableFuture<ListNotificationConfigurationsResponse> listNotificationConfigurations(ListNotificationConfigurationsRequest listNotificationConfigurationsRequest)

      List all notification configurations.

      Parameters:
      listNotificationConfigurationsRequest -
      Returns:
      A Java Future containing the result of the ListNotificationConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listNotificationConfigurations

      default CompletableFuture<ListNotificationConfigurationsResponse> listNotificationConfigurations(Consumer<ListNotificationConfigurationsRequest.Builder> listNotificationConfigurationsRequest)

      List all notification configurations.


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

      Parameters:
      listNotificationConfigurationsRequest - A Consumer that will call methods on ListNotificationConfigurationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListNotificationConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listNotificationConfigurationsPaginator

      default ListNotificationConfigurationsPublisher listNotificationConfigurationsPaginator(ListNotificationConfigurationsRequest listNotificationConfigurationsRequest)

      This is a variant of listNotificationConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListNotificationConfigurationsRequest) 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.iotmanagedintegrations.paginators.ListNotificationConfigurationsPublisher publisher = client.listNotificationConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListNotificationConfigurationsPublisher publisher = client.listNotificationConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListNotificationConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListNotificationConfigurationsResponse 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 listNotificationConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListNotificationConfigurationsRequest) operation.

      Parameters:
      listNotificationConfigurationsRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listNotificationConfigurationsPaginator

      default ListNotificationConfigurationsPublisher listNotificationConfigurationsPaginator(Consumer<ListNotificationConfigurationsRequest.Builder> listNotificationConfigurationsRequest)

      This is a variant of listNotificationConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListNotificationConfigurationsRequest) 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.iotmanagedintegrations.paginators.ListNotificationConfigurationsPublisher publisher = client.listNotificationConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListNotificationConfigurationsPublisher publisher = client.listNotificationConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListNotificationConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListNotificationConfigurationsResponse 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 listNotificationConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListNotificationConfigurationsRequest) operation.


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

      Parameters:
      listNotificationConfigurationsRequest - A Consumer that will call methods on ListNotificationConfigurationsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTaskConfigurations

      default CompletableFuture<ListOtaTaskConfigurationsResponse> listOtaTaskConfigurations(ListOtaTaskConfigurationsRequest listOtaTaskConfigurationsRequest)

      List all of the over-the-air (OTA) task configurations.

      Parameters:
      listOtaTaskConfigurationsRequest -
      Returns:
      A Java Future containing the result of the ListOtaTaskConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTaskConfigurations

      default CompletableFuture<ListOtaTaskConfigurationsResponse> listOtaTaskConfigurations(Consumer<ListOtaTaskConfigurationsRequest.Builder> listOtaTaskConfigurationsRequest)

      List all of the over-the-air (OTA) task configurations.


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

      Parameters:
      listOtaTaskConfigurationsRequest - A Consumer that will call methods on ListOtaTaskConfigurationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListOtaTaskConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTaskConfigurationsPaginator

      default ListOtaTaskConfigurationsPublisher listOtaTaskConfigurationsPaginator(ListOtaTaskConfigurationsRequest listOtaTaskConfigurationsRequest)

      This is a variant of listOtaTaskConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskConfigurationsRequest) 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.iotmanagedintegrations.paginators.ListOtaTaskConfigurationsPublisher publisher = client.listOtaTaskConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListOtaTaskConfigurationsPublisher publisher = client.listOtaTaskConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskConfigurationsResponse 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 listOtaTaskConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskConfigurationsRequest) operation.

      Parameters:
      listOtaTaskConfigurationsRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTaskConfigurationsPaginator

      default ListOtaTaskConfigurationsPublisher listOtaTaskConfigurationsPaginator(Consumer<ListOtaTaskConfigurationsRequest.Builder> listOtaTaskConfigurationsRequest)

      This is a variant of listOtaTaskConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskConfigurationsRequest) 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.iotmanagedintegrations.paginators.ListOtaTaskConfigurationsPublisher publisher = client.listOtaTaskConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListOtaTaskConfigurationsPublisher publisher = client.listOtaTaskConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskConfigurationsResponse 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 listOtaTaskConfigurations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskConfigurationsRequest) operation.


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

      Parameters:
      listOtaTaskConfigurationsRequest - A Consumer that will call methods on ListOtaTaskConfigurationsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTaskExecutions

      default CompletableFuture<ListOtaTaskExecutionsResponse> listOtaTaskExecutions(ListOtaTaskExecutionsRequest listOtaTaskExecutionsRequest)

      List all of the over-the-air (OTA) task executions.

      Parameters:
      listOtaTaskExecutionsRequest -
      Returns:
      A Java Future containing the result of the ListOtaTaskExecutions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTaskExecutions

      default CompletableFuture<ListOtaTaskExecutionsResponse> listOtaTaskExecutions(Consumer<ListOtaTaskExecutionsRequest.Builder> listOtaTaskExecutionsRequest)

      List all of the over-the-air (OTA) task executions.


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

      Parameters:
      listOtaTaskExecutionsRequest - A Consumer that will call methods on ListOtaTaskExecutionsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListOtaTaskExecutions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTaskExecutionsPaginator

      default ListOtaTaskExecutionsPublisher listOtaTaskExecutionsPaginator(ListOtaTaskExecutionsRequest listOtaTaskExecutionsRequest)

      This is a variant of listOtaTaskExecutions(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskExecutionsRequest) 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.iotmanagedintegrations.paginators.ListOtaTaskExecutionsPublisher publisher = client.listOtaTaskExecutionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListOtaTaskExecutionsPublisher publisher = client.listOtaTaskExecutionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskExecutionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskExecutionsResponse 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 listOtaTaskExecutions(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskExecutionsRequest) operation.

      Parameters:
      listOtaTaskExecutionsRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTaskExecutionsPaginator

      default ListOtaTaskExecutionsPublisher listOtaTaskExecutionsPaginator(Consumer<ListOtaTaskExecutionsRequest.Builder> listOtaTaskExecutionsRequest)

      This is a variant of listOtaTaskExecutions(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskExecutionsRequest) 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.iotmanagedintegrations.paginators.ListOtaTaskExecutionsPublisher publisher = client.listOtaTaskExecutionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListOtaTaskExecutionsPublisher publisher = client.listOtaTaskExecutionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskExecutionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskExecutionsResponse 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 listOtaTaskExecutions(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTaskExecutionsRequest) operation.


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

      Parameters:
      listOtaTaskExecutionsRequest - A Consumer that will call methods on ListOtaTaskExecutionsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTasks

      default CompletableFuture<ListOtaTasksResponse> listOtaTasks(ListOtaTasksRequest listOtaTasksRequest)

      List all of the over-the-air (OTA) tasks.

      Parameters:
      listOtaTasksRequest -
      Returns:
      A Java Future containing the result of the ListOtaTasks operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTasks

      default CompletableFuture<ListOtaTasksResponse> listOtaTasks(Consumer<ListOtaTasksRequest.Builder> listOtaTasksRequest)

      List all of the over-the-air (OTA) tasks.


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

      Parameters:
      listOtaTasksRequest - A Consumer that will call methods on ListOtaTasksRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListOtaTasks operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTasksPaginator

      default ListOtaTasksPublisher listOtaTasksPaginator(ListOtaTasksRequest listOtaTasksRequest)

      This is a variant of listOtaTasks(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTasksRequest) 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.iotmanagedintegrations.paginators.ListOtaTasksPublisher publisher = client.listOtaTasksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListOtaTasksPublisher publisher = client.listOtaTasksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTasksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTasksResponse 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 listOtaTasks(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTasksRequest) operation.

      Parameters:
      listOtaTasksRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listOtaTasksPaginator

      default ListOtaTasksPublisher listOtaTasksPaginator(Consumer<ListOtaTasksRequest.Builder> listOtaTasksRequest)

      This is a variant of listOtaTasks(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTasksRequest) 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.iotmanagedintegrations.paginators.ListOtaTasksPublisher publisher = client.listOtaTasksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListOtaTasksPublisher publisher = client.listOtaTasksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTasksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTasksResponse 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 listOtaTasks(software.amazon.awssdk.services.iotmanagedintegrations.model.ListOtaTasksRequest) operation.


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

      Parameters:
      listOtaTasksRequest - A Consumer that will call methods on ListOtaTasksRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProvisioningProfiles

      default CompletableFuture<ListProvisioningProfilesResponse> listProvisioningProfiles(ListProvisioningProfilesRequest listProvisioningProfilesRequest)

      List the provisioning profiles within the Amazon Web Services account.

      Parameters:
      listProvisioningProfilesRequest -
      Returns:
      A Java Future containing the result of the ListProvisioningProfiles operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProvisioningProfiles

      default CompletableFuture<ListProvisioningProfilesResponse> listProvisioningProfiles(Consumer<ListProvisioningProfilesRequest.Builder> listProvisioningProfilesRequest)

      List the provisioning profiles within the Amazon Web Services account.


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

      Parameters:
      listProvisioningProfilesRequest - A Consumer that will call methods on ListProvisioningProfilesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListProvisioningProfiles operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProvisioningProfilesPaginator

      default ListProvisioningProfilesPublisher listProvisioningProfilesPaginator(ListProvisioningProfilesRequest listProvisioningProfilesRequest)

      This is a variant of listProvisioningProfiles(software.amazon.awssdk.services.iotmanagedintegrations.model.ListProvisioningProfilesRequest) 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.iotmanagedintegrations.paginators.ListProvisioningProfilesPublisher publisher = client.listProvisioningProfilesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListProvisioningProfilesPublisher publisher = client.listProvisioningProfilesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListProvisioningProfilesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListProvisioningProfilesResponse 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 listProvisioningProfiles(software.amazon.awssdk.services.iotmanagedintegrations.model.ListProvisioningProfilesRequest) operation.

      Parameters:
      listProvisioningProfilesRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProvisioningProfilesPaginator

      default ListProvisioningProfilesPublisher listProvisioningProfilesPaginator(Consumer<ListProvisioningProfilesRequest.Builder> listProvisioningProfilesRequest)

      This is a variant of listProvisioningProfiles(software.amazon.awssdk.services.iotmanagedintegrations.model.ListProvisioningProfilesRequest) 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.iotmanagedintegrations.paginators.ListProvisioningProfilesPublisher publisher = client.listProvisioningProfilesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListProvisioningProfilesPublisher publisher = client.listProvisioningProfilesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListProvisioningProfilesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListProvisioningProfilesResponse 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 listProvisioningProfiles(software.amazon.awssdk.services.iotmanagedintegrations.model.ListProvisioningProfilesRequest) operation.


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

      Parameters:
      listProvisioningProfilesRequest - A Consumer that will call methods on ListProvisioningProfilesRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSchemaVersions

      default CompletableFuture<ListSchemaVersionsResponse> listSchemaVersions(ListSchemaVersionsRequest listSchemaVersionsRequest)

      Lists schema versions with the provided information.

      Parameters:
      listSchemaVersionsRequest -
      Returns:
      A Java Future containing the result of the ListSchemaVersions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSchemaVersions

      default CompletableFuture<ListSchemaVersionsResponse> listSchemaVersions(Consumer<ListSchemaVersionsRequest.Builder> listSchemaVersionsRequest)

      Lists schema versions with the provided information.


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

      Parameters:
      listSchemaVersionsRequest - A Consumer that will call methods on ListSchemaVersionsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListSchemaVersions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSchemaVersionsPaginator

      default ListSchemaVersionsPublisher listSchemaVersionsPaginator(ListSchemaVersionsRequest listSchemaVersionsRequest)

      This is a variant of listSchemaVersions(software.amazon.awssdk.services.iotmanagedintegrations.model.ListSchemaVersionsRequest) 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.iotmanagedintegrations.paginators.ListSchemaVersionsPublisher publisher = client.listSchemaVersionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListSchemaVersionsPublisher publisher = client.listSchemaVersionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListSchemaVersionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListSchemaVersionsResponse 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 listSchemaVersions(software.amazon.awssdk.services.iotmanagedintegrations.model.ListSchemaVersionsRequest) operation.

      Parameters:
      listSchemaVersionsRequest -
      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSchemaVersionsPaginator

      default ListSchemaVersionsPublisher listSchemaVersionsPaginator(Consumer<ListSchemaVersionsRequest.Builder> listSchemaVersionsRequest)

      This is a variant of listSchemaVersions(software.amazon.awssdk.services.iotmanagedintegrations.model.ListSchemaVersionsRequest) 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.iotmanagedintegrations.paginators.ListSchemaVersionsPublisher publisher = client.listSchemaVersionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.iotmanagedintegrations.paginators.ListSchemaVersionsPublisher publisher = client.listSchemaVersionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListSchemaVersionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListSchemaVersionsResponse 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 listSchemaVersions(software.amazon.awssdk.services.iotmanagedintegrations.model.ListSchemaVersionsRequest) operation.


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

      Parameters:
      listSchemaVersionsRequest - A Consumer that will call methods on ListSchemaVersionsRequest.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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putDefaultEncryptionConfiguration

      default CompletableFuture<PutDefaultEncryptionConfigurationResponse> putDefaultEncryptionConfiguration(PutDefaultEncryptionConfigurationRequest putDefaultEncryptionConfigurationRequest)

      Sets the default encryption configuration for the Amazon Web Services account. For more information, see Key management in the AWS IoT SiteWise User Guide.

      Parameters:
      putDefaultEncryptionConfigurationRequest -
      Returns:
      A Java Future containing the result of the PutDefaultEncryptionConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalFailureException An unexpected error has occurred.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • ResourceNotFoundException The specified resource does not exist.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putDefaultEncryptionConfiguration

      default CompletableFuture<PutDefaultEncryptionConfigurationResponse> putDefaultEncryptionConfiguration(Consumer<PutDefaultEncryptionConfigurationRequest.Builder> putDefaultEncryptionConfigurationRequest)

      Sets the default encryption configuration for the Amazon Web Services account. For more information, see Key management in the AWS IoT SiteWise User Guide.


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

      Parameters:
      putDefaultEncryptionConfigurationRequest - A Consumer that will call methods on PutDefaultEncryptionConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the PutDefaultEncryptionConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalFailureException An unexpected error has occurred.
      • UnauthorizedException You are not authorized to perform this operation.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • ResourceNotFoundException The specified resource does not exist.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putHubConfiguration

      default CompletableFuture<PutHubConfigurationResponse> putHubConfiguration(PutHubConfigurationRequest putHubConfigurationRequest)

      Update a hub configuration.

      Parameters:
      putHubConfigurationRequest -
      Returns:
      A Java Future containing the result of the PutHubConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putHubConfiguration

      default CompletableFuture<PutHubConfigurationResponse> putHubConfiguration(Consumer<PutHubConfigurationRequest.Builder> putHubConfigurationRequest)

      Update a hub configuration.


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

      Parameters:
      putHubConfigurationRequest - A Consumer that will call methods on PutHubConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the PutHubConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putRuntimeLogConfiguration

      default CompletableFuture<PutRuntimeLogConfigurationResponse> putRuntimeLogConfiguration(PutRuntimeLogConfigurationRequest putRuntimeLogConfigurationRequest)

      Set the runtime log configuration for a specific managed thing or for all managed things as a group.

      Parameters:
      putRuntimeLogConfigurationRequest -
      Returns:
      A Java Future containing the result of the PutRuntimeLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putRuntimeLogConfiguration

      default CompletableFuture<PutRuntimeLogConfigurationResponse> putRuntimeLogConfiguration(Consumer<PutRuntimeLogConfigurationRequest.Builder> putRuntimeLogConfigurationRequest)

      Set the runtime log configuration for a specific managed thing or for all managed things as a group.


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

      Parameters:
      putRuntimeLogConfigurationRequest - A Consumer that will call methods on PutRuntimeLogConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the PutRuntimeLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • registerCustomEndpoint

      default CompletableFuture<RegisterCustomEndpointResponse> registerCustomEndpoint(RegisterCustomEndpointRequest registerCustomEndpointRequest)

      Customers can request IoT managed integrations to manage the server trust for them or bring their own external server trusts for the custom domain. Returns an IoT managed integrations endpoint.

      Parameters:
      registerCustomEndpointRequest -
      Returns:
      A Java Future containing the result of the RegisterCustomEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • registerCustomEndpoint

      default CompletableFuture<RegisterCustomEndpointResponse> registerCustomEndpoint(Consumer<RegisterCustomEndpointRequest.Builder> registerCustomEndpointRequest)

      Customers can request IoT managed integrations to manage the server trust for them or bring their own external server trusts for the custom domain. Returns an IoT managed integrations endpoint.


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

      Parameters:
      registerCustomEndpointRequest - A Consumer that will call methods on RegisterCustomEndpointRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RegisterCustomEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • resetRuntimeLogConfiguration

      default CompletableFuture<ResetRuntimeLogConfigurationResponse> resetRuntimeLogConfiguration(ResetRuntimeLogConfigurationRequest resetRuntimeLogConfigurationRequest)

      Reset a runtime log configuration for a specific managed thing or for all managed things as a group.

      Parameters:
      resetRuntimeLogConfigurationRequest -
      Returns:
      A Java Future containing the result of the ResetRuntimeLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • resetRuntimeLogConfiguration

      default CompletableFuture<ResetRuntimeLogConfigurationResponse> resetRuntimeLogConfiguration(Consumer<ResetRuntimeLogConfigurationRequest.Builder> resetRuntimeLogConfigurationRequest)

      Reset a runtime log configuration for a specific managed thing or for all managed things as a group.


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

      Parameters:
      resetRuntimeLogConfigurationRequest - A Consumer that will call methods on ResetRuntimeLogConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ResetRuntimeLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • sendManagedThingCommand

      default CompletableFuture<SendManagedThingCommandResponse> sendManagedThingCommand(SendManagedThingCommandRequest sendManagedThingCommandRequest)

      Send the command to the device represented by the managed thing.

      Parameters:
      sendManagedThingCommandRequest -
      Returns:
      A Java Future containing the result of the SendManagedThingCommand operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • sendManagedThingCommand

      default CompletableFuture<SendManagedThingCommandResponse> sendManagedThingCommand(Consumer<SendManagedThingCommandRequest.Builder> sendManagedThingCommandRequest)

      Send the command to the device represented by the managed thing.


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

      Parameters:
      sendManagedThingCommandRequest - A Consumer that will call methods on SendManagedThingCommandRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the SendManagedThingCommand operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startDeviceDiscovery

      default CompletableFuture<StartDeviceDiscoveryResponse> startDeviceDiscovery(StartDeviceDiscoveryRequest startDeviceDiscoveryRequest)

      During user-guided setup, this is used to start device discovery. The authentication material (install code) is passed as a message to the controller telling it to start the discovery.

      Parameters:
      startDeviceDiscoveryRequest -
      Returns:
      A Java Future containing the result of the StartDeviceDiscovery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startDeviceDiscovery

      default CompletableFuture<StartDeviceDiscoveryResponse> startDeviceDiscovery(Consumer<StartDeviceDiscoveryRequest.Builder> startDeviceDiscoveryRequest)

      During user-guided setup, this is used to start device discovery. The authentication material (install code) is passed as a message to the controller telling it to start the discovery.


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

      Parameters:
      startDeviceDiscoveryRequest - A Consumer that will call methods on StartDeviceDiscoveryRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartDeviceDiscovery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateDestination

      default CompletableFuture<UpdateDestinationResponse> updateDestination(UpdateDestinationRequest updateDestinationRequest)

      Update a destination specified by id.

      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateDestination

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

      Update a destination specified by id.


      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. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateEventLogConfiguration

      default CompletableFuture<UpdateEventLogConfigurationResponse> updateEventLogConfiguration(UpdateEventLogConfigurationRequest updateEventLogConfigurationRequest)

      Update an event log configuration by log configuration ID.

      Parameters:
      updateEventLogConfigurationRequest -
      Returns:
      A Java Future containing the result of the UpdateEventLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateEventLogConfiguration

      default CompletableFuture<UpdateEventLogConfigurationResponse> updateEventLogConfiguration(Consumer<UpdateEventLogConfigurationRequest.Builder> updateEventLogConfigurationRequest)

      Update an event log configuration by log configuration ID.


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

      Parameters:
      updateEventLogConfigurationRequest - A Consumer that will call methods on UpdateEventLogConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateEventLogConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateManagedThing

      default CompletableFuture<UpdateManagedThingResponse> updateManagedThing(UpdateManagedThingRequest updateManagedThingRequest)

      Update the attributes and capabilities associated with a managed thing.

      Parameters:
      updateManagedThingRequest -
      Returns:
      A Java Future containing the result of the UpdateManagedThing operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateManagedThing

      default CompletableFuture<UpdateManagedThingResponse> updateManagedThing(Consumer<UpdateManagedThingRequest.Builder> updateManagedThingRequest)

      Update the attributes and capabilities associated with a managed thing.


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

      Parameters:
      updateManagedThingRequest - A Consumer that will call methods on UpdateManagedThingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateManagedThing operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException A validation error occurred when performing the API request.
      • AccessDeniedException User is not authorized.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • ServiceUnavailableException The service is temporarily unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateNotificationConfiguration

      default CompletableFuture<UpdateNotificationConfigurationResponse> updateNotificationConfiguration(UpdateNotificationConfigurationRequest updateNotificationConfigurationRequest)

      Update a notification configuration.

      Parameters:
      updateNotificationConfigurationRequest -
      Returns:
      A Java Future containing the result of the UpdateNotificationConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateNotificationConfiguration

      default CompletableFuture<UpdateNotificationConfigurationResponse> updateNotificationConfiguration(Consumer<UpdateNotificationConfigurationRequest.Builder> updateNotificationConfigurationRequest)

      Update a notification configuration.


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

      Parameters:
      updateNotificationConfigurationRequest - A Consumer that will call methods on UpdateNotificationConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateNotificationConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateOtaTask

      default CompletableFuture<UpdateOtaTaskResponse> updateOtaTask(UpdateOtaTaskRequest updateOtaTaskRequest)

      Update an over-the-air (OTA) task.

      Parameters:
      updateOtaTaskRequest -
      Returns:
      A Java Future containing the result of the UpdateOtaTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateOtaTask

      default CompletableFuture<UpdateOtaTaskResponse> updateOtaTask(Consumer<UpdateOtaTaskRequest.Builder> updateOtaTaskRequest)

      Update an over-the-air (OTA) task.


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

      Parameters:
      updateOtaTaskRequest - A Consumer that will call methods on UpdateOtaTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateOtaTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • AccessDeniedException User is not authorized.
      • ValidationException A validation error occurred when performing the API request.
      • InternalServerException Internal error from the service that indicates an unexpected error or that the service is unavailable.
      • ResourceNotFoundException The specified resource does not exist.
      • ThrottlingException The rate exceeds the limit.
      • 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.
      • IotManagedIntegrationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • serviceClientConfiguration

      default IotManagedIntegrationsServiceClientConfiguration serviceClientConfiguration()
      Description copied from interface: SdkClient
      The SDK service client configuration exposes client settings to the user, e.g., ClientOverrideConfiguration
      Specified by:
      serviceClientConfiguration in interface AwsClient
      Specified by:
      serviceClientConfiguration in interface SdkClient
      Returns:
      SdkServiceClientConfiguration

    • create

      static IotManagedIntegrationsAsyncClient create()
      Create a IotManagedIntegrationsAsyncClient with the region loaded from the DefaultAwsRegionProviderChain and credentials loaded from the DefaultCredentialsProvider.

    • builder

      static IotManagedIntegrationsAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a IotManagedIntegrationsAsyncClient.