import { ReadStream } from "fs";

//#region src/models/achievement.d.ts
interface Achievement {
  type_id: number;
  type: string;
  rank: number;
}
//#endregion
//#region src/models/activityStats.d.ts
interface ActivityStats {
  biggest_ride_distance: number;
  biggest_climb_elevation_gain: number;
  recent_ride_totals: ActivityTotal;
  recent_run_totals: ActivityTotal;
  recent_swim_totals: ActivityTotal;
  ytd_ride_totals: ActivityTotal;
  ytd_run_totals: ActivityTotal;
  ytd_swim_totals: ActivityTotal;
  all_ride_totals: ActivityTotal;
  all_run_totals: ActivityTotal;
  all_swim_totals: ActivityTotal;
}
//#endregion
//#region src/models/activityTotal.d.ts
interface ActivityTotal {
  count: number;
  distance: number;
  moving_time: number;
  elapsed_time: number;
  elevation_gain: number;
  achievement_count: number;
}
//#endregion
//#region src/enums/activityType.d.ts
type ActivityType = 'AlpineSki' | 'BackcountrySki' | 'Canoeing' | 'Crossfit' | 'EBikeRide' | 'Elliptical' | 'Golf' | 'Handcycle' | 'Hike' | 'IceSkate' | 'InlineSkate' | 'Kayaking' | 'Kitesurf' | 'NordicSki' | 'Ride' | 'RockClimbing' | 'RollerSki' | 'Rowing' | 'Run' | 'Sail' | 'Skateboard' | 'Snowboard' | 'Snowshoe' | 'Soccer' | 'StairStepper' | 'StandUpPaddling' | 'Surfing' | 'Swim' | 'Velomobile' | 'VirtualRide' | 'VirtualRun' | 'Walk' | 'WeightTraining' | 'Wheelchair' | 'Windsurf' | 'Workout' | 'Yoga';
//#endregion
//#region src/enums/activityZoneType.d.ts
declare enum ActivityZoneType {
  Heartrate = "heartrate",
  Power = "power",
}
//#endregion
//#region src/enums/followerStatus.d.ts
declare enum FollowerStatus {
  Pending = "pending",
  Accepted = "accepted",
  Blocked = "blocked",
}
//#endregion
//#region src/enums/membership.d.ts
declare enum Membership {
  Member = "member",
  Pending = "pending",
}
//#endregion
//#region src/enums/resourceState.d.ts
declare enum ResourceState {
  Meta = 1,
  Summary = 2,
  Detail = 3,
}
//#endregion
//#region src/enums/routeType.d.ts
declare enum RouteType {
  Ride = 1,
  Run = 2,
}
//#endregion
//#region src/enums/routeSubType.d.ts
declare enum RouteSubType {
  Road = 1,
  MountainBike = 2,
  Cross = 3,
  Trail = 4,
  Mixed = 5,
}
//#endregion
//#region src/enums/sex.d.ts
declare enum Sex {
  Female = "F",
  Male = "M",
}
//#endregion
//#region src/enums/sportType.d.ts
type SportType = 'AlpineSki' | 'BackcountrySki' | 'Canoeing' | 'Crossfit' | 'EBikeRide' | 'Elliptical' | 'EMountainBikeRide' | 'Golf' | 'GravelRide' | 'Handcycle' | 'Hike' | 'IceSkate' | 'InlineSkate' | 'Kayaking' | 'Kitesurf' | 'MountainBikeRide' | 'NordicSki' | 'Ride' | 'RockClimbing' | 'RollerSki' | 'Rowing' | 'Run' | 'Sail' | 'Skateboard' | 'Snowboard' | 'Snowshoe' | 'Soccer' | 'StairStepper' | 'StandUpPaddling' | 'Surfing' | 'Swim' | 'TrailRun' | 'Velomobile' | 'VirtualRide' | 'VirtualRun' | 'Walk' | 'WeightTraining' | 'Wheelchair' | 'Windsurf' | 'Workout' | 'Yoga';
//#endregion
//#region src/enums/streamKeys.d.ts
type StreamKeys = 'time' | 'distance' | 'latlng' | 'altitude' | 'velocity_smooth' | 'heartrate' | 'cadence' | 'watts' | 'temp' | 'moving' | 'grade_smooth';
//#endregion
//#region src/enums/unitSystem.d.ts
declare enum UnitSystem {
  Feet = "feet",
  Meters = "meters",
}
//#endregion
//#region src/models/activityZone.d.ts
interface ActivityZone {
  score: number;
  distribution_buckets: TimedZoneRange[];
  type: ActivityZoneType;
  sensor_based: boolean;
  points: number;
  custom_zones: boolean;
  max: number;
}
//#endregion
//#region src/models/comment.d.ts
interface Comment {
  id: number;
  activity_id: number;
  text: string;
  athlete: SummaryAthlete;
  created_at: string;
}
//#endregion
//#region src/models/detailedActivity.d.ts
interface DetailedActivity {
  resource_state: ResourceState;
  athlete: MetaAthlete;
  name: string;
  distance: number;
  moving_time: number;
  elapsed_time: number;
  total_elevation_gain: number;
  type: ActivityType;
  sport_type: SportType;
  workout_type: number;
  id: number;
  external_id: string;
  upload_id: number;
  start_date: string;
  start_date_local: string;
  timezone: string;
  utc_offset: number;
  start_latlng: LatLng;
  end_latlng: LatLng;
  location_city: string;
  location_state: string;
  location_country: string;
  start_latitude: number;
  start_longitude: number;
  achievement_count: number;
  kudos_count: number;
  comment_count: number;
  athlete_count: number;
  photo_count: number;
  map: PolylineMap;
  trainer: boolean;
  commute: boolean;
  manual: boolean;
  private: boolean;
  visibility: string;
  flagged: boolean;
  gear_id: string;
  from_accepted_tag: boolean;
  upload_id_str: string;
  average_speed: number;
  max_speed: number;
  has_heartrate: boolean;
  average_heartrate: number;
  max_heartrate: number;
  heartrate_opt_out: boolean;
  display_hide_heartrate_option: boolean;
  elev_high: number;
  elev_low: number;
  pr_count: number;
  total_photo_count: number;
  has_kudoed: boolean;
  description: string;
  calories: number;
  perceived_exertion: string;
  prefer_perceived_exertion: string;
  segment_efforts: DetailedSegmentEffort[];
  splits_metric: Split[];
  splits_standard: Split[];
  laps: Lap[];
  best_efforts: DetailedSegmentEffort[];
  gear: SummaryGear;
  photos: PhotoSummary;
  device_name: string;
  embed_token: string;
  similar_activities: SimilarActivity;
  available_zones: ActivityZone[];
  average_cadence: number;
  average_watts: number;
  device_watts: boolean;
  kilojoules: number;
  max_watts: number;
  suffer_score: number;
  private_note: string;
}
//#endregion
//#region src/models/detailedAthlete.d.ts
interface DetailedAthlete {
  id: number;
  resource_state: ResourceState;
  firstname: string;
  lastname: string;
  profile_medium: string;
  profile: string;
  city: string;
  state: string;
  country: string;
  sex: string;
  friend: FollowerStatus;
  follower: FollowerStatus;
  premium: boolean;
  created_at: string;
  updated_at: string;
  follower_count: number;
  friend_count: number;
  mutual_friend_count: number;
  measurement_preference: UnitSystem;
  email: string;
  ftp: number;
  weight: number;
  clubs: SummaryClub[];
  bikes: SummaryGear[];
  shoes: SummaryGear[];
}
//#endregion
//#region src/models/detailedClub.d.ts
interface DetailedClub {
  id: number;
  resource_state: ResourceState;
  name: string;
  profile_medium: string;
  cover_photo: string;
  cover_photo_small: string;
  activity_types: ActivityType;
  city: string;
  state: string;
  country: string;
  private: boolean;
  member_count: number;
  featured: boolean;
  verified: boolean;
  url: string;
  membership: Membership;
  admin: boolean;
  owner: boolean;
  following_count: number;
}
//#endregion
//#region src/models/detailedGear.d.ts
interface DetailedGear {
  id: string;
  resource_state: ResourceState;
  primary: boolean;
  name: string;
  distance: number;
  brand_name: string;
  model_name: string;
  frame_type: number;
  description: string;
}
//#endregion
//#region src/models/detailedSegment.d.ts
declare enum ActivityType$3 {
  Ride = "Ride",
  Run = "Run",
}
interface DetailedSegment {
  id: number;
  name: string;
  activity_type: ActivityType$3;
  distance: number;
  average_grade: number;
  maximum_grade: number;
  elevation_high: number;
  elevation_low: number;
  start_latlng: LatLng;
  end_latlng: LatLng;
  climb_category: number;
  city: string;
  state: string;
  country: string;
  private: boolean;
  athlete_pr_effort: SummarySegmentEffort;
  athlete_segment_stats: SummaryPRSegmentEffort;
  created_at: string;
  updated_at: string;
  total_elevation_gain: number;
  map: PolylineMap;
  effort_count: number;
  athlete_count: number;
  hazardous: boolean;
  star_count: number;
}
//#endregion
//#region src/models/detailedSegmentEffort.d.ts
interface DetailedSegmentEffort {
  id: number;
  resource_state: ResourceState;
  name: string;
  activity: MetaActivity;
  athlete: MetaAthlete;
  elapsed_time: number;
  moving_time: number;
  start_date: string;
  start_date_local: string;
  distance: number;
  start_index: number;
  end_index: number;
  pr_rank: string;
  achievements: Achievement[];
}
//#endregion
//#region src/models/explorerResponse.d.ts
interface ExplorerResponse {
  segments: ExplorerSegment[];
}
//#endregion
//#region src/models/explorerSegment.d.ts
declare enum ClimbCategoryDesc {
  NC = "NC",
  ONE = "1",
  TWO = "2",
  THREE = "3",
  FOUR = "4",
  HC = "HC",
}
interface ExplorerSegment {
  id: number;
  name: string;
  climb_category: number;
  climb_category_desc: ClimbCategoryDesc;
  avg_grade: number;
  start_latlng: LatLng;
  end_latlng: LatLng;
  elev_difference: number;
  distance: number;
  points: string;
}
//#endregion
//#region src/models/heartRateZoneRanges.d.ts
interface HeartRateZoneRanges {
  custom_zones: boolean;
  zones: ZoneRange[];
}
//#endregion
//#region src/models/lap.d.ts
interface Lap {
  id: number;
  resource_state: ResourceState;
  name: string;
  activity: MetaActivity;
  athlete: MetaAthlete;
  elapsed_time: number;
  moving_time: number;
  start_date: string;
  start_date_local: string;
  distance: number;
  start_index: number;
  end_index: number;
  total_elevation_gain: number;
  average_speed: number;
  max_speed: number;
  average_heartrate: number;
  max_heartrate: number;
  lap_index: number;
  split: number;
  pace_zone: number;
}
//#endregion
//#region src/models/metaActivity.d.ts
interface MetaActivity {
  id: number;
  resource_state: ResourceState;
}
//#endregion
//#region src/models/metaAthlete.d.ts
interface MetaAthlete {
  id: number;
  resource_state: ResourceState;
}
//#endregion
//#region src/models/photoSummary.d.ts
interface PhotoSummary {
  count: number;
  primary: PhotoSummaryPrimary;
}
//#endregion
//#region src/models/photoSummaryPrimary.d.ts
interface PhotoSummaryPrimary {
  id: number;
  source: number;
  unique_id: string;
  urls: string;
}
//#endregion
//#region src/models/polylineMap.d.ts
interface PolylineMap {
  id: string;
  polyline: string;
  resource_state: ResourceState;
  summary_polyline: string;
}
//#endregion
//#region src/models/powerZoneRanges.d.ts
interface PowerZoneRanges {
  zones: ZoneRange[];
}
//#endregion
//#region src/models/runningRace.d.ts
interface RunningRace {
  id: number;
  name: string;
  running_race_type: number;
  distance: number;
  start_date_local: string;
  city: string;
  state: string;
  country: string;
  route_ids: number[];
  measurement_preference: UnitSystem;
  url: string;
  website_url: string;
}
//#endregion
//#region src/models/route.d.ts
interface Route {
  athlete: SummaryAthlete;
  description: string;
  distance: number;
  elevation_gain: number;
  id: number;
  id_srt: string;
  map: PolylineMap;
  name: string;
  private: boolean;
  starred: boolean;
  timestamp: number;
  type: RouteType;
  sub_type: RouteSubType;
  created_at: string;
  updated_at: string;
  estimated_moving_time: number;
  segments: SummarySegment[];
}
//#endregion
//#region src/models/similarActivitity.d.ts
interface SimilarActivity {
  effort_count: number;
  average_speed: number;
  min_average_speed: number;
  mid_average_speed: number;
  max_average_speed: number;
  pr_rank: string;
  frequency_milestone: string;
  trend: {
    speeds: number[];
    current_activity_index: number;
    min_speed: number;
    mid_speed: number;
    max_speed: number;
    direction: number;
  };
  resource_state: ResourceState;
}
//#endregion
//#region src/models/split.d.ts
interface Split {
  distance: number;
  elapsed_time: number;
  elevation_difference: number;
  moving_time: number;
  split: number;
  average_speed: number;
  average_grade_adjusted_speed: number;
  average_heartrate: number;
  pace_zone: number;
}
//#endregion
//#region src/models/stream.d.ts
interface BaseStream<StreamKey extends StreamKeys, Data> {
  type: StreamKey;
  original_size: number;
  resolution: 'low' | 'medium' | 'high';
  series_type: 'distance' | 'time';
  data: Data[];
}
type Stream = BaseStream<'time' | 'distance' | 'altitude' | 'velocity_smooth' | 'heartrate' | 'cadence' | 'watts' | 'temp' | 'moving' | 'grade_smooth', number>;
type LatLngStream = BaseStream<'latlng', LatLng>;
//#endregion
//#region src/models/streamSet.d.ts
interface StreamSet {
  time: Stream;
  distance: Stream;
  latlng: LatLngStream;
  altitude: Stream;
  velocity_smooth: Stream;
  heartrate: Stream;
  cadence: Stream;
  watts: Stream;
  temp: Stream;
  moving: Stream;
  grade_smooth: Stream;
}
//#endregion
//#region src/models/subscriptionEvent.d.ts
interface SubscriptionEvent {
  object_type: 'activity' | 'athlete';
  object_id: number;
  aspect_type: 'create' | 'update' | 'delete';
  updates: {
    title?: string;
    type?: ActivityType;
    private?: boolean;
    authorized?: false;
  };
  owner_id: number;
  subscription_id: number;
  event_time: number;
}
//#endregion
//#region src/models/summaryActivity.d.ts
interface SummaryActivity {
  resource_state: ResourceState;
  athlete: MetaAthlete;
  name: string;
  distance: number;
  moving_time: number;
  elapsed_time: number;
  total_elevation_gain: number;
  type: ActivityType;
  workout_type: number;
  id: number;
  external_id: string;
  upload_id: number;
  start_date: string;
  start_date_local: string;
  timezone: string;
  utc_offset: number;
  start_latlng: LatLng;
  end_latlng: LatLng;
  location_city: string;
  location_state: string;
  location_country: string;
  start_latitude: number;
  start_longitude: number;
  achievement_count: number;
  kudos_count: number;
  comment_count: number;
  athlete_count: number;
  photo_count: number;
  map: PolylineMap;
  trainer: boolean;
  commute: boolean;
  manual: boolean;
  private: boolean;
  visibility: string;
  flagged: boolean;
  gear_id: string;
  from_accepted_tag: boolean;
  upload_id_str: string;
  average_speed: number;
  max_speed: number;
  average_cadence: number;
  average_temp: number;
  average_watts: number;
  weighted_average_watts: number;
  kilojoules: number;
  device_watts: boolean;
  has_heartrate: boolean;
  average_heartrate: number;
  max_heartrate: number;
  heartrate_opt_out: boolean;
  display_hide_heartrate_option: boolean;
  max_watts: number;
  elev_high: number;
  elev_low: number;
  pr_count: number;
  total_photo_count: number;
  has_kudoed: boolean;
  suffer_score: number;
}
//#endregion
//#region src/models/summaryAthlete.d.ts
interface SummaryAthlete {
  id: number;
  resource_state: ResourceState;
  firstname: string;
  lastname: string;
  profile_medium: string;
  profile: string;
  city: string;
  state: string;
  country: string;
  sex: Sex;
  friend: string;
  follower: string;
  premium: boolean;
  created_at: string;
  updated_at: string;
}
//#endregion
//#region src/models/summaryClub.d.ts
interface SummaryClub {
  id: number;
  resource_state: ResourceState;
  name: string;
  profile_medium: string;
  cover_photo: string;
  cover_photo_small: string;
  sport_type: SportType;
  city: string;
  state: string;
  country: string;
  private: boolean;
  member_count: number;
  featured: boolean;
  verified: boolean;
  url: string;
}
//#endregion
//#region src/models/summaryGear.d.ts
interface SummaryGear {
  id: string;
  primary: boolean;
  name: string;
  resource_state: ResourceState;
  distance: number;
}
//#endregion
//#region src/models/summarySegment.d.ts
declare enum ActivityType$2 {
  Ride = "Ride",
  Run = "Run",
}
interface SummarySegment {
  id: number;
  name: string;
  activity_type: ActivityType$2;
  distance: number;
  average_grade: number;
  maximum_grade: number;
  elevation_high: number;
  elevation_low: number;
  start_latlng: LatLng;
  end_latlng: LatLng;
  climb_category: number;
  city: string;
  state: string;
  country: string;
  private: boolean;
  athlete_pr_effort: SummarySegmentEffort;
}
//#endregion
//#region src/models/summaryPRSegmentEffort.d.ts
interface SummaryPRSegmentEffort {
  pr_activity_id: number;
  pr_elapsed_time: number;
  pr_date: string;
  effort_count: number;
}
//#endregion
//#region src/models/summarySegmentEffort.d.ts
interface SummarySegmentEffort {
  id: number;
  elapsed_time: number;
  start_date: string;
  start_date_local: string;
  distance: number;
  is_kom: boolean;
}
//#endregion
//#region src/models/timedZoneRange.d.ts
interface TimedZoneRange {
  min: number;
  max: number;
  time: number;
}
//#endregion
//#region src/models/upload.d.ts
interface Upload {
  id: number;
  id_str: string;
  external_id: string;
  error: string;
  status: string;
  activity_id: number;
}
//#endregion
//#region src/models/zoneRange.d.ts
interface ZoneRange {
  min: number;
  max: number;
}
//#endregion
//#region src/models/zones.d.ts
interface Zones {
  heart_rate: HeartRateZoneRanges;
  power: PowerZoneRanges;
}
//#endregion
//#region src/types.d.ts
interface AppConfig {
  client_id: string;
  client_secret: string;
  on_token_refresh?: (token: RefreshTokenResponse) => void;
  on_rate_limit_update?: RateLimitCallback;
}
interface RefreshTokenRequest extends AppConfig {
  refresh_token: string;
}
interface AccessToken {
  access_token: string;
  expires_at: number;
  refresh_token?: string;
}
interface RefreshTokenResponse extends AccessToken {
  expires_in: number;
  /** The athlete is only provided on the initial request */
  athlete?: SummaryAthlete;
}
/**
 * Latitude, Longitude
 */
