@gooin/garmin-connect 1.6.5 → 1.6.7

package/dist/garmin/GarminConnect.js

@@ -1,106 +1,29 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Event = void 0;
-var app_root_path_1 = __importDefault(require("app-root-path"));
-var form_data_1 = __importDefault(require("form-data"));
-var lodash_1 = __importDefault(require("lodash"));
-var luxon_1 = require("luxon");
-var fs = __importStar(require("fs"));
-var path = __importStar(require("path"));
-var HttpClient_1 = require("../common/HttpClient");
-var utils_1 = require("../utils");
-var UrlClass_1 = require("./UrlClass");
-var types_1 = require("./types");
-var Running_1 = __importDefault(require("./workouts/Running"));
-var config = undefined;
-try {
-    config = app_root_path_1.default.require('/garmin.config.json');
-}
-catch (e) {
-    // Do nothing
-}
+const form_data_1 = __importDefault(require("form-data"));
+const lodash_1 = __importDefault(require("lodash"));
+const luxon_1 = require("luxon");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const HttpClient_1 = require("../common/HttpClient");
+const utils_1 = require("../utils");
+const UrlClass_1 = require("./UrlClass");
+const DateUtils_1 = require("./common/DateUtils");
+const HydrationUtils_1 = require("./common/HydrationUtils");
+const WeightUtils_1 = require("./common/WeightUtils");
+const types_1 = require("./types");
+const Running_1 = __importDefault(require("./workouts/Running"));
 var Event;
 (function (Event) {
     Event["sessionChange"] = "sessionChange";
 })(Event = exports.Event || (exports.Event = {}));
