software.amazon.awssdk.services.pinpoint.PinpointAsyncClient Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pinpoint Show documentation
The AWS Java SDK for Amazon Pinpoint module holds the client classes that are used for communicating with Amazon Pinpoint Service
There is a newer version: 2.28.4
Show newest version
/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
 * the License. A copy of the License is located at
 * 
 * http://aws.amazon.com/apache2.0
 * 
 * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
 * and limitations under the License.
 */

package software.amazon.awssdk.services.pinpoint;

import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkPublicApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.core.SdkClient;
import software.amazon.awssdk.services.pinpoint.model.CreateAppRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateAppResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateCampaignRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateCampaignResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateEmailTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateEmailTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateExportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateExportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateJourneyRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateJourneyResponse;
import software.amazon.awssdk.services.pinpoint.model.CreatePushTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.CreatePushTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateRecommenderConfigurationRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateRecommenderConfigurationResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateSmsTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSmsTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.CreateVoiceTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateVoiceTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteAdmChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteAdmChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteApnsChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteApnsChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteApnsSandboxChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteApnsSandboxChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteApnsVoipChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteApnsVoipChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteApnsVoipSandboxChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteApnsVoipSandboxChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteAppRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteAppResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteBaiduChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteBaiduChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteCampaignRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteCampaignResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteEmailChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteEmailChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteEmailTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteEmailTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteEndpointRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteEndpointResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteEventStreamRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteEventStreamResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteGcmChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteGcmChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteJourneyRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteJourneyResponse;
import software.amazon.awssdk.services.pinpoint.model.DeletePushTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.DeletePushTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteRecommenderConfigurationRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteRecommenderConfigurationResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteSegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteSmsChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteSmsChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteSmsTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteSmsTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteUserEndpointsRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteUserEndpointsResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteVoiceChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteVoiceChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.DeleteVoiceTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.DeleteVoiceTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.GetAdmChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetAdmChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetApnsChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetApnsChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetApnsSandboxChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetApnsSandboxChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetApnsVoipChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetApnsVoipChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetApnsVoipSandboxChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetApnsVoipSandboxChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetAppRequest;
import software.amazon.awssdk.services.pinpoint.model.GetAppResponse;
import software.amazon.awssdk.services.pinpoint.model.GetApplicationDateRangeKpiRequest;
import software.amazon.awssdk.services.pinpoint.model.GetApplicationDateRangeKpiResponse;
import software.amazon.awssdk.services.pinpoint.model.GetApplicationSettingsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetApplicationSettingsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetAppsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetAppsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetBaiduChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetBaiduChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignActivitiesRequest;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignActivitiesResponse;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignDateRangeKpiRequest;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignDateRangeKpiResponse;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignRequest;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignResponse;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignVersionRequest;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignVersionResponse;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignVersionsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignVersionsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetCampaignsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetChannelsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetChannelsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetEmailChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetEmailChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetEmailTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.GetEmailTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.GetEndpointRequest;
import software.amazon.awssdk.services.pinpoint.model.GetEndpointResponse;
import software.amazon.awssdk.services.pinpoint.model.GetEventStreamRequest;
import software.amazon.awssdk.services.pinpoint.model.GetEventStreamResponse;
import software.amazon.awssdk.services.pinpoint.model.GetExportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.GetExportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.GetExportJobsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetExportJobsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetGcmChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetGcmChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.GetImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.GetImportJobsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetImportJobsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetJourneyDateRangeKpiRequest;
import software.amazon.awssdk.services.pinpoint.model.GetJourneyDateRangeKpiResponse;
import software.amazon.awssdk.services.pinpoint.model.GetJourneyExecutionActivityMetricsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetJourneyExecutionActivityMetricsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetJourneyExecutionMetricsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetJourneyExecutionMetricsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetJourneyRequest;
import software.amazon.awssdk.services.pinpoint.model.GetJourneyResponse;
import software.amazon.awssdk.services.pinpoint.model.GetPushTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.GetPushTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.GetRecommenderConfigurationRequest;
import software.amazon.awssdk.services.pinpoint.model.GetRecommenderConfigurationResponse;
import software.amazon.awssdk.services.pinpoint.model.GetRecommenderConfigurationsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetRecommenderConfigurationsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentExportJobsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentExportJobsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentImportJobsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentImportJobsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentVersionRequest;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentVersionResponse;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentVersionsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentVersionsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetSegmentsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetSmsChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetSmsChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetSmsTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.GetSmsTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.GetUserEndpointsRequest;
import software.amazon.awssdk.services.pinpoint.model.GetUserEndpointsResponse;
import software.amazon.awssdk.services.pinpoint.model.GetVoiceChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.GetVoiceChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.GetVoiceTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.GetVoiceTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.ListJourneysRequest;
import software.amazon.awssdk.services.pinpoint.model.ListJourneysResponse;
import software.amazon.awssdk.services.pinpoint.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.pinpoint.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.pinpoint.model.ListTemplateVersionsRequest;
import software.amazon.awssdk.services.pinpoint.model.ListTemplateVersionsResponse;
import software.amazon.awssdk.services.pinpoint.model.ListTemplatesRequest;
import software.amazon.awssdk.services.pinpoint.model.ListTemplatesResponse;
import software.amazon.awssdk.services.pinpoint.model.PhoneNumberValidateRequest;
import software.amazon.awssdk.services.pinpoint.model.PhoneNumberValidateResponse;
import software.amazon.awssdk.services.pinpoint.model.PutEventStreamRequest;
import software.amazon.awssdk.services.pinpoint.model.PutEventStreamResponse;
import software.amazon.awssdk.services.pinpoint.model.PutEventsRequest;
import software.amazon.awssdk.services.pinpoint.model.PutEventsResponse;
import software.amazon.awssdk.services.pinpoint.model.RemoveAttributesRequest;
import software.amazon.awssdk.services.pinpoint.model.RemoveAttributesResponse;
import software.amazon.awssdk.services.pinpoint.model.SendMessagesRequest;
import software.amazon.awssdk.services.pinpoint.model.SendMessagesResponse;
import software.amazon.awssdk.services.pinpoint.model.SendUsersMessagesRequest;
import software.amazon.awssdk.services.pinpoint.model.SendUsersMessagesResponse;
import software.amazon.awssdk.services.pinpoint.model.TagResourceRequest;
import software.amazon.awssdk.services.pinpoint.model.TagResourceResponse;
import software.amazon.awssdk.services.pinpoint.model.UntagResourceRequest;
import software.amazon.awssdk.services.pinpoint.model.UntagResourceResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateAdmChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateAdmChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateApnsChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateApnsChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateApnsSandboxChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateApnsSandboxChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateApnsVoipChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateApnsVoipChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateApnsVoipSandboxChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateApnsVoipSandboxChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateApplicationSettingsRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateApplicationSettingsResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateBaiduChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateBaiduChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateCampaignRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateCampaignResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateEmailChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateEmailChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateEmailTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateEmailTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateEndpointRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateEndpointResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateEndpointsBatchRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateEndpointsBatchResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateGcmChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateGcmChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateJourneyRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateJourneyResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateJourneyStateRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateJourneyStateResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdatePushTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdatePushTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateRecommenderConfigurationRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateRecommenderConfigurationResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateSegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateSmsChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateSmsChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateSmsTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateSmsTemplateResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateTemplateActiveVersionRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateTemplateActiveVersionResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateVoiceChannelRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateVoiceChannelResponse;
import software.amazon.awssdk.services.pinpoint.model.UpdateVoiceTemplateRequest;
import software.amazon.awssdk.services.pinpoint.model.UpdateVoiceTemplateResponse;

/**
 * Service client for accessing Amazon Pinpoint asynchronously. This can be created using the static {@link #builder()}
 * method.
 *
 * 
 * Doc Engage API - Amazon Pinpoint API
 * 
 */
@Generated("software.amazon.awssdk:codegen")
@SdkPublicApi
@ThreadSafe
public interface PinpointAsyncClient extends SdkClient {
    String SERVICE_NAME = "mobiletargeting";

    /**
     * Value for looking up the service's metadata from the
     * {@link software.amazon.awssdk.regions.ServiceMetadataProvider}.
     */
    String SERVICE_METADATA_ID = "pinpoint";

    /**
     * Create a {@link PinpointAsyncClient} with the region loaded from the
     * {@link software.amazon.awssdk.regions.providers.DefaultAwsRegionProviderChain} and credentials loaded from the
     * {@link software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider}.
     */
    static PinpointAsyncClient create() {
        return builder().build();
    }

    /**
     * Create a builder that can be used to configure and create a {@link PinpointAsyncClient}.
     */
    static PinpointAsyncClientBuilder builder() {
        return new DefaultPinpointAsyncClientBuilder();
    }

