API (Strava API 1.0.4-SNAPSHOT API)

java.lang.Object
- javastrava.api.v3.rest.API

```
public class API
extends Object
```
Provides a static method instance(Class, Token) which constructs a standard retrofit service with all the required options.

Author:

Dan Shannon

Constructor Summary

Constructors
Constructor and Description

API(Token token)
Construct an API instance with a given token

Constructors
Constructor and Description
`API(Token token)` Construct an API instance with a given token

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static AuthorisationAPI`	`authorisationInstance()` Get an instance of the authorisation API (cached)
`StravaUploadResponse`	`checkUploadStatus(Integer uploadId)`
`StravaAPIFuture<StravaUploadResponse>`	`checkUploadStatusAsync(Integer uploadId)`
`StravaComment`	`createComment(Integer activityId, String text)`
`StravaAPIFuture<StravaComment>`	`createCommentAsync(Integer activityId, String text)`
`StravaActivity`	`createManualActivity(StravaActivity activity)` Create a manual activity
`StravaAPIFuture<StravaActivity>`	`createManualActivityAsync(StravaActivity activity)`
`StravaEventSubscription`	`createSubscription(Integer clientId, String clientSecret, StravaSubscriptionObjectType objectType, StravaSubscriptionAspectType aspectType, String callbackURL, String verifyToken)`
`StravaAPIFuture<StravaEventSubscription>`	`createSubscriptionAsync(Integer clientId, String clientSecret, StravaSubscriptionObjectType objectType, StravaSubscriptionAspectType aspectType, String callbackURL, String verifyToken)`
`TokenResponse`	`deauthoriseToken(String accessToken)`
`StravaAPIFuture<TokenResponse>`	`deauthoriseTokenAsync(String accessToken)`
`StravaActivity`	`deleteActivity(Integer id)` Delete an activity on Strava
`StravaAPIFuture<StravaActivity>`	`deleteActivityAsync(Integer activityId)` Delete an activity on Strava
`StravaResponse`	`deleteComment(Integer activityId, Integer commentId)`
`StravaAPIFuture<StravaResponse>`	`deleteCommentAsync(Integer activityId, Integer commentId)`
`StravaResponse`	`deleteSubscription(Integer subscriptionId, Integer clientId, String clientSecret)`
`StravaAPIFuture<StravaResponse>`	`deleteSubscriptionAsync(Integer subscriptionId, Integer clientId, String clientSecret)`
`StravaActivity`	`getActivity(Integer id, Boolean includeAllEfforts)` Get details of an activity
`StravaAPIFuture<StravaActivity>`	`getActivityAsync(Integer id, Boolean includeAllEfforts)` Get details of an activity
`StravaStream[]`	`getActivityStreams(Integer activityId, String types, StravaStreamResolutionType resolution, StravaStreamSeriesDownsamplingType seriesType)`
`StravaAPIFuture<StravaStream[]>`	`getActivityStreamsAsync(Integer activityId, String types, StravaStreamResolutionType resolution, StravaStreamSeriesDownsamplingType seriesType)`
`StravaAthlete`	`getAthlete(Integer athleteId)`
`StravaAPIFuture<StravaAthlete>`	`getAthleteAsync(Integer athleteId)`
`StravaAthlete`	`getAuthenticatedAthlete()`
`StravaAPIFuture<StravaAthlete>`	`getAuthenticatedAthleteAsync()`
`StravaAthleteZones`	`getAuthenticatedAthleteZones()` Returns the current athlete’s heart rate zones.
`StravaAPIFuture<StravaAthleteZones>`	`getAuthenticatedAthleteZonesAsync()` Returns the current athlete’s heart rate zones.
`StravaClub`	`getClub(Integer clubId)`
`StravaAPIFuture<StravaClub>`	`getClubAsync(Integer clubId)`
`StravaStream[]`	`getEffortStreams(Long segmentEffortId, String types, StravaStreamResolutionType resolution, StravaStreamSeriesDownsamplingType seriesType)`
`StravaAPIFuture<StravaStream[]>`	`getEffortStreamsAsync(Long segmentEffortId, String types, StravaStreamResolutionType resolution, StravaStreamSeriesDownsamplingType seriesType)`
`StravaGear`	`getGear(String gearId)`
`StravaAPIFuture<StravaGear>`	`getGearAsync(String gearId)`
`StravaSegment`	`getSegment(Integer segmentId)`
`StravaAPIFuture<StravaSegment>`	`getSegmentAsync(Integer segmentId)`
`StravaSegmentEffort`	`getSegmentEffort(Long segmentEffortId)`
`StravaAPIFuture<StravaSegmentEffort>`	`getSegmentEffortAsync(Long segmentEffortId)`
`StravaSegmentLeaderboard`	`getSegmentLeaderboard(Integer segmentId, StravaGender gender, StravaAgeGroup ageGroup, StravaWeightClass weightClass, Boolean following, Integer clubId, StravaLeaderboardDateRange dateRange, Integer page, Integer perPage, Integer contextEntries)`
`StravaAPIFuture<StravaSegmentLeaderboard>`	`getSegmentLeaderboardAsync(Integer segmentId, StravaGender gender, StravaAgeGroup ageGroup, StravaWeightClass weightClass, Boolean following, Integer clubId, StravaLeaderboardDateRange dateRange, Integer page, Integer perPage, Integer contextEntries)`
`StravaStream[]`	`getSegmentStreams(Integer segmentId, String types, StravaStreamResolutionType resolution, StravaStreamSeriesDownsamplingType seriesType)`
`StravaAPIFuture<StravaStream[]>`	`getSegmentStreamsAsync(Integer segmentId, String types, StravaStreamResolutionType resolution, StravaStreamSeriesDownsamplingType seriesType)`
`StravaResponse`	`giveKudos(Integer activityId)`
`StravaAPIFuture<StravaResponse>`	`giveKudosAsync(Integer activityId)`
`static <T> T`	`instance(Class<T> class1, Token token)` Creates and returns a new API RestAdapter instance.
`StravaClubMembershipResponse`	`joinClub(Integer clubId)`
`StravaAPIFuture<StravaClubMembershipResponse>`	`joinClubAsync(Integer clubId)`
`StravaClubMembershipResponse`	`leaveClub(Integer clubId)`
`StravaAPIFuture<StravaClubMembershipResponse>`	`leaveClubAsync(Integer clubId)`
`StravaComment[]`	`listActivityComments(Integer activityId, Boolean markdown, Integer page, Integer perPage)`
`StravaAPIFuture<StravaComment[]>`	`listActivityCommentsAsync(Integer activityId, Boolean markdown, Integer page, Integer perPage)`
`StravaAthlete[]`	`listActivityKudoers(Integer activityId, Integer page, Integer perPage)`
`StravaAPIFuture<StravaAthlete[]>`	`listActivityKudoersAsync(Integer activityId, Integer page, Integer perPage)`
`StravaLap[]`	`listActivityLaps(Integer activityId)`
`StravaAPIFuture<StravaLap[]>`	`listActivityLapsAsync(Integer activityId)`
`StravaPhoto[]`	`listActivityPhotos(Integer activityId)`
`StravaAPIFuture<StravaPhoto[]>`	`listActivityPhotosAsync(Integer activityId)`
`StravaActivityZone[]`	`listActivityZones(Integer activityId)`
`StravaAPIFuture<StravaActivityZone[]>`	`listActivityZonesAsync(Integer activityId)`
`StravaAthlete[]`	`listAthleteFriends(Integer athleteId, Integer page, Integer perPage)`
`StravaAPIFuture<StravaAthlete[]>`	`listAthleteFriendsAsync(Integer athleteId, Integer page, Integer perPage)`
`StravaSegmentEffort[]`	`listAthleteKOMs(Integer athleteId, Integer page, Integer perPage)`
`StravaAPIFuture<StravaSegmentEffort[]>`	`listAthleteKOMsAsync(Integer athleteId, Integer page, Integer perPage)`
`StravaAthlete[]`	`listAthletesBothFollowing(Integer athleteId, Integer page, Integer perPage)`
`StravaAPIFuture<StravaAthlete[]>`	`listAthletesBothFollowingAsync(Integer athleteId, Integer page, Integer perPage)`
`StravaActivity[]`	`listAuthenticatedAthleteActivities(Integer before, Integer after, Integer page, Integer perPage)`
`StravaAPIFuture<StravaActivity[]>`	`listAuthenticatedAthleteActivitiesAsync(Integer before, Integer after, Integer page, Integer perPage)`
`StravaClub[]`	`listAuthenticatedAthleteClubs()`
`StravaAPIFuture<StravaClub[]>`	`listAuthenticatedAthleteClubsAsync()`
`StravaAthlete[]`	`listAuthenticatedAthleteFriends(Integer page, Integer perPage)`
`StravaAPIFuture<StravaAthlete[]>`	`listAuthenticatedAthleteFriendsAsync(Integer page, Integer perPage)`
`StravaSegment[]`	`listAuthenticatedAthleteStarredSegments(Integer page, Integer perPage)`
`StravaAPIFuture<StravaSegment[]>`	`listAuthenticatedAthleteStarredSegmentsAsync(Integer page, Integer perPage)`
`StravaAthlete[]`	`listClubAdmins(Integer clubId, Integer page, Integer perPage)`
`StravaClubAnnouncement[]`	`listClubAnnouncements(Integer clubId)`
`StravaAPIFuture<StravaClubAnnouncement[]>`	`listClubAnnouncementsAsync(Integer clubId)`
`StravaClubEvent[]`	`listClubGroupEvents(Integer clubId)`
`StravaAPIFuture<StravaClubEvent[]>`	`listClubGroupEventsAsync(Integer clubId)`
`StravaAthlete[]`	`listClubMembers(Integer clubId, Integer page, Integer perPage)`
`StravaAPIFuture<StravaAthlete[]>`	`listClubMembersAsync(Integer clubId, Integer page, Integer perPage)`
`StravaActivity[]`	`listFriendsActivities(Integer page, Integer perPage)`
`StravaAPIFuture<StravaActivity[]>`	`listFriendsActivitiesAsync(Integer page, Integer perPage)`
`StravaActivity[]`	`listRecentClubActivities(Integer clubId, Integer page, Integer perPage)`
`StravaAPIFuture<StravaActivity[]>`	`listRecentClubActivitiesAsync(Integer clubId, Integer page, Integer perPage)`
`StravaActivity[]`	`listRelatedActivities(Integer activityId, Integer page, Integer perPage)`
`StravaAPIFuture<StravaActivity[]>`	`listRelatedActivitiesAsync(Integer activityId, Integer page, Integer perPage)`
`StravaSegmentEffort[]`	`listSegmentEfforts(Integer segmentId, Integer athleteId, String start, String end, Integer page, Integer perPage)`
`StravaAPIFuture<StravaSegmentEffort[]>`	`listSegmentEffortsAsync(Integer segmentId, Integer athleteId, String start, String end, Integer page, Integer perPage)`
`StravaSegment[]`	`listStarredSegments(Integer athleteId, Integer page, Integer perPage)`
`StravaAPIFuture<StravaSegment[]>`	`listStarredSegmentsAsync(Integer athleteId, Integer page, Integer perPage)`
`StravaEventSubscription[]`	`listSubscriptions(Integer clientId, String clientSecret)`
`StravaAPIFuture<StravaEventSubscription[]>`	`listSubscriptionsAsync(Integer clientId, String clientSecret)`
`static retrofit.RestAdapter.LogLevel`	`logLevel(Class<?> class1)`
`StravaSegmentExplorerResponse`	`segmentExplore(String bounds, StravaSegmentExplorerActivityType activityType, StravaClimbCategory minCategory, StravaClimbCategory maxCategory)`
`StravaAPIFuture<StravaSegmentExplorerResponse>`	`segmentExploreAsync(String bounds, StravaSegmentExplorerActivityType activityType, StravaClimbCategory minCategory, StravaClimbCategory maxCategory)`
`StravaStatistics`	`statistics(Integer athleteId)`
`StravaAPIFuture<StravaStatistics>`	`statisticsAsync(Integer athleteId)`
`StravaActivity`	`updateActivity(Integer id, StravaActivityUpdate activity)` Update an activity that already exists on Strava
`StravaAPIFuture<StravaActivity>`	`updateActivityAsync(Integer id, StravaActivityUpdate activity)` Update an activity that already exists on Strava
`StravaAthlete`	`updateAuthenticatedAthlete(String city, String state, String country, StravaGender sex, Float weight)`
`StravaAPIFuture<StravaAthlete>`	`updateAuthenticatedAthleteAsync(String city, String state, String country, StravaGender sex, Float weight)`
`StravaUploadResponse`	`upload(StravaActivityType activityType, String name, String description, Boolean _private, Boolean trainer, Boolean commute, String dataType, String externalId, retrofit.mime.TypedFile file)`
`StravaAPIFuture<StravaUploadResponse>`	`uploadAsync(StravaActivityType activityType, String name, String description, Boolean _private, Boolean trainer, Boolean commute, String dataType, String externalId, retrofit.mime.TypedFile file)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - API
```
public API(Token token)
```
    Construct an API instance with a given token
    
    Parameters:
    
    token - The access token to be used with calls to the API
