Interface IotManagedIntegrationsAsyncClient

All Superinterfaces:
AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
@Generated("software.amazon.awssdk:codegen") @SdkPublicApi @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

    • createAccountAssociation

      default CompletableFuture<CreateAccountAssociationResponse> createAccountAssociation(CreateAccountAssociationRequest createAccountAssociationRequest)

      Creates a new account association via the destination id.

      Parameters:
      createAccountAssociationRequest -
      Returns:
      A Java Future containing the result of the CreateAccountAssociation 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.
      • 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:

    • createAccountAssociation

      default CompletableFuture<CreateAccountAssociationResponse> createAccountAssociation(Consumer<CreateAccountAssociationRequest.Builder> createAccountAssociationRequest)

      Creates a new account association via the destination id.


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

      Parameters:
      createAccountAssociationRequest - A Consumer that will call methods on CreateAccountAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateAccountAssociation 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.
      • 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:

    • createCloudConnector

      default CompletableFuture<CreateCloudConnectorResponse> createCloudConnector(CreateCloudConnectorRequest createCloudConnectorRequest)

      Creates a C2C (cloud-to-cloud) connector.

      Parameters:
      createCloudConnectorRequest -
      Returns:
      A Java Future containing the result of the CreateCloudConnector 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:

    • createCloudConnector

      default CompletableFuture<CreateCloudConnectorResponse> createCloudConnector(Consumer<CreateCloudConnectorRequest.Builder> createCloudConnectorRequest)

      Creates a C2C (cloud-to-cloud) connector.


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

      Parameters:
      createCloudConnectorRequest - A Consumer that will call methods on CreateCloudConnectorRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateCloudConnector 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:

    • createConnectorDestination

      default CompletableFuture<CreateConnectorDestinationResponse> createConnectorDestination(CreateConnectorDestinationRequest createConnectorDestinationRequest)

      Create a connector destination for connecting a cloud-to-cloud (C2C) connector to the customer's Amazon Web Services account.

      Parameters:
      createConnectorDestinationRequest -
      Returns:
      A Java Future containing the result of the CreateConnectorDestination 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:

    • createConnectorDestination

      default CompletableFuture<CreateConnectorDestinationResponse> createConnectorDestination(Consumer<CreateConnectorDestinationRequest.Builder> createConnectorDestinationRequest)

      Create a connector destination for connecting a cloud-to-cloud (C2C) connector to the customer's Amazon Web Services account.


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

      Parameters:
      createConnectorDestinationRequest - A Consumer that will call methods on CreateConnectorDestinationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateConnectorDestination 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:

    • 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.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • 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:

    • 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.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • 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:

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

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

    • deleteAccountAssociation

      default CompletableFuture<DeleteAccountAssociationResponse> deleteAccountAssociation(DeleteAccountAssociationRequest deleteAccountAssociationRequest)

      Remove a third party account and related devices from an end user.

      Parameters:
      deleteAccountAssociationRequest -
      Returns:
      A Java Future containing the result of the DeleteAccountAssociation 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:

    • deleteAccountAssociation

      default CompletableFuture<DeleteAccountAssociationResponse> deleteAccountAssociation(Consumer<DeleteAccountAssociationRequest.Builder> deleteAccountAssociationRequest)

      Remove a third party account and related devices from an end user.


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

      Parameters:
      deleteAccountAssociationRequest - A Consumer that will call methods on DeleteAccountAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteAccountAssociation 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:

    • deleteCloudConnector

      default CompletableFuture<DeleteCloudConnectorResponse> deleteCloudConnector(DeleteCloudConnectorRequest deleteCloudConnectorRequest)

      Delete a cloud connector.

      Parameters:
      deleteCloudConnectorRequest -
      Returns:
      A Java Future containing the result of the DeleteCloudConnector 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:

    • deleteCloudConnector

      default CompletableFuture<DeleteCloudConnectorResponse> deleteCloudConnector(Consumer<DeleteCloudConnectorRequest.Builder> deleteCloudConnectorRequest)

      Delete a cloud connector.


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

      Parameters:
      deleteCloudConnectorRequest - A Consumer that will call methods on DeleteCloudConnectorRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteCloudConnector 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:

    • deleteConnectorDestination

      default CompletableFuture<DeleteConnectorDestinationResponse> deleteConnectorDestination(DeleteConnectorDestinationRequest deleteConnectorDestinationRequest)

      Delete a connector destination for connecting a cloud-to-cloud (C2C) connector to the customer's Amazon Web Services account.

      Parameters:
      deleteConnectorDestinationRequest -
      Returns:
      A Java Future containing the result of the DeleteConnectorDestination 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:

    • deleteConnectorDestination

      default CompletableFuture<DeleteConnectorDestinationResponse> deleteConnectorDestination(Consumer<DeleteConnectorDestinationRequest.Builder> deleteConnectorDestinationRequest)

      Delete a connector destination for connecting a cloud-to-cloud (C2C) connector to the customer's Amazon Web Services account.


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

      Parameters:
      deleteConnectorDestinationRequest - A Consumer that will call methods on DeleteConnectorDestinationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteConnectorDestination 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:

    • 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.
      • LimitExceededException The request exceeds a service limit or quota. Adjust your request parameters and try again.
      • 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.
      • LimitExceededException The request exceeds a service limit or quota. Adjust your request parameters and try again.
      • 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:

    • deregisterAccountAssociation

      default CompletableFuture<DeregisterAccountAssociationResponse> deregisterAccountAssociation(DeregisterAccountAssociationRequest deregisterAccountAssociationRequest)

      Deregisters an account association, removing the connection between a managed thing and a third-party account.

      Parameters:
      deregisterAccountAssociationRequest - Request for deregister a managed thing from account association
      Returns:
      A Java Future containing the result of the DeregisterAccountAssociation 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.
      • 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:

    • deregisterAccountAssociation

      default CompletableFuture<DeregisterAccountAssociationResponse> deregisterAccountAssociation(Consumer<DeregisterAccountAssociationRequest.Builder> deregisterAccountAssociationRequest)

      Deregisters an account association, removing the connection between a managed thing and a third-party account.


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

      Parameters:
      deregisterAccountAssociationRequest - A Consumer that will call methods on DeregisterAccountAssociationRequest.Builder to create a request. Request for deregister a managed thing from account association
      Returns:
      A Java Future containing the result of the DeregisterAccountAssociation 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.
      • 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:

    • getAccountAssociation

      default CompletableFuture<GetAccountAssociationResponse> getAccountAssociation(GetAccountAssociationRequest getAccountAssociationRequest)

      Get an account association for an Amazon Web Services account linked to a customer-managed destination.

      Parameters:
      getAccountAssociationRequest -
      Returns:
      A Java Future containing the result of the GetAccountAssociation 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:

    • getAccountAssociation

      default CompletableFuture<GetAccountAssociationResponse> getAccountAssociation(Consumer<GetAccountAssociationRequest.Builder> getAccountAssociationRequest)

      Get an account association for an Amazon Web Services account linked to a customer-managed destination.


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

      Parameters:
      getAccountAssociationRequest - A Consumer that will call methods on GetAccountAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetAccountAssociation 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:

    • getCloudConnector

      default CompletableFuture<GetCloudConnectorResponse> getCloudConnector(GetCloudConnectorRequest getCloudConnectorRequest)

      Gets all the information about a connector for a connector developer.

      Parameters:
      getCloudConnectorRequest -
      Returns:
      A Java Future containing the result of the GetCloudConnector 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:

    • getCloudConnector

      default CompletableFuture<GetCloudConnectorResponse> getCloudConnector(Consumer<GetCloudConnectorRequest.Builder> getCloudConnectorRequest)

      Gets all the information about a connector for a connector developer.


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

      Parameters:
      getCloudConnectorRequest - A Consumer that will call methods on GetCloudConnectorRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetCloudConnector 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:

    • getConnectorDestination

      default CompletableFuture<GetConnectorDestinationResponse> getConnectorDestination(GetConnectorDestinationRequest getConnectorDestinationRequest)

      Get a connector destination of a cloud-to-cloud (C2C) connector connecting to a customer's Amazon Web Services account.

      Parameters:
      getConnectorDestinationRequest -
      Returns:
      A Java Future containing the result of the GetConnectorDestination 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:

    • getConnectorDestination

      default CompletableFuture<GetConnectorDestinationResponse> getConnectorDestination(Consumer<GetConnectorDestinationRequest.Builder> getConnectorDestinationRequest)

      Get a connector destination of a cloud-to-cloud (C2C) connector connecting to a customer's Amazon Web Services account.


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

      Parameters:
      getConnectorDestinationRequest - A Consumer that will call methods on GetConnectorDestinationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetConnectorDestination 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:

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

      The managedThing metadata parameter is used for associating attributes with a managedThing that can be used for grouping over-the-air (OTA) tasks. Name value pairs in metadata can be used in the OtaTargetQueryString parameter for the CreateOtaTask API operation.

      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.

      The managedThing metadata parameter is used for associating attributes with a managedThing that can be used for grouping over-the-air (OTA) tasks. Name value pairs in metadata can be used in the OtaTargetQueryString parameter for the CreateOtaTask API operation.


      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:

    • listAccountAssociations

      default CompletableFuture<ListAccountAssociationsResponse> listAccountAssociations(ListAccountAssociationsRequest listAccountAssociationsRequest)

      Lists all account associations, with optional filtering by connector destination ID.

      Parameters:
      listAccountAssociationsRequest -
      Returns:
      A Java Future containing the result of the ListAccountAssociations 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:

    • listAccountAssociations

      default CompletableFuture<ListAccountAssociationsResponse> listAccountAssociations(Consumer<ListAccountAssociationsRequest.Builder> listAccountAssociationsRequest)

      Lists all account associations, with optional filtering by connector destination ID.


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

      Parameters:
      listAccountAssociationsRequest - A Consumer that will call methods on ListAccountAssociationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListAccountAssociations 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:

    • listAccountAssociationsPaginator

      default ListAccountAssociationsPublisher listAccountAssociationsPaginator(ListAccountAssociationsRequest listAccountAssociationsRequest)

      This is a variant of listAccountAssociations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListAccountAssociationsRequest) 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.ListAccountAssociationsPublisher publisher = client.listAccountAssociationsPaginator(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.ListAccountAssociationsPublisher publisher = client.listAccountAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListAccountAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListAccountAssociationsResponse 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 listAccountAssociations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListAccountAssociationsRequest) operation.

      Parameters:
      listAccountAssociationsRequest -
      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:

    • listAccountAssociationsPaginator

      default ListAccountAssociationsPublisher listAccountAssociationsPaginator(Consumer<ListAccountAssociationsRequest.Builder> listAccountAssociationsRequest)

      This is a variant of listAccountAssociations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListAccountAssociationsRequest) 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.ListAccountAssociationsPublisher publisher = client.listAccountAssociationsPaginator(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.ListAccountAssociationsPublisher publisher = client.listAccountAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListAccountAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListAccountAssociationsResponse 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 listAccountAssociations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListAccountAssociationsRequest) operation.


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

      Parameters:
      listAccountAssociationsRequest - A Consumer that will call methods on ListAccountAssociationsRequest.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:

    • listCloudConnectors

      default CompletableFuture<ListCloudConnectorsResponse> listCloudConnectors(ListCloudConnectorsRequest listCloudConnectorsRequest)

      Returns a list of connectors based on permissions.

      Parameters:
      listCloudConnectorsRequest -
      Returns:
      A Java Future containing the result of the ListCloudConnectors 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:

    • listCloudConnectors

      default CompletableFuture<ListCloudConnectorsResponse> listCloudConnectors(Consumer<ListCloudConnectorsRequest.Builder> listCloudConnectorsRequest)

      Returns a list of connectors based on permissions.


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

      Parameters:
      listCloudConnectorsRequest - A Consumer that will call methods on ListCloudConnectorsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListCloudConnectors 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:

    • listCloudConnectorsPaginator

      default ListCloudConnectorsPublisher listCloudConnectorsPaginator(ListCloudConnectorsRequest listCloudConnectorsRequest)

      This is a variant of listCloudConnectors(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCloudConnectorsRequest) 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.ListCloudConnectorsPublisher publisher = client.listCloudConnectorsPaginator(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.ListCloudConnectorsPublisher publisher = client.listCloudConnectorsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListCloudConnectorsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCloudConnectorsResponse 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 listCloudConnectors(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCloudConnectorsRequest) operation.

      Parameters:
      listCloudConnectorsRequest -
      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:

    • listCloudConnectorsPaginator

      default ListCloudConnectorsPublisher listCloudConnectorsPaginator(Consumer<ListCloudConnectorsRequest.Builder> listCloudConnectorsRequest)

      This is a variant of listCloudConnectors(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCloudConnectorsRequest) 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.ListCloudConnectorsPublisher publisher = client.listCloudConnectorsPaginator(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.ListCloudConnectorsPublisher publisher = client.listCloudConnectorsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListCloudConnectorsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCloudConnectorsResponse 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 listCloudConnectors(software.amazon.awssdk.services.iotmanagedintegrations.model.ListCloudConnectorsRequest) operation.


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

      Parameters:
      listCloudConnectorsRequest - A Consumer that will call methods on ListCloudConnectorsRequest.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:

    • listConnectorDestinations

      default CompletableFuture<ListConnectorDestinationsResponse> listConnectorDestinations(ListConnectorDestinationsRequest listConnectorDestinationsRequest)

      Lists all connector destinations, with optional filtering by cloud connector ID.

      Parameters:
      listConnectorDestinationsRequest -
      Returns:
      A Java Future containing the result of the ListConnectorDestinations 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:

    • listConnectorDestinations

      default CompletableFuture<ListConnectorDestinationsResponse> listConnectorDestinations(Consumer<ListConnectorDestinationsRequest.Builder> listConnectorDestinationsRequest)

      Lists all connector destinations, with optional filtering by cloud connector ID.


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

      Parameters:
      listConnectorDestinationsRequest - A Consumer that will call methods on ListConnectorDestinationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListConnectorDestinations 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:

    • listConnectorDestinationsPaginator

      default ListConnectorDestinationsPublisher listConnectorDestinationsPaginator(ListConnectorDestinationsRequest listConnectorDestinationsRequest)

      This is a variant of listConnectorDestinations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListConnectorDestinationsRequest) 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.ListConnectorDestinationsPublisher publisher = client.listConnectorDestinationsPaginator(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.ListConnectorDestinationsPublisher publisher = client.listConnectorDestinationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListConnectorDestinationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListConnectorDestinationsResponse 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 listConnectorDestinations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListConnectorDestinationsRequest) operation.

      Parameters:
      listConnectorDestinationsRequest -
      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:

    • listConnectorDestinationsPaginator

      default ListConnectorDestinationsPublisher listConnectorDestinationsPaginator(Consumer<ListConnectorDestinationsRequest.Builder> listConnectorDestinationsRequest)

      This is a variant of listConnectorDestinations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListConnectorDestinationsRequest) 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.ListConnectorDestinationsPublisher publisher = client.listConnectorDestinationsPaginator(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.ListConnectorDestinationsPublisher publisher = client.listConnectorDestinationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListConnectorDestinationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListConnectorDestinationsResponse 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 listConnectorDestinations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListConnectorDestinationsRequest) operation.


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

      Parameters:
      listConnectorDestinationsRequest - A Consumer that will call methods on ListConnectorDestinationsRequest.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:

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

    • listDeviceDiscoveries

      default CompletableFuture<ListDeviceDiscoveriesResponse> listDeviceDiscoveries(ListDeviceDiscoveriesRequest listDeviceDiscoveriesRequest)

      Lists all device discovery tasks, with optional filtering by type and status.

      Parameters:
      listDeviceDiscoveriesRequest -
      Returns:
      A Java Future containing the result of the ListDeviceDiscoveries 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:

    • listDeviceDiscoveries

      default CompletableFuture<ListDeviceDiscoveriesResponse> listDeviceDiscoveries(Consumer<ListDeviceDiscoveriesRequest.Builder> listDeviceDiscoveriesRequest)

      Lists all device discovery tasks, with optional filtering by type and status.


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

      Parameters:
      listDeviceDiscoveriesRequest - A Consumer that will call methods on ListDeviceDiscoveriesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListDeviceDiscoveries 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:

    • listDeviceDiscoveriesPaginator

      default ListDeviceDiscoveriesPublisher listDeviceDiscoveriesPaginator(ListDeviceDiscoveriesRequest listDeviceDiscoveriesRequest)

      This is a variant of listDeviceDiscoveries(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDeviceDiscoveriesRequest) 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.ListDeviceDiscoveriesPublisher publisher = client.listDeviceDiscoveriesPaginator(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.ListDeviceDiscoveriesPublisher publisher = client.listDeviceDiscoveriesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListDeviceDiscoveriesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDeviceDiscoveriesResponse 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 listDeviceDiscoveries(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDeviceDiscoveriesRequest) operation.

      Parameters:
      listDeviceDiscoveriesRequest -
      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:

    • listDeviceDiscoveriesPaginator

      default ListDeviceDiscoveriesPublisher listDeviceDiscoveriesPaginator(Consumer<ListDeviceDiscoveriesRequest.Builder> listDeviceDiscoveriesRequest)

      This is a variant of listDeviceDiscoveries(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDeviceDiscoveriesRequest) 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.ListDeviceDiscoveriesPublisher publisher = client.listDeviceDiscoveriesPaginator(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.ListDeviceDiscoveriesPublisher publisher = client.listDeviceDiscoveriesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListDeviceDiscoveriesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDeviceDiscoveriesResponse 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 listDeviceDiscoveries(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDeviceDiscoveriesRequest) operation.


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

      Parameters:
      listDeviceDiscoveriesRequest - A Consumer that will call methods on ListDeviceDiscoveriesRequest.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:

    • listDiscoveredDevices

      default CompletableFuture<ListDiscoveredDevicesResponse> listDiscoveredDevices(ListDiscoveredDevicesRequest listDiscoveredDevicesRequest)

      Lists all devices discovered during a specific device discovery task.

      Parameters:
      listDiscoveredDevicesRequest -
      Returns:
      A Java Future containing the result of the ListDiscoveredDevices 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:

    • listDiscoveredDevices

      default CompletableFuture<ListDiscoveredDevicesResponse> listDiscoveredDevices(Consumer<ListDiscoveredDevicesRequest.Builder> listDiscoveredDevicesRequest)

      Lists all devices discovered during a specific device discovery task.


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

      Parameters:
      listDiscoveredDevicesRequest - A Consumer that will call methods on ListDiscoveredDevicesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListDiscoveredDevices 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:

    • listDiscoveredDevicesPaginator

      default ListDiscoveredDevicesPublisher listDiscoveredDevicesPaginator(ListDiscoveredDevicesRequest listDiscoveredDevicesRequest)

      This is a variant of listDiscoveredDevices(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDiscoveredDevicesRequest) 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.ListDiscoveredDevicesPublisher publisher = client.listDiscoveredDevicesPaginator(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.ListDiscoveredDevicesPublisher publisher = client.listDiscoveredDevicesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListDiscoveredDevicesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDiscoveredDevicesResponse 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 listDiscoveredDevices(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDiscoveredDevicesRequest) operation.

      Parameters:
      listDiscoveredDevicesRequest -
      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:

    • listDiscoveredDevicesPaginator

      default ListDiscoveredDevicesPublisher listDiscoveredDevicesPaginator(Consumer<ListDiscoveredDevicesRequest.Builder> listDiscoveredDevicesRequest)

      This is a variant of listDiscoveredDevices(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDiscoveredDevicesRequest) 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.ListDiscoveredDevicesPublisher publisher = client.listDiscoveredDevicesPaginator(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.ListDiscoveredDevicesPublisher publisher = client.listDiscoveredDevicesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListDiscoveredDevicesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDiscoveredDevicesResponse 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 listDiscoveredDevices(software.amazon.awssdk.services.iotmanagedintegrations.model.ListDiscoveredDevicesRequest) operation.


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

      Parameters:
      listDiscoveredDevicesRequest - A Consumer that will call methods on ListDiscoveredDevicesRequest.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:

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

    • listManagedThingAccountAssociations

      default CompletableFuture<ListManagedThingAccountAssociationsResponse> listManagedThingAccountAssociations(ListManagedThingAccountAssociationsRequest listManagedThingAccountAssociationsRequest)

      Lists all account associations for a specific managed thing.

      Parameters:
      listManagedThingAccountAssociationsRequest -
      Returns:
      A Java Future containing the result of the ListManagedThingAccountAssociations 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:

    • listManagedThingAccountAssociations

      default CompletableFuture<ListManagedThingAccountAssociationsResponse> listManagedThingAccountAssociations(Consumer<ListManagedThingAccountAssociationsRequest.Builder> listManagedThingAccountAssociationsRequest)

      Lists all account associations for a specific managed thing.


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

      Parameters:
      listManagedThingAccountAssociationsRequest - A Consumer that will call methods on ListManagedThingAccountAssociationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListManagedThingAccountAssociations 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:

    • listManagedThingAccountAssociationsPaginator

      default ListManagedThingAccountAssociationsPublisher listManagedThingAccountAssociationsPaginator(ListManagedThingAccountAssociationsRequest listManagedThingAccountAssociationsRequest)

      This is a variant of listManagedThingAccountAssociations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingAccountAssociationsRequest) 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.ListManagedThingAccountAssociationsPublisher publisher = client.listManagedThingAccountAssociationsPaginator(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.ListManagedThingAccountAssociationsPublisher publisher = client.listManagedThingAccountAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingAccountAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingAccountAssociationsResponse 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 listManagedThingAccountAssociations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingAccountAssociationsRequest) operation.

      Parameters:
      listManagedThingAccountAssociationsRequest -
      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:

    • listManagedThingAccountAssociationsPaginator

      default ListManagedThingAccountAssociationsPublisher listManagedThingAccountAssociationsPaginator(Consumer<ListManagedThingAccountAssociationsRequest.Builder> listManagedThingAccountAssociationsRequest)

      This is a variant of listManagedThingAccountAssociations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingAccountAssociationsRequest) 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.ListManagedThingAccountAssociationsPublisher publisher = client.listManagedThingAccountAssociationsPaginator(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.ListManagedThingAccountAssociationsPublisher publisher = client.listManagedThingAccountAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingAccountAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingAccountAssociationsResponse 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 listManagedThingAccountAssociations(software.amazon.awssdk.services.iotmanagedintegrations.model.ListManagedThingAccountAssociationsRequest) operation.


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

      Parameters:
      listManagedThingAccountAssociationsRequest - A Consumer that will call methods on ListManagedThingAccountAssociationsRequest.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)

      Listing all managed things with provision for filters.

      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)

      Listing all managed things with provision for filters.


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

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

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

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

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

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

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

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

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

    • listTagsForResource

      default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest)

      List tags for the specified resource.

      Parameters:
      listTagsForResourceRequest -
      Returns:
      A Java Future containing the result of the ListTagsForResource 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.
      • UnauthorizedException You are not authorized to perform this operation.
      • InvalidRequestException The request is not valid.
      • 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:

    • listTagsForResource

      default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(Consumer<ListTagsForResourceRequest.Builder> listTagsForResourceRequest)

      List tags for the specified resource.


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

      Parameters:
      listTagsForResourceRequest - A Consumer that will call methods on ListTagsForResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTagsForResource 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.
      • UnauthorizedException You are not authorized to perform this operation.
      • InvalidRequestException The request is not valid.
      • 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:

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

    • registerAccountAssociation

      default CompletableFuture<RegisterAccountAssociationResponse> registerAccountAssociation(RegisterAccountAssociationRequest registerAccountAssociationRequest)

      Registers an account association with a managed thing, establishing a connection between a device and a third-party account.

      Parameters:
      registerAccountAssociationRequest -
      Returns:
      A Java Future containing the result of the RegisterAccountAssociation 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.
      • 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:

    • registerAccountAssociation

      default CompletableFuture<RegisterAccountAssociationResponse> registerAccountAssociation(Consumer<RegisterAccountAssociationRequest.Builder> registerAccountAssociationRequest)

      Registers an account association with a managed thing, establishing a connection between a device and a third-party account.


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

      Parameters:
      registerAccountAssociationRequest - A Consumer that will call methods on RegisterAccountAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RegisterAccountAssociation 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.
      • 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:

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

    • sendConnectorEvent

      default CompletableFuture<SendConnectorEventResponse> sendConnectorEvent(SendConnectorEventRequest sendConnectorEventRequest)

      Relays third-party device events for a connector such as a new device or a device state change event.

      Parameters:
      sendConnectorEventRequest -
      Returns:
      A Java Future containing the result of the SendConnectorEvent 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:

    • sendConnectorEvent

      default CompletableFuture<SendConnectorEventResponse> sendConnectorEvent(Consumer<SendConnectorEventRequest.Builder> sendConnectorEventRequest)

      Relays third-party device events for a connector such as a new device or a device state change event.


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

      Parameters:
      sendConnectorEventRequest - A Consumer that will call methods on SendConnectorEventRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the SendConnectorEvent 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(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.
      • 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:

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

    • startAccountAssociationRefresh

      default CompletableFuture<StartAccountAssociationRefreshResponse> startAccountAssociationRefresh(StartAccountAssociationRefreshRequest startAccountAssociationRefreshRequest)

      Initiates a refresh of an existing account association to update its authorization and connection status.

      Parameters:
      startAccountAssociationRefreshRequest -
      Returns:
      A Java Future containing the result of the StartAccountAssociationRefresh 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:

    • startAccountAssociationRefresh

      default CompletableFuture<StartAccountAssociationRefreshResponse> startAccountAssociationRefresh(Consumer<StartAccountAssociationRefreshRequest.Builder> startAccountAssociationRefreshRequest)

      Initiates a refresh of an existing account association to update its authorization and connection status.


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

      Parameters:
      startAccountAssociationRefreshRequest - A Consumer that will call methods on StartAccountAssociationRefreshRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartAccountAssociationRefresh 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)

      This API is used to start device discovery for hub-connected and third-party-connected devices. 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)

      This API is used to start device discovery for hub-connected and third-party-connected devices. 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:

    • tagResource

      default CompletableFuture<TagResourceResponse> tagResource(TagResourceRequest tagResourceRequest)

      Add tags for the specified resource.

      Parameters:
      tagResourceRequest -
      Returns:
      A Java Future containing the result of the TagResource 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.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • InvalidRequestException The request is not valid.
      • 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:

    • tagResource

      default CompletableFuture<TagResourceResponse> tagResource(Consumer<TagResourceRequest.Builder> tagResourceRequest)

      Add tags for the specified resource.


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

      Parameters:
      tagResourceRequest - A Consumer that will call methods on TagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TagResource 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.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • InvalidRequestException The request is not valid.
      • 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:

    • untagResource

      default CompletableFuture<UntagResourceResponse> untagResource(UntagResourceRequest untagResourceRequest)

      Remove tags for the specified resource.

      Parameters:
      untagResourceRequest -
      Returns:
      A Java Future containing the result of the UntagResource 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.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • InvalidRequestException The request is not valid.
      • 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:

    • untagResource

      default CompletableFuture<UntagResourceResponse> untagResource(Consumer<UntagResourceRequest.Builder> untagResourceRequest)

      Remove tags for the specified resource.


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

      Parameters:
      untagResourceRequest - A Consumer that will call methods on UntagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UntagResource 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.
      • UnauthorizedException You are not authorized to perform this operation.
      • ConflictException There is a conflict with the request.
      • InvalidRequestException The request is not valid.
      • 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:

    • updateAccountAssociation

      default CompletableFuture<UpdateAccountAssociationResponse> updateAccountAssociation(UpdateAccountAssociationRequest updateAccountAssociationRequest)

      Updates the properties of an existing account association.

      Parameters:
      updateAccountAssociationRequest -
      Returns:
      A Java Future containing the result of the UpdateAccountAssociation 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:

    • updateAccountAssociation

      default CompletableFuture<UpdateAccountAssociationResponse> updateAccountAssociation(Consumer<UpdateAccountAssociationRequest.Builder> updateAccountAssociationRequest)

      Updates the properties of an existing account association.


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

      Parameters:
      updateAccountAssociationRequest - A Consumer that will call methods on UpdateAccountAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateAccountAssociation 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:

    • updateCloudConnector

      default CompletableFuture<UpdateCloudConnectorResponse> updateCloudConnector(UpdateCloudConnectorRequest updateCloudConnectorRequest)

      Update an existing cloud connector.

      Parameters:
      updateCloudConnectorRequest -
      Returns:
      A Java Future containing the result of the UpdateCloudConnector 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:

    • updateCloudConnector

      default CompletableFuture<UpdateCloudConnectorResponse> updateCloudConnector(Consumer<UpdateCloudConnectorRequest.Builder> updateCloudConnectorRequest)

      Update an existing cloud connector.


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

      Parameters:
      updateCloudConnectorRequest - A Consumer that will call methods on UpdateCloudConnectorRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateCloudConnector 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:

    • updateConnectorDestination

      default CompletableFuture<UpdateConnectorDestinationResponse> updateConnectorDestination(UpdateConnectorDestinationRequest updateConnectorDestinationRequest)

      Updates the properties of an existing connector destination.

      Parameters:
      updateConnectorDestinationRequest -
      Returns:
      A Java Future containing the result of the UpdateConnectorDestination 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:

    • updateConnectorDestination

      default CompletableFuture<UpdateConnectorDestinationResponse> updateConnectorDestination(Consumer<UpdateConnectorDestinationRequest.Builder> updateConnectorDestinationRequest)

      Updates the properties of an existing connector destination.


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

      Parameters:
      updateConnectorDestinationRequest - A Consumer that will call methods on UpdateConnectorDestinationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateConnectorDestination 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(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.