    /**
     * 
     * Creates an application.
     * 
     *
     * @param createAppRequest
     * @return A Java Future containing the result of the CreateApp operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateApp
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createApp(CreateAppRequest createAppRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateAppRequest.Builder} avoiding the need to
     * create one manually via {@link CreateAppRequest#builder()}
     * 
     *
     * @param createAppRequest
     *        A {@link Consumer} that will call methods on {@link CreateAppRequest.Builder} to create a request.
     * @return A Java Future containing the result of the CreateApp operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateApp
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createApp(Consumer createAppRequest) {
        return createApp(CreateAppRequest.builder().applyMutation(createAppRequest).build());
    }

    /**
     * 
     * Creates a new campaign for an application or updates the settings of an existing campaign for an application.
     * 
     *
     * @param createCampaignRequest
     * @return A Java Future containing the result of the CreateCampaign operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateCampaign
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createCampaign(CreateCampaignRequest createCampaignRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a new campaign for an application or updates the settings of an existing campaign for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateCampaignRequest.Builder} avoiding the need to
     * create one manually via {@link CreateCampaignRequest#builder()}
     * 
     *
     * @param createCampaignRequest
     *        A {@link Consumer} that will call methods on {@link CreateCampaignRequest.Builder} to create a request.
     * @return A Java Future containing the result of the CreateCampaign operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateCampaign
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createCampaign(Consumer createCampaignRequest) {
        return createCampaign(CreateCampaignRequest.builder().applyMutation(createCampaignRequest).build());
    }

    /**
     * 
     * Creates a message template for messages that are sent through the email channel.
     * 
     *
     * @param createEmailTemplateRequest
     * @return A Java Future containing the result of the CreateEmailTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateEmailTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture createEmailTemplate(
            CreateEmailTemplateRequest createEmailTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a message template for messages that are sent through the email channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateEmailTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link CreateEmailTemplateRequest#builder()}
     * 
     *
     * @param createEmailTemplateRequest
     *        A {@link Consumer} that will call methods on {@link CreateEmailTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the CreateEmailTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateEmailTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture createEmailTemplate(
            Consumer createEmailTemplateRequest) {
        return createEmailTemplate(CreateEmailTemplateRequest.builder().applyMutation(createEmailTemplateRequest).build());
    }

    /**
     * 
     * Creates an export job for an application.
     * 
     *
     * @param createExportJobRequest
     * @return A Java Future containing the result of the CreateExportJob operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateExportJob
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createExportJob(CreateExportJobRequest createExportJobRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates an export job for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateExportJobRequest.Builder} avoiding the need
     * to create one manually via {@link CreateExportJobRequest#builder()}
     * 
     *
     * @param createExportJobRequest
     *        A {@link Consumer} that will call methods on {@link CreateExportJobRequest.Builder} to create a request.
     * @return A Java Future containing the result of the CreateExportJob operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateExportJob
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createExportJob(
            Consumer createExportJobRequest) {
        return createExportJob(CreateExportJobRequest.builder().applyMutation(createExportJobRequest).build());
    }

    /**
     * 
     * Creates an import job for an application.
     * 
     *
     * @param createImportJobRequest
     * @return A Java Future containing the result of the CreateImportJob operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateImportJob
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createImportJob(CreateImportJobRequest createImportJobRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates an import job for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateImportJobRequest.Builder} avoiding the need
     * to create one manually via {@link CreateImportJobRequest#builder()}
     * 
     *
     * @param createImportJobRequest
     *        A {@link Consumer} that will call methods on {@link CreateImportJobRequest.Builder} to create a request.
     * @return A Java Future containing the result of the CreateImportJob operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateImportJob
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createImportJob(
            Consumer createImportJobRequest) {
        return createImportJob(CreateImportJobRequest.builder().applyMutation(createImportJobRequest).build());
    }

    /**
     * 
     * Creates a journey for an application.
     * 
     *
     * @param createJourneyRequest
     * @return A Java Future containing the result of the CreateJourney operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateJourney
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createJourney(CreateJourneyRequest createJourneyRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a journey for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateJourneyRequest.Builder} avoiding the need to
     * create one manually via {@link CreateJourneyRequest#builder()}
     * 
     *
     * @param createJourneyRequest
     *        A {@link Consumer} that will call methods on {@link CreateJourneyRequest.Builder} to create a request.
     * @return A Java Future containing the result of the CreateJourney operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateJourney
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createJourney(Consumer createJourneyRequest) {
        return createJourney(CreateJourneyRequest.builder().applyMutation(createJourneyRequest).build());
    }

    /**
     * 
     * Creates a message template for messages that are sent through a push notification channel.
     * 
     *
     * @param createPushTemplateRequest
     * @return A Java Future containing the result of the CreatePushTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreatePushTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture createPushTemplate(CreatePushTemplateRequest createPushTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a message template for messages that are sent through a push notification channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreatePushTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link CreatePushTemplateRequest#builder()}
     * 
     *
     * @param createPushTemplateRequest
     *        A {@link Consumer} that will call methods on {@link CreatePushTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the CreatePushTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreatePushTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture createPushTemplate(
            Consumer createPushTemplateRequest) {
        return createPushTemplate(CreatePushTemplateRequest.builder().applyMutation(createPushTemplateRequest).build());
    }

    /**
     * 
     * Creates an Amazon Pinpoint configuration for a recommender model.
     * 
     *
     * @param createRecommenderConfigurationRequest
     * @return A Java Future containing the result of the CreateRecommenderConfiguration operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateRecommenderConfiguration
     * @see AWS API Documentation
     */
    default CompletableFuture createRecommenderConfiguration(
            CreateRecommenderConfigurationRequest createRecommenderConfigurationRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates an Amazon Pinpoint configuration for a recommender model.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateRecommenderConfigurationRequest.Builder}
     * avoiding the need to create one manually via {@link CreateRecommenderConfigurationRequest#builder()}
     * 
     *
     * @param createRecommenderConfigurationRequest
     *        A {@link Consumer} that will call methods on {@link CreateRecommenderConfigurationRequest.Builder} to
     *        create a request.
     * @return A Java Future containing the result of the CreateRecommenderConfiguration operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateRecommenderConfiguration
     * @see AWS API Documentation
     */
    default CompletableFuture createRecommenderConfiguration(
            Consumer createRecommenderConfigurationRequest) {
        return createRecommenderConfiguration(CreateRecommenderConfigurationRequest.builder()
                .applyMutation(createRecommenderConfigurationRequest).build());
    }

    /**
     * 
     * Creates a new segment for an application or updates the configuration, dimension, and other settings for an
     * existing segment that's associated with an application.
     * 
     *
     * @param createSegmentRequest
     * @return A Java Future containing the result of the CreateSegment operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateSegment
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createSegment(CreateSegmentRequest createSegmentRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a new segment for an application or updates the configuration, dimension, and other settings for an
     * existing segment that's associated with an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateSegmentRequest.Builder} avoiding the need to
     * create one manually via {@link CreateSegmentRequest#builder()}
     * 
     *
     * @param createSegmentRequest
     *        A {@link Consumer} that will call methods on {@link CreateSegmentRequest.Builder} to create a request.
     * @return A Java Future containing the result of the CreateSegment operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateSegment
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture createSegment(Consumer createSegmentRequest) {
        return createSegment(CreateSegmentRequest.builder().applyMutation(createSegmentRequest).build());
    }

    /**
     * 
     * Creates a message template for messages that are sent through the SMS channel.
     * 
     *
     * @param createSmsTemplateRequest
     * @return A Java Future containing the result of the CreateSmsTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateSmsTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture createSmsTemplate(CreateSmsTemplateRequest createSmsTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a message template for messages that are sent through the SMS channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateSmsTemplateRequest.Builder} avoiding the need
     * to create one manually via {@link CreateSmsTemplateRequest#builder()}
     * 
     *
     * @param createSmsTemplateRequest
     *        A {@link Consumer} that will call methods on {@link CreateSmsTemplateRequest.Builder} to create a request.
     * @return A Java Future containing the result of the CreateSmsTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateSmsTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture createSmsTemplate(
            Consumer createSmsTemplateRequest) {
        return createSmsTemplate(CreateSmsTemplateRequest.builder().applyMutation(createSmsTemplateRequest).build());
    }

    /**
     * 
     * Creates a message template for messages that are sent through the voice channel.
     * 
     *
     * @param createVoiceTemplateRequest
     * @return A Java Future containing the result of the CreateVoiceTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateVoiceTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture createVoiceTemplate(
            CreateVoiceTemplateRequest createVoiceTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a message template for messages that are sent through the voice channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link CreateVoiceTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link CreateVoiceTemplateRequest#builder()}
     * 
     *
     * @param createVoiceTemplateRequest
     *        A {@link Consumer} that will call methods on {@link CreateVoiceTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the CreateVoiceTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.CreateVoiceTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture createVoiceTemplate(
            Consumer createVoiceTemplateRequest) {
        return createVoiceTemplate(CreateVoiceTemplateRequest.builder().applyMutation(createVoiceTemplateRequest).build());
    }

    /**
     * 
     * Disables the ADM channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteAdmChannelRequest
     * @return A Java Future containing the result of the DeleteAdmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteAdmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteAdmChannel(DeleteAdmChannelRequest deleteAdmChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the ADM channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteAdmChannelRequest.Builder} avoiding the need
     * to create one manually via {@link DeleteAdmChannelRequest#builder()}
     * 
     *
     * @param deleteAdmChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteAdmChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteAdmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteAdmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteAdmChannel(
            Consumer deleteAdmChannelRequest) {
        return deleteAdmChannel(DeleteAdmChannelRequest.builder().applyMutation(deleteAdmChannelRequest).build());
    }

    /**
     * 
     * Disables the APNs channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteApnsChannelRequest
     * @return A Java Future containing the result of the DeleteApnsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApnsChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteApnsChannel(DeleteApnsChannelRequest deleteApnsChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the APNs channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteApnsChannelRequest.Builder} avoiding the need
     * to create one manually via {@link DeleteApnsChannelRequest#builder()}
     * 
     *
     * @param deleteApnsChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteApnsChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteApnsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApnsChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteApnsChannel(
            Consumer deleteApnsChannelRequest) {
        return deleteApnsChannel(DeleteApnsChannelRequest.builder().applyMutation(deleteApnsChannelRequest).build());
    }

    /**
     * 
     * Disables the APNs sandbox channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteApnsSandboxChannelRequest
     * @return A Java Future containing the result of the DeleteApnsSandboxChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApnsSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture deleteApnsSandboxChannel(
            DeleteApnsSandboxChannelRequest deleteApnsSandboxChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the APNs sandbox channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteApnsSandboxChannelRequest.Builder} avoiding
     * the need to create one manually via {@link DeleteApnsSandboxChannelRequest#builder()}
     * 
     *
     * @param deleteApnsSandboxChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteApnsSandboxChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeleteApnsSandboxChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApnsSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture deleteApnsSandboxChannel(
            Consumer deleteApnsSandboxChannelRequest) {
        return deleteApnsSandboxChannel(DeleteApnsSandboxChannelRequest.builder().applyMutation(deleteApnsSandboxChannelRequest)
                .build());
    }

    /**
     * 
     * Disables the APNs VoIP channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteApnsVoipChannelRequest
     * @return A Java Future containing the result of the DeleteApnsVoipChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApnsVoipChannel
     * @see AWS API Documentation
     */
    default CompletableFuture deleteApnsVoipChannel(
            DeleteApnsVoipChannelRequest deleteApnsVoipChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the APNs VoIP channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteApnsVoipChannelRequest.Builder} avoiding the
     * need to create one manually via {@link DeleteApnsVoipChannelRequest#builder()}
     * 
     *
     * @param deleteApnsVoipChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteApnsVoipChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeleteApnsVoipChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApnsVoipChannel
     * @see AWS API Documentation
     */
    default CompletableFuture deleteApnsVoipChannel(
            Consumer deleteApnsVoipChannelRequest) {
        return deleteApnsVoipChannel(DeleteApnsVoipChannelRequest.builder().applyMutation(deleteApnsVoipChannelRequest).build());
    }

    /**
     * 
     * Disables the APNs VoIP sandbox channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteApnsVoipSandboxChannelRequest
     * @return A Java Future containing the result of the DeleteApnsVoipSandboxChannel operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApnsVoipSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture deleteApnsVoipSandboxChannel(
            DeleteApnsVoipSandboxChannelRequest deleteApnsVoipSandboxChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the APNs VoIP sandbox channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteApnsVoipSandboxChannelRequest.Builder}
     * avoiding the need to create one manually via {@link DeleteApnsVoipSandboxChannelRequest#builder()}
     * 
     *
     * @param deleteApnsVoipSandboxChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteApnsVoipSandboxChannelRequest.Builder} to create
     *        a request.
     * @return A Java Future containing the result of the DeleteApnsVoipSandboxChannel operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApnsVoipSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture deleteApnsVoipSandboxChannel(
            Consumer deleteApnsVoipSandboxChannelRequest) {
        return deleteApnsVoipSandboxChannel(DeleteApnsVoipSandboxChannelRequest.builder()
                .applyMutation(deleteApnsVoipSandboxChannelRequest).build());
    }

    /**
     * 
     * Deletes an application.
     * 
     *
     * @param deleteAppRequest
     * @return A Java Future containing the result of the DeleteApp operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApp
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteApp(DeleteAppRequest deleteAppRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteAppRequest.Builder} avoiding the need to
     * create one manually via {@link DeleteAppRequest#builder()}
     * 
     *
     * @param deleteAppRequest
     *        A {@link Consumer} that will call methods on {@link DeleteAppRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteApp operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteApp
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteApp(Consumer deleteAppRequest) {
        return deleteApp(DeleteAppRequest.builder().applyMutation(deleteAppRequest).build());
    }

    /**
     * 
     * Disables the Baidu channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteBaiduChannelRequest
     * @return A Java Future containing the result of the DeleteBaiduChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteBaiduChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteBaiduChannel(DeleteBaiduChannelRequest deleteBaiduChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the Baidu channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteBaiduChannelRequest.Builder} avoiding the
     * need to create one manually via {@link DeleteBaiduChannelRequest#builder()}
     * 
     *
     * @param deleteBaiduChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteBaiduChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeleteBaiduChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteBaiduChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteBaiduChannel(
            Consumer deleteBaiduChannelRequest) {
        return deleteBaiduChannel(DeleteBaiduChannelRequest.builder().applyMutation(deleteBaiduChannelRequest).build());
    }

    /**
     * 
     * Deletes a campaign from an application.
     * 
     *
     * @param deleteCampaignRequest
     * @return A Java Future containing the result of the DeleteCampaign operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteCampaign
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteCampaign(DeleteCampaignRequest deleteCampaignRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes a campaign from an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteCampaignRequest.Builder} avoiding the need to
     * create one manually via {@link DeleteCampaignRequest#builder()}
     * 
     *
     * @param deleteCampaignRequest
     *        A {@link Consumer} that will call methods on {@link DeleteCampaignRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteCampaign operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteCampaign
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteCampaign(Consumer deleteCampaignRequest) {
        return deleteCampaign(DeleteCampaignRequest.builder().applyMutation(deleteCampaignRequest).build());
    }

    /**
     * 
     * Disables the email channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteEmailChannelRequest
     * @return A Java Future containing the result of the DeleteEmailChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteEmailChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteEmailChannel(DeleteEmailChannelRequest deleteEmailChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the email channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteEmailChannelRequest.Builder} avoiding the
     * need to create one manually via {@link DeleteEmailChannelRequest#builder()}
     * 
     *
     * @param deleteEmailChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteEmailChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeleteEmailChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteEmailChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteEmailChannel(
            Consumer deleteEmailChannelRequest) {
        return deleteEmailChannel(DeleteEmailChannelRequest.builder().applyMutation(deleteEmailChannelRequest).build());
    }

    /**
     * 
     * Deletes a message template for messages that were sent through the email channel.
     * 
     *
     * @param deleteEmailTemplateRequest
     * @return A Java Future containing the result of the DeleteEmailTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteEmailTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteEmailTemplate(
            DeleteEmailTemplateRequest deleteEmailTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes a message template for messages that were sent through the email channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteEmailTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link DeleteEmailTemplateRequest#builder()}
     * 
     *
     * @param deleteEmailTemplateRequest
     *        A {@link Consumer} that will call methods on {@link DeleteEmailTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeleteEmailTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteEmailTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteEmailTemplate(
            Consumer deleteEmailTemplateRequest) {
        return deleteEmailTemplate(DeleteEmailTemplateRequest.builder().applyMutation(deleteEmailTemplateRequest).build());
    }

    /**
     * 
     * Deletes an endpoint from an application.
     * 
     *
     * @param deleteEndpointRequest
     * @return A Java Future containing the result of the DeleteEndpoint operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteEndpoint
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteEndpoint(DeleteEndpointRequest deleteEndpointRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes an endpoint from an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteEndpointRequest.Builder} avoiding the need to
     * create one manually via {@link DeleteEndpointRequest#builder()}
     * 
     *
     * @param deleteEndpointRequest
     *        A {@link Consumer} that will call methods on {@link DeleteEndpointRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteEndpoint operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteEndpoint
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteEndpoint(Consumer deleteEndpointRequest) {
        return deleteEndpoint(DeleteEndpointRequest.builder().applyMutation(deleteEndpointRequest).build());
    }

    /**
     * 
     * Deletes the event stream for an application.
     * 
     *
     * @param deleteEventStreamRequest
     * @return A Java Future containing the result of the DeleteEventStream operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteEventStream
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteEventStream(DeleteEventStreamRequest deleteEventStreamRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes the event stream for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteEventStreamRequest.Builder} avoiding the need
     * to create one manually via {@link DeleteEventStreamRequest#builder()}
     * 
     *
     * @param deleteEventStreamRequest
     *        A {@link Consumer} that will call methods on {@link DeleteEventStreamRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteEventStream operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteEventStream
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteEventStream(
            Consumer deleteEventStreamRequest) {
        return deleteEventStream(DeleteEventStreamRequest.builder().applyMutation(deleteEventStreamRequest).build());
    }

    /**
     * 
     * Disables the GCM channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteGcmChannelRequest
     * @return A Java Future containing the result of the DeleteGcmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteGcmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteGcmChannel(DeleteGcmChannelRequest deleteGcmChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the GCM channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteGcmChannelRequest.Builder} avoiding the need
     * to create one manually via {@link DeleteGcmChannelRequest#builder()}
     * 
     *
     * @param deleteGcmChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteGcmChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteGcmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteGcmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteGcmChannel(
            Consumer deleteGcmChannelRequest) {
        return deleteGcmChannel(DeleteGcmChannelRequest.builder().applyMutation(deleteGcmChannelRequest).build());
    }

    /**
     * 
     * Deletes a journey from an application.
     * 
     *
     * @param deleteJourneyRequest
     * @return A Java Future containing the result of the DeleteJourney operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteJourney
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteJourney(DeleteJourneyRequest deleteJourneyRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes a journey from an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteJourneyRequest.Builder} avoiding the need to
     * create one manually via {@link DeleteJourneyRequest#builder()}
     * 
     *
     * @param deleteJourneyRequest
     *        A {@link Consumer} that will call methods on {@link DeleteJourneyRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteJourney operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteJourney
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteJourney(Consumer deleteJourneyRequest) {
        return deleteJourney(DeleteJourneyRequest.builder().applyMutation(deleteJourneyRequest).build());
    }

    /**
     * 
     * Deletes a message template for messages that were sent through a push notification channel.
     * 
     *
     * @param deletePushTemplateRequest
     * @return A Java Future containing the result of the DeletePushTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeletePushTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deletePushTemplate(DeletePushTemplateRequest deletePushTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes a message template for messages that were sent through a push notification channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeletePushTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link DeletePushTemplateRequest#builder()}
     * 
     *
     * @param deletePushTemplateRequest
     *        A {@link Consumer} that will call methods on {@link DeletePushTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeletePushTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeletePushTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deletePushTemplate(
            Consumer deletePushTemplateRequest) {
        return deletePushTemplate(DeletePushTemplateRequest.builder().applyMutation(deletePushTemplateRequest).build());
    }

    /**
     * 
     * Deletes an Amazon Pinpoint configuration for a recommender model.
     * 
     *
     * @param deleteRecommenderConfigurationRequest
     * @return A Java Future containing the result of the DeleteRecommenderConfiguration operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteRecommenderConfiguration
     * @see AWS API Documentation
     */
    default CompletableFuture deleteRecommenderConfiguration(
            DeleteRecommenderConfigurationRequest deleteRecommenderConfigurationRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes an Amazon Pinpoint configuration for a recommender model.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteRecommenderConfigurationRequest.Builder}
     * avoiding the need to create one manually via {@link DeleteRecommenderConfigurationRequest#builder()}
     * 
     *
     * @param deleteRecommenderConfigurationRequest
     *        A {@link Consumer} that will call methods on {@link DeleteRecommenderConfigurationRequest.Builder} to
     *        create a request.
     * @return A Java Future containing the result of the DeleteRecommenderConfiguration operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteRecommenderConfiguration
     * @see AWS API Documentation
     */
    default CompletableFuture deleteRecommenderConfiguration(
            Consumer deleteRecommenderConfigurationRequest) {
        return deleteRecommenderConfiguration(DeleteRecommenderConfigurationRequest.builder()
                .applyMutation(deleteRecommenderConfigurationRequest).build());
    }

    /**
     * 
     * Deletes a segment from an application.
     * 
     *
     * @param deleteSegmentRequest
     * @return A Java Future containing the result of the DeleteSegment operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteSegment
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteSegment(DeleteSegmentRequest deleteSegmentRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes a segment from an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteSegmentRequest.Builder} avoiding the need to
     * create one manually via {@link DeleteSegmentRequest#builder()}
     * 
     *
     * @param deleteSegmentRequest
     *        A {@link Consumer} that will call methods on {@link DeleteSegmentRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteSegment operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteSegment
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteSegment(Consumer deleteSegmentRequest) {
        return deleteSegment(DeleteSegmentRequest.builder().applyMutation(deleteSegmentRequest).build());
    }

    /**
     * 
     * Disables the SMS channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteSmsChannelRequest
     * @return A Java Future containing the result of the DeleteSmsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteSmsChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteSmsChannel(DeleteSmsChannelRequest deleteSmsChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the SMS channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteSmsChannelRequest.Builder} avoiding the need
     * to create one manually via {@link DeleteSmsChannelRequest#builder()}
     * 
     *
     * @param deleteSmsChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteSmsChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteSmsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteSmsChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture deleteSmsChannel(
            Consumer deleteSmsChannelRequest) {
        return deleteSmsChannel(DeleteSmsChannelRequest.builder().applyMutation(deleteSmsChannelRequest).build());
    }

    /**
     * 
     * Deletes a message template for messages that were sent through the SMS channel.
     * 
     *
     * @param deleteSmsTemplateRequest
     * @return A Java Future containing the result of the DeleteSmsTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteSmsTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteSmsTemplate(DeleteSmsTemplateRequest deleteSmsTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes a message template for messages that were sent through the SMS channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteSmsTemplateRequest.Builder} avoiding the need
     * to create one manually via {@link DeleteSmsTemplateRequest#builder()}
     * 
     *
     * @param deleteSmsTemplateRequest
     *        A {@link Consumer} that will call methods on {@link DeleteSmsTemplateRequest.Builder} to create a request.
     * @return A Java Future containing the result of the DeleteSmsTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteSmsTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteSmsTemplate(
            Consumer deleteSmsTemplateRequest) {
        return deleteSmsTemplate(DeleteSmsTemplateRequest.builder().applyMutation(deleteSmsTemplateRequest).build());
    }

    /**
     * 
     * Deletes all the endpoints that are associated with a specific user ID.
     * 
     *
     * @param deleteUserEndpointsRequest
     * @return A Java Future containing the result of the DeleteUserEndpoints operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteUserEndpoints
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteUserEndpoints(
            DeleteUserEndpointsRequest deleteUserEndpointsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes all the endpoints that are associated with a specific user ID.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteUserEndpointsRequest.Builder} avoiding the
     * need to create one manually via {@link DeleteUserEndpointsRequest#builder()}
     * 
     *
     * @param deleteUserEndpointsRequest
     *        A {@link Consumer} that will call methods on {@link DeleteUserEndpointsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeleteUserEndpoints operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteUserEndpoints
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteUserEndpoints(
            Consumer deleteUserEndpointsRequest) {
        return deleteUserEndpoints(DeleteUserEndpointsRequest.builder().applyMutation(deleteUserEndpointsRequest).build());
    }

    /**
     * 
     * Disables the voice channel for an application and deletes any existing settings for the channel.
     * 
     *
     * @param deleteVoiceChannelRequest
     * @return A Java Future containing the result of the DeleteVoiceChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteVoiceChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteVoiceChannel(DeleteVoiceChannelRequest deleteVoiceChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Disables the voice channel for an application and deletes any existing settings for the channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteVoiceChannelRequest.Builder} avoiding the
     * need to create one manually via {@link DeleteVoiceChannelRequest#builder()}
     * 
     *
     * @param deleteVoiceChannelRequest
     *        A {@link Consumer} that will call methods on {@link DeleteVoiceChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeleteVoiceChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteVoiceChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteVoiceChannel(
            Consumer deleteVoiceChannelRequest) {
        return deleteVoiceChannel(DeleteVoiceChannelRequest.builder().applyMutation(deleteVoiceChannelRequest).build());
    }

    /**
     * 
     * Deletes a message template for messages that were sent through the voice channel.
     * 
     *
     * @param deleteVoiceTemplateRequest
     * @return A Java Future containing the result of the DeleteVoiceTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteVoiceTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteVoiceTemplate(
            DeleteVoiceTemplateRequest deleteVoiceTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Deletes a message template for messages that were sent through the voice channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link DeleteVoiceTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link DeleteVoiceTemplateRequest#builder()}
     * 
     *
     * @param deleteVoiceTemplateRequest
     *        A {@link Consumer} that will call methods on {@link DeleteVoiceTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the DeleteVoiceTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.DeleteVoiceTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture deleteVoiceTemplate(
            Consumer deleteVoiceTemplateRequest) {
        return deleteVoiceTemplate(DeleteVoiceTemplateRequest.builder().applyMutation(deleteVoiceTemplateRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the ADM channel for an application.
     * 
     *
     * @param getAdmChannelRequest
     * @return A Java Future containing the result of the GetAdmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetAdmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getAdmChannel(GetAdmChannelRequest getAdmChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the ADM channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetAdmChannelRequest.Builder} avoiding the need to
     * create one manually via {@link GetAdmChannelRequest#builder()}
     * 
     *
     * @param getAdmChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetAdmChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetAdmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetAdmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getAdmChannel(Consumer getAdmChannelRequest) {
        return getAdmChannel(GetAdmChannelRequest.builder().applyMutation(getAdmChannelRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the APNs channel for an application.
     * 
     *
     * @param getApnsChannelRequest
     * @return A Java Future containing the result of the GetApnsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApnsChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getApnsChannel(GetApnsChannelRequest getApnsChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the APNs channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetApnsChannelRequest.Builder} avoiding the need to
     * create one manually via {@link GetApnsChannelRequest#builder()}
     * 
     *
     * @param getApnsChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetApnsChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetApnsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApnsChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getApnsChannel(Consumer getApnsChannelRequest) {
        return getApnsChannel(GetApnsChannelRequest.builder().applyMutation(getApnsChannelRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the APNs sandbox channel for an application.
     * 
     *
     * @param getApnsSandboxChannelRequest
     * @return A Java Future containing the result of the GetApnsSandboxChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApnsSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture getApnsSandboxChannel(
            GetApnsSandboxChannelRequest getApnsSandboxChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the APNs sandbox channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetApnsSandboxChannelRequest.Builder} avoiding the
     * need to create one manually via {@link GetApnsSandboxChannelRequest#builder()}
     * 
     *
     * @param getApnsSandboxChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetApnsSandboxChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetApnsSandboxChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApnsSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture getApnsSandboxChannel(
            Consumer getApnsSandboxChannelRequest) {
        return getApnsSandboxChannel(GetApnsSandboxChannelRequest.builder().applyMutation(getApnsSandboxChannelRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the APNs VoIP channel for an application.
     * 
     *
     * @param getApnsVoipChannelRequest
     * @return A Java Future containing the result of the GetApnsVoipChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApnsVoipChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getApnsVoipChannel(GetApnsVoipChannelRequest getApnsVoipChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the APNs VoIP channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetApnsVoipChannelRequest.Builder} avoiding the
     * need to create one manually via {@link GetApnsVoipChannelRequest#builder()}
     * 
     *
     * @param getApnsVoipChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetApnsVoipChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetApnsVoipChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApnsVoipChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getApnsVoipChannel(
            Consumer getApnsVoipChannelRequest) {
        return getApnsVoipChannel(GetApnsVoipChannelRequest.builder().applyMutation(getApnsVoipChannelRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the APNs VoIP sandbox channel for an application.
     * 
     *
     * @param getApnsVoipSandboxChannelRequest
     * @return A Java Future containing the result of the GetApnsVoipSandboxChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApnsVoipSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture getApnsVoipSandboxChannel(
            GetApnsVoipSandboxChannelRequest getApnsVoipSandboxChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the APNs VoIP sandbox channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetApnsVoipSandboxChannelRequest.Builder} avoiding
     * the need to create one manually via {@link GetApnsVoipSandboxChannelRequest#builder()}
     * 
     *
     * @param getApnsVoipSandboxChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetApnsVoipSandboxChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetApnsVoipSandboxChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApnsVoipSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture getApnsVoipSandboxChannel(
            Consumer getApnsVoipSandboxChannelRequest) {
        return getApnsVoipSandboxChannel(GetApnsVoipSandboxChannelRequest.builder()
                .applyMutation(getApnsVoipSandboxChannelRequest).build());
    }

    /**
     * 
     * Retrieves information about an application.
     * 
     *
     * @param getAppRequest
     * @return A Java Future containing the result of the GetApp operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApp
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getApp(GetAppRequest getAppRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetAppRequest.Builder} avoiding the need to create
     * one manually via {@link GetAppRequest#builder()}
     * 
     *
     * @param getAppRequest
     *        A {@link Consumer} that will call methods on {@link GetAppRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetApp operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApp
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getApp(Consumer getAppRequest) {
        return getApp(GetAppRequest.builder().applyMutation(getAppRequest).build());
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard metric that applies to an application.
     * 
     *
     * @param getApplicationDateRangeKpiRequest
     * @return A Java Future containing the result of the GetApplicationDateRangeKpi operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApplicationDateRangeKpi
     * @see AWS API Documentation
     */
    default CompletableFuture getApplicationDateRangeKpi(
            GetApplicationDateRangeKpiRequest getApplicationDateRangeKpiRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard metric that applies to an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetApplicationDateRangeKpiRequest.Builder} avoiding
     * the need to create one manually via {@link GetApplicationDateRangeKpiRequest#builder()}
     * 
     *
     * @param getApplicationDateRangeKpiRequest
     *        A {@link Consumer} that will call methods on {@link GetApplicationDateRangeKpiRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetApplicationDateRangeKpi operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApplicationDateRangeKpi
     * @see AWS API Documentation
     */
    default CompletableFuture getApplicationDateRangeKpi(
            Consumer getApplicationDateRangeKpiRequest) {
        return getApplicationDateRangeKpi(GetApplicationDateRangeKpiRequest.builder()
                .applyMutation(getApplicationDateRangeKpiRequest).build());
    }

    /**
     * 
     * Retrieves information about the settings for an application.
     * 
     *
     * @param getApplicationSettingsRequest
     * @return A Java Future containing the result of the GetApplicationSettings operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApplicationSettings
     * @see AWS API Documentation
     */
    default CompletableFuture getApplicationSettings(
            GetApplicationSettingsRequest getApplicationSettingsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the settings for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetApplicationSettingsRequest.Builder} avoiding the
     * need to create one manually via {@link GetApplicationSettingsRequest#builder()}
     * 
     *
     * @param getApplicationSettingsRequest
     *        A {@link Consumer} that will call methods on {@link GetApplicationSettingsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetApplicationSettings operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApplicationSettings
     * @see AWS API Documentation
     */
    default CompletableFuture getApplicationSettings(
            Consumer getApplicationSettingsRequest) {
        return getApplicationSettings(GetApplicationSettingsRequest.builder().applyMutation(getApplicationSettingsRequest)
                .build());
    }

    /**
     * 
     * Retrieves information about all the applications that are associated with your Amazon Pinpoint account.
     * 
     *
     * @param getAppsRequest
     * @return A Java Future containing the result of the GetApps operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApps
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getApps(GetAppsRequest getAppsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about all the applications that are associated with your Amazon Pinpoint account.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetAppsRequest.Builder} avoiding the need to create
     * one manually via {@link GetAppsRequest#builder()}
     * 
     *
     * @param getAppsRequest
     *        A {@link Consumer} that will call methods on {@link GetAppsRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetApps operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetApps
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getApps(Consumer getAppsRequest) {
        return getApps(GetAppsRequest.builder().applyMutation(getAppsRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the Baidu channel for an application.
     * 
     *
     * @param getBaiduChannelRequest
     * @return A Java Future containing the result of the GetBaiduChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetBaiduChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getBaiduChannel(GetBaiduChannelRequest getBaiduChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the Baidu channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetBaiduChannelRequest.Builder} avoiding the need
     * to create one manually via {@link GetBaiduChannelRequest#builder()}
     * 
     *
     * @param getBaiduChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetBaiduChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetBaiduChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetBaiduChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getBaiduChannel(
            Consumer getBaiduChannelRequest) {
        return getBaiduChannel(GetBaiduChannelRequest.builder().applyMutation(getBaiduChannelRequest).build());
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for a campaign.
     * 
     *
     * @param getCampaignRequest
     * @return A Java Future containing the result of the GetCampaign operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaign
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getCampaign(GetCampaignRequest getCampaignRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for a campaign.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetCampaignRequest.Builder} avoiding the need to
     * create one manually via {@link GetCampaignRequest#builder()}
     * 
     *
     * @param getCampaignRequest
     *        A {@link Consumer} that will call methods on {@link GetCampaignRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetCampaign operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaign
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getCampaign(Consumer getCampaignRequest) {
        return getCampaign(GetCampaignRequest.builder().applyMutation(getCampaignRequest).build());
    }

    /**
     * 
     * Retrieves information about all the activities for a campaign.
     * 
     *
     * @param getCampaignActivitiesRequest
     * @return A Java Future containing the result of the GetCampaignActivities operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaignActivities
     * @see AWS API Documentation
     */
    default CompletableFuture getCampaignActivities(
            GetCampaignActivitiesRequest getCampaignActivitiesRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about all the activities for a campaign.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetCampaignActivitiesRequest.Builder} avoiding the
     * need to create one manually via {@link GetCampaignActivitiesRequest#builder()}
     * 
     *
     * @param getCampaignActivitiesRequest
     *        A {@link Consumer} that will call methods on {@link GetCampaignActivitiesRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetCampaignActivities operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaignActivities
     * @see AWS API Documentation
     */
    default CompletableFuture getCampaignActivities(
            Consumer getCampaignActivitiesRequest) {
        return getCampaignActivities(GetCampaignActivitiesRequest.builder().applyMutation(getCampaignActivitiesRequest).build());
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard metric that applies to a campaign.
     * 
     *
     * @param getCampaignDateRangeKpiRequest
     * @return A Java Future containing the result of the GetCampaignDateRangeKpi operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaignDateRangeKpi
     * @see AWS API Documentation
     */
    default CompletableFuture getCampaignDateRangeKpi(
            GetCampaignDateRangeKpiRequest getCampaignDateRangeKpiRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard metric that applies to a campaign.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetCampaignDateRangeKpiRequest.Builder} avoiding
     * the need to create one manually via {@link GetCampaignDateRangeKpiRequest#builder()}
     * 
     *
     * @param getCampaignDateRangeKpiRequest
     *        A {@link Consumer} that will call methods on {@link GetCampaignDateRangeKpiRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetCampaignDateRangeKpi operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaignDateRangeKpi
     * @see AWS API Documentation
     */
    default CompletableFuture getCampaignDateRangeKpi(
            Consumer getCampaignDateRangeKpiRequest) {
        return getCampaignDateRangeKpi(GetCampaignDateRangeKpiRequest.builder().applyMutation(getCampaignDateRangeKpiRequest)
                .build());
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for a specific version of a campaign.
     * 
     *
     * @param getCampaignVersionRequest
     * @return A Java Future containing the result of the GetCampaignVersion operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaignVersion
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getCampaignVersion(GetCampaignVersionRequest getCampaignVersionRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for a specific version of a campaign.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetCampaignVersionRequest.Builder} avoiding the
     * need to create one manually via {@link GetCampaignVersionRequest#builder()}
     * 
     *
     * @param getCampaignVersionRequest
     *        A {@link Consumer} that will call methods on {@link GetCampaignVersionRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetCampaignVersion operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaignVersion
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getCampaignVersion(
            Consumer getCampaignVersionRequest) {
        return getCampaignVersion(GetCampaignVersionRequest.builder().applyMutation(getCampaignVersionRequest).build());
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for all versions of a campaign.
     * 
     *
     * @param getCampaignVersionsRequest
     * @return A Java Future containing the result of the GetCampaignVersions operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaignVersions
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getCampaignVersions(
            GetCampaignVersionsRequest getCampaignVersionsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for all versions of a campaign.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetCampaignVersionsRequest.Builder} avoiding the
     * need to create one manually via {@link GetCampaignVersionsRequest#builder()}
     * 
     *
     * @param getCampaignVersionsRequest
     *        A {@link Consumer} that will call methods on {@link GetCampaignVersionsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetCampaignVersions operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaignVersions
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getCampaignVersions(
            Consumer getCampaignVersionsRequest) {
        return getCampaignVersions(GetCampaignVersionsRequest.builder().applyMutation(getCampaignVersionsRequest).build());
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for all the campaigns that are
     * associated with an application.
     * 
     *
     * @param getCampaignsRequest
     * @return A Java Future containing the result of the GetCampaigns operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaigns
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getCampaigns(GetCampaignsRequest getCampaignsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for all the campaigns that are
     * associated with an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetCampaignsRequest.Builder} avoiding the need to
     * create one manually via {@link GetCampaignsRequest#builder()}
     * 
     *
     * @param getCampaignsRequest
     *        A {@link Consumer} that will call methods on {@link GetCampaignsRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetCampaigns operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetCampaigns
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getCampaigns(Consumer getCampaignsRequest) {
        return getCampaigns(GetCampaignsRequest.builder().applyMutation(getCampaignsRequest).build());
    }

    /**
     * 
     * Retrieves information about the history and status of each channel for an application.
     * 
     *
     * @param getChannelsRequest
     * @return A Java Future containing the result of the GetChannels operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetChannels
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getChannels(GetChannelsRequest getChannelsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the history and status of each channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetChannelsRequest.Builder} avoiding the need to
     * create one manually via {@link GetChannelsRequest#builder()}
     * 
     *
     * @param getChannelsRequest
     *        A {@link Consumer} that will call methods on {@link GetChannelsRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetChannels operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetChannels
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getChannels(Consumer getChannelsRequest) {
        return getChannels(GetChannelsRequest.builder().applyMutation(getChannelsRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the email channel for an application.
     * 
     *
     * @param getEmailChannelRequest
     * @return A Java Future containing the result of the GetEmailChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetEmailChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getEmailChannel(GetEmailChannelRequest getEmailChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the email channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetEmailChannelRequest.Builder} avoiding the need
     * to create one manually via {@link GetEmailChannelRequest#builder()}
     * 
     *
     * @param getEmailChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetEmailChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetEmailChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetEmailChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getEmailChannel(
            Consumer getEmailChannelRequest) {
        return getEmailChannel(GetEmailChannelRequest.builder().applyMutation(getEmailChannelRequest).build());
    }

    /**
     * 
     * Retrieves the content and settings of a message template for messages that are sent through the email channel.
     * 
     *
     * @param getEmailTemplateRequest
     * @return A Java Future containing the result of the GetEmailTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetEmailTemplate
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getEmailTemplate(GetEmailTemplateRequest getEmailTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves the content and settings of a message template for messages that are sent through the email channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetEmailTemplateRequest.Builder} avoiding the need
     * to create one manually via {@link GetEmailTemplateRequest#builder()}
     * 
     *
     * @param getEmailTemplateRequest
     *        A {@link Consumer} that will call methods on {@link GetEmailTemplateRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetEmailTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetEmailTemplate
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getEmailTemplate(
            Consumer getEmailTemplateRequest) {
        return getEmailTemplate(GetEmailTemplateRequest.builder().applyMutation(getEmailTemplateRequest).build());
    }

    /**
     * 
     * Retrieves information about the settings and attributes of a specific endpoint for an application.
     * 
     *
     * @param getEndpointRequest
     * @return A Java Future containing the result of the GetEndpoint operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetEndpoint
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getEndpoint(GetEndpointRequest getEndpointRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the settings and attributes of a specific endpoint for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetEndpointRequest.Builder} avoiding the need to
     * create one manually via {@link GetEndpointRequest#builder()}
     * 
     *
     * @param getEndpointRequest
     *        A {@link Consumer} that will call methods on {@link GetEndpointRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetEndpoint operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetEndpoint
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getEndpoint(Consumer getEndpointRequest) {
        return getEndpoint(GetEndpointRequest.builder().applyMutation(getEndpointRequest).build());
    }

    /**
     * 
     * Retrieves information about the event stream settings for an application.
     * 
     *
     * @param getEventStreamRequest
     * @return A Java Future containing the result of the GetEventStream operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetEventStream
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getEventStream(GetEventStreamRequest getEventStreamRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the event stream settings for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetEventStreamRequest.Builder} avoiding the need to
     * create one manually via {@link GetEventStreamRequest#builder()}
     * 
     *
     * @param getEventStreamRequest
     *        A {@link Consumer} that will call methods on {@link GetEventStreamRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetEventStream operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetEventStream
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getEventStream(Consumer getEventStreamRequest) {
        return getEventStream(GetEventStreamRequest.builder().applyMutation(getEventStreamRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of a specific export job for an application.
     * 
     *
     * @param getExportJobRequest
     * @return A Java Future containing the result of the GetExportJob operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetExportJob
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getExportJob(GetExportJobRequest getExportJobRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of a specific export job for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetExportJobRequest.Builder} avoiding the need to
     * create one manually via {@link GetExportJobRequest#builder()}
     * 
     *
     * @param getExportJobRequest
     *        A {@link Consumer} that will call methods on {@link GetExportJobRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetExportJob operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetExportJob
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getExportJob(Consumer getExportJobRequest) {
        return getExportJob(GetExportJobRequest.builder().applyMutation(getExportJobRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of all the export jobs for an application.
     * 
     *
     * @param getExportJobsRequest
     * @return A Java Future containing the result of the GetExportJobs operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetExportJobs
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getExportJobs(GetExportJobsRequest getExportJobsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of all the export jobs for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetExportJobsRequest.Builder} avoiding the need to
     * create one manually via {@link GetExportJobsRequest#builder()}
     * 
     *
     * @param getExportJobsRequest
     *        A {@link Consumer} that will call methods on {@link GetExportJobsRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetExportJobs operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetExportJobs
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getExportJobs(Consumer getExportJobsRequest) {
        return getExportJobs(GetExportJobsRequest.builder().applyMutation(getExportJobsRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the GCM channel for an application.
     * 
     *
     * @param getGcmChannelRequest
     * @return A Java Future containing the result of the GetGcmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetGcmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getGcmChannel(GetGcmChannelRequest getGcmChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the GCM channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetGcmChannelRequest.Builder} avoiding the need to
     * create one manually via {@link GetGcmChannelRequest#builder()}
     * 
     *
     * @param getGcmChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetGcmChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetGcmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetGcmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getGcmChannel(Consumer getGcmChannelRequest) {
        return getGcmChannel(GetGcmChannelRequest.builder().applyMutation(getGcmChannelRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of a specific import job for an application.
     * 
     *
     * @param getImportJobRequest
     * @return A Java Future containing the result of the GetImportJob operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetImportJob
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getImportJob(GetImportJobRequest getImportJobRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of a specific import job for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetImportJobRequest.Builder} avoiding the need to
     * create one manually via {@link GetImportJobRequest#builder()}
     * 
     *
     * @param getImportJobRequest
     *        A {@link Consumer} that will call methods on {@link GetImportJobRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetImportJob operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetImportJob
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getImportJob(Consumer getImportJobRequest) {
        return getImportJob(GetImportJobRequest.builder().applyMutation(getImportJobRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of all the import jobs for an application.
     * 
     *
     * @param getImportJobsRequest
     * @return A Java Future containing the result of the GetImportJobs operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetImportJobs
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getImportJobs(GetImportJobsRequest getImportJobsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of all the import jobs for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetImportJobsRequest.Builder} avoiding the need to
     * create one manually via {@link GetImportJobsRequest#builder()}
     * 
     *
     * @param getImportJobsRequest
     *        A {@link Consumer} that will call methods on {@link GetImportJobsRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetImportJobs operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetImportJobs
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getImportJobs(Consumer getImportJobsRequest) {
        return getImportJobs(GetImportJobsRequest.builder().applyMutation(getImportJobsRequest).build());
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for a journey.
     * 
     *
     * @param getJourneyRequest
     * @return A Java Future containing the result of the GetJourney operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetJourney
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getJourney(GetJourneyRequest getJourneyRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for a journey.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetJourneyRequest.Builder} avoiding the need to
     * create one manually via {@link GetJourneyRequest#builder()}
     * 
     *
     * @param getJourneyRequest
     *        A {@link Consumer} that will call methods on {@link GetJourneyRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetJourney operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetJourney
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getJourney(Consumer getJourneyRequest) {
        return getJourney(GetJourneyRequest.builder().applyMutation(getJourneyRequest).build());
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard engagement metric that applies to a journey.
     * 
     *
     * @param getJourneyDateRangeKpiRequest
     * @return A Java Future containing the result of the GetJourneyDateRangeKpi operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetJourneyDateRangeKpi
     * @see AWS API Documentation
     */
    default CompletableFuture getJourneyDateRangeKpi(
            GetJourneyDateRangeKpiRequest getJourneyDateRangeKpiRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard engagement metric that applies to a journey.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetJourneyDateRangeKpiRequest.Builder} avoiding the
     * need to create one manually via {@link GetJourneyDateRangeKpiRequest#builder()}
     * 
     *
     * @param getJourneyDateRangeKpiRequest
     *        A {@link Consumer} that will call methods on {@link GetJourneyDateRangeKpiRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetJourneyDateRangeKpi operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetJourneyDateRangeKpi
     * @see AWS API Documentation
     */
    default CompletableFuture getJourneyDateRangeKpi(
            Consumer getJourneyDateRangeKpiRequest) {
        return getJourneyDateRangeKpi(GetJourneyDateRangeKpiRequest.builder().applyMutation(getJourneyDateRangeKpiRequest)
                .build());
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard execution metric that applies to a journey activity.
     * 
     *
     * @param getJourneyExecutionActivityMetricsRequest
     * @return A Java Future containing the result of the GetJourneyExecutionActivityMetrics operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetJourneyExecutionActivityMetrics
     * @see AWS API Documentation
     */
    default CompletableFuture getJourneyExecutionActivityMetrics(
            GetJourneyExecutionActivityMetricsRequest getJourneyExecutionActivityMetricsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard execution metric that applies to a journey activity.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetJourneyExecutionActivityMetricsRequest.Builder}
     * avoiding the need to create one manually via {@link GetJourneyExecutionActivityMetricsRequest#builder()}
     * 
     *
     * @param getJourneyExecutionActivityMetricsRequest
     *        A {@link Consumer} that will call methods on {@link GetJourneyExecutionActivityMetricsRequest.Builder} to
     *        create a request.
     * @return A Java Future containing the result of the GetJourneyExecutionActivityMetrics operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetJourneyExecutionActivityMetrics
     * @see AWS API Documentation
     */
    default CompletableFuture getJourneyExecutionActivityMetrics(
            Consumer getJourneyExecutionActivityMetricsRequest) {
        return getJourneyExecutionActivityMetrics(GetJourneyExecutionActivityMetricsRequest.builder()
                .applyMutation(getJourneyExecutionActivityMetricsRequest).build());
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard execution metric that applies to a journey.
     * 
     *
     * @param getJourneyExecutionMetricsRequest
     * @return A Java Future containing the result of the GetJourneyExecutionMetrics operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetJourneyExecutionMetrics
     * @see AWS API Documentation
     */
    default CompletableFuture getJourneyExecutionMetrics(
            GetJourneyExecutionMetricsRequest getJourneyExecutionMetricsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves (queries) pre-aggregated data for a standard execution metric that applies to a journey.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetJourneyExecutionMetricsRequest.Builder} avoiding
     * the need to create one manually via {@link GetJourneyExecutionMetricsRequest#builder()}
     * 
     *
     * @param getJourneyExecutionMetricsRequest
     *        A {@link Consumer} that will call methods on {@link GetJourneyExecutionMetricsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetJourneyExecutionMetrics operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetJourneyExecutionMetrics
     * @see AWS API Documentation
     */
    default CompletableFuture getJourneyExecutionMetrics(
            Consumer getJourneyExecutionMetricsRequest) {
        return getJourneyExecutionMetrics(GetJourneyExecutionMetricsRequest.builder()
                .applyMutation(getJourneyExecutionMetricsRequest).build());
    }

    /**
     * 
     * Retrieves the content and settings of a message template for messages that are sent through a push notification
     * channel.
     * 
     *
     * @param getPushTemplateRequest
     * @return A Java Future containing the result of the GetPushTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetPushTemplate
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getPushTemplate(GetPushTemplateRequest getPushTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves the content and settings of a message template for messages that are sent through a push notification
     * channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetPushTemplateRequest.Builder} avoiding the need
     * to create one manually via {@link GetPushTemplateRequest#builder()}
     * 
     *
     * @param getPushTemplateRequest
     *        A {@link Consumer} that will call methods on {@link GetPushTemplateRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetPushTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetPushTemplate
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getPushTemplate(
            Consumer getPushTemplateRequest) {
        return getPushTemplate(GetPushTemplateRequest.builder().applyMutation(getPushTemplateRequest).build());
    }

    /**
     * 
     * Retrieves information about an Amazon Pinpoint configuration for a recommender model.
     * 
     *
     * @param getRecommenderConfigurationRequest
     * @return A Java Future containing the result of the GetRecommenderConfiguration operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetRecommenderConfiguration
     * @see AWS API Documentation
     */
    default CompletableFuture getRecommenderConfiguration(
            GetRecommenderConfigurationRequest getRecommenderConfigurationRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about an Amazon Pinpoint configuration for a recommender model.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetRecommenderConfigurationRequest.Builder}
     * avoiding the need to create one manually via {@link GetRecommenderConfigurationRequest#builder()}
     * 
     *
     * @param getRecommenderConfigurationRequest
     *        A {@link Consumer} that will call methods on {@link GetRecommenderConfigurationRequest.Builder} to create
     *        a request.
     * @return A Java Future containing the result of the GetRecommenderConfiguration operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetRecommenderConfiguration
     * @see AWS API Documentation
     */
    default CompletableFuture getRecommenderConfiguration(
            Consumer getRecommenderConfigurationRequest) {
        return getRecommenderConfiguration(GetRecommenderConfigurationRequest.builder()
                .applyMutation(getRecommenderConfigurationRequest).build());
    }

    /**
     * 
     * Retrieves information about all the recommender model configurations that are associated with your Amazon
     * Pinpoint account.
     * 
     *
     * @param getRecommenderConfigurationsRequest
     * @return A Java Future containing the result of the GetRecommenderConfigurations operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetRecommenderConfigurations
     * @see AWS API Documentation
     */
    default CompletableFuture getRecommenderConfigurations(
            GetRecommenderConfigurationsRequest getRecommenderConfigurationsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about all the recommender model configurations that are associated with your Amazon
     * Pinpoint account.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetRecommenderConfigurationsRequest.Builder}
     * avoiding the need to create one manually via {@link GetRecommenderConfigurationsRequest#builder()}
     * 
     *
     * @param getRecommenderConfigurationsRequest
     *        A {@link Consumer} that will call methods on {@link GetRecommenderConfigurationsRequest.Builder} to create
     *        a request.
     * @return A Java Future containing the result of the GetRecommenderConfigurations operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetRecommenderConfigurations
     * @see AWS API Documentation
     */
    default CompletableFuture getRecommenderConfigurations(
            Consumer getRecommenderConfigurationsRequest) {
        return getRecommenderConfigurations(GetRecommenderConfigurationsRequest.builder()
                .applyMutation(getRecommenderConfigurationsRequest).build());
    }

    /**
     * 
     * Retrieves information about the configuration, dimension, and other settings for a specific segment that's
     * associated with an application.
     * 
     *
     * @param getSegmentRequest
     * @return A Java Future containing the result of the GetSegment operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegment
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getSegment(GetSegmentRequest getSegmentRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the configuration, dimension, and other settings for a specific segment that's
     * associated with an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetSegmentRequest.Builder} avoiding the need to
     * create one manually via {@link GetSegmentRequest#builder()}
     * 
     *
     * @param getSegmentRequest
     *        A {@link Consumer} that will call methods on {@link GetSegmentRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetSegment operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegment
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getSegment(Consumer getSegmentRequest) {
        return getSegment(GetSegmentRequest.builder().applyMutation(getSegmentRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the export jobs for a segment.
     * 
     *
     * @param getSegmentExportJobsRequest
     * @return A Java Future containing the result of the GetSegmentExportJobs operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegmentExportJobs
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getSegmentExportJobs(
            GetSegmentExportJobsRequest getSegmentExportJobsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the export jobs for a segment.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetSegmentExportJobsRequest.Builder} avoiding the
     * need to create one manually via {@link GetSegmentExportJobsRequest#builder()}
     * 
     *
     * @param getSegmentExportJobsRequest
     *        A {@link Consumer} that will call methods on {@link GetSegmentExportJobsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetSegmentExportJobs operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegmentExportJobs
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getSegmentExportJobs(
            Consumer getSegmentExportJobsRequest) {
        return getSegmentExportJobs(GetSegmentExportJobsRequest.builder().applyMutation(getSegmentExportJobsRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the import jobs for a segment.
     * 
     *
     * @param getSegmentImportJobsRequest
     * @return A Java Future containing the result of the GetSegmentImportJobs operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegmentImportJobs
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getSegmentImportJobs(
            GetSegmentImportJobsRequest getSegmentImportJobsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the import jobs for a segment.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetSegmentImportJobsRequest.Builder} avoiding the
     * need to create one manually via {@link GetSegmentImportJobsRequest#builder()}
     * 
     *
     * @param getSegmentImportJobsRequest
     *        A {@link Consumer} that will call methods on {@link GetSegmentImportJobsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetSegmentImportJobs operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegmentImportJobs
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getSegmentImportJobs(
            Consumer getSegmentImportJobsRequest) {
        return getSegmentImportJobs(GetSegmentImportJobsRequest.builder().applyMutation(getSegmentImportJobsRequest).build());
    }

    /**
     * 
     * Retrieves information about the configuration, dimension, and other settings for a specific version of a segment
     * that's associated with an application.
     * 
     *
     * @param getSegmentVersionRequest
     * @return A Java Future containing the result of the GetSegmentVersion operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegmentVersion
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getSegmentVersion(GetSegmentVersionRequest getSegmentVersionRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the configuration, dimension, and other settings for a specific version of a segment
     * that's associated with an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetSegmentVersionRequest.Builder} avoiding the need
     * to create one manually via {@link GetSegmentVersionRequest#builder()}
     * 
     *
     * @param getSegmentVersionRequest
     *        A {@link Consumer} that will call methods on {@link GetSegmentVersionRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetSegmentVersion operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegmentVersion
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getSegmentVersion(
            Consumer getSegmentVersionRequest) {
        return getSegmentVersion(GetSegmentVersionRequest.builder().applyMutation(getSegmentVersionRequest).build());
    }

    /**
     * 
     * Retrieves information about the configuration, dimension, and other settings for all the versions of a specific
     * segment that's associated with an application.
     * 
     *
     * @param getSegmentVersionsRequest
     * @return A Java Future containing the result of the GetSegmentVersions operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegmentVersions
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getSegmentVersions(GetSegmentVersionsRequest getSegmentVersionsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the configuration, dimension, and other settings for all the versions of a specific
     * segment that's associated with an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetSegmentVersionsRequest.Builder} avoiding the
     * need to create one manually via {@link GetSegmentVersionsRequest#builder()}
     * 
     *
     * @param getSegmentVersionsRequest
     *        A {@link Consumer} that will call methods on {@link GetSegmentVersionsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the GetSegmentVersions operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegmentVersions
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture getSegmentVersions(
            Consumer getSegmentVersionsRequest) {
        return getSegmentVersions(GetSegmentVersionsRequest.builder().applyMutation(getSegmentVersionsRequest).build());
    }

    /**
     * 
     * Retrieves information about the configuration, dimension, and other settings for all the segments that are
     * associated with an application.
     * 
     *
     * @param getSegmentsRequest
     * @return A Java Future containing the result of the GetSegments operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegments
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getSegments(GetSegmentsRequest getSegmentsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the configuration, dimension, and other settings for all the segments that are
     * associated with an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetSegmentsRequest.Builder} avoiding the need to
     * create one manually via {@link GetSegmentsRequest#builder()}
     * 
     *
     * @param getSegmentsRequest
     *        A {@link Consumer} that will call methods on {@link GetSegmentsRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetSegments operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSegments
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getSegments(Consumer getSegmentsRequest) {
        return getSegments(GetSegmentsRequest.builder().applyMutation(getSegmentsRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the SMS channel for an application.
     * 
     *
     * @param getSmsChannelRequest
     * @return A Java Future containing the result of the GetSmsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSmsChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getSmsChannel(GetSmsChannelRequest getSmsChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the SMS channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetSmsChannelRequest.Builder} avoiding the need to
     * create one manually via {@link GetSmsChannelRequest#builder()}
     * 
     *
     * @param getSmsChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetSmsChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetSmsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSmsChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getSmsChannel(Consumer getSmsChannelRequest) {
        return getSmsChannel(GetSmsChannelRequest.builder().applyMutation(getSmsChannelRequest).build());
    }

    /**
     * 
     * Retrieves the content and settings of a message template for messages that are sent through the SMS channel.
     * 
     *
     * @param getSmsTemplateRequest
     * @return A Java Future containing the result of the GetSmsTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSmsTemplate
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getSmsTemplate(GetSmsTemplateRequest getSmsTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves the content and settings of a message template for messages that are sent through the SMS channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetSmsTemplateRequest.Builder} avoiding the need to
     * create one manually via {@link GetSmsTemplateRequest#builder()}
     * 
     *
     * @param getSmsTemplateRequest
     *        A {@link Consumer} that will call methods on {@link GetSmsTemplateRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetSmsTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetSmsTemplate
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getSmsTemplate(Consumer getSmsTemplateRequest) {
        return getSmsTemplate(GetSmsTemplateRequest.builder().applyMutation(getSmsTemplateRequest).build());
    }

    /**
     * 
     * Retrieves information about all the endpoints that are associated with a specific user ID.
     * 
     *
     * @param getUserEndpointsRequest
     * @return A Java Future containing the result of the GetUserEndpoints operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetUserEndpoints
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getUserEndpoints(GetUserEndpointsRequest getUserEndpointsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about all the endpoints that are associated with a specific user ID.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetUserEndpointsRequest.Builder} avoiding the need
     * to create one manually via {@link GetUserEndpointsRequest#builder()}
     * 
     *
     * @param getUserEndpointsRequest
     *        A {@link Consumer} that will call methods on {@link GetUserEndpointsRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetUserEndpoints operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetUserEndpoints
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getUserEndpoints(
            Consumer getUserEndpointsRequest) {
        return getUserEndpoints(GetUserEndpointsRequest.builder().applyMutation(getUserEndpointsRequest).build());
    }

    /**
     * 
     * Retrieves information about the status and settings of the voice channel for an application.
     * 
     *
     * @param getVoiceChannelRequest
     * @return A Java Future containing the result of the GetVoiceChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetVoiceChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getVoiceChannel(GetVoiceChannelRequest getVoiceChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status and settings of the voice channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetVoiceChannelRequest.Builder} avoiding the need
     * to create one manually via {@link GetVoiceChannelRequest#builder()}
     * 
     *
     * @param getVoiceChannelRequest
     *        A {@link Consumer} that will call methods on {@link GetVoiceChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetVoiceChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetVoiceChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getVoiceChannel(
            Consumer getVoiceChannelRequest) {
        return getVoiceChannel(GetVoiceChannelRequest.builder().applyMutation(getVoiceChannelRequest).build());
    }

    /**
     * 
     * Retrieves the content and settings of a message template for messages that are sent through the voice channel.
     * 
     *
     * @param getVoiceTemplateRequest
     * @return A Java Future containing the result of the GetVoiceTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetVoiceTemplate
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getVoiceTemplate(GetVoiceTemplateRequest getVoiceTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves the content and settings of a message template for messages that are sent through the voice channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link GetVoiceTemplateRequest.Builder} avoiding the need
     * to create one manually via {@link GetVoiceTemplateRequest#builder()}
     * 
     *
     * @param getVoiceTemplateRequest
     *        A {@link Consumer} that will call methods on {@link GetVoiceTemplateRequest.Builder} to create a request.
     * @return A Java Future containing the result of the GetVoiceTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.GetVoiceTemplate
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture getVoiceTemplate(
            Consumer getVoiceTemplateRequest) {
        return getVoiceTemplate(GetVoiceTemplateRequest.builder().applyMutation(getVoiceTemplateRequest).build());
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for all the journeys that are
     * associated with an application.
     * 
     *
     * @param listJourneysRequest
     * @return A Java Future containing the result of the ListJourneys operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.ListJourneys
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture listJourneys(ListJourneysRequest listJourneysRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about the status, configuration, and other settings for all the journeys that are
     * associated with an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link ListJourneysRequest.Builder} avoiding the need to
     * create one manually via {@link ListJourneysRequest#builder()}
     * 
     *
     * @param listJourneysRequest
     *        A {@link Consumer} that will call methods on {@link ListJourneysRequest.Builder} to create a request.
     * @return A Java Future containing the result of the ListJourneys operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.ListJourneys
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture listJourneys(Consumer listJourneysRequest) {
        return listJourneys(ListJourneysRequest.builder().applyMutation(listJourneysRequest).build());
    }

    /**
     * 
     * Retrieves all the tags (keys and values) that are associated with an application, campaign, message template, or
     * segment.
     * 
     *
     * @param listTagsForResourceRequest
     * @return 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.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.ListTagsForResource
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture listTagsForResource(
            ListTagsForResourceRequest listTagsForResourceRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves all the tags (keys and values) that are associated with an application, campaign, message template, or
     * segment.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link ListTagsForResourceRequest.Builder} avoiding the
     * need to create one manually via {@link ListTagsForResourceRequest#builder()}
     * 
     *
     * @param listTagsForResourceRequest
     *        A {@link Consumer} that will call methods on {@link ListTagsForResourceRequest.Builder} to create a
     *        request.
     * @return 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.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.ListTagsForResource
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture listTagsForResource(
            Consumer listTagsForResourceRequest) {
        return listTagsForResource(ListTagsForResourceRequest.builder().applyMutation(listTagsForResourceRequest).build());
    }

    /**
     * 
     * Retrieves information about all the versions of a specific message template.
     * 
     *
     * @param listTemplateVersionsRequest
     * @return A Java Future containing the result of the ListTemplateVersions operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.ListTemplateVersions
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture listTemplateVersions(
            ListTemplateVersionsRequest listTemplateVersionsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about all the versions of a specific message template.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link ListTemplateVersionsRequest.Builder} avoiding the
     * need to create one manually via {@link ListTemplateVersionsRequest#builder()}
     * 
     *
     * @param listTemplateVersionsRequest
     *        A {@link Consumer} that will call methods on {@link ListTemplateVersionsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the ListTemplateVersions operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.ListTemplateVersions
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture listTemplateVersions(
            Consumer listTemplateVersionsRequest) {
        return listTemplateVersions(ListTemplateVersionsRequest.builder().applyMutation(listTemplateVersionsRequest).build());
    }

    /**
     * 
     * Retrieves information about all the message templates that are associated with your Amazon Pinpoint account.
     * 
     *
     * @param listTemplatesRequest
     * @return A Java Future containing the result of the ListTemplates operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.ListTemplates
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture listTemplates(ListTemplatesRequest listTemplatesRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about all the message templates that are associated with your Amazon Pinpoint account.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link ListTemplatesRequest.Builder} avoiding the need to
     * create one manually via {@link ListTemplatesRequest#builder()}
     * 
     *
     * @param listTemplatesRequest
     *        A {@link Consumer} that will call methods on {@link ListTemplatesRequest.Builder} to create a request.
     * @return A Java Future containing the result of the ListTemplates operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.ListTemplates
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture listTemplates(Consumer listTemplatesRequest) {
        return listTemplates(ListTemplatesRequest.builder().applyMutation(listTemplatesRequest).build());
    }

    /**
     * 
     * Retrieves information about a phone number.
     * 
     *
     * @param phoneNumberValidateRequest
     * @return A Java Future containing the result of the PhoneNumberValidate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.PhoneNumberValidate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture phoneNumberValidate(
            PhoneNumberValidateRequest phoneNumberValidateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Retrieves information about a phone number.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link PhoneNumberValidateRequest.Builder} avoiding the
     * need to create one manually via {@link PhoneNumberValidateRequest#builder()}
     * 
     *
     * @param phoneNumberValidateRequest
     *        A {@link Consumer} that will call methods on {@link PhoneNumberValidateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the PhoneNumberValidate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.PhoneNumberValidate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture phoneNumberValidate(
            Consumer phoneNumberValidateRequest) {
        return phoneNumberValidate(PhoneNumberValidateRequest.builder().applyMutation(phoneNumberValidateRequest).build());
    }

    /**
     * 
     * Creates a new event stream for an application or updates the settings of an existing event stream for an
     * application.
     * 
     *
     * @param putEventStreamRequest
     * @return A Java Future containing the result of the PutEventStream operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.PutEventStream
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture putEventStream(PutEventStreamRequest putEventStreamRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a new event stream for an application or updates the settings of an existing event stream for an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link PutEventStreamRequest.Builder} avoiding the need to
     * create one manually via {@link PutEventStreamRequest#builder()}
     * 
     *
     * @param putEventStreamRequest
     *        A {@link Consumer} that will call methods on {@link PutEventStreamRequest.Builder} to create a request.
     * @return A Java Future containing the result of the PutEventStream operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.PutEventStream
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture putEventStream(Consumer putEventStreamRequest) {
        return putEventStream(PutEventStreamRequest.builder().applyMutation(putEventStreamRequest).build());
    }

    /**
     * 
     * Creates a new event to record for endpoints, or creates or updates endpoint data that existing events are
     * associated with.
     * 
     *
     * @param putEventsRequest
     * @return A Java Future containing the result of the PutEvents operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.PutEvents
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture putEvents(PutEventsRequest putEventsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a new event to record for endpoints, or creates or updates endpoint data that existing events are
     * associated with.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link PutEventsRequest.Builder} avoiding the need to
     * create one manually via {@link PutEventsRequest#builder()}
     * 
     *
     * @param putEventsRequest
     *        A {@link Consumer} that will call methods on {@link PutEventsRequest.Builder} to create a request.
     * @return A Java Future containing the result of the PutEvents operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.PutEvents
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture putEvents(Consumer putEventsRequest) {
        return putEvents(PutEventsRequest.builder().applyMutation(putEventsRequest).build());
    }

    /**
     * 
     * Removes one or more attributes, of the same attribute type, from all the endpoints that are associated with an
     * application.
     * 
     *
     * @param removeAttributesRequest
     * @return A Java Future containing the result of the RemoveAttributes operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.RemoveAttributes
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture removeAttributes(RemoveAttributesRequest removeAttributesRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Removes one or more attributes, of the same attribute type, from all the endpoints that are associated with an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link RemoveAttributesRequest.Builder} avoiding the need
     * to create one manually via {@link RemoveAttributesRequest#builder()}
     * 
     *
     * @param removeAttributesRequest
     *        A {@link Consumer} that will call methods on {@link RemoveAttributesRequest.Builder} to create a request.
     * @return A Java Future containing the result of the RemoveAttributes operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.RemoveAttributes
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture removeAttributes(
            Consumer removeAttributesRequest) {
        return removeAttributes(RemoveAttributesRequest.builder().applyMutation(removeAttributesRequest).build());
    }

    /**
     * 
     * Creates and sends a direct message.
     * 
     *
     * @param sendMessagesRequest
     * @return A Java Future containing the result of the SendMessages operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.SendMessages
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture sendMessages(SendMessagesRequest sendMessagesRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates and sends a direct message.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link SendMessagesRequest.Builder} avoiding the need to
     * create one manually via {@link SendMessagesRequest#builder()}
     * 
     *
     * @param sendMessagesRequest
     *        A {@link Consumer} that will call methods on {@link SendMessagesRequest.Builder} to create a request.
     * @return A Java Future containing the result of the SendMessages operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.SendMessages
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture sendMessages(Consumer sendMessagesRequest) {
        return sendMessages(SendMessagesRequest.builder().applyMutation(sendMessagesRequest).build());
    }

    /**
     * 
     * Creates and sends a message to a list of users.
     * 
     *
     * @param sendUsersMessagesRequest
     * @return A Java Future containing the result of the SendUsersMessages operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.SendUsersMessages
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture sendUsersMessages(SendUsersMessagesRequest sendUsersMessagesRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates and sends a message to a list of users.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link SendUsersMessagesRequest.Builder} avoiding the need
     * to create one manually via {@link SendUsersMessagesRequest#builder()}
     * 
     *
     * @param sendUsersMessagesRequest
     *        A {@link Consumer} that will call methods on {@link SendUsersMessagesRequest.Builder} to create a request.
     * @return A Java Future containing the result of the SendUsersMessages operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.SendUsersMessages
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture sendUsersMessages(
            Consumer sendUsersMessagesRequest) {
        return sendUsersMessages(SendUsersMessagesRequest.builder().applyMutation(sendUsersMessagesRequest).build());
    }

    /**
     * 
     * Adds one or more tags (keys and values) to an application, campaign, message template, or segment.
     * 
     *
     * @param tagResourceRequest
     * @return 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.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.TagResource
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture tagResource(TagResourceRequest tagResourceRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Adds one or more tags (keys and values) to an application, campaign, message template, or segment.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link TagResourceRequest.Builder} avoiding the need to
     * create one manually via {@link TagResourceRequest#builder()}
     * 
     *
     * @param tagResourceRequest
     *        A {@link Consumer} that will call methods on {@link TagResourceRequest.Builder} to create a request.
     * @return 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.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.TagResource
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture tagResource(Consumer tagResourceRequest) {
        return tagResource(TagResourceRequest.builder().applyMutation(tagResourceRequest).build());
    }

    /**
     * 
     * Removes one or more tags (keys and values) from an application, campaign, message template, or segment.
     * 
     *
     * @param untagResourceRequest
     * @return 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.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UntagResource
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture untagResource(UntagResourceRequest untagResourceRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Removes one or more tags (keys and values) from an application, campaign, message template, or segment.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UntagResourceRequest.Builder} avoiding the need to
     * create one manually via {@link UntagResourceRequest#builder()}
     * 
     *
     * @param untagResourceRequest
     *        A {@link Consumer} that will call methods on {@link UntagResourceRequest.Builder} to create a request.
     * @return 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.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UntagResource
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture untagResource(Consumer untagResourceRequest) {
        return untagResource(UntagResourceRequest.builder().applyMutation(untagResourceRequest).build());
    }

    /**
     * 
     * Enables the ADM channel for an application or updates the status and settings of the ADM channel for an
     * application.
     * 
     *
     * @param updateAdmChannelRequest
     * @return A Java Future containing the result of the UpdateAdmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateAdmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateAdmChannel(UpdateAdmChannelRequest updateAdmChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the ADM channel for an application or updates the status and settings of the ADM channel for an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateAdmChannelRequest.Builder} avoiding the need
     * to create one manually via {@link UpdateAdmChannelRequest#builder()}
     * 
     *
     * @param updateAdmChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateAdmChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateAdmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateAdmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateAdmChannel(
            Consumer updateAdmChannelRequest) {
        return updateAdmChannel(UpdateAdmChannelRequest.builder().applyMutation(updateAdmChannelRequest).build());
    }

    /**
     * 
     * Enables the APNs channel for an application or updates the status and settings of the APNs channel for an
     * application.
     * 
     *
     * @param updateApnsChannelRequest
     * @return A Java Future containing the result of the UpdateApnsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApnsChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateApnsChannel(UpdateApnsChannelRequest updateApnsChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the APNs channel for an application or updates the status and settings of the APNs channel for an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateApnsChannelRequest.Builder} avoiding the need
     * to create one manually via {@link UpdateApnsChannelRequest#builder()}
     * 
     *
     * @param updateApnsChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateApnsChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateApnsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApnsChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateApnsChannel(
            Consumer updateApnsChannelRequest) {
        return updateApnsChannel(UpdateApnsChannelRequest.builder().applyMutation(updateApnsChannelRequest).build());
    }

    /**
     * 
     * Enables the APNs sandbox channel for an application or updates the status and settings of the APNs sandbox
     * channel for an application.
     * 
     *
     * @param updateApnsSandboxChannelRequest
     * @return A Java Future containing the result of the UpdateApnsSandboxChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApnsSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture updateApnsSandboxChannel(
            UpdateApnsSandboxChannelRequest updateApnsSandboxChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the APNs sandbox channel for an application or updates the status and settings of the APNs sandbox
     * channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateApnsSandboxChannelRequest.Builder} avoiding
     * the need to create one manually via {@link UpdateApnsSandboxChannelRequest#builder()}
     * 
     *
     * @param updateApnsSandboxChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateApnsSandboxChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateApnsSandboxChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApnsSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture updateApnsSandboxChannel(
            Consumer updateApnsSandboxChannelRequest) {
        return updateApnsSandboxChannel(UpdateApnsSandboxChannelRequest.builder().applyMutation(updateApnsSandboxChannelRequest)
                .build());
    }

    /**
     * 
     * Enables the APNs VoIP channel for an application or updates the status and settings of the APNs VoIP channel for
     * an application.
     * 
     *
     * @param updateApnsVoipChannelRequest
     * @return A Java Future containing the result of the UpdateApnsVoipChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApnsVoipChannel
     * @see AWS API Documentation
     */
    default CompletableFuture updateApnsVoipChannel(
            UpdateApnsVoipChannelRequest updateApnsVoipChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the APNs VoIP channel for an application or updates the status and settings of the APNs VoIP channel for
     * an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateApnsVoipChannelRequest.Builder} avoiding the
     * need to create one manually via {@link UpdateApnsVoipChannelRequest#builder()}
     * 
     *
     * @param updateApnsVoipChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateApnsVoipChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateApnsVoipChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApnsVoipChannel
     * @see AWS API Documentation
     */
    default CompletableFuture updateApnsVoipChannel(
            Consumer updateApnsVoipChannelRequest) {
        return updateApnsVoipChannel(UpdateApnsVoipChannelRequest.builder().applyMutation(updateApnsVoipChannelRequest).build());
    }

    /**
     * 
     * Enables the APNs VoIP sandbox channel for an application or updates the status and settings of the APNs VoIP
     * sandbox channel for an application.
     * 
     *
     * @param updateApnsVoipSandboxChannelRequest
     * @return A Java Future containing the result of the UpdateApnsVoipSandboxChannel operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApnsVoipSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture updateApnsVoipSandboxChannel(
            UpdateApnsVoipSandboxChannelRequest updateApnsVoipSandboxChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the APNs VoIP sandbox channel for an application or updates the status and settings of the APNs VoIP
     * sandbox channel for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateApnsVoipSandboxChannelRequest.Builder}
     * avoiding the need to create one manually via {@link UpdateApnsVoipSandboxChannelRequest#builder()}
     * 
     *
     * @param updateApnsVoipSandboxChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateApnsVoipSandboxChannelRequest.Builder} to create
     *        a request.
     * @return A Java Future containing the result of the UpdateApnsVoipSandboxChannel operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApnsVoipSandboxChannel
     * @see AWS API Documentation
     */
    default CompletableFuture updateApnsVoipSandboxChannel(
            Consumer updateApnsVoipSandboxChannelRequest) {
        return updateApnsVoipSandboxChannel(UpdateApnsVoipSandboxChannelRequest.builder()
                .applyMutation(updateApnsVoipSandboxChannelRequest).build());
    }

    /**
     * 
     * Updates the settings for an application.
     * 
     *
     * @param updateApplicationSettingsRequest
     * @return A Java Future containing the result of the UpdateApplicationSettings operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApplicationSettings
     * @see AWS API Documentation
     */
    default CompletableFuture updateApplicationSettings(
            UpdateApplicationSettingsRequest updateApplicationSettingsRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Updates the settings for an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateApplicationSettingsRequest.Builder} avoiding
     * the need to create one manually via {@link UpdateApplicationSettingsRequest#builder()}
     * 
     *
     * @param updateApplicationSettingsRequest
     *        A {@link Consumer} that will call methods on {@link UpdateApplicationSettingsRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateApplicationSettings operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateApplicationSettings
     * @see AWS API Documentation
     */
    default CompletableFuture updateApplicationSettings(
            Consumer updateApplicationSettingsRequest) {
        return updateApplicationSettings(UpdateApplicationSettingsRequest.builder()
                .applyMutation(updateApplicationSettingsRequest).build());
    }

    /**
     * 
     * Enables the Baidu channel for an application or updates the status and settings of the Baidu channel for an
     * application.
     * 
     *
     * @param updateBaiduChannelRequest
     * @return A Java Future containing the result of the UpdateBaiduChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateBaiduChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateBaiduChannel(UpdateBaiduChannelRequest updateBaiduChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the Baidu channel for an application or updates the status and settings of the Baidu channel for an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateBaiduChannelRequest.Builder} avoiding the
     * need to create one manually via {@link UpdateBaiduChannelRequest#builder()}
     * 
     *
     * @param updateBaiduChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateBaiduChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateBaiduChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateBaiduChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateBaiduChannel(
            Consumer updateBaiduChannelRequest) {
        return updateBaiduChannel(UpdateBaiduChannelRequest.builder().applyMutation(updateBaiduChannelRequest).build());
    }

    /**
     * 
     * Updates the configuration and other settings for a campaign.
     * 
     *
     * @param updateCampaignRequest
     * @return A Java Future containing the result of the UpdateCampaign operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateCampaign
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateCampaign(UpdateCampaignRequest updateCampaignRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Updates the configuration and other settings for a campaign.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateCampaignRequest.Builder} avoiding the need to
     * create one manually via {@link UpdateCampaignRequest#builder()}
     * 
     *
     * @param updateCampaignRequest
     *        A {@link Consumer} that will call methods on {@link UpdateCampaignRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateCampaign operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateCampaign
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateCampaign(Consumer updateCampaignRequest) {
        return updateCampaign(UpdateCampaignRequest.builder().applyMutation(updateCampaignRequest).build());
    }

    /**
     * 
     * Enables the email channel for an application or updates the status and settings of the email channel for an
     * application.
     * 
     *
     * @param updateEmailChannelRequest
     * @return A Java Future containing the result of the UpdateEmailChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateEmailChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateEmailChannel(UpdateEmailChannelRequest updateEmailChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the email channel for an application or updates the status and settings of the email channel for an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateEmailChannelRequest.Builder} avoiding the
     * need to create one manually via {@link UpdateEmailChannelRequest#builder()}
     * 
     *
     * @param updateEmailChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateEmailChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateEmailChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateEmailChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateEmailChannel(
            Consumer updateEmailChannelRequest) {
        return updateEmailChannel(UpdateEmailChannelRequest.builder().applyMutation(updateEmailChannelRequest).build());
    }

    /**
     * 
     * Updates an existing message template for messages that are sent through the email channel.
     * 
     *
     * @param updateEmailTemplateRequest
     * @return A Java Future containing the result of the UpdateEmailTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateEmailTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateEmailTemplate(
            UpdateEmailTemplateRequest updateEmailTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Updates an existing message template for messages that are sent through the email channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateEmailTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link UpdateEmailTemplateRequest#builder()}
     * 
     *
     * @param updateEmailTemplateRequest
     *        A {@link Consumer} that will call methods on {@link UpdateEmailTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateEmailTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateEmailTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateEmailTemplate(
            Consumer updateEmailTemplateRequest) {
        return updateEmailTemplate(UpdateEmailTemplateRequest.builder().applyMutation(updateEmailTemplateRequest).build());
    }

    /**
     * 
     * Creates a new endpoint for an application or updates the settings and attributes of an existing endpoint for an
     * application. You can also use this operation to define custom attributes for an endpoint. If an update includes
     * one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites) any existing values with the new
     * values.
     * 
     *
     * @param updateEndpointRequest
     * @return A Java Future containing the result of the UpdateEndpoint operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateEndpoint
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateEndpoint(UpdateEndpointRequest updateEndpointRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a new endpoint for an application or updates the settings and attributes of an existing endpoint for an
     * application. You can also use this operation to define custom attributes for an endpoint. If an update includes
     * one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites) any existing values with the new
     * values.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateEndpointRequest.Builder} avoiding the need to
     * create one manually via {@link UpdateEndpointRequest#builder()}
     * 
     *
     * @param updateEndpointRequest
     *        A {@link Consumer} that will call methods on {@link UpdateEndpointRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateEndpoint operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateEndpoint
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateEndpoint(Consumer updateEndpointRequest) {
        return updateEndpoint(UpdateEndpointRequest.builder().applyMutation(updateEndpointRequest).build());
    }

    /**
     * 
     * Creates a new batch of endpoints for an application or updates the settings and attributes of a batch of existing
     * endpoints for an application. You can also use this operation to define custom attributes for a batch of
     * endpoints. If an update includes one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites)
     * any existing values with the new values.
     * 
     *
     * @param updateEndpointsBatchRequest
     * @return A Java Future containing the result of the UpdateEndpointsBatch operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateEndpointsBatch
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateEndpointsBatch(
            UpdateEndpointsBatchRequest updateEndpointsBatchRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a new batch of endpoints for an application or updates the settings and attributes of a batch of existing
     * endpoints for an application. You can also use this operation to define custom attributes for a batch of
     * endpoints. If an update includes one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites)
     * any existing values with the new values.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateEndpointsBatchRequest.Builder} avoiding the
     * need to create one manually via {@link UpdateEndpointsBatchRequest#builder()}
     * 
     *
     * @param updateEndpointsBatchRequest
     *        A {@link Consumer} that will call methods on {@link UpdateEndpointsBatchRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateEndpointsBatch operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateEndpointsBatch
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateEndpointsBatch(
            Consumer updateEndpointsBatchRequest) {
        return updateEndpointsBatch(UpdateEndpointsBatchRequest.builder().applyMutation(updateEndpointsBatchRequest).build());
    }

    /**
     * 
     * Enables the GCM channel for an application or updates the status and settings of the GCM channel for an
     * application.
     * 
     *
     * @param updateGcmChannelRequest
     * @return A Java Future containing the result of the UpdateGcmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateGcmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateGcmChannel(UpdateGcmChannelRequest updateGcmChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the GCM channel for an application or updates the status and settings of the GCM channel for an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateGcmChannelRequest.Builder} avoiding the need
     * to create one manually via {@link UpdateGcmChannelRequest#builder()}
     * 
     *
     * @param updateGcmChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateGcmChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateGcmChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateGcmChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateGcmChannel(
            Consumer updateGcmChannelRequest) {
        return updateGcmChannel(UpdateGcmChannelRequest.builder().applyMutation(updateGcmChannelRequest).build());
    }

    /**
     * 
     * Updates the configuration and other settings for a journey.
     * 
     *
     * @param updateJourneyRequest
     * @return A Java Future containing the result of the UpdateJourney operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         ConflictException The request failed due to a conflict with the current state of the specified
     *         resource (ConflictException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateJourney
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateJourney(UpdateJourneyRequest updateJourneyRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Updates the configuration and other settings for a journey.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateJourneyRequest.Builder} avoiding the need to
     * create one manually via {@link UpdateJourneyRequest#builder()}
     * 
     *
     * @param updateJourneyRequest
     *        A {@link Consumer} that will call methods on {@link UpdateJourneyRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateJourney operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         ConflictException The request failed due to a conflict with the current state of the specified
     *         resource (ConflictException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateJourney
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateJourney(Consumer updateJourneyRequest) {
        return updateJourney(UpdateJourneyRequest.builder().applyMutation(updateJourneyRequest).build());
    }

    /**
     * 
     * Cancels (stops) an active journey.
     * 
     *
     * @param updateJourneyStateRequest
     * @return A Java Future containing the result of the UpdateJourneyState operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateJourneyState
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateJourneyState(UpdateJourneyStateRequest updateJourneyStateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Cancels (stops) an active journey.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateJourneyStateRequest.Builder} avoiding the
     * need to create one manually via {@link UpdateJourneyStateRequest#builder()}
     * 
     *
     * @param updateJourneyStateRequest
     *        A {@link Consumer} that will call methods on {@link UpdateJourneyStateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateJourneyState operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateJourneyState
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateJourneyState(
            Consumer updateJourneyStateRequest) {
        return updateJourneyState(UpdateJourneyStateRequest.builder().applyMutation(updateJourneyStateRequest).build());
    }

    /**
     * 
     * Updates an existing message template for messages that are sent through a push notification channel.
     * 
     *
     * @param updatePushTemplateRequest
     * @return A Java Future containing the result of the UpdatePushTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdatePushTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updatePushTemplate(UpdatePushTemplateRequest updatePushTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Updates an existing message template for messages that are sent through a push notification channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdatePushTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link UpdatePushTemplateRequest#builder()}
     * 
     *
     * @param updatePushTemplateRequest
     *        A {@link Consumer} that will call methods on {@link UpdatePushTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdatePushTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdatePushTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updatePushTemplate(
            Consumer updatePushTemplateRequest) {
        return updatePushTemplate(UpdatePushTemplateRequest.builder().applyMutation(updatePushTemplateRequest).build());
    }

    /**
     * 
     * Updates an Amazon Pinpoint configuration for a recommender model.
     * 
     *
     * @param updateRecommenderConfigurationRequest
     * @return A Java Future containing the result of the UpdateRecommenderConfiguration operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateRecommenderConfiguration
     * @see AWS API Documentation
     */
    default CompletableFuture updateRecommenderConfiguration(
            UpdateRecommenderConfigurationRequest updateRecommenderConfigurationRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Updates an Amazon Pinpoint configuration for a recommender model.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateRecommenderConfigurationRequest.Builder}
     * avoiding the need to create one manually via {@link UpdateRecommenderConfigurationRequest#builder()}
     * 
     *
     * @param updateRecommenderConfigurationRequest
     *        A {@link Consumer} that will call methods on {@link UpdateRecommenderConfigurationRequest.Builder} to
     *        create a request.
     * @return A Java Future containing the result of the UpdateRecommenderConfiguration operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateRecommenderConfiguration
     * @see AWS API Documentation
     */
    default CompletableFuture updateRecommenderConfiguration(
            Consumer updateRecommenderConfigurationRequest) {
        return updateRecommenderConfiguration(UpdateRecommenderConfigurationRequest.builder()
                .applyMutation(updateRecommenderConfigurationRequest).build());
    }

    /**
     * 
     * Creates a new segment for an application or updates the configuration, dimension, and other settings for an
     * existing segment that's associated with an application.
     * 
     *
     * @param updateSegmentRequest
     * @return A Java Future containing the result of the UpdateSegment operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateSegment
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateSegment(UpdateSegmentRequest updateSegmentRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Creates a new segment for an application or updates the configuration, dimension, and other settings for an
     * existing segment that's associated with an application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateSegmentRequest.Builder} avoiding the need to
     * create one manually via {@link UpdateSegmentRequest#builder()}
     * 
     *
     * @param updateSegmentRequest
     *        A {@link Consumer} that will call methods on {@link UpdateSegmentRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateSegment operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateSegment
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateSegment(Consumer updateSegmentRequest) {
        return updateSegment(UpdateSegmentRequest.builder().applyMutation(updateSegmentRequest).build());
    }

    /**
     * 
     * Enables the SMS channel for an application or updates the status and settings of the SMS channel for an
     * application.
     * 
     *
     * @param updateSmsChannelRequest
     * @return A Java Future containing the result of the UpdateSmsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateSmsChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateSmsChannel(UpdateSmsChannelRequest updateSmsChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the SMS channel for an application or updates the status and settings of the SMS channel for an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateSmsChannelRequest.Builder} avoiding the need
     * to create one manually via {@link UpdateSmsChannelRequest#builder()}
     * 
     *
     * @param updateSmsChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateSmsChannelRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateSmsChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateSmsChannel
     * @see AWS API
     *      Documentation
     */
    default CompletableFuture updateSmsChannel(
            Consumer updateSmsChannelRequest) {
        return updateSmsChannel(UpdateSmsChannelRequest.builder().applyMutation(updateSmsChannelRequest).build());
    }

    /**
     * 
     * Updates an existing message template for messages that are sent through the SMS channel.
     * 
     *
     * @param updateSmsTemplateRequest
     * @return A Java Future containing the result of the UpdateSmsTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateSmsTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateSmsTemplate(UpdateSmsTemplateRequest updateSmsTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Updates an existing message template for messages that are sent through the SMS channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateSmsTemplateRequest.Builder} avoiding the need
     * to create one manually via {@link UpdateSmsTemplateRequest#builder()}
     * 
     *
     * @param updateSmsTemplateRequest
     *        A {@link Consumer} that will call methods on {@link UpdateSmsTemplateRequest.Builder} to create a request.
     * @return A Java Future containing the result of the UpdateSmsTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateSmsTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateSmsTemplate(
            Consumer updateSmsTemplateRequest) {
        return updateSmsTemplate(UpdateSmsTemplateRequest.builder().applyMutation(updateSmsTemplateRequest).build());
    }

    /**
     * 
     * Changes the status of a specific version of a message template to active.
     * 
     *
     * @param updateTemplateActiveVersionRequest
     * @return A Java Future containing the result of the UpdateTemplateActiveVersion operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateTemplateActiveVersion
     * @see AWS API Documentation
     */
    default CompletableFuture updateTemplateActiveVersion(
            UpdateTemplateActiveVersionRequest updateTemplateActiveVersionRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Changes the status of a specific version of a message template to active.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateTemplateActiveVersionRequest.Builder}
     * avoiding the need to create one manually via {@link UpdateTemplateActiveVersionRequest#builder()}
     * 
     *
     * @param updateTemplateActiveVersionRequest
     *        A {@link Consumer} that will call methods on {@link UpdateTemplateActiveVersionRequest.Builder} to create
     *        a request.
     * @return A Java Future containing the result of the UpdateTemplateActiveVersion operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateTemplateActiveVersion
     * @see AWS API Documentation
     */
    default CompletableFuture updateTemplateActiveVersion(
            Consumer updateTemplateActiveVersionRequest) {
        return updateTemplateActiveVersion(UpdateTemplateActiveVersionRequest.builder()
                .applyMutation(updateTemplateActiveVersionRequest).build());
    }

    /**
     * 
     * Enables the voice channel for an application or updates the status and settings of the voice channel for an
     * application.
     * 
     *
     * @param updateVoiceChannelRequest
     * @return A Java Future containing the result of the UpdateVoiceChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateVoiceChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateVoiceChannel(UpdateVoiceChannelRequest updateVoiceChannelRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Enables the voice channel for an application or updates the status and settings of the voice channel for an
     * application.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateVoiceChannelRequest.Builder} avoiding the
     * need to create one manually via {@link UpdateVoiceChannelRequest#builder()}
     * 
     *
     * @param updateVoiceChannelRequest
     *        A {@link Consumer} that will call methods on {@link UpdateVoiceChannelRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateVoiceChannel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateVoiceChannel
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateVoiceChannel(
            Consumer updateVoiceChannelRequest) {
        return updateVoiceChannel(UpdateVoiceChannelRequest.builder().applyMutation(updateVoiceChannelRequest).build());
    }

    /**
     * 
     * Updates an existing message template for messages that are sent through the voice channel.
     * 
     *
     * @param updateVoiceTemplateRequest
     * @return A Java Future containing the result of the UpdateVoiceTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateVoiceTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateVoiceTemplate(
            UpdateVoiceTemplateRequest updateVoiceTemplateRequest) {
        throw new UnsupportedOperationException();
    }

    /**
     * 
     * Updates an existing message template for messages that are sent through the voice channel.
     * 
     * 

     * 
     * This is a convenience which creates an instance of the {@link UpdateVoiceTemplateRequest.Builder} avoiding the
     * need to create one manually via {@link UpdateVoiceTemplateRequest#builder()}
     * 
     *
     * @param updateVoiceTemplateRequest
     *        A {@link Consumer} that will call methods on {@link UpdateVoiceTemplateRequest.Builder} to create a
     *        request.
     * @return A Java Future containing the result of the UpdateVoiceTemplate operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         BadRequestException The request contains a syntax error (BadRequestException).
     *         InternalServerErrorException The request failed due to an unknown internal server error, exception,
     *         or failure (InternalServerErrorException).
     *         PayloadTooLargeException The request failed because the payload for the body of the request is too
     *         large (RequestEntityTooLargeException).
     *         ForbiddenException The request was denied because access to the specified resource is forbidden
     *         (ForbiddenException).
     *         NotFoundException The request failed because the specified resource was not found
     *         (NotFoundException).
     *         MethodNotAllowedException The request failed because the method is not allowed for the specified
     *         resource (MethodNotAllowedException).
     *         TooManyRequestsException The request failed because too many requests were sent during a certain
     *         amount of time (TooManyRequestsException).
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         PinpointException Base class for all service exceptions. Unknown exceptions will be thrown as an
     *         instance of this type.
     *         
     * @sample PinpointAsyncClient.UpdateVoiceTemplate
     * @see AWS
     *      API Documentation
     */
    default CompletableFuture updateVoiceTemplate(
            Consumer updateVoiceTemplateRequest) {
        return updateVoiceTemplate(UpdateVoiceTemplateRequest.builder().applyMutation(updateVoiceTemplateRequest).build());
    }
}