- Method Detail
  - authorisationInstance
```
public static AuthorisationAPI authorisationInstance()
```
    Get an instance of the authorisation API (cached)
    
    Returns:
    
    Instance of the authorisation API
  - instance
```
public static <T> T instance(Class<T> class1,
                             Token token)
```
    Creates and returns a new API RestAdapter instance.
    
    Type Parameters:
    
    T - Class of API interface to be instantiated (one of the *API.java interfaces)
    
    Parameters:
    
    class1 - The class to be returned
    
    token - The access token required for authentication of requests to the Strava API
    
    Returns:
    
    A REST service
  - logLevel
```
public static retrofit.RestAdapter.LogLevel logLevel(Class<?> class1)
```
    Parameters:
    
    class1 - Class for which log level is to be determined
    
    Returns:
    
    The appropriate log level for the class
  - checkUploadStatus
```
public StravaUploadResponse checkUploadStatus(Integer uploadId)
```
    Parameters:
    
    uploadId - The upload id as given back in the response to upload(StravaActivityType, String, String, Boolean, Boolean, Boolean, String, String, TypedFile)
    
    Returns:
    
    Upload response containing the upload id and activity id and current status of the upload
    
    See Also:
    
    UploadAPI.checkUploadStatus(java.lang.Integer)
  - checkUploadStatusAsync
