Interface BillingAsyncClient

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

You can use the Billing API to programatically list the billing views available to you for a given time period. A billing view represents a set of billing data.

The Billing API provides the following endpoint:

https://billing.us-east-1.api.aws

  • Field Details

  • Method Details

    • associateContract

      default CompletableFuture<AssociateContractResponse> associateContract(AssociateContractRequest associateContractRequest)

      Private Pricing contracts let eligible payer accounts manage private pricing agreements with Amazon Web Services. This operation associates a private pricing contract with the caller's Amazon Web Services account. The caller must be a payer (management) account listed on the contract. This operation is idempotent, so retrying a request that already succeeded is safe.

      Parameters:
      associateContractRequest -
      Returns:
      A Java Future containing the result of the AssociateContract operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • associateContract

      default CompletableFuture<AssociateContractResponse> associateContract(Consumer<AssociateContractRequest.Builder> associateContractRequest)

      Private Pricing contracts let eligible payer accounts manage private pricing agreements with Amazon Web Services. This operation associates a private pricing contract with the caller's Amazon Web Services account. The caller must be a payer (management) account listed on the contract. This operation is idempotent, so retrying a request that already succeeded is safe.


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

      Parameters:
      associateContractRequest - A Consumer that will call methods on AssociateContractRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the AssociateContract operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • associateSourceViews

      default CompletableFuture<AssociateSourceViewsResponse> associateSourceViews(AssociateSourceViewsRequest associateSourceViewsRequest)

      Associates one or more source billing views with an existing billing view. This allows creating aggregate billing views that combine data from multiple sources.

      Parameters:
      associateSourceViewsRequest -
      Returns:
      A Java Future containing the result of the AssociateSourceViews operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ServiceQuotaExceededException You've reached the limit of resources you can create, or exceeded the size of an individual resource.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • associateSourceViews

      default CompletableFuture<AssociateSourceViewsResponse> associateSourceViews(Consumer<AssociateSourceViewsRequest.Builder> associateSourceViewsRequest)

      Associates one or more source billing views with an existing billing view. This allows creating aggregate billing views that combine data from multiple sources.


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

      Parameters:
      associateSourceViewsRequest - A Consumer that will call methods on AssociateSourceViewsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the AssociateSourceViews operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ServiceQuotaExceededException You've reached the limit of resources you can create, or exceeded the size of an individual resource.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • cancelContractualInvestmentAttestation

      default CompletableFuture<CancelContractualInvestmentAttestationResponse> cancelContractualInvestmentAttestation(CancelContractualInvestmentAttestationRequest cancelContractualInvestmentAttestationRequest)

      Cancels a contractual investment attestation. This operation is idempotent, so retrying is safe. You can cancel an attestation only while it is still pending (its isCancellable value is true).

      Parameters:
      cancelContractualInvestmentAttestationRequest -
      Returns:
      A Java Future containing the result of the CancelContractualInvestmentAttestation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • cancelContractualInvestmentAttestation

      default CompletableFuture<CancelContractualInvestmentAttestationResponse> cancelContractualInvestmentAttestation(Consumer<CancelContractualInvestmentAttestationRequest.Builder> cancelContractualInvestmentAttestationRequest)

      Cancels a contractual investment attestation. This operation is idempotent, so retrying is safe. You can cancel an attestation only while it is still pending (its isCancellable value is true).


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

      Parameters:
      cancelContractualInvestmentAttestationRequest - A Consumer that will call methods on CancelContractualInvestmentAttestationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CancelContractualInvestmentAttestation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createBillingView

      default CompletableFuture<CreateBillingViewResponse> createBillingView(CreateBillingViewRequest createBillingViewRequest)

      Creates a billing view with the specified billing view attributes.

      Parameters:
      createBillingViewRequest -
      Returns:
      A Java Future containing the result of the CreateBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ServiceQuotaExceededException You've reached the limit of resources you can create, or exceeded the size of an individual resource.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createBillingView

      default CompletableFuture<CreateBillingViewResponse> createBillingView(Consumer<CreateBillingViewRequest.Builder> createBillingViewRequest)

      Creates a billing view with the specified billing view attributes.


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

      Parameters:
      createBillingViewRequest - A Consumer that will call methods on CreateBillingViewRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ServiceQuotaExceededException You've reached the limit of resources you can create, or exceeded the size of an individual resource.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createContractualInvestmentAttestation

      default CompletableFuture<CreateContractualInvestmentAttestationResponse> createContractualInvestmentAttestation(CreateContractualInvestmentAttestationRequest createContractualInvestmentAttestationRequest)

      Creates an attestation that claims an investment award for a completed milestone or outcome within a private pricing contract. Supply a clientToken to make the request idempotent so a safe retry does not create a duplicate attestation. This operation starts an asynchronous review and returns an attestationId while the attestation is pending.

      Parameters:
      createContractualInvestmentAttestationRequest -
      Returns:
      A Java Future containing the result of the CreateContractualInvestmentAttestation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createContractualInvestmentAttestation

      default CompletableFuture<CreateContractualInvestmentAttestationResponse> createContractualInvestmentAttestation(Consumer<CreateContractualInvestmentAttestationRequest.Builder> createContractualInvestmentAttestationRequest)

      Creates an attestation that claims an investment award for a completed milestone or outcome within a private pricing contract. Supply a clientToken to make the request idempotent so a safe retry does not create a duplicate attestation. This operation starts an asynchronous review and returns an attestationId while the attestation is pending.


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

      Parameters:
      createContractualInvestmentAttestationRequest - A Consumer that will call methods on CreateContractualInvestmentAttestationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateContractualInvestmentAttestation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteBillingView

      default CompletableFuture<DeleteBillingViewResponse> deleteBillingView(DeleteBillingViewRequest deleteBillingViewRequest)

      Deletes the specified billing view.

      Parameters:
      deleteBillingViewRequest -
      Returns:
      A Java Future containing the result of the DeleteBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteBillingView

      default CompletableFuture<DeleteBillingViewResponse> deleteBillingView(Consumer<DeleteBillingViewRequest.Builder> deleteBillingViewRequest)

      Deletes the specified billing view.


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

      Parameters:
      deleteBillingViewRequest - A Consumer that will call methods on DeleteBillingViewRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • disassociateContract

      default CompletableFuture<DisassociateContractResponse> disassociateContract(DisassociateContractRequest disassociateContractRequest)

      Removes the association between a private pricing contract and your Amazon Web Services account. The account must have been associated with the contract previously. This operation is idempotent, so retrying is safe.

      Parameters:
      disassociateContractRequest -
      Returns:
      A Java Future containing the result of the DisassociateContract operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • disassociateContract

      default CompletableFuture<DisassociateContractResponse> disassociateContract(Consumer<DisassociateContractRequest.Builder> disassociateContractRequest)

      Removes the association between a private pricing contract and your Amazon Web Services account. The account must have been associated with the contract previously. This operation is idempotent, so retrying is safe.


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

      Parameters:
      disassociateContractRequest - A Consumer that will call methods on DisassociateContractRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DisassociateContract operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • disassociateSourceViews

      default CompletableFuture<DisassociateSourceViewsResponse> disassociateSourceViews(DisassociateSourceViewsRequest disassociateSourceViewsRequest)

      Removes the association between one or more source billing views and an existing billing view. This allows modifying the composition of aggregate billing views.

      Parameters:
      disassociateSourceViewsRequest -
      Returns:
      A Java Future containing the result of the DisassociateSourceViews operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • disassociateSourceViews

      default CompletableFuture<DisassociateSourceViewsResponse> disassociateSourceViews(Consumer<DisassociateSourceViewsRequest.Builder> disassociateSourceViewsRequest)

      Removes the association between one or more source billing views and an existing billing view. This allows modifying the composition of aggregate billing views.


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

      Parameters:
      disassociateSourceViewsRequest - A Consumer that will call methods on DisassociateSourceViewsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DisassociateSourceViews operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getBillingPreferences

      default CompletableFuture<GetBillingPreferencesResponse> getBillingPreferences(GetBillingPreferencesRequest getBillingPreferencesRequest)

      Retrieves billing preferences for the specified feature. Each feature controls a distinct billing capability: which accounts can share Reserved Instances or credits, whether billing alerts are enabled, the historical record of sharing changes, and per-credit options.

      Parameters:
      getBillingPreferencesRequest -
      Returns:
      A Java Future containing the result of the GetBillingPreferences operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getBillingPreferences

      default CompletableFuture<GetBillingPreferencesResponse> getBillingPreferences(Consumer<GetBillingPreferencesRequest.Builder> getBillingPreferencesRequest)

      Retrieves billing preferences for the specified feature. Each feature controls a distinct billing capability: which accounts can share Reserved Instances or credits, whether billing alerts are enabled, the historical record of sharing changes, and per-credit options.


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

      Parameters:
      getBillingPreferencesRequest - A Consumer that will call methods on GetBillingPreferencesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetBillingPreferences operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getBillingView

      default CompletableFuture<GetBillingViewResponse> getBillingView(GetBillingViewRequest getBillingViewRequest)

      Returns the metadata associated to the specified billing view ARN.

      Parameters:
      getBillingViewRequest -
      Returns:
      A Java Future containing the result of the GetBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getBillingView

      default CompletableFuture<GetBillingViewResponse> getBillingView(Consumer<GetBillingViewRequest.Builder> getBillingViewRequest)

      Returns the metadata associated to the specified billing view ARN.


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

      Parameters:
      getBillingViewRequest - A Consumer that will call methods on GetBillingViewRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getContractInformation

      default CompletableFuture<GetContractInformationResponse> getContractInformation(GetContractInformationRequest getContractInformationRequest)

      Returns information about a specific private pricing contract, including its term (duration), eligible payer accounts, investment accounts, and legal entities. This operation is read-only.

      Parameters:
      getContractInformationRequest -
      Returns:
      A Java Future containing the result of the GetContractInformation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getContractInformation

      default CompletableFuture<GetContractInformationResponse> getContractInformation(Consumer<GetContractInformationRequest.Builder> getContractInformationRequest)

      Returns information about a specific private pricing contract, including its term (duration), eligible payer accounts, investment accounts, and legal entities. This operation is read-only.


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

      Parameters:
      getContractInformationRequest - A Consumer that will call methods on GetContractInformationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetContractInformation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCreditAllocationHistory

      default CompletableFuture<GetCreditAllocationHistoryResponse> getCreditAllocationHistory(GetCreditAllocationHistoryRequest getCreditAllocationHistoryRequest)

      Returns the per-billing-month allocation history for credits applied to an Amazon Web Services account's bills. Traverses the consolidated billing family to capture cross-account credit applications. Supports pagination and optional filtering to a single credit.

      Parameters:
      getCreditAllocationHistoryRequest -
      Returns:
      A Java Future containing the result of the GetCreditAllocationHistory operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCreditAllocationHistory

      default CompletableFuture<GetCreditAllocationHistoryResponse> getCreditAllocationHistory(Consumer<GetCreditAllocationHistoryRequest.Builder> getCreditAllocationHistoryRequest)

      Returns the per-billing-month allocation history for credits applied to an Amazon Web Services account's bills. Traverses the consolidated billing family to capture cross-account credit applications. Supports pagination and optional filtering to a single credit.


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

      Parameters:
      getCreditAllocationHistoryRequest - A Consumer that will call methods on GetCreditAllocationHistoryRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetCreditAllocationHistory operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCreditAllocationHistoryPaginator

      default GetCreditAllocationHistoryPublisher getCreditAllocationHistoryPaginator(GetCreditAllocationHistoryRequest getCreditAllocationHistoryRequest)

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

      Parameters:
      getCreditAllocationHistoryRequest -
      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.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCreditAllocationHistoryPaginator

      default GetCreditAllocationHistoryPublisher getCreditAllocationHistoryPaginator(Consumer<GetCreditAllocationHistoryRequest.Builder> getCreditAllocationHistoryRequest)

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


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

      Parameters:
      getCreditAllocationHistoryRequest - A Consumer that will call methods on GetCreditAllocationHistoryRequest.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.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCredits

      default CompletableFuture<GetCreditsResponse> getCredits(GetCreditsRequest getCreditsRequest)

      Returns the list of Amazon Web Services account credits for the specified account. Each credit includes its identifier, type, monetary amounts, applicable products, expiration, sharing configuration, and current enabled status.

      When the caller is the management account of a consolidated billing family and payerAccountFlag is true, the response aggregates credits across the entire family. Otherwise, the response includes only credits owned by the account specified in accountId.

      Parameters:
      getCreditsRequest -
      Returns:
      A Java Future containing the result of the GetCredits operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCredits

      default CompletableFuture<GetCreditsResponse> getCredits(Consumer<GetCreditsRequest.Builder> getCreditsRequest)

      Returns the list of Amazon Web Services account credits for the specified account. Each credit includes its identifier, type, monetary amounts, applicable products, expiration, sharing configuration, and current enabled status.

      When the caller is the management account of a consolidated billing family and payerAccountFlag is true, the response aggregates credits across the entire family. Otherwise, the response includes only credits owned by the account specified in accountId.


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

      Parameters:
      getCreditsRequest - A Consumer that will call methods on GetCreditsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetCredits operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEnterpriseSupportChargeSummary

      default CompletableFuture<GetEnterpriseSupportChargeSummaryResponse> getEnterpriseSupportChargeSummary(GetEnterpriseSupportChargeSummaryRequest getEnterpriseSupportChargeSummaryRequest)

      Returns a summary of Enterprise Support data aggregated across all accounts in the Enterprise Support profile.

      Parameters:
      getEnterpriseSupportChargeSummaryRequest - The request structure for GetEnterpriseSupportChargeSummary.
      Returns:
      A Java Future containing the result of the GetEnterpriseSupportChargeSummary operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEnterpriseSupportChargeSummary

      default CompletableFuture<GetEnterpriseSupportChargeSummaryResponse> getEnterpriseSupportChargeSummary(Consumer<GetEnterpriseSupportChargeSummaryRequest.Builder> getEnterpriseSupportChargeSummaryRequest)

      Returns a summary of Enterprise Support data aggregated across all accounts in the Enterprise Support profile.


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

      Parameters:
      getEnterpriseSupportChargeSummaryRequest - A Consumer that will call methods on GetEnterpriseSupportChargeSummaryRequest.Builder to create a request. The request structure for GetEnterpriseSupportChargeSummary.
      Returns:
      A Java Future containing the result of the GetEnterpriseSupportChargeSummary operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEnterpriseSupportContractDetails

      default CompletableFuture<GetEnterpriseSupportContractDetailsResponse> getEnterpriseSupportContractDetails(GetEnterpriseSupportContractDetailsRequest getEnterpriseSupportContractDetailsRequest)

      Returns Enterprise Support contract details.

      Parameters:
      getEnterpriseSupportContractDetailsRequest - The request structure for GetEnterpriseSupportContractDetails.
      Returns:
      A Java Future containing the result of the GetEnterpriseSupportContractDetails operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEnterpriseSupportContractDetails

      default CompletableFuture<GetEnterpriseSupportContractDetailsResponse> getEnterpriseSupportContractDetails(Consumer<GetEnterpriseSupportContractDetailsRequest.Builder> getEnterpriseSupportContractDetailsRequest)

      Returns Enterprise Support contract details.


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

      Parameters:
      getEnterpriseSupportContractDetailsRequest - A Consumer that will call methods on GetEnterpriseSupportContractDetailsRequest.Builder to create a request. The request structure for GetEnterpriseSupportContractDetails.
      Returns:
      A Java Future containing the result of the GetEnterpriseSupportContractDetails operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getResourcePolicy

      default CompletableFuture<GetResourcePolicyResponse> getResourcePolicy(GetResourcePolicyRequest getResourcePolicyRequest)

      Returns the resource-based policy document attached to the resource in JSON format.

      Parameters:
      getResourcePolicyRequest -
      Returns:
      A Java Future containing the result of the GetResourcePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getResourcePolicy

      default CompletableFuture<GetResourcePolicyResponse> getResourcePolicy(Consumer<GetResourcePolicyRequest.Builder> getResourcePolicyRequest)

      Returns the resource-based policy document attached to the resource in JSON format.


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

      Parameters:
      getResourcePolicyRequest - A Consumer that will call methods on GetResourcePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetResourcePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBillingViewSegments

      default CompletableFuture<ListBillingViewSegmentsResponse> listBillingViewSegments(ListBillingViewSegmentsRequest listBillingViewSegmentsRequest)

      Lists the segments of a billing view over a given time period. Each segment identifies the billing domain ( PRO_FORMA or BILLABLE) and the account relationships that apply during its time range.

      If you don't provide an arn, the response includes segments for the caller's PRIMARY billing view.

      If a mid-period change occurs, the response includes multiple segments, each with its own time range. The response omits hidden segments, so the segments it returns might not cover the entire requested time period.

      Parameters:
      listBillingViewSegmentsRequest -
      Returns:
      A Java Future containing the result of the ListBillingViewSegments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBillingViewSegments

      default CompletableFuture<ListBillingViewSegmentsResponse> listBillingViewSegments(Consumer<ListBillingViewSegmentsRequest.Builder> listBillingViewSegmentsRequest)

      Lists the segments of a billing view over a given time period. Each segment identifies the billing domain ( PRO_FORMA or BILLABLE) and the account relationships that apply during its time range.

      If you don't provide an arn, the response includes segments for the caller's PRIMARY billing view.

      If a mid-period change occurs, the response includes multiple segments, each with its own time range. The response omits hidden segments, so the segments it returns might not cover the entire requested time period.


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

      Parameters:
      listBillingViewSegmentsRequest - A Consumer that will call methods on ListBillingViewSegmentsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListBillingViewSegments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBillingViewSegmentsPaginator

      default ListBillingViewSegmentsPublisher listBillingViewSegmentsPaginator(ListBillingViewSegmentsRequest listBillingViewSegmentsRequest)

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

      Parameters:
      listBillingViewSegmentsRequest -
      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.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBillingViewSegmentsPaginator

      default ListBillingViewSegmentsPublisher listBillingViewSegmentsPaginator(Consumer<ListBillingViewSegmentsRequest.Builder> listBillingViewSegmentsRequest)

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


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

      Parameters:
      listBillingViewSegmentsRequest - A Consumer that will call methods on ListBillingViewSegmentsRequest.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.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBillingViews

      default CompletableFuture<ListBillingViewsResponse> listBillingViews(ListBillingViewsRequest listBillingViewsRequest)

      Lists the billing views available for a given time period.

      Every Amazon Web Services account has a unique PRIMARY billing view that represents the billing data available by default. Accounts that use Billing Conductor also have BILLING_GROUP billing views representing pro forma costs associated with each created billing group.

      Parameters:
      listBillingViewsRequest -
      Returns:
      A Java Future containing the result of the ListBillingViews operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBillingViews

      default CompletableFuture<ListBillingViewsResponse> listBillingViews(Consumer<ListBillingViewsRequest.Builder> listBillingViewsRequest)

      Lists the billing views available for a given time period.

      Every Amazon Web Services account has a unique PRIMARY billing view that represents the billing data available by default. Accounts that use Billing Conductor also have BILLING_GROUP billing views representing pro forma costs associated with each created billing group.


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

      Parameters:
      listBillingViewsRequest - A Consumer that will call methods on ListBillingViewsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListBillingViews operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBillingViewsPaginator

      default ListBillingViewsPublisher listBillingViewsPaginator(ListBillingViewsRequest listBillingViewsRequest)

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

      Parameters:
      listBillingViewsRequest -
      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.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBillingViewsPaginator

      default ListBillingViewsPublisher listBillingViewsPaginator(Consumer<ListBillingViewsRequest.Builder> listBillingViewsRequest)

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


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

      Parameters:
      listBillingViewsRequest - A Consumer that will call methods on ListBillingViewsRequest.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.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBusinessSupportAccountCharges

      default CompletableFuture<ListBusinessSupportAccountChargesResponse> listBusinessSupportAccountCharges(ListBusinessSupportAccountChargesRequest listBusinessSupportAccountChargesRequest)

      Returns Business Support charges broken down at the linked account level for a given billing month.

      Parameters:
      listBusinessSupportAccountChargesRequest - Contains the billing month and optional filters used to retrieve Business Support charges broken down by linked account.
      Returns:
      A Java Future containing the result of the ListBusinessSupportAccountCharges operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBusinessSupportAccountCharges

      default CompletableFuture<ListBusinessSupportAccountChargesResponse> listBusinessSupportAccountCharges(Consumer<ListBusinessSupportAccountChargesRequest.Builder> listBusinessSupportAccountChargesRequest)

      Returns Business Support charges broken down at the linked account level for a given billing month.


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

      Parameters:
      listBusinessSupportAccountChargesRequest - A Consumer that will call methods on ListBusinessSupportAccountChargesRequest.Builder to create a request. Contains the billing month and optional filters used to retrieve Business Support charges broken down by linked account.
      Returns:
      A Java Future containing the result of the ListBusinessSupportAccountCharges operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBusinessSupportAccountChargesPaginator

      default ListBusinessSupportAccountChargesPublisher listBusinessSupportAccountChargesPaginator(ListBusinessSupportAccountChargesRequest listBusinessSupportAccountChargesRequest)

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

      Parameters:
      listBusinessSupportAccountChargesRequest - Contains the billing month and optional filters used to retrieve Business Support charges broken down by linked account.
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBusinessSupportAccountChargesPaginator

      default ListBusinessSupportAccountChargesPublisher listBusinessSupportAccountChargesPaginator(Consumer<ListBusinessSupportAccountChargesRequest.Builder> listBusinessSupportAccountChargesRequest)

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


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

      Parameters:
      listBusinessSupportAccountChargesRequest - A Consumer that will call methods on ListBusinessSupportAccountChargesRequest.Builder to create a request. Contains the billing month and optional filters used to retrieve Business Support charges broken down by linked account.
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBusinessSupportSubscriptionHistory

      default CompletableFuture<ListBusinessSupportSubscriptionHistoryResponse> listBusinessSupportSubscriptionHistory(ListBusinessSupportSubscriptionHistoryRequest listBusinessSupportSubscriptionHistoryRequest)

      Returns the history of Business Support subscription contracts across accounts.

      Parameters:
      listBusinessSupportSubscriptionHistoryRequest - Contains the optional filters used to retrieve the history of Business Support subscription contracts across accounts.
      Returns:
      A Java Future containing the result of the ListBusinessSupportSubscriptionHistory operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBusinessSupportSubscriptionHistory

      default CompletableFuture<ListBusinessSupportSubscriptionHistoryResponse> listBusinessSupportSubscriptionHistory(Consumer<ListBusinessSupportSubscriptionHistoryRequest.Builder> listBusinessSupportSubscriptionHistoryRequest)

      Returns the history of Business Support subscription contracts across accounts.


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

      Parameters:
      listBusinessSupportSubscriptionHistoryRequest - A Consumer that will call methods on ListBusinessSupportSubscriptionHistoryRequest.Builder to create a request. Contains the optional filters used to retrieve the history of Business Support subscription contracts across accounts.
      Returns:
      A Java Future containing the result of the ListBusinessSupportSubscriptionHistory operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBusinessSupportSubscriptionHistoryPaginator

      default ListBusinessSupportSubscriptionHistoryPublisher listBusinessSupportSubscriptionHistoryPaginator(ListBusinessSupportSubscriptionHistoryRequest listBusinessSupportSubscriptionHistoryRequest)

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

      Parameters:
      listBusinessSupportSubscriptionHistoryRequest - Contains the optional filters used to retrieve the history of Business Support subscription contracts across accounts.
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listBusinessSupportSubscriptionHistoryPaginator

      default ListBusinessSupportSubscriptionHistoryPublisher listBusinessSupportSubscriptionHistoryPaginator(Consumer<ListBusinessSupportSubscriptionHistoryRequest.Builder> listBusinessSupportSubscriptionHistoryRequest)

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


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

      Parameters:
      listBusinessSupportSubscriptionHistoryRequest - A Consumer that will call methods on ListBusinessSupportSubscriptionHistoryRequest.Builder to create a request. Contains the optional filters used to retrieve the history of Business Support subscription contracts across accounts.
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContracts

      default CompletableFuture<ListContractsResponse> listContracts(ListContractsRequest listContractsRequest)

      Lists the private pricing contracts that your Amazon Web Services account is an eligible payer account of. This operation is read-only and paginated.

      Parameters:
      listContractsRequest -
      Returns:
      A Java Future containing the result of the ListContracts operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContracts

      default CompletableFuture<ListContractsResponse> listContracts(Consumer<ListContractsRequest.Builder> listContractsRequest)

      Lists the private pricing contracts that your Amazon Web Services account is an eligible payer account of. This operation is read-only and paginated.


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

      Parameters:
      listContractsRequest - A Consumer that will call methods on ListContractsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListContracts operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractsPaginator

      default ListContractsPublisher listContractsPaginator(ListContractsRequest listContractsRequest)

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

      Parameters:
      listContractsRequest -
      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.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractsPaginator

      default ListContractsPublisher listContractsPaginator(Consumer<ListContractsRequest.Builder> listContractsRequest)

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


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

      Parameters:
      listContractsRequest - A Consumer that will call methods on ListContractsRequest.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.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentAttestations

      default CompletableFuture<ListContractualInvestmentAttestationsResponse> listContractualInvestmentAttestations(ListContractualInvestmentAttestationsRequest listContractualInvestmentAttestationsRequest)

      Lists the investment attestations submitted under a specific private pricing contract. Use this operation to track attestation status, including the terminal statuses DISBURSED, REJECTED, and CANCELLED. This operation is read-only and paginated.

      Parameters:
      listContractualInvestmentAttestationsRequest -
      Returns:
      A Java Future containing the result of the ListContractualInvestmentAttestations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentAttestations

      default CompletableFuture<ListContractualInvestmentAttestationsResponse> listContractualInvestmentAttestations(Consumer<ListContractualInvestmentAttestationsRequest.Builder> listContractualInvestmentAttestationsRequest)

      Lists the investment attestations submitted under a specific private pricing contract. Use this operation to track attestation status, including the terminal statuses DISBURSED, REJECTED, and CANCELLED. This operation is read-only and paginated.


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

      Parameters:
      listContractualInvestmentAttestationsRequest - A Consumer that will call methods on ListContractualInvestmentAttestationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListContractualInvestmentAttestations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentAttestationsPaginator

      default ListContractualInvestmentAttestationsPublisher listContractualInvestmentAttestationsPaginator(ListContractualInvestmentAttestationsRequest listContractualInvestmentAttestationsRequest)

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

      Parameters:
      listContractualInvestmentAttestationsRequest -
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentAttestationsPaginator

      default ListContractualInvestmentAttestationsPublisher listContractualInvestmentAttestationsPaginator(Consumer<ListContractualInvestmentAttestationsRequest.Builder> listContractualInvestmentAttestationsRequest)

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


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

      Parameters:
      listContractualInvestmentAttestationsRequest - A Consumer that will call methods on ListContractualInvestmentAttestationsRequest.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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentSummaries

      default CompletableFuture<ListContractualInvestmentSummariesResponse> listContractualInvestmentSummaries(ListContractualInvestmentSummariesRequest listContractualInvestmentSummariesRequest)

      Lists the investment summaries within a specific private pricing contract. This operation is read-only and paginated.

      Parameters:
      listContractualInvestmentSummariesRequest -
      Returns:
      A Java Future containing the result of the ListContractualInvestmentSummaries operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentSummaries

      default CompletableFuture<ListContractualInvestmentSummariesResponse> listContractualInvestmentSummaries(Consumer<ListContractualInvestmentSummariesRequest.Builder> listContractualInvestmentSummariesRequest)

      Lists the investment summaries within a specific private pricing contract. This operation is read-only and paginated.


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

      Parameters:
      listContractualInvestmentSummariesRequest - A Consumer that will call methods on ListContractualInvestmentSummariesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListContractualInvestmentSummaries operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentSummariesPaginator

      default ListContractualInvestmentSummariesPublisher listContractualInvestmentSummariesPaginator(ListContractualInvestmentSummariesRequest listContractualInvestmentSummariesRequest)

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

      Parameters:
      listContractualInvestmentSummariesRequest -
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentSummariesPaginator

      default ListContractualInvestmentSummariesPublisher listContractualInvestmentSummariesPaginator(Consumer<ListContractualInvestmentSummariesRequest.Builder> listContractualInvestmentSummariesRequest)

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


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

      Parameters:
      listContractualInvestmentSummariesRequest - A Consumer that will call methods on ListContractualInvestmentSummariesRequest.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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestments

      default CompletableFuture<ListContractualInvestmentsResponse> listContractualInvestments(ListContractualInvestmentsRequest listContractualInvestmentsRequest)

      Lists the investments within a specific investment summary. This operation is read-only and paginated.

      Parameters:
      listContractualInvestmentsRequest -
      Returns:
      A Java Future containing the result of the ListContractualInvestments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestments

      default CompletableFuture<ListContractualInvestmentsResponse> listContractualInvestments(Consumer<ListContractualInvestmentsRequest.Builder> listContractualInvestmentsRequest)

      Lists the investments within a specific investment summary. This operation is read-only and paginated.


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

      Parameters:
      listContractualInvestmentsRequest - A Consumer that will call methods on ListContractualInvestmentsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListContractualInvestments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentsPaginator

      default ListContractualInvestmentsPublisher listContractualInvestmentsPaginator(ListContractualInvestmentsRequest listContractualInvestmentsRequest)

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

      Parameters:
      listContractualInvestmentsRequest -
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listContractualInvestmentsPaginator

      default ListContractualInvestmentsPublisher listContractualInvestmentsPaginator(Consumer<ListContractualInvestmentsRequest.Builder> listContractualInvestmentsRequest)

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


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

      Parameters:
      listContractualInvestmentsRequest - A Consumer that will call methods on ListContractualInvestmentsRequest.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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEnterpriseSupportLinkedAccountCharges

      default CompletableFuture<ListEnterpriseSupportLinkedAccountChargesResponse> listEnterpriseSupportLinkedAccountCharges(ListEnterpriseSupportLinkedAccountChargesRequest listEnterpriseSupportLinkedAccountChargesRequest)

      Returns Support-eligible spend broken down at linked account level.

      Parameters:
      listEnterpriseSupportLinkedAccountChargesRequest - The request structure for ListEnterpriseSupportLinkedAccountCharges.
      Returns:
      A Java Future containing the result of the ListEnterpriseSupportLinkedAccountCharges operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEnterpriseSupportLinkedAccountCharges

      default CompletableFuture<ListEnterpriseSupportLinkedAccountChargesResponse> listEnterpriseSupportLinkedAccountCharges(Consumer<ListEnterpriseSupportLinkedAccountChargesRequest.Builder> listEnterpriseSupportLinkedAccountChargesRequest)

      Returns Support-eligible spend broken down at linked account level.


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

      Parameters:
      listEnterpriseSupportLinkedAccountChargesRequest - A Consumer that will call methods on ListEnterpriseSupportLinkedAccountChargesRequest.Builder to create a request. The request structure for ListEnterpriseSupportLinkedAccountCharges.
      Returns:
      A Java Future containing the result of the ListEnterpriseSupportLinkedAccountCharges operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEnterpriseSupportLinkedAccountChargesPaginator

      default ListEnterpriseSupportLinkedAccountChargesPublisher listEnterpriseSupportLinkedAccountChargesPaginator(ListEnterpriseSupportLinkedAccountChargesRequest listEnterpriseSupportLinkedAccountChargesRequest)

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

      Parameters:
      listEnterpriseSupportLinkedAccountChargesRequest - The request structure for ListEnterpriseSupportLinkedAccountCharges.
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEnterpriseSupportLinkedAccountChargesPaginator

      default ListEnterpriseSupportLinkedAccountChargesPublisher listEnterpriseSupportLinkedAccountChargesPaginator(Consumer<ListEnterpriseSupportLinkedAccountChargesRequest.Builder> listEnterpriseSupportLinkedAccountChargesRequest)

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


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

      Parameters:
      listEnterpriseSupportLinkedAccountChargesRequest - A Consumer that will call methods on ListEnterpriseSupportLinkedAccountChargesRequest.Builder to create a request. The request structure for ListEnterpriseSupportLinkedAccountCharges.
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSourceViewsForBillingView

      default CompletableFuture<ListSourceViewsForBillingViewResponse> listSourceViewsForBillingView(ListSourceViewsForBillingViewRequest listSourceViewsForBillingViewRequest)

      Lists the source views (managed Amazon Web Services billing views) associated with the billing view.

      Parameters:
      listSourceViewsForBillingViewRequest -
      Returns:
      A Java Future containing the result of the ListSourceViewsForBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSourceViewsForBillingView

      default CompletableFuture<ListSourceViewsForBillingViewResponse> listSourceViewsForBillingView(Consumer<ListSourceViewsForBillingViewRequest.Builder> listSourceViewsForBillingViewRequest)

      Lists the source views (managed Amazon Web Services billing views) associated with the billing view.


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

      Parameters:
      listSourceViewsForBillingViewRequest - A Consumer that will call methods on ListSourceViewsForBillingViewRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListSourceViewsForBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSourceViewsForBillingViewPaginator

      default ListSourceViewsForBillingViewPublisher listSourceViewsForBillingViewPaginator(ListSourceViewsForBillingViewRequest listSourceViewsForBillingViewRequest)

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

      Parameters:
      listSourceViewsForBillingViewRequest -
      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSourceViewsForBillingViewPaginator

      default ListSourceViewsForBillingViewPublisher listSourceViewsForBillingViewPaginator(Consumer<ListSourceViewsForBillingViewRequest.Builder> listSourceViewsForBillingViewRequest)

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


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

      Parameters:
      listSourceViewsForBillingViewRequest - A Consumer that will call methods on ListSourceViewsForBillingViewRequest.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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException 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 tags associated with the billing view resource.

      Parameters:
      listTagsForResourceRequest -
      Returns:
      A Java Future containing the result of the ListTagsForResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException 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 tags associated with the billing view resource.


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

      Parameters:
      listTagsForResourceRequest - A Consumer that will call methods on ListTagsForResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTagsForResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • redeemCredits

      default CompletableFuture<RedeemCreditsResponse> redeemCredits(RedeemCreditsRequest redeemCreditsRequest)

      Redeems an Amazon Web Services promotional credit code on behalf of the calling account. On success, a new credit is added to the account's credit ledger with the amount, validity period, and applicable products defined by the promotion. The credit is then automatically applied to subsequent bills according to the standard credit application order.

      Parameters:
      redeemCreditsRequest -
      Returns:
      A Java Future containing the result of the RedeemCredits operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • redeemCredits

      default CompletableFuture<RedeemCreditsResponse> redeemCredits(Consumer<RedeemCreditsRequest.Builder> redeemCreditsRequest)

      Redeems an Amazon Web Services promotional credit code on behalf of the calling account. On success, a new credit is added to the account's credit ledger with the amount, validity period, and applicable products defined by the promotion. The credit is then automatically applied to subsequent bills according to the standard credit application order.


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

      Parameters:
      redeemCreditsRequest - A Consumer that will call methods on RedeemCreditsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RedeemCredits operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException 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)

      An API operation for adding one or more tags (key-value pairs) to a resource.

      Parameters:
      tagResourceRequest -
      Returns:
      A Java Future containing the result of the TagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException 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)

      An API operation for adding one or more tags (key-value pairs) to a resource.


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

      Parameters:
      tagResourceRequest - A Consumer that will call methods on TagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException 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)

      Removes one or more tags from a resource. Specify only tag keys in your request. Don't specify the value.

      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException 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)

      Removes one or more tags from a resource. Specify only tag keys in your request. Don't specify the value.


      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.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateBillingPreferences

      default CompletableFuture<UpdateBillingPreferencesResponse> updateBillingPreferences(UpdateBillingPreferencesRequest updateBillingPreferencesRequest)

      Updates billing preferences for the specified feature. Each feature targets a distinct billing capability and has its own set of supported keys. The action sets the value for each provided key; keys not present in the request are unchanged.

      Sharing keys (RI_SHARING, CREDIT_SHARING, CREDIT_LEVEL_SHARING, and sharing keys under CREDIT_PREFERENCE_OPTIONS) may only be set by the management account of a consolidated billing family. The credit/{creditId}/status key may be set by member accounts for credits they own, or by the management account for any credit in the family.

      Parameters:
      updateBillingPreferencesRequest -
      Returns:
      A Java Future containing the result of the UpdateBillingPreferences operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateBillingPreferences

      default CompletableFuture<UpdateBillingPreferencesResponse> updateBillingPreferences(Consumer<UpdateBillingPreferencesRequest.Builder> updateBillingPreferencesRequest)

      Updates billing preferences for the specified feature. Each feature targets a distinct billing capability and has its own set of supported keys. The action sets the value for each provided key; keys not present in the request are unchanged.

      Sharing keys (RI_SHARING, CREDIT_SHARING, CREDIT_LEVEL_SHARING, and sharing keys under CREDIT_PREFERENCE_OPTIONS) may only be set by the management account of a consolidated billing family. The credit/{creditId}/status key may be set by member accounts for credits they own, or by the management account for any credit in the family.


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

      Parameters:
      updateBillingPreferencesRequest - A Consumer that will call methods on UpdateBillingPreferencesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateBillingPreferences operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied due to request throttling.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateBillingView

      default CompletableFuture<UpdateBillingViewResponse> updateBillingView(UpdateBillingViewRequest updateBillingViewRequest)

      An API to update the attributes of the billing view.

      Parameters:
      updateBillingViewRequest -
      Returns:
      A Java Future containing the result of the UpdateBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ServiceQuotaExceededException You've reached the limit of resources you can create, or exceeded the size of an individual resource.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateBillingView

      default CompletableFuture<UpdateBillingViewResponse> updateBillingView(Consumer<UpdateBillingViewRequest.Builder> updateBillingViewRequest)

      An API to update the attributes of the billing view.


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

      Parameters:
      updateBillingViewRequest - A Consumer that will call methods on UpdateBillingViewRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateBillingView operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • BillingViewHealthStatusException Exception thrown when a billing view's health status prevents an operation from being performed. This may occur if the billing view is in a state other than HEALTHY.
      • ServiceQuotaExceededException You've reached the limit of resources you can create, or exceeded the size of an individual resource.
      • ThrottlingException The request was denied due to request throttling.
      • ResourceNotFoundException The specified ARN in the request doesn't exist.
      • AccessDeniedException You don't have sufficient access to perform this action.
      • ConflictException The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.
      • ValidationException The input fails to satisfy the constraints specified by an Amazon Web Services service.
      • InternalServerException The request processing failed because of an unknown error, exception, or failure.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • BillingException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • serviceClientConfiguration

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

    • builder

      static BillingAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a BillingAsyncClient.