-var GarminConnect = /** @class */ (function () {
+class GarminConnect {
     // private oauth1: OAuth;
-    function GarminConnect(credentials, domain) {
-        if (credentials === void 0) { credentials = config; }
-        if (domain === void 0) { domain = 'garmin.com'; }
+    constructor(credentials, domain = 'garmin.com') {
         if (!credentials) {
             throw new Error('Missing credentials');
         }
@@ -110,47 +33,46 @@ var GarminConnect = /** @class */ (function () {
         this._userHash = undefined;
         this.listeners = {};
     }
-    GarminConnect.prototype.login = function (username, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (username && password) {
-                            this.credentials.username = username;
-                            this.credentials.password = password;
-                        }
-                        return [4 /*yield*/, this.client.login(this.credentials.username, this.credentials.password)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this];
-                }
-            });
-        });
-    };
-    GarminConnect.prototype.exportTokenToFile = function (dirPath) {
-        if (!(0, utils_1.checkIsDirectory)(dirPath)) {
-            (0, utils_1.createDirectory)(dirPath);
+    async login(username, password) {
+        if (username && password) {
+            this.credentials.username = username;
+            this.credentials.password = password;
+        }
+        await this.client.login(this.credentials.username, this.credentials.password);
+        return this;
+    }
+    async exportTokenToFile(dirPath) {
+        const isDir = await (0, utils_1.checkIsDirectory)(dirPath);
+        if (!isDir) {
+            await (0, utils_1.createDirectory)(dirPath);
         }
         // save oauth1 to json
         if (this.client.oauth1Token) {
-            (0, utils_1.writeToFile)(path.join(dirPath, 'oauth1_token.json'), JSON.stringify(this.client.oauth1Token));
+            await (0, utils_1.writeToFile)(node_path_1.default.join(dirPath, 'oauth1_token.json'), JSON.stringify(this.client.oauth1Token));
         }
         if (this.client.oauth2Token) {
-            (0, utils_1.writeToFile)(path.join(dirPath, 'oauth2_token.json'), JSON.stringify(this.client.oauth2Token));
+            await (0, utils_1.writeToFile)(node_path_1.default.join(dirPath, 'oauth2_token.json'), JSON.stringify(this.client.oauth2Token));
         }
-    };
-    GarminConnect.prototype.loadTokenByFile = function (dirPath) {
-        if (!(0, utils_1.checkIsDirectory)(dirPath)) {
+    }
+    async loadTokenByFile(dirPath) {
+        const isDir = await (0, utils_1.checkIsDirectory)(dirPath);
+        if (!isDir) {
             throw new Error('loadTokenByFile: Directory not found: ' + dirPath);
         }
-        var oauth1Data = fs.readFileSync(path.join(dirPath, 'oauth1_token.json'));
-        var oauth1 = JSON.parse(oauth1Data);
+        let oauth1Data = await node_fs_1.promises.readFile(node_path_1.default.join(dirPath, 'oauth1_token.json'), 'utf-8');
+        // console.log('loadTokenByFile - oauth1Data:', oauth1Data);
+        const oauth1 = JSON.parse(oauth1Data);
+        // console.log('loadTokenByFile - oauth1:', oauth1);
         this.client.oauth1Token = oauth1;
-        var oauth2Data = fs.readFileSync(path.join(dirPath, 'oauth2_token.json'));
-        var oauth2 = JSON.parse(oauth2Data);
+        let oauth2Data = await node_fs_1.promises.readFile(node_path_1.default.join(dirPath, 'oauth2_token.json'), 'utf-8');
+        // console.log('loadTokenByFile - oauth2Data:', oauth2Data);
+        const oauth2 = JSON.parse(oauth2Data);
+        // console.log('loadTokenByFile - oauth2:', oauth2);
         this.client.oauth2Token = oauth2;
-    };
-    GarminConnect.prototype.exportToken = function () {
+        // console.log('loadTokenByFile - oauth2Token:', this);
+        // console.log('loadTokenByFile - oauth2Token:', this.client.oauth2Token);
+    }
+    exportToken() {
         if (!this.client.oauth1Token || !this.client.oauth2Token) {
             throw new Error('exportToken: Token not found');
         }
@@ -158,218 +80,378 @@ var GarminConnect = /** @class */ (function () {
             oauth1: this.client.oauth1Token,
             oauth2: this.client.oauth2Token
         };
-    };
+    }
     // from db or localstorage etc
-    GarminConnect.prototype.loadToken = function (oauth1, oauth2) {
+    loadToken(oauth1, oauth2) {
         this.client.oauth1Token = oauth1;
         this.client.oauth2Token = oauth2;
-    };
-    GarminConnect.prototype.getUserSettings = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.client.get(this.url.USER_SETTINGS)];
-            });
-        });
-    };
-    GarminConnect.prototype.getUserProfile = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.client.get(this.url.USER_PROFILE)];
-            });
-        });
-    };
-    GarminConnect.prototype.getActivities = function (start, limit) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.client.get(this.url.ACTIVITIES, {
-                        params: { start: start, limit: limit }
-                    })];
-            });
+    }
+    async getUserSettings() {
+        return this.client.get(this.url.USER_SETTINGS);
+    }
+    async getUserProfile() {
+        return this.client.get(this.url.USER_PROFILE);
+    }
+    async getActivities(start, limit, activityType, subActivityType) {
+        return this.client.get(this.url.ACTIVITIES, {
+            params: { start, limit, activityType, subActivityType }
         });
-    };
-    GarminConnect.prototype.getActivity = function (activity) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (!activity.activityId)
-                    throw new Error('Missing activityId');
-                return [2 /*return*/, this.client.get(this.url.ACTIVITY + activity.activityId)];
-            });
+    }
+    async getActivity(activity) {
+        if (!activity.activityId)
+            throw new Error('Missing activityId');
+        return this.client.get(this.url.ACTIVITY + activity.activityId);
+    }
+    async countActivities() {
+        return this.client.get(this.url.STAT_ACTIVITIES, {
+            params: {
+                aggregation: 'lifetime',
+                startDate: '1970-01-01',
+                endDate: luxon_1.DateTime.now().toFormat('yyyy-MM-dd'),
+                metric: 'duration'
+            }
         });
-    };
-    GarminConnect.prototype.countActivities = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.client.get(this.url.STAT_ACTIVITIES, {
-                        params: {
-                            aggregation: 'lifetime',
-                            startDate: '1970-01-01',
-                            endDate: luxon_1.DateTime.now().toFormat('yyyy-MM-dd'),
-                            metric: 'duration'
-                        }
-                    })];
-            });
+    }
+    async downloadWellnessData(date, dir) {
+        const dateStr = (0, DateUtils_1.toDateString)(date);
+        const isDir = await (0, utils_1.checkIsDirectory)(dir);
+        if (!isDir) {
+            await (0, utils_1.createDirectory)(dir);
+        }
+        let fileBuffer = await this.client.get(this.url.DOWNLOAD_WELLNESS + dateStr, {
+            responseType: 'arraybuffer'
         });
-    };
-    GarminConnect.prototype.downloadOriginalActivityData = function (activity, dir, type) {
-        if (type === void 0) { type = 'zip'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var fileBuffer;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!activity.activityId)
-                            throw new Error('Missing activityId');
-                        if (!(0, utils_1.checkIsDirectory)(dir)) {
-                            (0, utils_1.createDirectory)(dir);
-                        }
-                        if (!(type === 'tcx')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.client.get(this.url.DOWNLOAD_TCX + activity.activityId)];
-                    case 1:
-                        fileBuffer = _a.sent();
-                        return [3 /*break*/, 9];
-                    case 2:
-                        if (!(type === 'gpx')) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.client.get(this.url.DOWNLOAD_GPX + activity.activityId)];
-                    case 3:
-                        fileBuffer = _a.sent();
-                        return [3 /*break*/, 9];
-                    case 4:
-                        if (!(type === 'kml')) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.client.get(this.url.DOWNLOAD_KML + activity.activityId)];
-                    case 5:
-                        fileBuffer = _a.sent();
-                        return [3 /*break*/, 9];
-                    case 6:
-                        if (!(type === 'zip')) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this.client.get(this.url.DOWNLOAD_ZIP + activity.activityId, {
-                                responseType: 'arraybuffer'
-                            })];
-                    case 7:
-                        fileBuffer = _a.sent();
-                        return [3 /*break*/, 9];
-                    case 8: throw new Error('downloadOriginalActivityData - Invalid type: ' + type);
-                    case 9:
-                        (0, utils_1.writeToFile)(path.join(dir, "".concat(activity.activityId, ".").concat(type)), fileBuffer);
-                        return [2 /*return*/];
-                }
+        await (0, utils_1.writeToFile)(node_path_1.default.join(dir, `${dateStr}.zip`), fileBuffer);
+    }
+    async downloadOriginalActivityData(activity, dir, type = 'zip') {
+        if (!activity.activityId)
+            throw new Error('Missing activityId');
+        const isDir = await (0, utils_1.checkIsDirectory)(dir);
+        if (!isDir) {
+            await (0, utils_1.createDirectory)(dir);
+        }
+        let fileBuffer;
+        if (type === 'tcx') {
+            fileBuffer = await this.client.get(this.url.DOWNLOAD_TCX + activity.activityId);
+        }
+        else if (type === 'gpx') {
+            fileBuffer = await this.client.get(this.url.DOWNLOAD_GPX + activity.activityId);
+        }
+        else if (type === 'kml') {
+            fileBuffer = await this.client.get(this.url.DOWNLOAD_KML + activity.activityId);
+        }
+        else if (type === 'zip') {
+            fileBuffer = await this.client.get(this.url.DOWNLOAD_ZIP + activity.activityId, {
+                responseType: 'arraybuffer'
             });
-        });
-    };
-    GarminConnect.prototype.uploadActivity = function (file, format) {
+        }
+        else {
+            throw new Error('downloadOriginalActivityData - Invalid type: ' + type);
+        }
+        await (0, utils_1.writeToFile)(node_path_1.default.join(dir, `${activity.activityId}.${type}`), fileBuffer);
+    }
+    async uploadActivity(file, format = 'fit') {
         var _a;
-        if (format === void 0) { format = 'fit'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var detectedFormat, fileBuffer, form, response;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        detectedFormat = (_a = (format || path.extname(file))) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-                        if (!lodash_1.default.includes(types_1.UploadFileType, detectedFormat)) {
-                            throw new Error('uploadActivity - Invalid format: ' + format);
-                        }
-                        fileBuffer = fs.createReadStream(file);
-                        form = new form_data_1.default();
-                        form.append('userfile', fileBuffer);
-                        return [4 /*yield*/, this.client.post(this.url.UPLOAD + '.' + format, form, {
-                                headers: {
-                                    'Content-Type': form.getHeaders()['content-type']
-                                }
-                            })];
-                    case 1:
-                        response = _b.sent();
-                        return [2 /*return*/, response];
-                }
-            });
-        });
-    };
-    GarminConnect.prototype.deleteActivity = function (activity) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!activity.activityId)
-                            throw new Error('Missing activityId');
-                        return [4 /*yield*/, this.client.delete(this.url.ACTIVITY + activity.activityId)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    GarminConnect.prototype.getWorkouts = function (start, limit) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.client.get(this.url.WORKOUTS, {
-                        params: {
-                            start: start,
-                            limit: limit
-                        }
-                    })];
-            });
+        const detectedFormat = (_a = (format || node_path_1.default.extname(file))) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (!lodash_1.default.includes(types_1.UploadFileType, detectedFormat)) {
+            throw new Error('uploadActivity - Invalid format: ' + format);
+        }
+        // const fh = await fs.open(file);
+        const fileBuffer = (0, node_fs_1.createReadStream)(file);
+        // console.log('fileBuffer:', fileBuffer);
+        const form = new form_data_1.default();
+        form.append('userfile', fileBuffer);
+        const response = await this.client.post(this.url.UPLOAD + '.' + format, form, {
+            headers: {
+                'Content-Type': form.getHeaders()['content-type']
+            }
         });
