@gooin/garmin-connect 1.7.6 → 1.8.1

package/dist/garmin/GarminConnect.d.ts

@@ -1,16 +1,9 @@
 import { HttpClient } from '../common/HttpClient';
 import { UrlClass } from './UrlClass';
-import { ExportFileTypeValue, GarminDomain, ICalendar, ICountActivities, IGarminTokens, IOauth1Token, IOauth2Token, IScheduleWorkout, ISocialProfile, IUserSettings, IWorkout, IWorkoutDetail, UploadFileTypeTypeValue, GCConfig } from './types';
-import { ActivitySubType, ActivityType, GCActivityId, IActivity } from './types/activity';
-import { ICourse, ICourseDetail } from './types/course';
-import { SleepData, SleepDailySummary } from './types/sleep';
-import { HRVData } from './types/hrv';
-import { LatestTrainingStatusResponse, TrainingLoadBalanceResponse, WeeklyTrainingStatusResponse } from './types/training-status';
-import { PersonalInfoResponse } from './types/personal-info';
-import Running from './workouts/Running';
+import { GarminDomain, IGarminTokens, IOauth1Token, IOauth2Token, ISocialProfile, GCConfig } from './types';
 export interface Session {
 }
-export default class GarminConnect {
+declare class GarminConnectBase {
     client: HttpClient;
     domain: GarminDomain;
     config: GCConfig;
@@ -18,66 +11,250 @@ export default class GarminConnect {
     private listeners;
     url: UrlClass;
     constructor(config: GCConfig, domain?: GarminDomain);
-    login(username?: string, password?: string, sessionId?: string): Promise<GarminConnect>;
+    login(username?: string, password?: string, sessionId?: string): Promise<this>;
     exportTokenToFile(dirPath: string): Promise<void>;
     loadTokenByFile(dirPath: string): Promise<void>;
     exportToken(): IGarminTokens;
     loadToken(oauth1: IOauth1Token, oauth2: IOauth2Token): void;
-    getUserSettings(): Promise<IUserSettings>;
     getUserProfile(): Promise<ISocialProfile>;
-    getActivities(start?: number, limit?: number, activityType?: ActivityType, subActivityType?: ActivitySubType): Promise<IActivity[]>;
-    getActivity(activity: {
-        activityId: GCActivityId;
-    }): Promise<IActivity>;
-    countActivities(): Promise<ICountActivities>;
-    downloadWellnessData(date: Date, dir: string): Promise<void>;
-    downloadOriginalActivityData(activity: {
-        activityId: GCActivityId;
-    }, dir: string, type?: ExportFileTypeValue): Promise<void>;
-    uploadActivity(file: string, format?: UploadFileTypeTypeValue): Promise<unknown>;
-    deleteActivity(activity: {
-        activityId: GCActivityId;
-    }): Promise<void>;
-    getWorkouts(start: number, limit: number): Promise<IWorkout[]>;
-    getWorkoutDetail(workout: {
-        workoutId: string;
-    }): Promise<IWorkoutDetail>;
-    addWorkout(workout: IWorkoutDetail | Running): Promise<IWorkoutDetail>;
-    addRunningWorkout(name: string, meters: number, description: string): Promise<IWorkoutDetail>;
-    deleteWorkout(workout: {
-        workoutId: string;
-    }): Promise<unknown>;
-    scheduleWorkout(workout: {
-        workoutId: string;
-    }, date?: Date): Promise<IScheduleWorkout>;
-    getCalendar(year?: number, month?: number): Promise<ICalendar>;
-    getSteps(date?: Date): Promise<number>;
-    getSleepData(date?: Date): Promise<SleepData>;
-    getSleepDuration(date?: Date): Promise<{
-        hours: number;
-        minutes: number;
-    }>;
-    getSleepDailySummary(startDate: Date, endDate: Date): Promise<SleepDailySummary>;
-    getHRVData(date?: Date): Promise<HRVData>;
-    getTrainingStatus(date?: Date): Promise<LatestTrainingStatusResponse>;
-    getTrainingLoadBalance(date?: Date): Promise<TrainingLoadBalanceResponse>;
-    getWeeklyTrainingStatus(startDate: Date, endDate: Date): Promise<WeeklyTrainingStatusResponse>;
-    getPersonalInfo(): Promise<PersonalInfoResponse>;
-    getDailyWeightData(date?: Date): Promise<WeightData>;
-    getDailyWeightInPounds(date?: Date): Promise<number>;
-    getDailyHydration(date?: Date): Promise<number>;
-    updateWeight(date: Date | undefined, lbs: number, timezone: string): Promise<UpdateWeight>;
-    updateHydrationLogOunces(date: Date | undefined, valueInOz: number): Promise<WaterIntake>;
-    getGolfSummary(): Promise<GolfSummary>;
-    getGolfScorecard(scorecardId: number): Promise<GolfScorecard>;
-    getHeartRate(date?: Date): Promise<HeartRate>;
-    getCourses(): Promise<ICourse[]>;
-    getCourse(course: {
-        courseId: number;
-    }): Promise<ICourseDetail>;
-    createCourse(course: ICourseDetail): Promise<ICourseDetail>;
-    consentGrant(): Promise<void>;
-    get<T>(url: string, data?: any): Promise<T>;
-    post<T>(url: string, data: any): Promise<T>;
-    put<T>(url: string, data: any): Promise<T>;
 }
+declare const WithUser: {
+    new (...args: any[]): {
+        getUserSettings(): Promise<import("./types").IUserSettings>;
+        getPersonalInfo(): Promise<import("./types").PersonalInfoResponse>;
+        getPersonalRecordTypes(): Promise<import("./types").PersonalRecordType[]>;
+        getPersonalRecords(): Promise<import("./types").PersonalRecord[]>;
+        getDisplayName(): Promise<string>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithSleep: {
+    new (...args: any[]): {
+        getSleepData(date?: Date): Promise<import("./types").SleepData>;
+        getSleepDuration(date?: Date): Promise<{
+            hours: number;
+            minutes: number;
+        }>;
+        getSleepDailySummary(startDate: Date, endDate: Date): Promise<import("./types").SleepDailySummary>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithHRV: {
+    new (...args: any[]): {
+        getHRVData(date?: Date): Promise<import("./types").HRVData>;
+        getHRVDailySummary(startDate: string | Date, endDate: string | Date): Promise<import("./types").HRVDailySummary[]>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithWeight: {
+    new (...args: any[]): {
+        getDailyWeightData(date?: Date): Promise<import("./types").WeightData>;
+        getDailyWeightInPounds(date?: Date): Promise<number>;
+        getWeightRange(startDate: string | Date, endDate: string | Date, includeAll?: boolean): Promise<import("./types").WeightRangeData>;
+        buildFitbitWeightCsv(weightData: import("./types").WeightRangeData): string;
+        getFitbitWeightCsv(startDate: string | Date, endDate: string | Date, includeAll?: boolean): Promise<string>;
+        downloadFitbitWeightCsv(startDate: string | Date, endDate: string | Date, file: string, includeAll?: boolean): Promise<void>;
+        getUploadFeature(feature?: string): Promise<unknown>;
+        uploadFitbitWeightCsv(file: string): Promise<import("./types").FitbitCsvUploadResponse>;
+        getFitbitWeightUploadStatus(owner: number, date: string | Date, uploadUuid: string): Promise<import("./types").FitbitCsvUploadResponse>;
+        updateWeight(date: Date | undefined, lbs: number, timezone: string): Promise<import("./types").UpdateWeight>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithHydration: {
+    new (...args: any[]): {
+        getDailyHydration(date?: Date): Promise<number>;
+        updateHydrationLogOunces(date: Date | undefined, valueInOz: number): Promise<import("./types").WaterIntake>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithBodyBattery: {
+    new (...args: any[]): {
+        getBodyBattery(startDate: string | Date, endDate: string | Date): Promise<import("./types").BodyBatteryDailyEntry[]>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithHeartRate: {
+    new (...args: any[]): {
+        getHeartRate(date?: Date): Promise<import("./types").HeartRate>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithActivityBase: {
+    new (...args: any[]): {
+        getActivities(start?: number | undefined, limit?: number | undefined, activityType?: import("./types").ActivityType | undefined, subActivityType?: import("./types").ActivitySubType | undefined): Promise<import("./types").IActivity[]>;
+        getActivity(activity: {
+            activityId: number;
+        }): Promise<import("./types").IActivity>;
+        getActivityLaps(activity: {
+            activityId: number;
+        }): Promise<{
+            activityId: number;
+            lapDTOs: import("./types").ActivityLap[];
+        }>;
+        getActivityWeather(activity: {
+            activityId: number;
+        }): Promise<import("./types").ActivityWeather>;
+        getActivityWorkouts(activity: {
+            activityId: number;
+        }): Promise<import("./types").ActivityWorkout[]>;
+        countActivities(): Promise<import("./types").ICountActivities>;
+        getActivityStats(options: import("./types").ActivityStatsOptions): Promise<import("./types").ActivityStatsEntry[]>;
+        downloadWellnessData(date: Date, dir: string): Promise<void>;
+        downloadOriginalActivityData(activity: {
+            activityId: number;
+        }, dir: string, type?: "tcx" | "gpx" | "kml" | "zip"): Promise<void>;
+        uploadActivity(file: string, format?: "tcx" | "gpx" | "fit"): Promise<unknown>;
+        deleteActivity(activity: {
+            activityId: number;
+        }): Promise<void>;
+        getSteps(date?: Date): Promise<number>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithRunning: {
+    new (...args: any[]): {
+        getRacePredictionsMonthly(fromCalendarDate: string | Date, toCalendarDate: string | Date): Promise<import("./types").RacePredictionMonthlyReadable[]>;
+        getLactateThresholdSpeedRange(startDate: string | Date, endDate: string | Date): Promise<import("./types").BiometricStatRangeEntry[]>;
+        getLactateThresholdHeartRateRange(startDate: string | Date, endDate: string | Date): Promise<import("./types").BiometricStatRangeEntry[]>;
+        getLatestLactateThreshold(): Promise<import("./types").LatestLactateThresholdEntry[]>;
+        getRunningLactateThreshold(startDate: string | Date, endDate: string | Date): Promise<import("./types").RunningLactateThreshold>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithCycling: {
+    new (...args: any[]): {
+        getLatestPowerToWeight(date?: string | Date): Promise<import("./types").PowerToWeightEntry[]>;
+        getPowerToWeightRange(startDate: string | Date, endDate: string | Date, aggregation?: "monthly" | "weekly", sport?: "running" | "cycling"): Promise<import("./types").BiometricStatRangeEntry[]>;
+        getCyclingAbility(): Promise<import("./types").CyclingAbility | null>;
+        getPowerCurve(sport?: "running" | "cycling", startDate?: string | Date | undefined, endDate?: string | Date | undefined): Promise<import("./types").PowerCurveResponse>;
+        getMaxMet(date?: string | Date, sport?: "running" | "cycling" | undefined): Promise<import("./types").MaxMetResponse | null>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithTrainingStatus: {
+    new (...args: any[]): {
+        getTrainingStatus(date?: Date): Promise<import("./types").LatestTrainingStatusResponse>;
+        getTrainingLoadBalance(date?: Date): Promise<import("./types").TrainingLoadBalanceResponse>;
+        getWeeklyTrainingStatus(startDate: Date, endDate: Date): Promise<import("./types").WeeklyTrainingStatusResponse>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithDevice: {
+    new (...args: any[]): {
+        getPrimaryWearableDevice(): Promise<import("./types").PrimaryWearableDevice | null>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithWorkout: {
+    new (...args: any[]): {
+        getWorkouts(start: number, limit: number): Promise<import("./types").IWorkout[]>;
+        getWorkoutDetail(workout: {
+            workoutId: string;
+        }): Promise<import("./types").IWorkoutDetail>;
+        addWorkout(workout: import("./types").IWorkoutDetail | import("./workouts/Running").default): Promise<import("./types").IWorkoutDetail>;
+        addRunningWorkout(name: string, meters: number, description: string): Promise<import("./types").IWorkoutDetail>;
+        deleteWorkout(workout: {
+            workoutId: string;
+        }): Promise<unknown>;
+        scheduleWorkout(workout: {
+            workoutId: string;
+        }, date?: Date): Promise<import("./types").IScheduleWorkout>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithCourse: {
+    new (...args: any[]): {
+        getCourses(): Promise<import("./types").ICourse[]>;
+        getCourse(course: {
+            courseId: number;
+        }): Promise<import("./types").ICourseDetail>;
+        downloadCourseFit(course: {
+            courseId: number;
+        }, dir: string, elevation?: boolean): Promise<void>;
+        downloadCourseGpx(course: {
+            courseId: number;
+        }, dir: string): Promise<void>;
+        importCourse(file: string): Promise<unknown>;
+        confirmCourseImport(course: unknown): Promise<import("./types").ICourseDetail>;
+        deleteCourse(course: {
+            courseId: number;
+        }): Promise<void>;
+        createCourse(course: import("./types").ICourseDetail): Promise<import("./types").ICourseDetail>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithMisc: {
+    new (...args: any[]): {
+        getCalendar(year?: number, month?: number): Promise<import("./types").ICalendar>;
+        getGolfSummary(): Promise<import("./types").GolfSummary>;
+        getGolfScorecard(scorecardId: number): Promise<import("./types").GolfScorecard>;
+        consentGrant(): Promise<void>;
+        get<T>(url: string, data?: any): Promise<T>;
+        post<T_1>(url: string, data: any): Promise<T_1>;
+        put<T_2>(url: string, data: any): Promise<T_2>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+declare const WithCoach: {
+    new (...args: any[]): {
+        getTrainingOverview(options?: import("./types").TrainingOverviewOptions): Promise<import("./types").TrainingOverview>;
+        getWellnessOverview(options?: import("./types").WellnessOverviewOptions): Promise<import("./types").WellnessOverview>;
+        getActivitiesSummary(options?: import("./types").ActivitiesSummaryOptions): Promise<import("./types").ActivitiesSummary>;
+        getActivityDetailSummary(options: number | import("./types").ActivityDetailSummaryOptions): Promise<import("./types").ActivityDetailSummary>;
+        client: HttpClient;
+        url: UrlClass;
+        domain: GarminDomain;
+        getUserProfile(): Promise<ISocialProfile>;
+    };
+};
+export interface GarminConnect extends GarminConnectBase, InstanceType<typeof WithUser>, InstanceType<typeof WithSleep>, InstanceType<typeof WithHRV>, InstanceType<typeof WithWeight>, InstanceType<typeof WithHydration>, InstanceType<typeof WithBodyBattery>, InstanceType<typeof WithHeartRate>, InstanceType<typeof WithActivityBase>, InstanceType<typeof WithRunning>, InstanceType<typeof WithCycling>, InstanceType<typeof WithTrainingStatus>, InstanceType<typeof WithDevice>, InstanceType<typeof WithWorkout>, InstanceType<typeof WithCourse>, InstanceType<typeof WithMisc>, InstanceType<typeof WithCoach> {
+}
+export declare class GarminConnect extends WithCoach {
+}
+export default GarminConnect;