Interface B2BiAsyncClient

All Superinterfaces:
AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
@Generated("software.amazon.awssdk:codegen") @ThreadSafe public interface B2BiAsyncClient extends AwsClient
Service client for accessing AWS B2BI 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.

This is the Amazon Web Services B2B Data Interchange API Reference. It provides descriptions, API request parameters, and the XML response for each of the B2BI API actions.

B2BI enables automated exchange of EDI (electronic data interchange) based business-critical transactions at cloud scale, with elasticity and pay-as-you-go pricing. Businesses use EDI documents to exchange transactional data with trading partners, such as suppliers and end customers, using standardized formats such as X12.

Rather than actually running a command, you can use the --generate-cli-skeleton parameter with any API call to generate and display a parameter template. You can then use the generated template to customize and use as input on a later command. For details, see Generate and use a parameter skeleton file.

  • Field Details

  • Method Details

    • createCapability

      default CompletableFuture<CreateCapabilityResponse> createCapability(CreateCapabilityRequest createCapabilityRequest)

      Instantiates a capability based on the specified parameters. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.

      Parameters:
      createCapabilityRequest -
      Returns:
      A Java Future containing the result of the CreateCapability operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createCapability

      default CompletableFuture<CreateCapabilityResponse> createCapability(Consumer<CreateCapabilityRequest.Builder> createCapabilityRequest)

      Instantiates a capability based on the specified parameters. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.


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

      Parameters:
      createCapabilityRequest - A Consumer that will call methods on CreateCapabilityRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateCapability operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createPartnership

      default CompletableFuture<CreatePartnershipResponse> createPartnership(CreatePartnershipRequest createPartnershipRequest)

      Creates a partnership between a customer and a trading partner, based on the supplied parameters. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.

      Parameters:
      createPartnershipRequest -
      Returns:
      A Java Future containing the result of the CreatePartnership operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createPartnership

      default CompletableFuture<CreatePartnershipResponse> createPartnership(Consumer<CreatePartnershipRequest.Builder> createPartnershipRequest)

      Creates a partnership between a customer and a trading partner, based on the supplied parameters. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.


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

      Parameters:
      createPartnershipRequest - A Consumer that will call methods on CreatePartnershipRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreatePartnership operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createProfile

      default CompletableFuture<CreateProfileResponse> createProfile(CreateProfileRequest createProfileRequest)

      Creates a customer profile. You can have up to five customer profiles, each representing a distinct private network. A profile is the mechanism used to create the concept of a private network.

      Parameters:
      createProfileRequest -
      Returns:
      A Java Future containing the result of the CreateProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createProfile

      default CompletableFuture<CreateProfileResponse> createProfile(Consumer<CreateProfileRequest.Builder> createProfileRequest)

      Creates a customer profile. You can have up to five customer profiles, each representing a distinct private network. A profile is the mechanism used to create the concept of a private network.


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

      Parameters:
      createProfileRequest - A Consumer that will call methods on CreateProfileRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createStarterMappingTemplate

      default CompletableFuture<CreateStarterMappingTemplateResponse> createStarterMappingTemplate(CreateStarterMappingTemplateRequest createStarterMappingTemplateRequest)

      Amazon Web Services B2B Data Interchange uses a mapping template in JSONata or XSLT format to transform a customer input file into a JSON or XML file that can be converted to EDI.

      If you provide a sample EDI file with the same structure as the EDI files that you wish to generate, then the service can generate a mapping template. The starter template contains placeholder values which you can replace with JSONata or XSLT expressions to take data from your input file and insert it into the JSON or XML file that is used to generate the EDI.

      If you do not provide a sample EDI file, then the service can generate a mapping template based on the EDI settings in the templateDetails parameter.

      Currently, we only support generating a template that can generate the input to produce an Outbound X12 EDI file.

      Parameters:
      createStarterMappingTemplateRequest -
      Returns:
      A Java Future containing the result of the CreateStarterMappingTemplate operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createStarterMappingTemplate

      default CompletableFuture<CreateStarterMappingTemplateResponse> createStarterMappingTemplate(Consumer<CreateStarterMappingTemplateRequest.Builder> createStarterMappingTemplateRequest)

      Amazon Web Services B2B Data Interchange uses a mapping template in JSONata or XSLT format to transform a customer input file into a JSON or XML file that can be converted to EDI.

      If you provide a sample EDI file with the same structure as the EDI files that you wish to generate, then the service can generate a mapping template. The starter template contains placeholder values which you can replace with JSONata or XSLT expressions to take data from your input file and insert it into the JSON or XML file that is used to generate the EDI.

      If you do not provide a sample EDI file, then the service can generate a mapping template based on the EDI settings in the templateDetails parameter.

      Currently, we only support generating a template that can generate the input to produce an Outbound X12 EDI file.


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

      Parameters:
      createStarterMappingTemplateRequest - A Consumer that will call methods on CreateStarterMappingTemplateRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateStarterMappingTemplate operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createTransformer

      default CompletableFuture<CreateTransformerResponse> createTransformer(CreateTransformerRequest createTransformerRequest)

      Creates a transformer. Amazon Web Services B2B Data Interchange currently supports two scenarios:

      • Inbound EDI: the Amazon Web Services customer receives an EDI file from their trading partner. Amazon Web Services B2B Data Interchange converts this EDI file into a JSON or XML file with a service-defined structure. A mapping template provided by the customer, in JSONata or XSLT format, is optionally applied to this file to produce a JSON or XML file with the structure the customer requires.

      • Outbound EDI: the Amazon Web Services customer has a JSON or XML file containing data that they wish to use in an EDI file. A mapping template, provided by the customer (in either JSONata or XSLT format) is applied to this file to generate a JSON or XML file in the service-defined structure. This file is then converted to an EDI file.

      The following fields are provided for backwards compatibility only: fileFormat, mappingTemplate, ediType, and sampleDocument.

      • Use the mapping data type in place of mappingTemplate and fileFormat

      • Use the sampleDocuments data type in place of sampleDocument

      • Use either the inputConversion or outputConversion in place of ediType

      Parameters:
      createTransformerRequest -
      Returns:
      A Java Future containing the result of the CreateTransformer operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createTransformer

      default CompletableFuture<CreateTransformerResponse> createTransformer(Consumer<CreateTransformerRequest.Builder> createTransformerRequest)

      Creates a transformer. Amazon Web Services B2B Data Interchange currently supports two scenarios:

      • Inbound EDI: the Amazon Web Services customer receives an EDI file from their trading partner. Amazon Web Services B2B Data Interchange converts this EDI file into a JSON or XML file with a service-defined structure. A mapping template provided by the customer, in JSONata or XSLT format, is optionally applied to this file to produce a JSON or XML file with the structure the customer requires.

      • Outbound EDI: the Amazon Web Services customer has a JSON or XML file containing data that they wish to use in an EDI file. A mapping template, provided by the customer (in either JSONata or XSLT format) is applied to this file to generate a JSON or XML file in the service-defined structure. This file is then converted to an EDI file.

      The following fields are provided for backwards compatibility only: fileFormat, mappingTemplate, ediType, and sampleDocument.

      • Use the mapping data type in place of mappingTemplate and fileFormat

      • Use the sampleDocuments data type in place of sampleDocument

      • Use either the inputConversion or outputConversion in place of ediType


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

      Parameters:
      createTransformerRequest - A Consumer that will call methods on CreateTransformerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateTransformer operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteCapability

      default CompletableFuture<DeleteCapabilityResponse> deleteCapability(DeleteCapabilityRequest deleteCapabilityRequest)

      Deletes the specified capability. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.

      Parameters:
      deleteCapabilityRequest -
      Returns:
      A Java Future containing the result of the DeleteCapability operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteCapability

      default CompletableFuture<DeleteCapabilityResponse> deleteCapability(Consumer<DeleteCapabilityRequest.Builder> deleteCapabilityRequest)

      Deletes the specified capability. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.


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

      Parameters:
      deleteCapabilityRequest - A Consumer that will call methods on DeleteCapabilityRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteCapability operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deletePartnership

      default CompletableFuture<DeletePartnershipResponse> deletePartnership(DeletePartnershipRequest deletePartnershipRequest)

      Deletes the specified partnership. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.

      Parameters:
      deletePartnershipRequest -
      Returns:
      A Java Future containing the result of the DeletePartnership operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deletePartnership

      default CompletableFuture<DeletePartnershipResponse> deletePartnership(Consumer<DeletePartnershipRequest.Builder> deletePartnershipRequest)

      Deletes the specified partnership. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.


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

      Parameters:
      deletePartnershipRequest - A Consumer that will call methods on DeletePartnershipRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeletePartnership operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteProfile

      default CompletableFuture<DeleteProfileResponse> deleteProfile(DeleteProfileRequest deleteProfileRequest)

      Deletes the specified profile. A profile is the mechanism used to create the concept of a private network.

      Parameters:
      deleteProfileRequest -
      Returns:
      A Java Future containing the result of the DeleteProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteProfile

      default CompletableFuture<DeleteProfileResponse> deleteProfile(Consumer<DeleteProfileRequest.Builder> deleteProfileRequest)

      Deletes the specified profile. A profile is the mechanism used to create the concept of a private network.


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

      Parameters:
      deleteProfileRequest - A Consumer that will call methods on DeleteProfileRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteTransformer

      default CompletableFuture<DeleteTransformerResponse> deleteTransformer(DeleteTransformerRequest deleteTransformerRequest)

      Deletes the specified transformer. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.

      Parameters:
      deleteTransformerRequest -
      Returns:
      A Java Future containing the result of the DeleteTransformer operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteTransformer

      default CompletableFuture<DeleteTransformerResponse> deleteTransformer(Consumer<DeleteTransformerRequest.Builder> deleteTransformerRequest)

      Deletes the specified transformer. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.


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

      Parameters:
      deleteTransformerRequest - A Consumer that will call methods on DeleteTransformerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteTransformer operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • generateMapping

      default CompletableFuture<GenerateMappingResponse> generateMapping(GenerateMappingRequest generateMappingRequest)

      Takes sample input and output documents and uses Amazon Bedrock to generate a mapping automatically. Depending on the accuracy and other factors, you can then edit the mapping for your needs.

      Before you can use the AI-assisted feature for Amazon Web Services B2B Data Interchange you must enable models in Amazon Bedrock. For details, see AI-assisted template mapping prerequisites in the Amazon Web Services B2B Data Interchange User guide.

      Parameters:
      generateMappingRequest -
      Returns:
      A Java Future containing the result of the GenerateMapping operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • generateMapping

      default CompletableFuture<GenerateMappingResponse> generateMapping(Consumer<GenerateMappingRequest.Builder> generateMappingRequest)

      Takes sample input and output documents and uses Amazon Bedrock to generate a mapping automatically. Depending on the accuracy and other factors, you can then edit the mapping for your needs.

      Before you can use the AI-assisted feature for Amazon Web Services B2B Data Interchange you must enable models in Amazon Bedrock. For details, see AI-assisted template mapping prerequisites in the Amazon Web Services B2B Data Interchange User guide.


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

      Parameters:
      generateMappingRequest - A Consumer that will call methods on GenerateMappingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GenerateMapping operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCapability

      default CompletableFuture<GetCapabilityResponse> getCapability(GetCapabilityRequest getCapabilityRequest)

      Retrieves the details for the specified capability. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.

      Parameters:
      getCapabilityRequest -
      Returns:
      A Java Future containing the result of the GetCapability operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCapability

      default CompletableFuture<GetCapabilityResponse> getCapability(Consumer<GetCapabilityRequest.Builder> getCapabilityRequest)

      Retrieves the details for the specified capability. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.


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

      Parameters:
      getCapabilityRequest - A Consumer that will call methods on GetCapabilityRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetCapability operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getPartnership

      default CompletableFuture<GetPartnershipResponse> getPartnership(GetPartnershipRequest getPartnershipRequest)

      Retrieves the details for a partnership, based on the partner and profile IDs specified. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.

      Parameters:
      getPartnershipRequest -
      Returns:
      A Java Future containing the result of the GetPartnership operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getPartnership

      default CompletableFuture<GetPartnershipResponse> getPartnership(Consumer<GetPartnershipRequest.Builder> getPartnershipRequest)

      Retrieves the details for a partnership, based on the partner and profile IDs specified. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.


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

      Parameters:
      getPartnershipRequest - A Consumer that will call methods on GetPartnershipRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetPartnership operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getProfile

      default CompletableFuture<GetProfileResponse> getProfile(GetProfileRequest getProfileRequest)

      Retrieves the details for the profile specified by the profile ID. A profile is the mechanism used to create the concept of a private network.

      Parameters:
      getProfileRequest -
      Returns:
      A Java Future containing the result of the GetProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getProfile

      default CompletableFuture<GetProfileResponse> getProfile(Consumer<GetProfileRequest.Builder> getProfileRequest)

      Retrieves the details for the profile specified by the profile ID. A profile is the mechanism used to create the concept of a private network.


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

      Parameters:
      getProfileRequest - A Consumer that will call methods on GetProfileRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTransformer

      default CompletableFuture<GetTransformerResponse> getTransformer(GetTransformerRequest getTransformerRequest)

      Retrieves the details for the transformer specified by the transformer ID. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.

      Parameters:
      getTransformerRequest -
      Returns:
      A Java Future containing the result of the GetTransformer operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTransformer

      default CompletableFuture<GetTransformerResponse> getTransformer(Consumer<GetTransformerRequest.Builder> getTransformerRequest)

      Retrieves the details for the transformer specified by the transformer ID. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.


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

      Parameters:
      getTransformerRequest - A Consumer that will call methods on GetTransformerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetTransformer operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTransformerJob

      default CompletableFuture<GetTransformerJobResponse> getTransformerJob(GetTransformerJobRequest getTransformerJobRequest)

      Returns the details of the transformer run, based on the Transformer job ID.

      Parameters:
      getTransformerJobRequest -
      Returns:
      A Java Future containing the result of the GetTransformerJob operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTransformerJob

      default CompletableFuture<GetTransformerJobResponse> getTransformerJob(Consumer<GetTransformerJobRequest.Builder> getTransformerJobRequest)

      Returns the details of the transformer run, based on the Transformer job ID.


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

      Parameters:
      getTransformerJobRequest - A Consumer that will call methods on GetTransformerJobRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetTransformerJob operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCapabilities

      default CompletableFuture<ListCapabilitiesResponse> listCapabilities(ListCapabilitiesRequest listCapabilitiesRequest)

      Lists the capabilities associated with your Amazon Web Services account for your current or specified region. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.

      Parameters:
      listCapabilitiesRequest -
      Returns:
      A Java Future containing the result of the ListCapabilities operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCapabilities

      default CompletableFuture<ListCapabilitiesResponse> listCapabilities(Consumer<ListCapabilitiesRequest.Builder> listCapabilitiesRequest)

      Lists the capabilities associated with your Amazon Web Services account for your current or specified region. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.


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

      Parameters:
      listCapabilitiesRequest - A Consumer that will call methods on ListCapabilitiesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListCapabilities operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCapabilitiesPaginator

      default ListCapabilitiesPublisher listCapabilitiesPaginator(ListCapabilitiesRequest listCapabilitiesRequest)

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

      Parameters:
      listCapabilitiesRequest -
      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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCapabilitiesPaginator

      default ListCapabilitiesPublisher listCapabilitiesPaginator(Consumer<ListCapabilitiesRequest.Builder> listCapabilitiesRequest)

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


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

      Parameters:
      listCapabilitiesRequest - A Consumer that will call methods on ListCapabilitiesRequest.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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPartnerships

      default CompletableFuture<ListPartnershipsResponse> listPartnerships(ListPartnershipsRequest listPartnershipsRequest)

      Lists the partnerships associated with your Amazon Web Services account for your current or specified region. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.

      Parameters:
      listPartnershipsRequest -
      Returns:
      A Java Future containing the result of the ListPartnerships operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPartnerships

      default CompletableFuture<ListPartnershipsResponse> listPartnerships(Consumer<ListPartnershipsRequest.Builder> listPartnershipsRequest)

      Lists the partnerships associated with your Amazon Web Services account for your current or specified region. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.


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

      Parameters:
      listPartnershipsRequest - A Consumer that will call methods on ListPartnershipsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListPartnerships operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPartnershipsPaginator

      default ListPartnershipsPublisher listPartnershipsPaginator(ListPartnershipsRequest listPartnershipsRequest)

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

      Parameters:
      listPartnershipsRequest -
      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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPartnershipsPaginator

      default ListPartnershipsPublisher listPartnershipsPaginator(Consumer<ListPartnershipsRequest.Builder> listPartnershipsRequest)

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


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

      Parameters:
      listPartnershipsRequest - A Consumer that will call methods on ListPartnershipsRequest.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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProfiles

      default CompletableFuture<ListProfilesResponse> listProfiles(ListProfilesRequest listProfilesRequest)

      Lists the profiles associated with your Amazon Web Services account for your current or specified region. A profile is the mechanism used to create the concept of a private network.

      Parameters:
      listProfilesRequest -
      Returns:
      A Java Future containing the result of the ListProfiles operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProfiles

      default CompletableFuture<ListProfilesResponse> listProfiles(Consumer<ListProfilesRequest.Builder> listProfilesRequest)

      Lists the profiles associated with your Amazon Web Services account for your current or specified region. A profile is the mechanism used to create the concept of a private network.


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

      Parameters:
      listProfilesRequest - A Consumer that will call methods on ListProfilesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListProfiles operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProfilesPaginator

      default ListProfilesPublisher listProfilesPaginator(ListProfilesRequest listProfilesRequest)

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

      Parameters:
      listProfilesRequest -
      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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProfilesPaginator

      default ListProfilesPublisher listProfilesPaginator(Consumer<ListProfilesRequest.Builder> listProfilesRequest)

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


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

      Parameters:
      listProfilesRequest - A Consumer that will call methods on ListProfilesRequest.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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException 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)

      Lists all of the tags associated with the Amazon Resource Name (ARN) that you specify. The resource can be a capability, partnership, profile, or transformer.

      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.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException 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)

      Lists all of the tags associated with the Amazon Resource Name (ARN) that you specify. The resource can be a capability, partnership, profile, or transformer.


      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.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTransformers

      default CompletableFuture<ListTransformersResponse> listTransformers(ListTransformersRequest listTransformersRequest)

      Lists the available transformers. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.

      Parameters:
      listTransformersRequest -
      Returns:
      A Java Future containing the result of the ListTransformers operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTransformers

      default CompletableFuture<ListTransformersResponse> listTransformers(Consumer<ListTransformersRequest.Builder> listTransformersRequest)

      Lists the available transformers. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.


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

      Parameters:
      listTransformersRequest - A Consumer that will call methods on ListTransformersRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTransformers operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTransformersPaginator

      default ListTransformersPublisher listTransformersPaginator(ListTransformersRequest listTransformersRequest)

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

      Parameters:
      listTransformersRequest -
      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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTransformersPaginator

      default ListTransformersPublisher listTransformersPaginator(Consumer<ListTransformersRequest.Builder> listTransformersRequest)

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


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

      Parameters:
      listTransformersRequest - A Consumer that will call methods on ListTransformersRequest.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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startTransformerJob

      default CompletableFuture<StartTransformerJobResponse> startTransformerJob(StartTransformerJobRequest startTransformerJobRequest)

      Runs a job, using a transformer, to parse input EDI (electronic data interchange) file into the output structures used by Amazon Web Services B2B Data Interchange.

      If you only want to transform EDI (electronic data interchange) documents, you don't need to create profiles, partnerships or capabilities. Just create and configure a transformer, and then run the StartTransformerJob API to process your files.

      Parameters:
      startTransformerJobRequest -
      Returns:
      A Java Future containing the result of the StartTransformerJob operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startTransformerJob

      default CompletableFuture<StartTransformerJobResponse> startTransformerJob(Consumer<StartTransformerJobRequest.Builder> startTransformerJobRequest)

      Runs a job, using a transformer, to parse input EDI (electronic data interchange) file into the output structures used by Amazon Web Services B2B Data Interchange.

      If you only want to transform EDI (electronic data interchange) documents, you don't need to create profiles, partnerships or capabilities. Just create and configure a transformer, and then run the StartTransformerJob API to process your files.


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

      Parameters:
      startTransformerJobRequest - A Consumer that will call methods on StartTransformerJobRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartTransformerJob operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException 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)

      Attaches a key-value pair to a resource, as identified by its Amazon Resource Name (ARN). Resources are capability, partnership, profile, transformers and other entities.

      There is no response returned from this call.

      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.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException 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)

      Attaches a key-value pair to a resource, as identified by its Amazon Resource Name (ARN). Resources are capability, partnership, profile, transformers and other entities.

      There is no response returned from this call.


      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.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • testConversion

      default CompletableFuture<TestConversionResponse> testConversion(TestConversionRequest testConversionRequest)

      This operation mimics the latter half of a typical Outbound EDI request. It takes an input JSON/XML in the B2Bi shape as input, converts it to an X12 EDI string, and return that string.

      Parameters:
      testConversionRequest -
      Returns:
      A Java Future containing the result of the TestConversion operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • testConversion

      default CompletableFuture<TestConversionResponse> testConversion(Consumer<TestConversionRequest.Builder> testConversionRequest)

      This operation mimics the latter half of a typical Outbound EDI request. It takes an input JSON/XML in the B2Bi shape as input, converts it to an X12 EDI string, and return that string.


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

      Parameters:
      testConversionRequest - A Consumer that will call methods on TestConversionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TestConversion operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • testMapping

      default CompletableFuture<TestMappingResponse> testMapping(TestMappingRequest testMappingRequest)

      Maps the input file according to the provided template file. The API call downloads the file contents from the Amazon S3 location, and passes the contents in as a string, to the inputFileContent parameter.

      Parameters:
      testMappingRequest -
      Returns:
      A Java Future containing the result of the TestMapping operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • testMapping

      default CompletableFuture<TestMappingResponse> testMapping(Consumer<TestMappingRequest.Builder> testMappingRequest)

      Maps the input file according to the provided template file. The API call downloads the file contents from the Amazon S3 location, and passes the contents in as a string, to the inputFileContent parameter.


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

      Parameters:
      testMappingRequest - A Consumer that will call methods on TestMappingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TestMapping operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • testParsing

      default CompletableFuture<TestParsingResponse> testParsing(TestParsingRequest testParsingRequest)

      Parses the input EDI (electronic data interchange) file. The input file has a file size limit of 250 KB.

      Parameters:
      testParsingRequest -
      Returns:
      A Java Future containing the result of the TestParsing operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • testParsing

      default CompletableFuture<TestParsingResponse> testParsing(Consumer<TestParsingRequest.Builder> testParsingRequest)

      Parses the input EDI (electronic data interchange) file. The input file has a file size limit of 250 KB.


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

      Parameters:
      testParsingRequest - A Consumer that will call methods on TestParsingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TestParsing operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException 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)

      Detaches a key-value pair from the specified resource, as identified by its Amazon Resource Name (ARN). Resources are capability, partnership, profile, transformers and other entities.

      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.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException 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)

      Detaches a key-value pair from the specified resource, as identified by its Amazon Resource Name (ARN). Resources are capability, partnership, profile, transformers and other entities.


      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.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateCapability

      default CompletableFuture<UpdateCapabilityResponse> updateCapability(UpdateCapabilityRequest updateCapabilityRequest)

      Updates some of the parameters for a capability, based on the specified parameters. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.

      Parameters:
      updateCapabilityRequest -
      Returns:
      A Java Future containing the result of the UpdateCapability operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateCapability

      default CompletableFuture<UpdateCapabilityResponse> updateCapability(Consumer<UpdateCapabilityRequest.Builder> updateCapabilityRequest)

      Updates some of the parameters for a capability, based on the specified parameters. A trading capability contains the information required to transform incoming EDI documents into JSON or XML outputs.


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

      Parameters:
      updateCapabilityRequest - A Consumer that will call methods on UpdateCapabilityRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateCapability operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updatePartnership

      default CompletableFuture<UpdatePartnershipResponse> updatePartnership(UpdatePartnershipRequest updatePartnershipRequest)

      Updates some of the parameters for a partnership between a customer and trading partner. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.

      Parameters:
      updatePartnershipRequest -
      Returns:
      A Java Future containing the result of the UpdatePartnership operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updatePartnership

      default CompletableFuture<UpdatePartnershipResponse> updatePartnership(Consumer<UpdatePartnershipRequest.Builder> updatePartnershipRequest)

      Updates some of the parameters for a partnership between a customer and trading partner. A partnership represents the connection between you and your trading partner. It ties together a profile and one or more trading capabilities.


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

      Parameters:
      updatePartnershipRequest - A Consumer that will call methods on UpdatePartnershipRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdatePartnership operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateProfile

      default CompletableFuture<UpdateProfileResponse> updateProfile(UpdateProfileRequest updateProfileRequest)

      Updates the specified parameters for a profile. A profile is the mechanism used to create the concept of a private network.

      Parameters:
      updateProfileRequest -
      Returns:
      A Java Future containing the result of the UpdateProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateProfile

      default CompletableFuture<UpdateProfileResponse> updateProfile(Consumer<UpdateProfileRequest.Builder> updateProfileRequest)

      Updates the specified parameters for a profile. A profile is the mechanism used to create the concept of a private network.


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

      Parameters:
      updateProfileRequest - A Consumer that will call methods on UpdateProfileRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateProfile operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateTransformer

      default CompletableFuture<UpdateTransformerResponse> updateTransformer(UpdateTransformerRequest updateTransformerRequest)

      Updates the specified parameters for a transformer. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.

      Parameters:
      updateTransformerRequest -
      Returns:
      A Java Future containing the result of the UpdateTransformer operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateTransformer

      default CompletableFuture<UpdateTransformerResponse> updateTransformer(Consumer<UpdateTransformerRequest.Builder> updateTransformerRequest)

      Updates the specified parameters for a transformer. A transformer can take an EDI file as input and transform it into a JSON-or XML-formatted document. Alternatively, a transformer can take a JSON-or XML-formatted document as input and transform it into an EDI file.


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

      Parameters:
      updateTransformerRequest - A Consumer that will call methods on UpdateTransformerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateTransformer operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ConflictException A conflict exception is thrown when you attempt to delete a resource (such as a profile or a capability) that is being used by other resources.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ValidationException Occurs when a B2BI object cannot be validated against a request from another object.
      • ThrottlingException The request was denied due to throttling: the data speed and rendering may be limited depending on various parameters and conditions.
      • ResourceNotFoundException Occurs when the requested resource does not exist, or cannot be found. In some cases, the resource exists in a region other than the region specified in the API call.
      • ServiceQuotaExceededException Occurs when the calling command attempts to exceed one of the service quotas, for example trying to create a capability when you already have the maximum number of capabilities allowed.
      • InternalServerException This exception is thrown when an error occurs in the Amazon Web Services B2B Data Interchange service.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • B2BiException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • serviceClientConfiguration

      default B2BiServiceClientConfiguration 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 B2BiAsyncClient create()
      Create a B2BiAsyncClient with the region loaded from the DefaultAwsRegionProviderChain and credentials loaded from the DefaultCredentialsProvider.

    • builder

      static B2BiAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a B2BiAsyncClient.