-    };
-    GarminConnect.prototype.getWorkoutDetail = function (workout) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (!workout.workoutId)
-                    throw new Error('Missing workoutId');
-                return [2 /*return*/, this.client.get(this.url.WORKOUT(workout.workoutId))];
-            });
+        return response;
+    }
+    async deleteActivity(activity) {
+        if (!activity.activityId)
+            throw new Error('Missing activityId');
+        await this.client.delete(this.url.ACTIVITY + activity.activityId);
+    }
+    async getWorkouts(start, limit) {
+        return this.client.get(this.url.WORKOUTS, {
+            params: {
+                start,
+                limit
+            }
         });
-    };
-    GarminConnect.prototype.addWorkout = function (workout) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, newWorkout;
-            return __generator(this, function (_a) {
-                if (!workout)
-                    throw new Error('Missing workout');
-                if (workout instanceof Running_1.default) {
-                    if (workout.isValid()) {
-                        data = __assign({}, workout.toJson());
-                        if (!data.description) {
-                            data.description = 'Added by garmin-connect for Node.js';
-                        }
-                        return [2 /*return*/, this.client.post(this.url.WORKOUT(), data)];
-                    }
-                }
-                newWorkout = lodash_1.default.omit(workout, [
-                    'workoutId',
-                    'ownerId',
-                    'updatedDate',
-                    'createdDate',
-                    'author'
-                ]);
-                if (!newWorkout.description) {
-                    newWorkout.description = 'Added by garmin-connect for Node.js';
+    }
+    async getWorkoutDetail(workout) {
+        if (!workout.workoutId)
+            throw new Error('Missing workoutId');
+        return this.client.get(this.url.WORKOUT(workout.workoutId));
+    }
+    async addWorkout(workout) {
+        if (!workout)
+            throw new Error('Missing workout');
+        if (workout instanceof Running_1.default) {
+            if (workout.isValid()) {
+                const data = { ...workout.toJson() };
+                if (!data.description) {
+                    data.description = 'Added by garmin-connect for Node.js';
                 }
-                // console.log('addWorkout - newWorkout:', newWorkout)
-                return [2 /*return*/, this.client.post(this.url.WORKOUT(), newWorkout)];
-            });
+                return this.client.post(this.url.WORKOUT(), data);
+            }
+        }
+        if (!workout.workoutSegments)
+            throw new Error('Missing workoutSegments, please use WorkoutDetail, not Workout.');
+        const newWorkout = lodash_1.default.omit(workout, [
+            'workoutId',
+            'ownerId',
+            'updatedDate',
+            'createdDate',
+            'author'
+        ]);
+        if (!newWorkout.description) {
+            newWorkout.description = 'Added by garmin-connect for Node.js';
+        }
+        // console.log('addWorkout - newWorkout:', newWorkout)
+        return this.client.post(this.url.WORKOUT(), newWorkout);
+    }
+    async addRunningWorkout(name, meters, description) {
+        const running = new Running_1.default();
+        running.name = name;
+        running.distance = meters;
+        running.description = description;
+        return this.addWorkout(running);
+    }
+    async deleteWorkout(workout) {
+        if (!workout.workoutId)
+            throw new Error('Missing workout');
+        return this.client.delete(this.url.WORKOUT(workout.workoutId));
+    }
+    async scheduleWorkout(workout, date = new Date()) {
+        if (!workout.workoutId)
+            throw new Error('Missing workoutId');
+        const formatedDate = luxon_1.DateTime.fromJSDate(date).toFormat('yyyy-MM-dd');
+        return this.client.post(`${this.url.SCHEDULE_WORKOUTS}${workout.workoutId}`, {
+            date: formatedDate
         });
-    };
-    GarminConnect.prototype.addRunningWorkout = function (name, meters, description) {
-        return __awaiter(this, void 0, void 0, function () {
-            var running;
-            return __generator(this, function (_a) {
-                running = new Running_1.default();
-                running.name = name;
-                running.distance = meters;
-                running.description = description;
-                return [2 /*return*/, this.addWorkout(running)];
+    }
+    // Garmin use month 0-11, not real month.
+    async getCalendar(year = new Date().getFullYear(), month = new Date().getMonth()) {
+        return this.client.get(this.url.CALENDAR(year, month));
+    }
+    async getSteps(date = new Date()) {
+        const dateString = (0, DateUtils_1.toDateString)(date);
+        const days = await this.client.get(`${this.url.DAILY_STEPS}${dateString}/${dateString}`);
+        const dayStats = days.find(({ calendarDate }) => calendarDate === dateString);
+        if (!dayStats) {
+            throw new Error("Can't find daily steps for this date.");
+        }
+        return dayStats.totalSteps;
+    }
+    async getSleepData(date = new Date()) {
+        try {
+            const dateString = (0, DateUtils_1.toDateString)(date);
+            const sleepData = await this.client.get(`${this.url.DAILY_SLEEP}`, { params: { date: dateString } });
+            if (!sleepData) {
+                throw new Error('Invalid or empty sleep data response.');
+            }
+            return sleepData;
+        }
+        catch (error) {
+            throw new Error(`Error in getSleepData: ${error.message}`);
+        }
+    }
+    async getSleepDuration(date = new Date()) {
+        try {
+            const sleepData = await this.getSleepData(date);
+            if (!sleepData ||
+                !sleepData.dailySleepDTO ||
+                sleepData.dailySleepDTO.sleepStartTimestampGMT === undefined ||
+                sleepData.dailySleepDTO.sleepEndTimestampGMT === undefined) {
+                throw new Error('Invalid or missing sleep data for the specified date.');
+            }
+            const sleepStartTimestampGMT = sleepData.dailySleepDTO.sleepStartTimestampGMT;
+            const sleepEndTimestampGMT = sleepData.dailySleepDTO.sleepEndTimestampGMT;
+            const { hours, minutes } = (0, DateUtils_1.calculateTimeDifference)(sleepStartTimestampGMT, sleepEndTimestampGMT);
+            return {
+                hours,
+                minutes
+            };
+        }
+        catch (error) {
+            throw new Error(`Error in getSleepDuration: ${error.message}`);
+        }
+    }
+    async getDailyWeightData(date = new Date()) {
+        try {
+            const dateString = (0, DateUtils_1.toDateString)(date);
+            const weightData = await this.client.get(`${this.url.DAILY_WEIGHT}/${dateString}`);
+            if (!weightData) {
+                throw new Error('Invalid or empty weight data response.');
+            }
+            return weightData;
+        }
+        catch (error) {
+            throw new Error(`Error in getDailyWeightData: ${error.message}`);
+        }
+    }
+    async getDailyWeightInPounds(date = new Date()) {
+        const weightData = await this.getDailyWeightData(date);
+        if (weightData.totalAverage &&
+            typeof weightData.totalAverage.weight === 'number') {
+            return (0, WeightUtils_1.gramsToPounds)(weightData.totalAverage.weight);
+        }
+        else {
+            throw new Error("Can't find valid daily weight for this date.");
+        }
+    }
+    async getDailyHydration(date = new Date()) {
+        try {
+            const dateString = (0, DateUtils_1.toDateString)(date);
+            const hydrationData = await this.client.get(`${this.url.DAILY_HYDRATION}/${dateString}`);
+            if (!hydrationData || !hydrationData.valueInML) {
+                throw new Error('Invalid or empty hydration data response.');
+            }
+            return (0, HydrationUtils_1.convertMLToOunces)(hydrationData.valueInML);
+        }
+        catch (error) {
+            throw new Error(`Error in getDailyHydration: ${error.message}`);
+        }
+    }
+    async updateWeight(date = new Date(), lbs, timezone) {
+        try {
+            const weightData = await this.client.post(`${this.url.UPDATE_WEIGHT}`, {
+                dateTimestamp: (0, DateUtils_1.getLocalTimestamp)(date, timezone),
+                gmtTimestamp: date.toISOString().substring(0, 23),
+                unitKey: 'lbs',
+                value: lbs
             });
-        });
-    };
-    GarminConnect.prototype.deleteWorkout = function (workout) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (!workout.workoutId)
-                    throw new Error('Missing workout');
-                return [2 /*return*/, this.client.delete(this.url.WORKOUT(workout.workoutId))];
+            return weightData;
+        }
+        catch (error) {
+            throw new Error(`Error in updateWeight: ${error.message}`);
+        }
+    }
+    async updateHydrationLogOunces(date = new Date(), valueInOz) {
+        try {
+            const dateString = (0, DateUtils_1.toDateString)(date);
+            const hydrationData = await this.client.put(`${this.url.HYDRATION_LOG}`, {
+                calendarDate: dateString,
+                valueInML: (0, HydrationUtils_1.convertOuncesToML)(valueInOz),
+                userProfileId: (await this.getUserProfile()).profileId,
+                timestampLocal: date.toISOString().substring(0, 23)
             });
-        });
-    };
-    return GarminConnect;
-}());
+            return hydrationData;
+        }
+        catch (error) {
+            throw new Error(`Error in updateHydrationLogOunces: ${error.message}`);
+        }
+    }
+    async getGolfSummary() {
+        try {
+            const golfSummary = await this.client.get(`${this.url.GOLF_SCORECARD_SUMMARY}`);
+            if (!golfSummary) {
+                throw new Error('Invalid or empty golf summary data response.');
+            }
+            return golfSummary;
+        }
+        catch (error) {
+            throw new Error(`Error in getGolfSummary: ${error.message}`);
+        }
+    }
+    async getGolfScorecard(scorecardId) {
+        try {
+            const golfScorecard = await this.client.get(`${this.url.GOLF_SCORECARD_DETAIL}`, { params: { 'scorecard-ids': scorecardId } });
+            if (!golfScorecard) {
+                throw new Error('Invalid or empty golf scorecard data response.');
+            }
+            return golfScorecard;
+        }
+        catch (error) {
+            throw new Error(`Error in getGolfScorecard: ${error.message}`);
+        }
+    }
+    async getHeartRate(date = new Date()) {
+        try {
+            const dateString = (0, DateUtils_1.toDateString)(date);
+            const heartRate = await this.client.get(`${this.url.DAILY_HEART_RATE}`, { params: { date: dateString } });
+            return heartRate;
+        }
+        catch (error) {
+            throw new Error(`Error in getHeartRate: ${error.message}`);
+        }
+    }
+    async getCourses() {
+        try {
+            const coursesForUser = await this.client.get(`${this.url.COURSE_OWNER}`);
+            const courses_favorite = await this.client.get(`${this.url.COURSE_FAVORITE}`);
+            const course = [
+                ...coursesForUser.coursesForUser,
+                ...courses_favorite
+            ];
+            const uniqCourse = lodash_1.default.uniqBy(course, 'courseId');
+            return uniqCourse;
+        }
+        catch (error) {
+            throw new Error(`Error in getHeartRate: ${error.message}`);
+        }
+    }
+    async getCourse(course) {
+        try {
+            if (!course.courseId) {
+                throw new Error('Missing courseId');
+            }
+            const courseDetail = await this.client.get(`${this.url.COURSE(course.courseId)}`);
+            return courseDetail;
+        }
+        catch (error) {
+            throw new Error(`Error in getHeartRate: ${error.message}`);
+        }
+    }
+    async createCourse(course) {
+        try {
+            const createdCourse = await this.client.post(`${this.url.COURSE()}`, lodash_1.default.omit(course, [
+                'courseId',
+                // 'description',
+                'matchedToSegments',
+                'userProfilePk',
+                'userGroupPk',
+                'firstName',
+                'lastName',
+                'displayName',
+                'geoRoutePk',
+                'sourcePk',
+                'hasShareableEvent',
+                'virtualPartnerId',
+                'includeLaps',
+                'speedMeterPerSecond',
+                'createDate',
+                'updateDate',
+                'targetCoordinateSystem',
+                'originalCoordinateSystem',
+                'consumer',
+                'elevationSource',
+                'hasPaceBand',
+                'hasPowerGuide',
+                'favorite',
+                'curatedCoursePk'
+            ]));
+            return createdCourse;
+        }
+        catch (error) {
+            throw new Error(`Error in getHeartRate: ${error.message}`);
+        }
+    }
+    async get(url, data) {
+        const response = await this.client.get(url, data);
+        return response;
+    }
+    async post(url, data) {
+        const response = await this.client.post(url, data, {});
+        return response;
+    }
+    async put(url, data) {
+        const response = await this.client.put(url, data, {});
+        return response;
+    }
+}
 exports.default = GarminConnect;
 //# sourceMappingURL=GarminConnect.js.map