```
public StravaAPIFuture<StravaUploadResponse> checkUploadStatusAsync(Integer uploadId)
```
    Parameters:
    
    uploadId - The upload id as given back in the response to upload(StravaActivityType, String, String, Boolean, Boolean, Boolean, String, String, TypedFile)
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    See Also:
    
    UploadAPI.checkUploadStatus(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - createComment
```
public StravaComment createComment(Integer activityId,
                                   String text)
                            throws BadRequestException,
                                   NotFoundException
```
    Parameters:
    
    activityId - Activity identifier
    
    text - Text of the comment to create
    
    Returns:
    
    The comment as posted
    
    Throws:
    
    NotFoundException - If the activity does not exist
    
    BadRequestException - If the comment text is null or the empty string
    
    See Also:
    
    ActivityAPI.createComment(java.lang.Integer, java.lang.String)
  - createCommentAsync
```
public StravaAPIFuture<StravaComment> createCommentAsync(Integer activityId,
                                                         String text)
                                                  throws BadRequestException,
                                                         NotFoundException
```
    Parameters:
    
    activityId - Activity identifier
    
    text - Text of the comment to create
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity does not exist
    
    BadRequestException - If the comment text is null or the empty string
  - createManualActivity
```
public StravaActivity createManualActivity(StravaActivity activity)
                                    throws BadRequestException
```
    Create a manual activity
    
    Parameters:
    
    activity - Activity to create on Strava
    
    Returns:
    
    The activity as created on Strava, if successful
    
    Throws:
    
    BadRequestException - If the request is invalid in some way
    
    See Also:
    
    ActivityAPI.createManualActivity(javastrava.api.v3.model.StravaActivity)
  - createManualActivityAsync
```
public StravaAPIFuture<StravaActivity> createManualActivityAsync(StravaActivity activity)
                                                          throws BadRequestException
```
    Parameters:
    
    activity - The activity to be created on Strava
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    BadRequestException - If the activity is malformed and can't be uploaded
    
    See Also:
    
    ActivityAPI.createManualActivity(javastrava.api.v3.model.StravaActivity, javastrava.api.v3.rest.async.StravaAPICallback)
  - createSubscription
```
public StravaEventSubscription createSubscription(Integer clientId,
                                                  String clientSecret,
                                                  StravaSubscriptionObjectType objectType,
                                                  StravaSubscriptionAspectType aspectType,
                                                  String callbackURL,
                                                  String verifyToken)
```
    Parameters:
    
    clientId - Application's id, as obtained during registration with Strava
    
    clientSecret - Application's secret, as obtained during Strava registration
    
    objectType - The type of object being subscribed to
    
    aspectType - The aspect being subscribed to
    
    callbackURL - (Max 255 characters) URL which Strava will callback with an HTTP GET to verify the existence of the webhook endpoint, then subsequently will POST to with subscribed events
    
    verifyToken - The token's value will be included in the GET callback request when verifying the endpoint
    
    Returns:
    
    Details of the event subscription
  - createSubscriptionAsync
```
public StravaAPIFuture<StravaEventSubscription> createSubscriptionAsync(Integer clientId,
                                                                        String clientSecret,
                                                                        StravaSubscriptionObjectType objectType,
                                                                        StravaSubscriptionAspectType aspectType,
                                                                        String callbackURL,
                                                                        String verifyToken)
```
    Parameters:
    
    clientId - Application's id, as obtained during registration with Strava
    
    clientSecret - Application's secret, as obtained during Strava registration
    
    objectType - The type of object being subscribed to
    
    aspectType - The aspect being subscribed to
    
    callbackURL - (Max 255 characters) URL which Strava will callback with an HTTP GET to verify the existence of the webhook endpoint, then subsequently will POST to with subscribed events
    
    verifyToken - The token's value will be included in the GET callback request when verifying the endpoint
    
    Returns:
    
    Details of the event subscription
  - deauthoriseToken
```
public TokenResponse deauthoriseToken(String accessToken)
                               throws UnauthorizedException
```
    Parameters:
    
    accessToken - The access token for which the application is revoking its access.
    
    Returns:
    
    Responds with the access token submitted with the request.
    
    Throws:
    
    UnauthorizedException - if the token is not allowed to be deauthorised
    
    See Also:
    
    TokenAPI.deauthoriseToken(java.lang.String)
  - deauthoriseTokenAsync
```
public StravaAPIFuture<TokenResponse> deauthoriseTokenAsync(String accessToken)
                                                     throws UnauthorizedException
```
    Parameters:
    
    accessToken - The access token for which the application is revoking its access.
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    UnauthorizedException - if the token is not allowed to be deauthorised
    
    See Also:
    
    TokenAPI.deauthorise(java.lang.String, javastrava.api.v3.rest.async.StravaAPICallback)
  - deleteActivity
```
public StravaActivity deleteActivity(Integer id)
                              throws NotFoundException
```
    Delete an activity on Strava
    
    Parameters:
    
    id - Activity identifier
    
    Returns:
    
    The representation of the deleted activity
    
    Throws:
    
    NotFoundException - If the identified activity does not exist
    
    See Also:
    
    ActivityAPI.deleteActivity(java.lang.Integer)
  - deleteActivityAsync
```
public StravaAPIFuture<StravaActivity> deleteActivityAsync(Integer activityId)
                                                    throws NotFoundException
```
    Delete an activity on Strava
    
    Parameters:
    
    activityId - Activity identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the identified activity does not exist
    
    See Also:
    
    ActivityAPI.deleteActivity(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - deleteComment
```
public StravaResponse deleteComment(Integer activityId,
                                    Integer commentId)
                             throws NotFoundException
```
    Parameters:
    
    activityId - Id of the activity the comment was posted to
    
    commentId - Id of the comment
    
    Returns:
    
    Strava response
    
    Throws:
    
    NotFoundException - If the comment does not exist
    
    See Also:
    
    ActivityAPI.deleteComment(java.lang.Integer, java.lang.Integer)
  - deleteCommentAsync
```
public StravaAPIFuture<StravaResponse> deleteCommentAsync(Integer activityId,
                                                          Integer commentId)
                                                   throws NotFoundException
```
    Parameters:
    
    activityId - Id of the activity the comment was posted to
    
    commentId - Id of the comment
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the comment does not exist
    
    See Also:
    
    ActivityAPI.deleteComment(java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - deleteSubscription
```
public StravaResponse deleteSubscription(Integer subscriptionId,
                                         Integer clientId,
                                         String clientSecret)
```
    Parameters:
    
    subscriptionId - The id of the subscription to be deleted
    
    clientId - Application's id, as obtained during registration with Strava
    
    clientSecret - Application's secret, as obtained during Strava registration
    
    Returns:
    
    Returns nothing on success
    
    See Also:
    
    WebhookAPI.deleteSubscription(java.lang.Integer, java.lang.Integer, java.lang.String)
  - deleteSubscriptionAsync
```
public StravaAPIFuture<StravaResponse> deleteSubscriptionAsync(Integer subscriptionId,
                                                               Integer clientId,
                                                               String clientSecret)
```
    Parameters:
    
    subscriptionId - The id of the subscription to be deleted
    
    clientId - Application's id, as obtained during registration with Strava
    
    clientSecret - Application's secret, as obtained during Strava registration
    
    Returns:
    
    Returns nothing on success
    
    See Also:
    
    WebhookAPI.deleteSubscription(java.lang.Integer, java.lang.Integer, java.lang.String)
  - getActivity
```
public StravaActivity getActivity(Integer id,
                                  Boolean includeAllEfforts)
                           throws NotFoundException
```
    Get details of an activity
    
    Parameters:
    
    id - Activity identifier
    
    includeAllEfforts - Whether or not to include only efforts that Strava considers 'important'
    
    Returns:
    
    The Strava activity with the given id, if it exists
    
    Throws:
    
    NotFoundException - If the activity does not exist
    
    See Also:
    
    ActivityAPI.getActivity(java.lang.Integer, java.lang.Boolean)
  - getActivityAsync
```
public StravaAPIFuture<StravaActivity> getActivityAsync(Integer id,
                                                        Boolean includeAllEfforts)
                                                 throws NotFoundException
```
    Get details of an activity
    
    Parameters:
    
    id - Activity identifier
    
    includeAllEfforts - Whether or not to include only efforts that Strava considers 'important'
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity does not exist
    
    See Also:
    
    ActivityAPI.getActivity(java.lang.Integer, java.lang.Boolean, javastrava.api.v3.rest.async.StravaAPICallback)
  - getActivityStreams
```
public StravaStream[] getActivityStreams(Integer activityId,
                                         String types,
                                         StravaStreamResolutionType resolution,
                                         StravaStreamSeriesDownsamplingType seriesType)
                                  throws UnauthorizedException,
                                         NotFoundException,
                                         BadRequestException
```
    Parameters:
    
    activityId - The id of the activity for which streams are to be retrieved
    
    types - List of types, if the activity does not have that stream it will not be included in the response
    
    resolution - (Optional) low (100), medium (1000) or high (10000), default is all, indicates desired number of data points, streams will only be down sampled
    
    seriesType - (Optional) relevant only if using resolution. Either "time" or "distance", default is "distance", used to index the streams if the stream is being reduced
    
    Returns:
    
    Returns an array of unordered stream objects, or null if the activity doesn't exist
    
    Throws:
    
    UnauthorizedException - If there is a security exception
    
    NotFoundException - If the activity does not exist
    
    BadRequestException - If the request is malformed
    
    See Also:
    
    StreamAPI.getActivityStreams(java.lang.Integer, java.lang.String, javastrava.api.v3.model.reference.StravaStreamResolutionType, javastrava.api.v3.model.reference.StravaStreamSeriesDownsamplingType)
  - getActivityStreamsAsync
```
public StravaAPIFuture<StravaStream[]> getActivityStreamsAsync(Integer activityId,
                                                               String types,
                                                               StravaStreamResolutionType resolution,
                                                               StravaStreamSeriesDownsamplingType seriesType)
                                                        throws UnauthorizedException,
                                                               NotFoundException,
                                                               BadRequestException
```
    Parameters:
    
    activityId - The id of the activity for which streams are to be retrieved
    
    types - List of types, if the activity does not have that stream it will not be included in the response
    
    resolution - (Optional) low (100), medium (1000) or high (10000), default is all, indicates desired number of data points, streams will only be down sampled
    
    seriesType - (Optional) relevant only if using resolution. Either "time" or "distance", default is "distance", used to index the streams if the stream is being reduced
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    UnauthorizedException - If there is a security exception
    
    NotFoundException - If the activity does not exist
    
    BadRequestException - If the request is malformed
    
    See Also:
    
    StreamAPI.getActivityStreams(java.lang.Integer, java.lang.String, javastrava.api.v3.model.reference.StravaStreamResolutionType, javastrava.api.v3.model.reference.StravaStreamSeriesDownsamplingType, javastrava.api.v3.rest.async.StravaAPICallback)
  - getAthlete
```
public StravaAthlete getAthlete(Integer athleteId)
                         throws NotFoundException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    Returns:
    
    Details of the athlete, will be somewhat anonymised if the athlete is private
    
    Throws:
    
    NotFoundException - If the athlete doesn't exist
    
    See Also:
    
    AthleteAPI.getAthlete(java.lang.Integer)
  - getAthleteAsync
```
public StravaAPIFuture<StravaAthlete> getAthleteAsync(Integer athleteId)
                                               throws NotFoundException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the athlete doesn't exist
    
    See Also:
    
    AthleteAPI.getAthlete(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - getAuthenticatedAthlete
```
public StravaAthlete getAuthenticatedAthlete()
```
    Returns:
    
    Full details of the authenticated athlete
    
    See Also:
    
    AthleteAPI.getAuthenticatedAthlete()
  - getAuthenticatedAthleteAsync
```
public StravaAPIFuture<StravaAthlete> getAuthenticatedAthleteAsync()
```
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    See Also:
    
    AthleteAPI.getAuthenticatedAthlete(javastrava.api.v3.rest.async.StravaAPICallback)
  - getClub
```
public StravaClub getClub(Integer clubId)
                   throws NotFoundException
```
    Parameters:
    
    clubId - Club identifier
    
    Returns:
    
    Club details
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    See Also:
    
    ClubAPI.getClub(java.lang.Integer)
  - getClubAsync
```
public StravaAPIFuture<StravaClub> getClubAsync(Integer clubId)
                                         throws NotFoundException
```
    Parameters:
    
    clubId - Club identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    See Also:
    
    ClubAPI.getClub(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - getEffortStreams
```
public StravaStream[] getEffortStreams(Long segmentEffortId,
                                       String types,
                                       StravaStreamResolutionType resolution,
                                       StravaStreamSeriesDownsamplingType seriesType)
                                throws UnauthorizedException,
                                       NotFoundException,
                                       BadRequestException
```
    Parameters:
    
    segmentEffortId - The id of the segment effort for which streams are to be retrieved
    
    types - List of types, if the effort does not have that stream it will not be included in the response
    
    resolution - (Optional) low (100), medium (1000) or high (10000), default is all, indicates desired number of data points, streams will only be down sampled
    
    seriesType - (Optional) relevant only if using resolution. Either "time" or "distance", default is "distance", used to index the streams if the stream is being reduced
    
    Returns:
    
    Returns an array of unordered stream objects.
    
    Throws:
    
    UnauthorizedException - If the security token is not valid or the effort is flagged as private
    
    NotFoundException - If the effort does not exist
    
    BadRequestException - If the request is malformed
    
    See Also:
    
    StreamAPI.getEffortStreams(java.lang.Long, java.lang.String, javastrava.api.v3.model.reference.StravaStreamResolutionType, javastrava.api.v3.model.reference.StravaStreamSeriesDownsamplingType)
  - getEffortStreamsAsync
```
public StravaAPIFuture<StravaStream[]> getEffortStreamsAsync(Long segmentEffortId,
                                                             String types,
                                                             StravaStreamResolutionType resolution,
                                                             StravaStreamSeriesDownsamplingType seriesType)
                                                      throws UnauthorizedException,
                                                             NotFoundException,
                                                             BadRequestException
```
    Parameters:
    
    segmentEffortId - The id of the segment effort for which streams are to be retrieved
    
    types - List of types, if the effort does not have that stream it will not be included in the response
    
    resolution - (Optional) low (100), medium (1000) or high (10000), default is all, indicates desired number of data points, streams will only be down sampled
    
    seriesType - (Optional) relevant only if using resolution. Either "time" or "distance", default is "distance", used to index the streams if the stream is being reduced
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    UnauthorizedException - If the security token is not valid or the effort is flagged as private
    
    NotFoundException - If the effort does not exist
    
    BadRequestException - If the request is malformed
    
    See Also:
    
    StreamAPI.getEffortStreams(java.lang.Long, java.lang.String, javastrava.api.v3.model.reference.StravaStreamResolutionType, javastrava.api.v3.model.reference.StravaStreamSeriesDownsamplingType, javastrava.api.v3.rest.async.StravaAPICallback)
  - getGear
```
public StravaGear getGear(String gearId)
                   throws NotFoundException
```
    Parameters:
    
    gearId - Gear identifier
    
    Returns:
    
    Details of the identified gear
    
    Throws:
    
    NotFoundException - If the gear with the given id doesn't exist
    
    See Also:
    
    GearAPI.getGear(java.lang.String)
  - getGearAsync
```
public StravaAPIFuture<StravaGear> getGearAsync(String gearId)
                                         throws NotFoundException
```
    Parameters:
    
    gearId - Gear identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the gear with the given id doesn't exist
    
    See Also:
    
    GearAPI.getGear(java.lang.String, javastrava.api.v3.rest.async.StravaAPICallback)
  - getSegment
```
public StravaSegment getSegment(Integer segmentId)
                         throws NotFoundException
```
    Parameters:
    
    segmentId - The unique identifier of the segment
    
    Returns:
    
    The Segment
    
    Throws:
    
    NotFoundException - If the segment with the given id does not exist
    
    See Also:
    
    SegmentAPI.getSegment(java.lang.Integer)
  - getSegmentAsync
```
public StravaAPIFuture<StravaSegment> getSegmentAsync(Integer segmentId)
                                               throws NotFoundException
```
    Parameters:
    
    segmentId - The unique identifier of the segment
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the segment with the given id does not exist
    
    See Also:
    
    SegmentAPI.getSegment(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - getSegmentEffort
```
public StravaSegmentEffort getSegmentEffort(Long segmentEffortId)
                                     throws NotFoundException
```
    Parameters:
    
    segmentEffortId - Effort identifier
    
    Returns:
    
    Effort details
    
    Throws:
    
    NotFoundException - If the effort with the given id doesn't exist
    
    See Also:
    
    SegmentEffortAPI.getSegmentEffort(java.lang.Long)
  - getSegmentEffortAsync
```
public StravaAPIFuture<StravaSegmentEffort> getSegmentEffortAsync(Long segmentEffortId)
                                                           throws NotFoundException
```
    Parameters:
    
    segmentEffortId - Effort identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the effort with the given id doesn't exist
    
    See Also:
    
    SegmentEffortAPI.getSegmentEffort(java.lang.Long, javastrava.api.v3.rest.async.StravaAPICallback)
  - getSegmentLeaderboard
```
public StravaSegmentLeaderboard getSegmentLeaderboard(Integer segmentId,
                                                      StravaGender gender,
                                                      StravaAgeGroup ageGroup,
                                                      StravaWeightClass weightClass,
                                                      Boolean following,
                                                      Integer clubId,
                                                      StravaLeaderboardDateRange dateRange,
                                                      Integer page,
                                                      Integer perPage,
                                                      Integer contextEntries)
                                               throws NotFoundException,
                                                      BadRequestException
```
    Parameters:
    
    segmentId - Segment identifier
    
    gender - (Optional) Gender to filter the leaderboard by
    
    ageGroup - (Optional) Age group to filter the leaderboard by
    
    weightClass - (Optional) Weight class to filter the leaderboard by
    
    following - (Optional) If true then filter leaderboard by athletes the authenticated athlete is following
    
    clubId - (Optional) Club to filter the leaderboard by
    
    dateRange - (Optional) Date range (this year, this month etc.) to filter the leaderboard by
    
    page - (Optional) Page number to return (default is 1)
    
    perPage - (Optional) Page size to return (default is 50)
    
    contextEntries - (Optional) Number of context entries to return either side of the authenticated athlete (default is 2, maximum is 15)
    
    Returns:
    
    A Strava leaderboard
    
    Throws:
    
    NotFoundException - If the segment with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    SegmentAPI.getSegmentLeaderboard(java.lang.Integer, javastrava.api.v3.model.reference.StravaGender, javastrava.api.v3.model.reference.StravaAgeGroup, javastrava.api.v3.model.reference.StravaWeightClass, java.lang.Boolean, java.lang.Integer, javastrava.api.v3.model.reference.StravaLeaderboardDateRange, java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - getSegmentLeaderboardAsync
```
public StravaAPIFuture<StravaSegmentLeaderboard> getSegmentLeaderboardAsync(Integer segmentId,
                                                                            StravaGender gender,
                                                                            StravaAgeGroup ageGroup,
                                                                            StravaWeightClass weightClass,
                                                                            Boolean following,
                                                                            Integer clubId,
                                                                            StravaLeaderboardDateRange dateRange,
                                                                            Integer page,
                                                                            Integer perPage,
                                                                            Integer contextEntries)
                                                                     throws NotFoundException,
                                                                            BadRequestException
```
    Parameters:
    
    segmentId - Segment identifier
    
    gender - (Optional) Gender to filter the leaderboard by
    
    ageGroup - (Optional) Age group to filter the leaderboard by
    
    weightClass - (Optional) Weight class to filter the leaderboard by
    
    following - (Optional) If true then filter leaderboard by athletes the authenticated athlete is following
    
    clubId - (Optional) Club to filter the leaderboard by
    
    dateRange - (Optional) Date range (this year, this month etc.) to filter the leaderboard by
    
    page - (Optional) Page number to return (default is 1)
    
    perPage - (Optional) Page size to return (default is 50)
    
    contextEntries - (Optional) Number of context entries to return either side of the authenticated athlete (default is 2, maximum is 15)
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the segment with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    SegmentAPI.getSegmentLeaderboard(java.lang.Integer, javastrava.api.v3.model.reference.StravaGender, javastrava.api.v3.model.reference.StravaAgeGroup, javastrava.api.v3.model.reference.StravaWeightClass, java.lang.Boolean, java.lang.Integer, javastrava.api.v3.model.reference.StravaLeaderboardDateRange, java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - getSegmentStreams
```
public StravaStream[] getSegmentStreams(Integer segmentId,
                                        String types,
                                        StravaStreamResolutionType resolution,
                                        StravaStreamSeriesDownsamplingType seriesType)
                                 throws UnauthorizedException,
                                        NotFoundException,
                                        BadRequestException
```
    Parameters:
    
    segmentId - The id of the segment for which streams are to be retrieved
    
    types - List of types, if the segment does not have that stream it will not be included in the response
    
    resolution - (Optional) low (100), medium (1000) or high (10000), default is all, indicates desired number of data points, streams will only be down sampled
    
    seriesType - (Optional) relevant only if using resolution. Either "time" or "distance", default is "distance", used to index the streams if the stream is being reduced
    
    Returns:
    
    Returns an array of unordered stream objects.
    
    Throws:
    
    UnauthorizedException - If there is a security exception
    
    NotFoundException - If the segment does not exist
    
    BadRequestException - If the request is malformed
    
    See Also:
    
    StreamAPI.getSegmentStreams(java.lang.Integer, java.lang.String, javastrava.api.v3.model.reference.StravaStreamResolutionType, javastrava.api.v3.model.reference.StravaStreamSeriesDownsamplingType)
  - getSegmentStreamsAsync
```
public StravaAPIFuture<StravaStream[]> getSegmentStreamsAsync(Integer segmentId,
                                                              String types,
                                                              StravaStreamResolutionType resolution,
                                                              StravaStreamSeriesDownsamplingType seriesType)
                                                       throws UnauthorizedException,
                                                              NotFoundException,
                                                              BadRequestException
```
    Parameters:
    
    segmentId - The id of the segment for which streams are to be retrieved
    
    types - List of types, if the segment does not have that stream it will not be included in the response
    
    resolution - (Optional) low (100), medium (1000) or high (10000), default is all, indicates desired number of data points, streams will only be down sampled
    
    seriesType - (Optional) relevant only if using resolution. Either "time" or "distance", default is "distance", used to index the streams if the stream is being reduced
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    UnauthorizedException - If there is a security exception
    
    NotFoundException - If the segment does not exist
    
    BadRequestException - If the request is malformed
    
    See Also:
    
    StreamAPI.getSegmentStreams(java.lang.Integer, java.lang.String, javastrava.api.v3.model.reference.StravaStreamResolutionType, javastrava.api.v3.model.reference.StravaStreamSeriesDownsamplingType, javastrava.api.v3.rest.async.StravaAPICallback)
  - giveKudos
```
public StravaResponse giveKudos(Integer activityId)
                         throws NotFoundException
```
    Parameters:
    
    activityId - Activity to be kudoed
    
    Returns:
    
    Strava response
    
    Throws:
    
    NotFoundException - if the activity does not exist
    
    See Also:
    
    ActivityAPI.giveKudos(java.lang.Integer)
  - giveKudosAsync
```
public StravaAPIFuture<StravaResponse> giveKudosAsync(Integer activityId)
                                               throws NotFoundException
```
    Parameters:
    
    activityId - Activity to be kudoed
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - if the activity does not exist
    
    See Also:
    
    ActivityAPI.giveKudos(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - joinClub
```
public StravaClubMembershipResponse joinClub(Integer clubId)
                                      throws NotFoundException
```
    Parameters:
    
    clubId - The club the authenticated athlete wishes to join
    
    Returns:
    
    Membership response indicating success/failure
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    See Also:
    
    ClubAPI.joinClub(java.lang.Integer)
  - joinClubAsync
```
public StravaAPIFuture<StravaClubMembershipResponse> joinClubAsync(Integer clubId)
                                                            throws NotFoundException
```
    Parameters:
    
    clubId - The club the authenticated athlete wishes to join
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    See Also:
    
    ClubAPI.joinClub(Integer, StravaAPICallback)
  - leaveClub
```
public StravaClubMembershipResponse leaveClub(Integer clubId)
                                       throws NotFoundException
```
    Parameters:
    
    clubId - The club the authenticated athlete wishes to leave
    
    Returns:
    
    Membership response indicating success/failure
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    See Also:
    
    ClubAPI.leaveClub(java.lang.Integer)
  - leaveClubAsync
```
public StravaAPIFuture<StravaClubMembershipResponse> leaveClubAsync(Integer clubId)
                                                             throws NotFoundException
```
    Parameters:
    
    clubId - The club the authenticated athlete wishes to leave
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    See Also:
    
    ClubAPI.leaveClub(Integer, StravaAPICallback)
  - listActivityComments
```
public StravaComment[] listActivityComments(Integer activityId,
                                            Boolean markdown,
                                            Integer page,
                                            Integer perPage)
                                     throws NotFoundException,
                                            BadRequestException
```
    Parameters:
    
    activityId - Activity identifier
    
    markdown - Whether or not to return comments including markdown
    
    page - Page number to be returned
    
    perPage - Page size to be returned
    
    Returns:
    
    Array of comments belonging to the activity
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listActivityComments(java.lang.Integer, java.lang.Boolean, java.lang.Integer, java.lang.Integer)
  - listActivityCommentsAsync
```
public StravaAPIFuture<StravaComment[]> listActivityCommentsAsync(Integer activityId,
                                                                  Boolean markdown,
                                                                  Integer page,
                                                                  Integer perPage)
                                                           throws NotFoundException,
                                                                  BadRequestException
```
    Parameters:
    
    activityId - Activity identifier
    
    markdown - Whether or not to return comments including markdown
    
    page - Page number to be returned
    
    perPage - Page size to be returned
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listActivityComments(java.lang.Integer, java.lang.Boolean, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listActivityKudoers
```
public StravaAthlete[] listActivityKudoers(Integer activityId,
                                           Integer page,
                                           Integer perPage)
                                    throws NotFoundException,
                                           BadRequestException
```
    Parameters:
    
    activityId - Activity identifier
    
    page - Page number to be returned
    
    perPage - Page size to be returned
    
    Returns:
    
    Array of athletes who have kudoed the activity
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listActivityKudoers(java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - listActivityKudoersAsync
```
public StravaAPIFuture<StravaAthlete[]> listActivityKudoersAsync(Integer activityId,
                                                                 Integer page,
                                                                 Integer perPage)
                                                          throws NotFoundException,
                                                                 BadRequestException
```
    Parameters:
    
    activityId - Activity identifier
    
    page - Page number to be returned
    
    perPage - Page size to be returned
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listActivityKudoers(Integer, Integer, Integer, StravaAPICallback)
  - listActivityLaps
```
public StravaLap[] listActivityLaps(Integer activityId)
                             throws NotFoundException
```
    Parameters:
    
    activityId - The activity identifier
    
    Returns:
    
    Array of laps belonging to the activity
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    See Also:
    
    ActivityAPI.listActivityLaps(java.lang.Integer)
  - listActivityLapsAsync
```
public StravaAPIFuture<StravaLap[]> listActivityLapsAsync(Integer activityId)
                                                   throws NotFoundException
```
    Parameters:
    
    activityId - The activity identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listActivityLaps(Integer, StravaAPICallback)
  - listActivityPhotos
```
public StravaPhoto[] listActivityPhotos(Integer activityId)
                                 throws NotFoundException
```
    Parameters:
    
    activityId - Activity identifier
    
    Returns:
    
    Array of photos attached to the activity
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    See Also:
    
    ActivityAPI.listActivityPhotos(java.lang.Integer)
  - listActivityPhotosAsync
```
public StravaAPIFuture<StravaPhoto[]> listActivityPhotosAsync(Integer activityId)
                                                       throws NotFoundException
```
    Parameters:
    
    activityId - Activity identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    See Also:
    
    ActivityAPI.listActivityPhotos(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listActivityZones
```
public StravaActivityZone[] listActivityZones(Integer activityId)
                                       throws NotFoundException
```
    Parameters:
    
    activityId - The activity identifier
    
    Returns:
    
    Array of activity zones for the activity
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    See Also:
    
    ActivityAPI.listActivityZones(java.lang.Integer)
  - listActivityZonesAsync
```
public StravaAPIFuture<StravaActivityZone[]> listActivityZonesAsync(Integer activityId)
                                                             throws NotFoundException
```
    Parameters:
    
    activityId - The activity identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    See Also:
    
    ActivityAPI.listActivityZones(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listAthleteFriends
```
public StravaAthlete[] listAthleteFriends(Integer athleteId,
                                          Integer page,
                                          Integer perPage)
                                   throws NotFoundException,
                                          BadRequestException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    Array of athletes who the identified athlete is following
    
    Throws:
    
    NotFoundException - If the athlete with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    AthleteAPI.listAthleteFriends(java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - listAthleteFriendsAsync
```
public StravaAPIFuture<StravaAthlete[]> listAthleteFriendsAsync(Integer athleteId,
                                                                Integer page,
                                                                Integer perPage)
                                                         throws NotFoundException,
                                                                BadRequestException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the athlete with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    AthleteAPI.listAthleteFriends(java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listAthleteKOMs
```
public StravaSegmentEffort[] listAthleteKOMs(Integer athleteId,
                                             Integer page,
                                             Integer perPage)
                                      throws NotFoundException,
                                             BadRequestException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    Array of segment efforts which represent the athlete's KOM/QOM's
    
    Throws:
    
    NotFoundException - If the athlete doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    AthleteAPI.listAthleteKOMs(java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - listAthleteKOMsAsync
```
public StravaAPIFuture<StravaSegmentEffort[]> listAthleteKOMsAsync(Integer athleteId,
                                                                   Integer page,
                                                                   Integer perPage)
                                                            throws NotFoundException,
                                                                   BadRequestException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the athlete doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    AthleteAPI.listAthleteKOMs(java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listAthletesBothFollowing
```
public StravaAthlete[] listAthletesBothFollowing(Integer athleteId,
                                                 Integer page,
                                                 Integer perPage)
                                          throws NotFoundException,
                                                 BadRequestException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    Array of athletes who both the identified athlete and the authenticated athlete are following
    
    Throws:
    
    NotFoundException - If the athlete with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    AthleteAPI.listAthletesBothFollowing(java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - listAthletesBothFollowingAsync
```
public StravaAPIFuture<StravaAthlete[]> listAthletesBothFollowingAsync(Integer athleteId,
                                                                       Integer page,
                                                                       Integer perPage)
                                                                throws NotFoundException,
                                                                       BadRequestException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the athlete with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    AthleteAPI.listAthletesBothFollowing(java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listAuthenticatedAthleteActivities
```
public StravaActivity[] listAuthenticatedAthleteActivities(Integer before,
                                                           Integer after,
                                                           Integer page,
                                                           Integer perPage)
                                                    throws BadRequestException
```
    Parameters:
    
    before - Time in milliseconds since the UNIX epoch date - only return activities commenced before this time
    
    after - Time in milliseconds since the UNIX epoch date - only return activities commenced after this time
    
    page - Page number to return
    
    perPage - Number of results to return
    
    Returns:
    
    Array of activities
    
    Throws:
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listAuthenticatedAthleteActivities(java.lang.Integer, java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - listAuthenticatedAthleteActivitiesAsync
```
public StravaAPIFuture<StravaActivity[]> listAuthenticatedAthleteActivitiesAsync(Integer before,
                                                                                 Integer after,
                                                                                 Integer page,
                                                                                 Integer perPage)
                                                                          throws BadRequestException
```
    Parameters:
    
    before - Time in milliseconds since the UNIX epoch date - only return activities commenced before this time
    
    after - Time in milliseconds since the UNIX epoch date - only return activities commenced after this time
    
    page - Page number to return
    
    perPage - Number of results to return
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listAuthenticatedAthleteActivities(java.lang.Integer, java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listAuthenticatedAthleteClubs
```
public StravaClub[] listAuthenticatedAthleteClubs()
```
    Returns:
    
    Array of clubs that the authenticated athlete belongs to
    
    See Also:
    
    ClubAPI.listAuthenticatedAthleteClubs()
  - listAuthenticatedAthleteClubsAsync
```
public StravaAPIFuture<StravaClub[]> listAuthenticatedAthleteClubsAsync()
```
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    See Also:
    
    ClubAPI.listAuthenticatedAthleteClubs(javastrava.api.v3.rest.async.StravaAPICallback)
  - listAuthenticatedAthleteFriends
```
public StravaAthlete[] listAuthenticatedAthleteFriends(Integer page,
                                                       Integer perPage)
                                                throws BadRequestException
```
    Parameters:
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    Array of athletes who the authenticated athlete is following
    
    Throws:
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    AthleteAPI.listAuthenticatedAthleteFriends(java.lang.Integer, java.lang.Integer)
  - listAuthenticatedAthleteFriendsAsync
```
public StravaAPIFuture<StravaAthlete[]> listAuthenticatedAthleteFriendsAsync(Integer page,
                                                                             Integer perPage)
                                                                      throws BadRequestException
```
    Parameters:
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    AthleteAPI.listAuthenticatedAthleteFriends(java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listAuthenticatedAthleteStarredSegments
```
public StravaSegment[] listAuthenticatedAthleteStarredSegments(Integer page,
                                                               Integer perPage)
                                                        throws BadRequestException
```
    Parameters:
    
    page - (optional) Page number to be returned
    
    perPage - (optional) Number of entries to return per page
    
    Returns:
    
    An array of segments
    
    Throws:
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    SegmentAPI.listAuthenticatedAthleteStarredSegments(java.lang.Integer, java.lang.Integer)
  - listAuthenticatedAthleteStarredSegmentsAsync
```
public StravaAPIFuture<StravaSegment[]> listAuthenticatedAthleteStarredSegmentsAsync(Integer page,
                                                                                     Integer perPage)
                                                                              throws BadRequestException
```
    Parameters:
    
    page - (optional) Page number to be returned
    
    perPage - (optional) Number of entries to return per page
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    SegmentAPI.listAuthenticatedAthleteStarredSegments(java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listClubAnnouncements
```
public StravaClubAnnouncement[] listClubAnnouncements(Integer clubId)
                                               throws NotFoundException
```
    Parameters:
    
    clubId - The club id for which announcements should be returned
    
    Returns:
    
    Array of StravaClubAnnouncement for the given club
    
    Throws:
    
    NotFoundException - If the club with the given id does not exist
    
    See Also:
    
    ClubAPI.listClubAnnouncements(Integer)
  - listClubAnnouncementsAsync
```
public StravaAPIFuture<StravaClubAnnouncement[]> listClubAnnouncementsAsync(Integer clubId)
                                                                     throws NotFoundException
```
    Parameters:
    
    clubId - The club id for which announcements should be returned
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the club with the given id does not exist
    
    See Also:
    
    ClubAPI.listClubAnnouncements(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listClubGroupEvents
```
public StravaClubEvent[] listClubGroupEvents(Integer clubId)
```
    Parameters:
    
    clubId - Unique id of the club whose events should be listed
    
    Returns:
    
    Array of summary events
  - listClubGroupEventsAsync
```
public StravaAPIFuture<StravaClubEvent[]> listClubGroupEventsAsync(Integer clubId)
```
    Parameters:
    
    clubId - Unique id of the club whose events should be listed
    
    Returns:
    
    The CompletableFuture on which to call future.complete() when the API call returns.
  - listClubMembers
```
public StravaAthlete[] listClubMembers(Integer clubId,
                                       Integer page,
                                       Integer perPage)
                                throws NotFoundException,
                                       BadRequestException
```
    Parameters:
    
    clubId - CLub identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    Array of athletes who are members of the identified club
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ClubAPI.listClubMembers(java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - listClubMembersAsync
```
public StravaAPIFuture<StravaAthlete[]> listClubMembersAsync(Integer clubId,
                                                             Integer page,
                                                             Integer perPage)
                                                      throws NotFoundException,
                                                             BadRequestException
```
    Parameters:
    
    clubId - CLub identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ClubAPI.listClubMembers(java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listFriendsActivities
```
public StravaActivity[] listFriendsActivities(Integer page,
                                              Integer perPage)
                                       throws BadRequestException
```
    Parameters:
    
    page - Page number to be returned
    
    perPage - Page size to be returned
    
    Returns:
    
    List of Strava activities belonging to friends of the authenticated athlete
    
    Throws:
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listFriendsActivities(java.lang.Integer, java.lang.Integer)
  - listFriendsActivitiesAsync
```
public StravaAPIFuture<StravaActivity[]> listFriendsActivitiesAsync(Integer page,
                                                                    Integer perPage)
                                                             throws BadRequestException
```
    Parameters:
    
    page - Page number to be returned
    
    perPage - Page size to be returned
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listFriendsActivities(Integer, Integer, StravaAPICallback)
  - listRecentClubActivities
```
public StravaActivity[] listRecentClubActivities(Integer clubId,
                                                 Integer page,
                                                 Integer perPage)
                                          throws NotFoundException,
                                                 BadRequestException
```
    Parameters:
    
    clubId - Club identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    Array of activities recently done by club members (maximum 200 will be returned)
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ClubAPI.listRecentClubActivities(java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - listRecentClubActivitiesAsync
```
public StravaAPIFuture<StravaActivity[]> listRecentClubActivitiesAsync(Integer clubId,
                                                                       Integer page,
                                                                       Integer perPage)
                                                                throws NotFoundException,
                                                                       BadRequestException
```
    Parameters:
    
    clubId - Club identifier
    
    page - Page number to be returned (default is 1)
    
    perPage - Page size to be returned (default is 50)
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the club with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ClubAPI.listRecentClubActivities(java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listRelatedActivities
```
public StravaActivity[] listRelatedActivities(Integer activityId,
                                              Integer page,
                                              Integer perPage)
                                       throws NotFoundException,
                                              BadRequestException
```
    Parameters:
    
    activityId - Activity identifier
    
    page - Page number to be returned
    
    perPage - Page size to be returned
    
    Returns:
    
    Array of activities that Strava judges was 'done with' the activity identified by the id
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listRelatedActivities(java.lang.Integer, java.lang.Integer, java.lang.Integer)
  - listRelatedActivitiesAsync
```
public StravaAPIFuture<StravaActivity[]> listRelatedActivitiesAsync(Integer activityId,
                                                                    Integer page,
                                                                    Integer perPage)
                                                             throws NotFoundException,
                                                                    BadRequestException
```
    Parameters:
    
    activityId - Activity identifier
    
    page - Page number to be returned
    
    perPage - Page size to be returned
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    ActivityAPI.listRelatedActivities(java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listSegmentEfforts
```
public StravaSegmentEffort[] listSegmentEfforts(Integer segmentId,
                                                Integer athleteId,
                                                String start,
                                                String end,
                                                Integer page,
                                                Integer perPage)
                                         throws NotFoundException,
                                                BadRequestException
```
    Parameters:
    
    segmentId - The id of the StravaSegment for which segment efforts are to be returned
    
    athleteId - (Optional) id of the StravaAthlete to filter results by
    
    start - (Optional) ISO 8601 formatted date time
    
    end - (Optional) ISO 8601 formatted date time
    
    page - (optional) Page number to be returned
    
    perPage - (optional) Number of entries to return per page
    
    Returns:
    
    Returns an array of segment effort summary representations sorted by start_date_local ascending or by elapsed_time if an athlete_id is provided.
    
    Throws:
    
    NotFoundException - If the segment with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    SegmentAPI.listSegmentEfforts(java.lang.Integer, java.lang.Integer, java.lang.String, java.lang.String, java.lang.Integer, java.lang.Integer)
  - listSegmentEffortsAsync
```
public StravaAPIFuture<StravaSegmentEffort[]> listSegmentEffortsAsync(Integer segmentId,
                                                                      Integer athleteId,
                                                                      String start,
                                                                      String end,
                                                                      Integer page,
                                                                      Integer perPage)
                                                               throws NotFoundException,
                                                                      BadRequestException
```
    Parameters:
    
    segmentId - The id of the StravaSegment for which segment efforts are to be returned
    
    athleteId - (Optional) id of the StravaAthlete to filter results by
    
    start - (Optional) ISO 8601 formatted date time
    
    end - (Optional) ISO 8601 formatted date time
    
    page - (optional) Page number to be returned
    
    perPage - (optional) Number of entries to return per page
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the segment with the given id doesn't exist
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    SegmentAPI.listSegmentEfforts(java.lang.Integer, java.lang.Integer, java.lang.String, java.lang.String, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listStarredSegments
```
public StravaSegment[] listStarredSegments(Integer athleteId,
                                           Integer page,
                                           Integer perPage)
                                    throws NotFoundException,
                                           BadRequestException
```
    Parameters:
    
    athleteId - The id of the athlete whose starred segments are to be retrieved
    
    page - (optional) Page number to be returned
    
    perPage - (optional) Number of entries to return per page
    
    Returns:
    
    An array of segments
    
    Throws:
    
    NotFoundException - If the segment with the given id does not exist
    
    UnauthorizedException - If there is a security or privacy violation
    
    BadRequestException - If the paging instructions are invalid
  - listStarredSegmentsAsync
```
public StravaAPIFuture<StravaSegment[]> listStarredSegmentsAsync(Integer athleteId,
                                                                 Integer page,
                                                                 Integer perPage)
                                                          throws NotFoundException,
                                                                 BadRequestException
```
    Parameters:
    
    athleteId - The id of the athlete whose starred segments are to be retrieved
    
    page - (optional) Page number to be returned
    
    perPage - (optional) Number of entries to return per page
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the segment with the given id does not exist
    
    UnauthorizedException - If there is a security or privacy violation
    
    BadRequestException - If the paging instructions are invalid
    
    See Also:
    
    SegmentAPI.listStarredSegments(java.lang.Integer, java.lang.Integer, java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - listSubscriptions
```
public StravaEventSubscription[] listSubscriptions(Integer clientId,
                                                   String clientSecret)
```
    Parameters:
    
    clientId - Application's id, as obtained during registration with Strava
    
    clientSecret - Application's secret, as obtained during Strava registration
    
    Returns:
    
    Returns an array of summary representations of the application's current subscriptions
    
    See Also:
    
    WebhookAPI.listSubscriptions(java.lang.Integer, java.lang.String)
  - listSubscriptionsAsync
```
public StravaAPIFuture<StravaEventSubscription[]> listSubscriptionsAsync(Integer clientId,
                                                                         String clientSecret)
```
    Parameters:
    
    clientId - Application's id, as obtained during registration with Strava
    
    clientSecret - Application's secret, as obtained during Strava registration
    
    Returns:
    
    Returns an array of summary representations of the application's current subscriptions
    
    See Also:
    
    WebhookAPI.listSubscriptions(java.lang.Integer, java.lang.String)
  - segmentExplore
```
public StravaSegmentExplorerResponse segmentExplore(String bounds,
                                                    StravaSegmentExplorerActivityType activityType,
                                                    StravaClimbCategory minCategory,
                                                    StravaClimbCategory maxCategory)
```
    Parameters:
    
    bounds - Pair of co-ordinates defining a box which is to be searched for segments
    
    activityType - (Optional) Activity type to filter by (default is 'ride')
    
    minCategory - (Optional) Minimum climb category for which rides should be returned
    
    maxCategory - (Optional) Maximum climb category for which rides should be returned
    
    Returns:
    
    A response full of slightly weird-looking segments
    
    See Also:
    
    SegmentAPI.segmentExplore(java.lang.String, javastrava.api.v3.model.reference.StravaSegmentExplorerActivityType, javastrava.api.v3.model.reference.StravaClimbCategory, javastrava.api.v3.model.reference.StravaClimbCategory)
  - segmentExploreAsync
```
public StravaAPIFuture<StravaSegmentExplorerResponse> segmentExploreAsync(String bounds,
                                                                          StravaSegmentExplorerActivityType activityType,
                                                                          StravaClimbCategory minCategory,
                                                                          StravaClimbCategory maxCategory)
```
    Parameters:
    
    bounds - Pair of co-ordinates defining a box which is to be searched for segments
    
    activityType - (Optional) Activity type to filter by (default is 'ride')
    
    minCategory - (Optional) Minimum climb category for which rides should be returned
    
    maxCategory - (Optional) Maximum climb category for which rides should be returned
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    See Also:
    
    SegmentAPI.segmentExplore(java.lang.String, javastrava.api.v3.model.reference.StravaSegmentExplorerActivityType, javastrava.api.v3.model.reference.StravaClimbCategory, javastrava.api.v3.model.reference.StravaClimbCategory, javastrava.api.v3.rest.async.StravaAPICallback)
  - statistics
```
public StravaStatistics statistics(Integer athleteId)
                            throws NotFoundException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    Returns:
    
    Statistics summary for the identified athlete
    
    Throws:
    
    NotFoundException - If the identified athlete doesn't exist
    
    See Also:
    
    AthleteAPI.statistics(java.lang.Integer)
  - statisticsAsync
```
public StravaAPIFuture<StravaStatistics> statisticsAsync(Integer athleteId)
                                                  throws NotFoundException
```
    Parameters:
    
    athleteId - Athlete identifier
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the identified athlete doesn't exist
    
    See Also:
    
    AthleteAPI.statistics(java.lang.Integer, javastrava.api.v3.rest.async.StravaAPICallback)
  - updateActivity
```
public StravaActivity updateActivity(Integer id,
                                     StravaActivityUpdate activity)
                              throws NotFoundException
```
    Update an activity that already exists on Strava
    
    Parameters:
    
    id - Activity identifier
    
    activity - Update representation
    
    Returns:
    
    The activity as updated on Strava
    
    Throws:
    
    NotFoundException - If the activity with the given id does not exist
    
    See Also:
    
    ActivityAPI.updateActivity(java.lang.Integer, javastrava.api.v3.model.StravaActivityUpdate)
  - updateActivityAsync
```
public StravaAPIFuture<StravaActivity> updateActivityAsync(Integer id,
                                                           StravaActivityUpdate activity)
                                                    throws NotFoundException
```
    Update an activity that already exists on Strava
    
    Parameters:
    
    id - Activity identifier
    
    activity - Update representation
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    NotFoundException - If the activity with the given id does not exist
    
    See Also:
    
    ActivityAPI.updateActivity(java.lang.Integer, javastrava.api.v3.model.StravaActivityUpdate, javastrava.api.v3.rest.async.StravaAPICallback)
  - updateAuthenticatedAthlete
```
public StravaAthlete updateAuthenticatedAthlete(String city,
                                                String state,
                                                String country,
                                                StravaGender sex,
                                                Float weight)
```
    Parameters:
    
    city - City the athlete is from
    
    state - State/county/territory/canton/departement/whatever the athlete is from
    
    country - Country the athlete is from
    
    sex - Gender of the athlete
    
    weight - Weight in kilograms
    
    Returns:
    
    Athlete details as updated on Strava
    
    See Also:
    
    AthleteAPI.updateAuthenticatedAthlete(java.lang.String, java.lang.String, java.lang.String, javastrava.api.v3.model.reference.StravaGender, java.lang.Float)
  - updateAuthenticatedAthleteAsync
```
public StravaAPIFuture<StravaAthlete> updateAuthenticatedAthleteAsync(String city,
                                                                      String state,
                                                                      String country,
                                                                      StravaGender sex,
                                                                      Float weight)
```
    Parameters:
    
    city - City the athlete is from
    
    state - State/county/territory/canton/departement/whatever the athlete is from
    
    country - Country the athlete is from
    
    sex - Gender of the athlete
    
    weight - Weight in kilograms
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    See Also:
    
    AthleteAPI.updateAuthenticatedAthlete(java.lang.String, java.lang.String, java.lang.String, javastrava.api.v3.model.reference.StravaGender, java.lang.Float, javastrava.api.v3.rest.async.StravaAPICallback)
  - upload
```
public StravaUploadResponse upload(StravaActivityType activityType,
                                   String name,
                                   String description,
                                   Boolean _private,
                                   Boolean trainer,
                                   Boolean commute,
                                   String dataType,
                                   String externalId,
                                   retrofit.mime.TypedFile file)
                            throws BadRequestException
```
    Parameters:
    
    activityType - Type of activity being uploaded
    
    name - Name of the activity
    
    description - (Optional) Description of the activity
    
    _private - (Optional) Whether the activity should be flagged as private
    
    trainer - (Optional) If true then the activity was done on a stationary trainer
    
    commute - (Optional) If true then the activity was a commute
    
    dataType - Type of data file being uploaded
    
    externalId - (Optional) External identifier generated by your application which Strava will later use as a reference when you're checking upload status
    
    file - The file to be uploaded!
    
    Returns:
    
    Upload response containing the upload id and activity id and current status of the upload
    
    Throws:
    
    BadRequestException - If required elements of the call are missing
    
    See Also:
    
    UploadAPI.upload(javastrava.api.v3.model.reference.StravaActivityType, java.lang.String, java.lang.String, java.lang.Boolean, java.lang.Boolean, java.lang.Boolean, java.lang.String, java.lang.String, retrofit.mime.TypedFile)
  - uploadAsync
```
public StravaAPIFuture<StravaUploadResponse> uploadAsync(StravaActivityType activityType,
                                                         String name,
                                                         String description,
                                                         Boolean _private,
                                                         Boolean trainer,
                                                         Boolean commute,
                                                         String dataType,
                                                         String externalId,
                                                         retrofit.mime.TypedFile file)
                                                  throws BadRequestException
```
    Parameters:
    
    activityType - Type of activity being uploaded
    
    name - Name of the activity
    
    description - (Optional) Description of the activity
    
    _private - (Optional) Whether the activity should be flagged as private
    
    trainer - (Optional) If true then the activity was done on a stationary trainer
    
    commute - (Optional) If true then the activity was a commute
    
    dataType - Type of data file being uploaded
    
    externalId - (Optional) External identifier generated by your application which Strava will later use as a reference when you're checking upload status
    
    file - The file to be uploaded!
    
    Returns:
    
    future The CompletableFuture on which to call future.complete() when the API returns
    
    Throws:
    
    BadRequestException - If required elements of the call are missing
    
    See Also:
    
    UploadAPI.upload(javastrava.api.v3.model.reference.StravaActivityType, java.lang.String, java.lang.String, java.lang.Boolean, java.lang.Boolean, java.lang.Boolean, java.lang.String, java.lang.String, retrofit.mime.TypedFile, javastrava.api.v3.rest.async.StravaAPICallback)
  - listClubAdmins
```
public StravaAthlete[] listClubAdmins(Integer clubId,
                                      Integer page,
                                      Integer perPage)
```
  - getAuthenticatedAthleteZones
```
@GET(value="/athlete/zones")
public StravaAthleteZones getAuthenticatedAthleteZones()
```
    Returns the current athlete’s heart rate zones. The min for Zone 1 is always 0 and the max for Zone 5 is always -1
    
    Returns:
    
    The athlete zones object
  - getAuthenticatedAthleteZonesAsync
```
@GET(value="/athlete/zones")
public StravaAPIFuture<StravaAthleteZones> getAuthenticatedAthleteZonesAsync()
```
    Returns the current athlete’s heart rate zones. The min for Zone 1 is always 0 and the max for Zone 5 is always -1
    
    Returns:
    
    The athlete zones object (via a future)

Class API

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

API

Method Detail

authorisationInstance

instance

logLevel

checkUploadStatus

checkUploadStatusAsync

createComment

createCommentAsync

createManualActivity

createManualActivityAsync

createSubscription

createSubscriptionAsync

deauthoriseToken

deauthoriseTokenAsync

deleteActivity

deleteActivityAsync

deleteComment

deleteCommentAsync

deleteSubscription

deleteSubscriptionAsync

getActivity

getActivityAsync

getActivityStreams

getActivityStreamsAsync

getAthlete

getAthleteAsync

getAuthenticatedAthlete

getAuthenticatedAthleteAsync

getClub

getClubAsync

getEffortStreams

getEffortStreamsAsync

getGear

getGearAsync

getSegment

getSegmentAsync

getSegmentEffort

getSegmentEffortAsync

getSegmentLeaderboard

getSegmentLeaderboardAsync

getSegmentStreams

getSegmentStreamsAsync

giveKudos

giveKudosAsync

joinClub

joinClubAsync

leaveClub

leaveClubAsync

listActivityComments

listActivityCommentsAsync

listActivityKudoers

listActivityKudoersAsync

listActivityLaps

listActivityLapsAsync

listActivityPhotos

listActivityPhotosAsync

listActivityZones

listActivityZonesAsync

listAthleteFriends

listAthleteFriendsAsync

listAthleteKOMs

listAthleteKOMsAsync

listAthletesBothFollowing

listAthletesBothFollowingAsync

listAuthenticatedAthleteActivities

listAuthenticatedAthleteActivitiesAsync

listAuthenticatedAthleteClubs

listAuthenticatedAthleteClubsAsync

listAuthenticatedAthleteFriends

listAuthenticatedAthleteFriendsAsync

listAuthenticatedAthleteStarredSegments

listAuthenticatedAthleteStarredSegmentsAsync

listClubAnnouncements

listClubAnnouncementsAsync