type LatLng = [number, number];
/**
 * Strava API Rate Limit Information
 */
interface RateLimit {
  /** 15-minute limit */
  shortTermLimit: number;
  /** Daily limit */
  longTermLimit: number;
  /** Current 15-minute usage */
  shortTermUsage: number;
  /** Current daily usage */
  longTermUsage: number;
  /** Timestamp when the rate limit was last updated */
  timestamp: number;
}
/**
 * Callback function for rate limit updates
 */
type RateLimitCallback = (rateLimit: RateLimit) => void;
//#endregion
//#region src/resources/oauth.d.ts
declare class Oauth {
  refreshTokens(token: RefreshTokenRequest): Promise<RefreshTokenResponse>;
  static tokenExchange(config: AppConfig, code: string): Promise<RefreshTokenResponse>;
  private static oauthRequest;
}
//#endregion
//#region src/request.d.ts
type RequestParams = {
  query?: Record<string, any>;
  body?: Record<string, any> | any;
  headers?: Record<string, any>;
  access_token?: string;
};
type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch';
declare class StravaApiError extends Error {
  status: number;
  statusText: string;
  data?: any | undefined;
  constructor(status: number, statusText: string, data?: any | undefined);
}
declare class Request {
  readonly config: RefreshTokenRequest;
  private token?;
  private static readonly TOKEN_EXPIRY_BUFFER_SECONDS;
  readonly oauth: Oauth;
  private rateLimit;
  constructor(config: RefreshTokenRequest, token?: AccessToken | undefined);
  private getAccessToken;
  private updateRateLimitFromHeaders;
  /**
   * Get the current rate limit information
   * @returns Current rate limit information or null if not available yet
   */
  getRateLimit(): RateLimit | null;
  makeApiRequest<T>(method: HttpMethod, uri: string, params?: RequestParams): Promise<T>;
}
//#endregion
//#region src/resources/activities.d.ts
type CreateActivityRequest = {
  name: string;
  sport_type: ActivityType;
  start_date_local: string;
  elapsed_time: number;
  description?: string;
  distance?: number;
  trainer?: number;
  commute?: number;
};
type GetActivityByIdRequest = {
  id: number;
  include_all_efforts?: boolean;
};
type GetCommentsByActivityIdRequest = {
  id: number;
  page?: number;
  page_size?: number;
  after_cursor?: string;
};
type GetKudoersByActivityIdRequest = {
  id: number;
  page?: number;
  per_page?: number;
};
type GetLapsByActivityIdRequest = {
  id: number;
};
type GetZonesByActivityIdRequest = {
  id: number;
};
type GetLoggedInAthleteActivitiesRequest = {
  before?: number;
  after?: number;
  page?: number;
  per_page?: number;
};
type UpdateActivityByIdRequest = {
  id: number;
  name?: string;
  sport_type?: ActivityType;
  start_date_local?: string;
  elapsed_time?: number;
  description?: string;
  distance?: number;
  trainer?: number;
  commute?: number;
};
declare class Activities {
  private readonly request;
  constructor(request: Request);
  createActivity(params: CreateActivityRequest, access_token?: string): Promise<DetailedActivity>;
  getActivityById(params: GetActivityByIdRequest, access_token?: string): Promise<DetailedActivity>;
  getCommentsByActivityId(params: GetCommentsByActivityIdRequest, access_token?: string): Promise<Comment[]>;
  getKudoersByActivityId(params: GetKudoersByActivityIdRequest, access_token?: string): Promise<SummaryAthlete[]>;
  getLapsByActivityId(params: GetLapsByActivityIdRequest): Promise<Lap[]>;
  getLoggedInAthleteActivities(params?: GetLoggedInAthleteActivitiesRequest): Promise<SummaryActivity[]>;
  getZonesByActivityId(params: GetZonesByActivityIdRequest, access_token?: string): Promise<ActivityZone[]>;
  updateActivityById(params: UpdateActivityByIdRequest, access_token?: string): Promise<DetailedActivity>;
}
//#endregion
//#region src/resources/athletes.d.ts
type GetStatsRequest = {
  id: number;
};
type UpdateLoggedInAthleteRequest = {
  weight: number;
};
declare class Athletes {
  private readonly request;
  constructor(request: Request);
  getLoggedInAthlete(access_token?: string): Promise<DetailedAthlete>;
  getLoggedInAthleteZones(access_token?: string): Promise<Zones>;
  getStats(params: GetStatsRequest, access_token?: string): Promise<ActivityStats>;
  updateLoggedInAthlete(params: UpdateLoggedInAthleteRequest, access_token?: string): Promise<DetailedAthlete>;
}
//#endregion
//#region src/resources/clubs.d.ts
type GetClubActivitiesByIdRequest = {
  id: number;
  page?: number;
  per_page?: number;
};
type GetClubAdminsByIdRequest = {
  id: number;
  page?: number;
  per_page?: number;
};
type GetClubByIdRequest = {
  id: number;
};
type GetClubMembersByIdRequest = {
  id: number;
  page?: number;
  per_page?: number;
};
type GetLoggedInAthleteClubsRequest = {
  page?: number;
  per_page?: number;
};
declare class Clubs {
  private readonly request;
  constructor(request: Request);
  getClubActivitiesById(params: GetClubActivitiesByIdRequest, access_token?: string): Promise<SummaryActivity[]>;
  getClubAdminsById(params: GetClubAdminsByIdRequest, access_token?: string): Promise<SummaryAthlete[]>;
  getClubById(params: GetClubByIdRequest): Promise<DetailedClub>;
  getClubMembersById(params: GetClubMembersByIdRequest, access_token?: string): Promise<SummaryAthlete[]>;
  getLoggedInAthleteClubs(params?: GetLoggedInAthleteClubsRequest, access_token?: string): Promise<SummaryClub[]>;
}
//#endregion
//#region src/resources/gears.d.ts
type GetGearByIdRequest = {
  id: number;
};
declare class Gears {
  private readonly request;
  constructor(request: Request);
  getGearById(params: GetGearByIdRequest, access_token?: string): Promise<DetailedGear>;
}
//#endregion
//#region src/resources/routes.d.ts
type GetRouteAsGPXRequest = {
  id: number;
};
type GetRouteAsTCXRequest = {
  id: number;
};
type GetRouteByIdRequest = {
  id: number;
};
type GetRoutesByAthleteIdRequest = {
  id: number;
  page?: number;
  per_page?: number;
};
declare class Routes {
  private readonly request;
  constructor(request: Request);
  getRouteAsGPX(params: GetRouteAsGPXRequest, access_token?: string): Promise<any>;
  getRouteAsTCX(params: GetRouteAsTCXRequest, access_token?: string): Promise<any>;
  getRouteById(params: GetRouteByIdRequest): Promise<Route>;
  getRoutesByAthleteId(params: GetRoutesByAthleteIdRequest): Promise<Route[]>;
}
//#endregion
//#region src/resources/runningRaces.d.ts
type GetRunningRaceByIdRequest = {
  id: number;
};
type GetRunningRacesRequest = {
  year?: number;
};
declare class RunningRaces {
  private readonly request;
  constructor(request: Request);
  getRunningRaceById(params: GetRunningRaceByIdRequest, access_token?: string): Promise<RunningRace>;
  getRunningRaces(params?: GetRunningRacesRequest, access_token?: string): Promise<RunningRace[]>;
}
//#endregion
//#region src/resources/segmentEfforts.d.ts
type GetEffortsBySegmentIdRequest = {
  segment_id: number;
  start_date_local?: string;
  end_date_local?: string;
  per_page?: number;
};
type GetSegmentEffortByIdRequest = {
  id: number;
};
declare class SegmentEfforts {
  private readonly request;
  constructor(request: Request);
  getEffortsBySegmentId(params: GetEffortsBySegmentIdRequest, access_token?: string): Promise<DetailedSegmentEffort[]>;
  getSegmentEffortById(params: GetSegmentEffortByIdRequest, access_token?: string): Promise<DetailedSegmentEffort>;
}
//#endregion
//#region src/resources/segments.d.ts
type ActivityType$1 = 'running' | 'riding';
type ExploreSegmentsRequest = {
  bounds: string;
  activity_type?: ActivityType$1;
  min_cat?: number;
  max_cat?: number;
};
type GetLoggedInAthleteStarredSegmentsRequest = {
  page?: number;
  per_page?: number;
};
type GetSegmentByIdRequest = {
  id: number;
};
type StarSegmentRequest = {
  id: number;
  starred: boolean;
};
declare class Segments {
  private readonly request;
  constructor(request: Request);
  exploreSegments(params: ExploreSegmentsRequest, access_token?: string): Promise<ExplorerResponse>;
  getLoggedInAthleteStarredSegments(params: GetLoggedInAthleteStarredSegmentsRequest): Promise<SummarySegment[]>;
  getSegmentById(params: GetSegmentByIdRequest, access_token?: string): Promise<DetailedSegment>;
  starSegment(params: StarSegmentRequest, access_token?: string): Promise<DetailedSegment>;
}
//#endregion
//#region src/resources/streams.d.ts
type GetActivityStreamsRequest = {
  id: number;
  keys: StreamKeys | StreamKeys[];
};
type GetRouteStreamsRequest = {
  id: number;
};
type GetSegmentEffortStreamsRequest = {
  id: number;
  keys: StreamKeys | StreamKeys[];
};
type GetSegmentStreamsRequest = {
  id: number;
  keys: StreamKeys | StreamKeys[];
};
declare class Streams {
  private readonly request;
  constructor(request: Request);
  getActivityStreams(params: GetActivityStreamsRequest, access_token?: string): Promise<StreamSet>;
  getRouteStreams(params: GetRouteStreamsRequest, access_token?: string): Promise<StreamSet>;
  getSegmentEffortStreams(params: GetSegmentEffortStreamsRequest, access_token?: string): Promise<StreamSet>;
  getSegmentStreams(params: GetSegmentStreamsRequest, access_token?: string): Promise<StreamSet>;
}
//#endregion
//#region src/resources/subscriptions.d.ts
type Subscription = {
  id: number;
};
type SubscriptionCreationRequest = {
  callback_url: string;
  verify_token: string;
};
type SubscriptionCreationResponse = {
  id: number;
};
declare class Subscriptions {
  private readonly request;
  constructor(request: Request);
  createSubscription(params: SubscriptionCreationRequest): Promise<SubscriptionCreationResponse>;
  deleteSubscription(id: number): Promise<any>;
  getSubscriptions(): Promise<Subscription[]>;
}
//#endregion
//#region src/resources/uploads.d.ts
type CreateUploadRequest = {
  file: ReadStream;
  data_type: 'fit' | 'fit.gz' | 'tcx' | 'tcx.gz' | 'gpx' | 'gpx.gz';
  name?: string;
  description?: string;
  trainer?: string;
  commute?: string;
  external_id?: string;
};
type GetUploadByIdRequest = {
  uploadId: number;
};
declare class Uploads {
  private readonly request;
  constructor(request: Request);
  createUpload(params: CreateUploadRequest): Promise<Upload | void>;
  getUploadById(params: GetUploadByIdRequest, access_token?: string): Promise<Upload>;
}
//#endregion
//#region src/index.d.ts
declare class Strava {
  private readonly request;
  readonly activities: Activities;
  readonly athletes: Athletes;
  readonly clubs: Clubs;
  readonly gears: Gears;
  readonly oauth: Oauth;
  readonly routes: Routes;
  readonly runningRaces: RunningRaces;
  readonly segmentEfforts: SegmentEfforts;
  readonly segments: Segments;
  readonly streams: Streams;
  readonly subscriptions: Subscriptions;
  readonly uploads: Uploads;
  constructor(config: RefreshTokenRequest, access_token?: AccessToken);
  constructor(config: AppConfig, access_token: AccessToken);
  static createFromTokenExchange(config: AppConfig, code: string): Promise<Strava>;
  /**
   * Get the current API rate limit information
   * @returns Current rate limit information or null if no API calls have been made yet
   */
  getRateLimit(): RateLimit | null;
}
//#endregion
export { AccessToken, Achievement, ActivityStats, ActivityTotal, ActivityType, ActivityZone, ActivityZoneType, AppConfig, BaseStream, Comment, DetailedActivity, DetailedAthlete, DetailedClub, DetailedGear, DetailedSegment, DetailedSegmentEffort, ExplorerResponse, ExplorerSegment, FollowerStatus, HeartRateZoneRanges, Lap, LatLng, LatLngStream, Membership, MetaActivity, MetaAthlete, PhotoSummary, PhotoSummaryPrimary, PolylineMap, PowerZoneRanges, RateLimit, RateLimitCallback, RefreshTokenRequest, RefreshTokenResponse, ResourceState, Route, RouteSubType, RouteType, RunningRace, Sex, SimilarActivity, Split, SportType, Strava, StravaApiError, Stream, StreamKeys, StreamSet, SubscriptionEvent, SummaryActivity, SummaryAthlete, SummaryClub, SummaryGear, SummaryPRSegmentEffort, SummarySegment, SummarySegmentEffort, TimedZoneRange, UnitSystem, Upload, ZoneRange, Zones };
//# sourceMappingURL=index.d.ts.map