ts-garmin 0.1.0

package/dist/index.js

@@ -0,0 +1,1511 @@
+// src/garmin/GarminConnect.ts
+import * as fs2 from "node:fs";
+import * as path from "node:path";
+
+// src/common/HttpClient.ts
+import crypto from "node:crypto";
+var CSRF_RE = /name="_csrf"\s+value="(.+?)"/;
+var TICKET_RE = /ticket=([^"]+)"/;
+var ACCOUNT_LOCKED_RE = /var statuss*=s*"([^"]*)"/;
+var PAGE_TITLE_RE = /<title>([^<]*)<\/title>/;
+var USER_AGENT_CONNECTMOBILE = "com.garmin.android.apps.connectmobile";
+var USER_AGENT_BROWSER = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36";
+var OAUTH_CONSUMER_URL = "https://thegarth.s3.amazonaws.com/oauth_consumer.json";
+var isRefreshing = false;
+var refreshSubscribers = [];
+function encodeRFC3986(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function generateNonce() {
+  return crypto.randomBytes(16).toString("hex");
+}
+function generateTimestamp() {
+  return Math.floor(Date.now() / 1000).toString();
+}
+function hmacSha1(baseString, key) {
+  return crypto.createHmac("sha1", key).update(baseString).digest("base64");
+}
+function buildOAuthHeader(consumer, url, method, token, extraParams) {
+  const oauthParams = {
+    oauth_consumer_key: consumer.key,
+    oauth_signature_method: "HMAC-SHA1",
+    oauth_timestamp: generateTimestamp(),
+    oauth_nonce: generateNonce(),
+    oauth_version: "1.0"
+  };
+  if (token) {
+    oauthParams.oauth_token = token.key;
+  }
+  const allParams = { ...oauthParams };
+  if (extraParams) {
+    Object.assign(allParams, extraParams);
+  }
+  const urlObj = new URL(url);
+  urlObj.searchParams.forEach((value, key) => {
+    allParams[key] = value;
+  });
+  const sortedParams = Object.keys(allParams).sort().map((key) => `${encodeRFC3986(key)}=${encodeRFC3986(allParams[key])}`).join("&");
+  const baseUrl = `${urlObj.protocol}//${urlObj.host}${urlObj.pathname}`;
+  const baseString = `${method.toUpperCase()}&${encodeRFC3986(baseUrl)}&${encodeRFC3986(sortedParams)}`;
+  const signingKey = `${encodeRFC3986(consumer.secret)}&${token ? encodeRFC3986(token.secret) : ""}`;
+  oauthParams.oauth_signature = hmacSha1(baseString, signingKey);
+  const headerParams = Object.keys(oauthParams).filter((key) => key.startsWith("oauth_")).sort().map((key) => `${encodeRFC3986(key)}="${encodeRFC3986(oauthParams[key])}"`).join(", ");
+  return `OAuth ${headerParams}`;
+}
+function stringifyParams(params) {
+  return Object.entries(params).filter(([_, v]) => v !== undefined && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+}
+function parseQueryString(str) {
+  const result = {};
+  str.split("&").forEach((pair) => {
+    const [key, value] = pair.split("=");
+    if (key)
+      result[decodeURIComponent(key)] = decodeURIComponent(value || "");
+  });
+  return result;
+}
+
+class HttpClient {
+  url;
+  oauth1Token;
+  oauth2Token;
+  OAUTH_CONSUMER;
+  cookies = new Map;
+  constructor(url) {
+    this.url = url;
+  }
+  getCookieHeader() {
+    return Array.from(this.cookies.entries()).map(([k, v]) => `${k}=${v}`).join("; ");
+  }
+  extractCookies(response) {
+    const setCookie = response.headers.get("set-cookie");
+    if (setCookie) {
+      const cookieParts = setCookie.split(/,(?=\s*\w+=)/);
+      for (const part of cookieParts) {
+        const cookieValue = part.split(";")[0].trim();
+        const [name, value] = cookieValue.split("=");
+        if (name && value) {
+          this.cookies.set(name.trim(), value.trim());
+        }
+      }
+    }
+  }
+  async fetchOauthConsumer() {
+    const response = await fetch(OAUTH_CONSUMER_URL);
+    const data = await response.json();
+    this.OAUTH_CONSUMER = {
+      key: data.consumer_key,
+      secret: data.consumer_secret
+    };
+  }
+  async checkTokenValid() {
+    if (this.oauth2Token) {
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      if (this.oauth2Token.expires_at < nowSeconds) {
+        console.error("Token expired!");
+        await this.refreshOauth2Token();
+      }
+    }
+  }
+  async makeRequest(url, options = {}) {
+    const headers = {
+      ...options.headers || {}
+    };
+    if (this.oauth2Token) {
+      headers.Authorization = `Bearer ${this.oauth2Token.access_token}`;
+    }
+    if (this.cookies.size > 0) {
+      headers.Cookie = this.getCookieHeader();
+    }
+    const { responseType, _retry, ...fetchOptions } = options;
+    const response = await fetch(url, {
+      ...fetchOptions,
+      headers
+    });
+    this.extractCookies(response);
+    if (response.status === 401 && this.oauth2Token && !_retry) {
+      if (isRefreshing) {
+        const token = await new Promise((resolve) => {
+          refreshSubscribers.push(resolve);
+        });
+        headers.Authorization = `Bearer ${token}`;
+        return this.makeRequest(url, { ...options, headers, _retry: true });
+      }
+      isRefreshing = true;
+      await this.refreshOauth2Token();
+      isRefreshing = false;
+      refreshSubscribers.forEach((sub) => sub(this.oauth2Token.access_token));
+      refreshSubscribers = [];
+      headers.Authorization = `Bearer ${this.oauth2Token.access_token}`;
+      return this.makeRequest(url, { ...options, headers, _retry: true });
+    }
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`HTTP Error: ${response.status} ${response.statusText} - ${text}`);
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return response.json();
+    }
+    if (responseType === "arraybuffer") {
+      return response.arrayBuffer();
+    }
+    return response.text();
+  }
+  async get(url, config) {
+    let fullUrl = url;
+    if (config?.params) {
+      const queryString = stringifyParams(config.params);
+      fullUrl = queryString ? `${url}${url.includes("?") ? "&" : "?"}${queryString}` : url;
+    }
+    return this.makeRequest(fullUrl, {
+      method: "GET",
+      headers: config?.headers,
+      responseType: config?.responseType
+    });
+  }
+  async post(url, data, config) {
+    const headers = { ...config?.headers };
+    let body;
+    if (data !== null && data !== undefined) {
+      if (typeof data === "object" && !(data instanceof FormData)) {
+        headers["Content-Type"] = headers["Content-Type"] || "application/json";
+        body = JSON.stringify(data);
+      } else if (typeof data === "string") {
+        body = data;
+      }
+    }
+    return this.makeRequest(url, {
+      method: "POST",
+      headers,
+      body
+    });
+  }
+  async put(url, data, config) {
+    const headers = { ...config?.headers };
+    let body;
+    if (data !== null && data !== undefined) {
+      if (typeof data === "object") {
+        headers["Content-Type"] = headers["Content-Type"] || "application/json";
+        body = JSON.stringify(data);
+      } else if (typeof data === "string") {
+        body = data;
+      }
+    }
+    return this.makeRequest(url, {
+      method: "PUT",
+      headers,
+      body
+    });
+  }
+  async delete(url, config) {
+    return this.makeRequest(url, {
+      method: "POST",
+      headers: {
+        ...config?.headers,
+        "X-Http-Method-Override": "DELETE"
+      }
+    });
+  }
+  async login(username, password) {
+    await this.fetchOauthConsumer();
+    const ticket = await this.getLoginTicket(username, password);
+    const oauth1 = await this.getOauth1Token(ticket);
+    await this.exchange(oauth1);
+    return this;
+  }
+  async getLoginTicket(username, password) {
+    const step1Params = {
+      clientId: "GarminConnect",
+      locale: "en",
+      service: this.url.GC_MODERN
+    };
+    const step1Url = `${this.url.GARMIN_SSO_EMBED}?${stringifyParams(step1Params)}`;
+    const step1Response = await fetch(step1Url);
+    this.extractCookies(step1Response);
+    const step2Params = {
+      id: "gauth-widget",
+      embedWidget: "true",
+      locale: "en",
+      gauthHost: this.url.GARMIN_SSO_EMBED
+    };
+    const step2Url = `${this.url.SIGNIN_URL}?${stringifyParams(step2Params)}`;
+    const step2Response = await fetch(step2Url, {
+      headers: {
+        Cookie: this.getCookieHeader()
+      }
+    });
+    this.extractCookies(step2Response);
+    const step2Result = await step2Response.text();
+    const csrfRegResult = CSRF_RE.exec(step2Result);
+    if (!csrfRegResult) {
+      throw new Error("login - csrf not found");
+    }
+    const csrfToken = csrfRegResult[1];
+    const signinParams = {
+      id: "gauth-widget",
+      embedWidget: "true",
+      clientId: "GarminConnect",
+      locale: "en",
+      gauthHost: this.url.GARMIN_SSO_EMBED,
+      service: this.url.GARMIN_SSO_EMBED,
+      source: this.url.GARMIN_SSO_EMBED,
+      redirectAfterAccountLoginUrl: this.url.GARMIN_SSO_EMBED,
+      redirectAfterAccountCreationUrl: this.url.GARMIN_SSO_EMBED
+    };
+    const step3Url = `${this.url.SIGNIN_URL}?${stringifyParams(signinParams)}`;
+    const formData = new URLSearchParams;
+    formData.append("username", username);
+    formData.append("password", password);
+    formData.append("embed", "true");
+    formData.append("_csrf", csrfToken);
+    const step3Response = await fetch(step3Url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Dnt: "1",
+        Origin: this.url.GARMIN_SSO_ORIGIN,
+        Referer: this.url.SIGNIN_URL,
+        "User-Agent": USER_AGENT_BROWSER,
+        Cookie: this.getCookieHeader()
+      },
+      body: formData.toString()
+    });
+    this.extractCookies(step3Response);
+    const step3Result = await step3Response.text();
+    this.handleAccountLocked(step3Result);
+    this.handlePageTitle(step3Result);
+    const ticketRegResult = TICKET_RE.exec(step3Result);
+    if (!ticketRegResult) {
+      throw new Error("login failed (Ticket not found or MFA), please check username and password");
+    }
+    return ticketRegResult[1];
+  }
+  handlePageTitle(htmlStr) {
+    const pageTitleRegResult = PAGE_TITLE_RE.exec(htmlStr);
+    if (pageTitleRegResult) {
+      const title = pageTitleRegResult[1];
+      if (title.includes("Update Phone Number")) {
+        throw new Error("login failed (Update Phone number), please update your phone number");
+      }
+    }
+  }
+  handleAccountLocked(htmlStr) {
+    const accountLockedRegResult = ACCOUNT_LOCKED_RE.exec(htmlStr);
+    if (accountLockedRegResult) {
+      const msg = accountLockedRegResult[1];
+      console.error(msg);
+      throw new Error("login failed (AccountLocked), please open connect web page to unlock your account");
+    }
+  }
+  async refreshOauth2Token() {
+    if (!this.OAUTH_CONSUMER) {
+      await this.fetchOauthConsumer();
+    }
+    if (!this.oauth2Token || !this.oauth1Token) {
+      throw new Error("No Oauth2Token or Oauth1Token");
+    }
+    await this.exchange({
+      token: this.oauth1Token
+    });
+  }
+  async getOauth1Token(ticket) {
+    if (!this.OAUTH_CONSUMER) {
+      throw new Error("No OAUTH_CONSUMER");
+    }
+    const params = {
+      ticket,
+      "login-url": this.url.GARMIN_SSO_EMBED,
+      "accepts-mfa-tokens": "true"
+    };
+    const url = `${this.url.OAUTH_URL}/preauthorized?${stringifyParams(params)}`;
+    const authHeader = buildOAuthHeader(this.OAUTH_CONSUMER, url, "GET");
+    const response = await fetch(url, {
+      headers: {
+        Authorization: authHeader,
+        "User-Agent": USER_AGENT_CONNECTMOBILE
+      }
+    });
+    const responseText = await response.text();
+    const token = parseQueryString(responseText);
+    this.oauth1Token = token;
+    return { token };
+  }
+  async exchange(oauth1) {
+    if (!this.OAUTH_CONSUMER) {
+      throw new Error("No OAUTH_CONSUMER");
+    }
+    const token = {
+      key: oauth1.token.oauth_token,
+      secret: oauth1.token.oauth_token_secret
+    };
+    const baseUrl = `${this.url.OAUTH_URL}/exchange/user/2.0`;
+    const authHeader = buildOAuthHeader(this.OAUTH_CONSUMER, baseUrl, "POST", token);
+    const response = await fetch(baseUrl, {
+      method: "POST",
+      headers: {
+        Authorization: authHeader,
+        "User-Agent": USER_AGENT_CONNECTMOBILE,
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    const responseData = await response.json();
+    this.oauth2Token = this.setOauth2TokenExpiresAt(responseData);
+  }
+  setOauth2TokenExpiresAt(token) {
+    const now = Date.now();
+    const nowSeconds = Math.floor(now / 1000);
+    token.last_update_date = new Date(now).toISOString();
+    token.expires_date = new Date(now + token.expires_in * 1000).toISOString();
+    token.expires_at = nowSeconds + token.expires_in;
+    token.refresh_token_expires_at = nowSeconds + token.refresh_token_expires_in;
+    return token;
+  }
+}
+
+// src/utils.ts
+import * as fs from "node:fs";
+function checkIsDirectory(filePath) {
+  return fs.existsSync(filePath) && fs.lstatSync(filePath).isDirectory();
+}
+function createDirectory(directoryPath) {
+  fs.mkdirSync(directoryPath, { recursive: true });
+}
+function writeToFile(filePath, data) {
+  fs.writeFileSync(filePath, data);
+}
+
+// src/garmin/UrlClass.ts
+class UrlClass {
+  domain;
+  GC_MODERN;
+  GARMIN_SSO_ORIGIN;
+  GC_API;
+  constructor(domain = "garmin.com") {
+    this.domain = domain;
+    this.GC_MODERN = `https://connect.${this.domain}/modern`;
+    this.GARMIN_SSO_ORIGIN = `https://sso.${this.domain}`;
+    this.GC_API = `https://connectapi.${this.domain}`;
+  }
+  get GARMIN_SSO() {
+    return `${this.GARMIN_SSO_ORIGIN}/sso`;
+  }
+  get GARMIN_SSO_EMBED() {
+    return `${this.GARMIN_SSO_ORIGIN}/sso/embed`;
+  }
+  get BASE_URL() {
+    return `${this.GC_MODERN}/proxy`;
+  }
+  get SIGNIN_URL() {
+    return `${this.GARMIN_SSO}/signin`;
+  }
+  get LOGIN_URL() {
+    return `${this.GARMIN_SSO}/login`;
+  }
+  get OAUTH_URL() {
+    return `${this.GC_API}/oauth-service/oauth`;
+  }
+  get USER_SETTINGS() {
+    return `${this.GC_API}/userprofile-service/userprofile/user-settings/`;
+  }
+  get USER_PROFILE() {
+    return `${this.GC_API}/userprofile-service/socialProfile`;
+  }
+  get ACTIVITIES() {
+    return `${this.GC_API}/activitylist-service/activities/search/activities`;
+  }
+  get ACTIVITY() {
+    return `${this.GC_API}/activity-service/activity/`;
+  }
+  ACTIVITY_BY_ID(activityId) {
+    return `${this.GC_API}/activity-service/activity/${activityId}`;
+  }
+  get STAT_ACTIVITIES() {
+    return `${this.GC_API}/fitnessstats-service/activity`;
+  }
+  get DOWNLOAD_ZIP() {
+    return `${this.GC_API}/download-service/files/activity/`;
+  }
+  get DOWNLOAD_GPX() {
+    return `${this.GC_API}/download-service/export/gpx/activity/`;
+  }
+  get DOWNLOAD_TCX() {
+    return `${this.GC_API}/download-service/export/tcx/activity/`;
+  }
+  get DOWNLOAD_KML() {
+    return `${this.GC_API}/download-service/export/kml/activity/`;
+  }
+  get UPLOAD() {
+    return `${this.GC_API}/upload-service/upload/`;
+  }
+  get IMPORT_DATA() {
+    return `${this.GC_API}/modern/import-data`;
+  }
+  get DAILY_STEPS() {
+    return `${this.GC_API}/usersummary-service/stats/steps/daily/`;
+  }
+  get DAILY_SLEEP() {
+    return `${this.GC_API}/sleep-service/sleep/dailySleepData`;
+  }
+  get DAILY_WEIGHT() {
+    return `${this.GC_API}/weight-service/weight/dayview`;
+  }
+  get UPDATE_WEIGHT() {
+    return `${this.GC_API}/weight-service/user-weight`;
+  }
+  get DAILY_HYDRATION() {
+    return `${this.GC_API}/usersummary-service/usersummary/hydration/allData`;
+  }
+  get HYDRATION_LOG() {
+    return `${this.GC_API}/usersummary-service/usersummary/hydration/log`;
+  }
+  get GOLF_SCORECARD_SUMMARY() {
+    return `${this.GC_API}/gcs-golfcommunity/api/v2/scorecard/summary`;
+  }
+  get GOLF_SCORECARD_DETAIL() {
+    return `${this.GC_API}/gcs-golfcommunity/api/v2/scorecard/detail`;
+  }
+  get DAILY_HEART_RATE() {
+    return `${this.GC_API}/wellness-service/wellness/dailyHeartRate`;
+  }
+  WORKOUT(id) {
+    if (id) {
+      return `${this.GC_API}/workout-service/workout/${id}`;
+    }
+    return `${this.GC_API}/workout-service/workout`;
+  }
+  get WORKOUTS() {
+    return `${this.GC_API}/workout-service/workouts`;
+  }
+  GEAR_OF_ACTIVITY(activityId) {
+    return `${this.GC_API}/gear-service/gear/filterGear?activityId=${activityId}`;
+  }
+  GEAR(userProfilePk, availableGearDate) {
+    return `${this.GC_API}/gear-service/gear/filterGear?userProfilePk=${userProfilePk}${availableGearDate ? `&availableGearDate=${availableGearDate}` : ""}`;
+  }
+  LINK_GEAR_TO_ACTIVITY(activityId, gearId) {
+    return `${this.GC_API}/gear-service/gear/link/${gearId}/activity/${activityId}`;
+  }
+  UNLINK_GEAR_FROM_ACTIVITY(activityId, gearId) {
+    return `${this.GC_API}/gear-service/gear/unlink/${gearId}/activity/${activityId}`;
+  }
+  WORKOUTS_LIST(start = 1, limit = 999, myWorkoutsOnly = true, sharedWorkoutsOnly = false, orderBy = "UPDATE_DATE", orderSeq = "DESC", includeAtp = false) {
+    return `${this.GC_API}/workout-service/workouts?start=${start}&limit=${limit}&myWorkoutsOnly=${myWorkoutsOnly}&sharedWorkoutsOnly=${sharedWorkoutsOnly}&orderBy=${orderBy}&orderSeq=${orderSeq}&includeAtp=${includeAtp}`;
+  }
+  SCHEDULE_WORKOUT(workoutId) {
+    return `${this.GC_API}/workout-service/schedule/${workoutId}`;
+  }
+  get IMPORT_GPX_FILE() {
+    return `${this.GC_API}/course-service/course/import`;
+  }
+  EXPORT_COURSE_GPX_FILE(courseId) {
+    return `${this.GC_API}/course-service/course/gpx/${courseId}`;
+  }
+  get CREATE_COURSE_GPX_FILE() {
+    return `${this.GC_API}/course-service/course`;
+  }
+  UPDATE_COURSE_GPX_FILE(courseId) {
+    return `${this.GC_API}/course-service/course/${courseId}`;
+  }
+  get LIST_COURSES() {
+    return `${this.GC_API}/web-gateway/course/owner/`;
+  }
+  CALENDAR_YEAR(year) {
+    return `${this.GC_API}/calendar-service/year/${year}`;
+  }
+  CALENDAR_MONTH(year, month) {
+    return `${this.GC_API}/calendar-service/year/${year}/month/${month}`;
+  }
+  CALENDAR_WEEK(year, month, day, firstDateOfWeek = 1) {
+    return `${this.GC_API}/calendar-service/year/${year}/month/${month}/day/${day}/start/${firstDateOfWeek}`;
+  }
+  DAILY_STRESS(date) {
+    return `${this.GC_API}/wellness-service/wellness/dailyStress/${date}`;
+  }
+  HRV_DATA(date) {
+    return `${this.GC_API}/hrv-service/hrv/${date}`;
+  }
+  TRAINING_READINESS(date) {
+    return `${this.GC_API}/metrics-service/metrics/trainingreadiness/${date}`;
+  }
+  BODY_BATTERY(date) {
+    return `${this.GC_API}/wellness-service/wellness/bodyBattery?date=${date}`;
+  }
+  DAILY_SUMMARY(userId, date) {
+    return `${this.GC_API}/usersummary-service/usersummary/daily/${userId}?calendarDate=${date}`;
+  }
+}
+
+// src/garmin/types/activity.ts
+var ActivityType;
+((ActivityType2) => {
+  ActivityType2["Cycling"] = "cycling";
+  ActivityType2["FitnessEquipment"] = "fitness_equipment";
+  ActivityType2["Walking"] = "walking";
+  ActivityType2["Hiking"] = "hiking";
+  ActivityType2["Other"] = "other";
+  ActivityType2["WaterSport"] = "water_sports";
+  ActivityType2["Running"] = "street_running";
+})(ActivityType ||= {});
+var ActivitySubType;
+((ActivitySubType2) => {
+  ActivitySubType2["IndoorCardio"] = "indoor_cardio";
+  ActivitySubType2["StrengthTraining"] = "strength_training";
+  ActivitySubType2["HIIT"] = "hiit";
+  ActivitySubType2["Yoga"] = "yoga";
+  ActivitySubType2["IndoorCycling"] = "indoor_cycling";
+  ActivitySubType2["Breathwork"] = "breathwork";
+  ActivitySubType2["Surfing"] = "surfing";
+  ActivitySubType2["StreetRunning"] = "street_running";
+  ActivitySubType2["TrailRunning"] = "trail_running";
+  ActivitySubType2["IndoorRunning"] = "indoor_running";
+})(ActivitySubType ||= {});
+// src/garmin/types/gpx.ts
+var GpxActivityType;
+((GpxActivityType2) => {
+  GpxActivityType2[GpxActivityType2["Running"] = 1] = "Running";
+  GpxActivityType2[GpxActivityType2["Running_Road"] = 1] = "Running_Road";
+  GpxActivityType2[GpxActivityType2["Running_Trail"] = 1] = "Running_Trail";
+  GpxActivityType2[GpxActivityType2["Cycling"] = 10] = "Cycling";
+  GpxActivityType2[GpxActivityType2["Cycling_Road"] = 10] = "Cycling_Road";
+  GpxActivityType2[GpxActivityType2["Cycling_Gravel"] = 143] = "Cycling_Gravel";
+  GpxActivityType2[GpxActivityType2["Hiking"] = 3] = "Hiking";
+  GpxActivityType2[GpxActivityType2["Other"] = 4] = "Other";
+})(GpxActivityType ||= {});
+
+// src/garmin/types/index.ts
+var ExportFileType;
+((ExportFileType2) => {
+  ExportFileType2["tcx"] = "tcx";
+  ExportFileType2["gpx"] = "gpx";
+  ExportFileType2["kml"] = "kml";
+  ExportFileType2["zip"] = "zip";
+})(ExportFileType ||= {});
+var UploadFileType;
+((UploadFileType2) => {
+  UploadFileType2["tcx"] = "tcx";
+  UploadFileType2["gpx"] = "gpx";
+  UploadFileType2["fit"] = "fit";
+})(UploadFileType ||= {});
+
+// src/garmin/common/DateUtils.ts
+function toDateString(date) {
+  const offset = date.getTimezoneOffset();
+  const offsetDate = new Date(date.getTime() - offset * 60 * 1000);
+  const [dateString] = offsetDate.toISOString().split("T");
+  return dateString;
+}
+function calculateTimeDifference(sleepStartTimestampGMT, sleepEndTimestampGMT) {
+  const timeDifferenceInSeconds = (sleepEndTimestampGMT - sleepStartTimestampGMT) / 1000;
+  const hours = Math.floor(timeDifferenceInSeconds / 3600);
+  const minutes = Math.floor(timeDifferenceInSeconds % 3600 / 60);
+  return { hours, minutes };
+}
+function getLocalTimestamp(date, timezone) {
+  const localTimestampISO = date.toISOString().substring(0, 23);
+  const localTimestamp = new Date(localTimestampISO).toLocaleString("en-US", {
+    timeZone: timezone,
+    hour12: false
+  });
+  const formattedLocalTimestamp = new Date(localTimestamp).toISOString().substring(0, 23);
+  return formattedLocalTimestamp;
+}
+
+// src/garmin/common/WeightUtils.ts
+function gramsToPounds(weightInGrams) {
+  const gramsPerPound = 453.592;
+  return weightInGrams / gramsPerPound;
+}
+
+// src/garmin/common/HydrationUtils.ts
+function convertMLToOunces(valueInML) {
+  const conversionFactor = 0.033814;
+  return valueInML * conversionFactor;
+}
+function convertOuncesToML(ounces) {
+  const ouncesToMillilitersConversionFactor = 29.5735;
+  return ounces * ouncesToMillilitersConversionFactor;
+}
+
+// src/garmin/common/GpxUtils.ts
+function courseRequestTemplate(activityType, courseName, geoPoints, coursePoints = []) {
+  return {
+    activityTypePk: activityType,
+    hasTurnDetectionDisabled: false,
+    geoPoints,
+    courseLines: [],
+    coursePoints,
+    startPoint: geoPoints[0],
+    elapsedSeconds: null,
+    openStreetMap: false,
+    coordinateSystem: "WGS84",
+    rulePK: 2,
+    courseName,
+    matchedToSegments: false,
+    includeLaps: false,
+    hasPaceBand: false,
+    hasPowerGuide: false,
+    favorite: false,
+    speedMeterPerSecond: null,
+    sourceTypeId: 3
+  };
+}
+
+// src/garmin/GarminConnect.ts
+class GarminConnect {
+  client;
+  credentials;
+  listeners;
+  url;
+  constructor(credentials, domain = "garmin.com") {
+    if (!credentials) {
+      throw new Error("Missing credentials");
+    }
+    this.credentials = credentials;
+    this.url = new UrlClass(domain);
+    this.client = new HttpClient(this.url);
+    this.listeners = {};
+  }
+  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;
+  }
+  exportTokenToFile(dirPath) {
+    if (!checkIsDirectory(dirPath)) {
+      createDirectory(dirPath);
+    }
+    if (this.client.oauth1Token) {
+      writeToFile(path.join(dirPath, "oauth1_token.json"), JSON.stringify(this.client.oauth1Token));
+    }
+    if (this.client.oauth2Token) {
+      writeToFile(path.join(dirPath, "oauth2_token.json"), JSON.stringify(this.client.oauth2Token));
+    }
+  }
+  loadTokenByFile(dirPath) {
+    if (!checkIsDirectory(dirPath)) {
+      throw new Error(`loadTokenByFile: Directory not found: ${dirPath}`);
+    }
+    const oauth1Data = fs2.readFileSync(path.join(dirPath, "oauth1_token.json"), "utf-8");
+    const oauth1 = JSON.parse(oauth1Data);
+    this.client.oauth1Token = oauth1;
+    const oauth2Data = fs2.readFileSync(path.join(dirPath, "oauth2_token.json"), "utf-8");
+    const oauth2 = JSON.parse(oauth2Data);
+    this.client.oauth2Token = oauth2;
+  }
+  exportToken() {
+    if (!this.client.oauth1Token || !this.client.oauth2Token) {
+      throw new Error("exportToken: Token not found");
+    }
+    return {
+      oauth1: this.client.oauth1Token,
+      oauth2: this.client.oauth2Token
+    };
+  }
+  loadToken(oauth1, oauth2) {
+    this.client.oauth1Token = oauth1;
+    this.client.oauth2Token = oauth2;
+  }
+  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 }
+    });
+  }
+  async getActivity(activity2) {
+    if (!activity2.activityId)
+      throw new Error("Missing activityId");
+    return this.client.get(`${this.url.ACTIVITY}${activity2.activityId}`);
+  }
+  async countActivities() {
+    const now = new Date;
+    const endDate = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+    return this.client.get(this.url.STAT_ACTIVITIES, {
+      params: {
+        aggregation: "lifetime",
+        startDate: "1970-01-01",
+        endDate,
+        metric: "duration"
+      }
+    });
+  }
+  async downloadOriginalActivityData(activity2, dir, type = "zip") {
+    if (!activity2.activityId)
+      throw new Error("Missing activityId");
+    if (!checkIsDirectory(dir)) {
+      createDirectory(dir);
+    }
+    let fileBuffer;
+    let url;
+    if (type === "tcx") {
+      url = `${this.url.DOWNLOAD_TCX}${activity2.activityId}`;
+    } else if (type === "gpx") {
+      url = `${this.url.DOWNLOAD_GPX}${activity2.activityId}`;
+    } else if (type === "kml") {
+      url = `${this.url.DOWNLOAD_KML}${activity2.activityId}`;
+    } else if (type === "zip") {
+      url = `${this.url.DOWNLOAD_ZIP}${activity2.activityId}`;
+    } else {
+      throw new Error(`downloadOriginalActivityData - Invalid type: ${type}`);
+    }
+    fileBuffer = await this.client.get(url, { responseType: "arraybuffer" });
+    writeToFile(path.join(dir, `${activity2.activityId}.${type}`), Buffer.from(fileBuffer));
+  }
+  async uploadActivity(file, format = "fit") {
+    const detectedFormat = (format || path.extname(file))?.toLowerCase();
+    if (!Object.values(UploadFileType).includes(detectedFormat)) {
+      throw new Error(`uploadActivity - Invalid format: ${format}`);
+    }
+    const fileBuffer = fs2.readFileSync(file);
+    const formData = new FormData;
+    formData.append("userfile", new Blob([fileBuffer]), path.basename(file));
+    const response = await fetch(`${this.url.UPLOAD}.${format}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.client.oauth2Token?.access_token}`
+      },
+      body: formData
+    });
+    return response.json();
+  }
+  async deleteActivity(activity2) {
+    if (!activity2.activityId)
+      throw new Error("Missing activityId");
+    await this.client.delete(`${this.url.ACTIVITY}${activity2.activityId}`);
+  }
+  async getWorkouts(start, limit) {
+    return this.client.get(this.url.WORKOUTS, {
+      params: { start, limit }
+    });
+  }
+  async getWorkoutDetail(workout2) {
+    if (!workout2.workoutId)
+      throw new Error("Missing workoutId");
+    return this.client.get(this.url.WORKOUT(workout2.workoutId));
+  }
+  async createWorkout(workout2) {
+    return this.client.post(this.url.WORKOUT(), workout2);
+  }
+  async deleteWorkout(workout2) {
+    if (!workout2.workoutId)
+      throw new Error("Missing workout");
+    return this.client.delete(this.url.WORKOUT(workout2.workoutId));
+  }
+  async scheduleWorkout(workout2, scheduleDate) {
+    return this.client.post(this.url.SCHEDULE_WORKOUT(Number.parseInt(workout2.workoutId)), { date: scheduleDate });
+  }
+  async getSteps(date = new Date) {
+    const dateString = 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 = 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 instanceof Error ? error.message : error}`);
+    }
+  }
+  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 { hours, minutes } = calculateTimeDifference(sleepData.dailySleepDTO.sleepStartTimestampGMT, sleepData.dailySleepDTO.sleepEndTimestampGMT);
+      return { hours, minutes };
+    } catch (error) {
+      throw new Error(`Error in getSleepDuration: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async getDailyWeightData(date = new Date) {
+    try {
+      const dateString = 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 instanceof Error ? error.message : error}`);
+    }
+  }
+  async getDailyWeightInPounds(date = new Date) {
+    const weightData = await this.getDailyWeightData(date);
+    if (weightData.totalAverage && typeof weightData.totalAverage.weight === "number") {
+      return 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 = 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 convertMLToOunces(hydrationData.valueInML);
+    } catch (error) {
+      throw new Error(`Error in getDailyHydration: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async updateWeight(date = new Date, lbs, timezone) {
+    try {
+      const weightData = await this.client.post(this.url.UPDATE_WEIGHT, {
+        dateTimestamp: getLocalTimestamp(date, timezone),
+        gmtTimestamp: date.toISOString().substring(0, 23),
+        unitKey: "lbs",
+        value: lbs
+      });
+      return weightData;
+    } catch (error) {
+      throw new Error(`Error in updateWeight: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async updateHydrationLogOunces(date = new Date, valueInOz) {
+    try {
+      const dateString = toDateString(date);
+      const hydrationData = await this.client.put(this.url.HYDRATION_LOG, {
+        calendarDate: dateString,
+        valueInML: convertOuncesToML(valueInOz),
+        userProfileId: (await this.getUserProfile()).profileId,
+        timestampLocal: date.toISOString().substring(0, 23)
+      });
+      return hydrationData;
+    } catch (error) {
+      throw new Error(`Error in updateHydrationLogOunces: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  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 instanceof Error ? error.message : error}`);
+    }
+  }
+  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 instanceof Error ? error.message : error}`);
+    }
+  }
+  async getHeartRate(date = new Date) {
+    try {
+      const dateString = 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 instanceof Error ? error.message : error}`);
+    }
+  }
+  async getStressData(date = new Date) {
+    try {
+      const dateString = toDateString(date);
+      const stressData = await this.client.get(this.url.DAILY_STRESS(dateString));
+      if (!stressData) {
+        throw new Error("Invalid or empty stress data response.");
+      }
+      return stressData;
+    } catch (error) {
+      throw new Error(`Error in getStressData: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async getHrvData(date = new Date) {
+    try {
+      const dateString = toDateString(date);
+      const hrvData = await this.client.get(this.url.HRV_DATA(dateString));
+      if (!hrvData) {
+        throw new Error("Invalid or empty HRV data response.");
+      }
+      return hrvData;
+    } catch (error) {
+      throw new Error(`Error in getHrvData: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async getTrainingReadiness(date = new Date) {
+    try {
+      const dateString = toDateString(date);
+      const trainingReadiness = await this.client.get(this.url.TRAINING_READINESS(dateString));
+      if (!trainingReadiness) {
+        throw new Error("Invalid or empty training readiness data response.");
+      }
+      return trainingReadiness;
+    } catch (error) {
+      throw new Error(`Error in getTrainingReadiness: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async getBodyBattery(date = new Date) {
+    try {
+      const dateString = toDateString(date);
+      const bodyBattery = await this.client.get(this.url.BODY_BATTERY(dateString));
+      if (!bodyBattery) {
+        throw new Error("Invalid or empty body battery data response.");
+      }
+      return bodyBattery;
+    } catch (error) {
+      throw new Error(`Error in getBodyBattery: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async getDailySummary(date = new Date) {
+    try {
+      const dateString = toDateString(date);
+      const profile = await this.getUserProfile();
+      const summary = await this.client.get(this.url.DAILY_SUMMARY(profile.profileId, dateString));
+      if (!summary) {
+        throw new Error("Invalid or empty daily summary response.");
+      }
+      return summary;
+    } catch (error) {
+      throw new Error(`Error in getDailySummary: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async getGear(availableGearDate) {
+    const id = (await this.getUserProfile()).profileId;
+    return this.client.get(this.url.GEAR(id, availableGearDate));
+  }
+  async getGearsForActivity(activityId) {
+    return this.client.get(this.url.GEAR_OF_ACTIVITY(activityId));
+  }
+  async linkGearToActivity(activityId, gearId) {
+    return this.client.put(this.url.LINK_GEAR_TO_ACTIVITY(activityId, gearId), {});
+  }
+  async unlinkGearFromActivity(activityId, gearId) {
+    return this.client.put(this.url.UNLINK_GEAR_FROM_ACTIVITY(activityId, gearId), {});
+  }
+  async workouts() {
+    return this.client.get(this.url.WORKOUTS_LIST());
+  }
+  async importGpx(fileName, fileContent) {
+    const formData = new FormData;
+    formData.append("file", new Blob([fileContent], { type: "application/octet-stream" }), fileName);
+    const response = await fetch(this.url.IMPORT_GPX_FILE, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.client.oauth2Token?.access_token}`
+      },
+      body: formData
+    });
+    return response.json();
+  }
+  async createCourse(activityType, courseName, geoPoints, coursePoints = []) {
+    return this.client.post(this.url.CREATE_COURSE_GPX_FILE, courseRequestTemplate(activityType, courseName, geoPoints, coursePoints));
+  }
+  async listCourses() {
+    return this.client.get(this.url.LIST_COURSES);
+  }
+  async exportCourseAsGpx(courseId) {
+    return this.client.get(this.url.EXPORT_COURSE_GPX_FILE(courseId), {
+      responseType: "text"
+    });
+  }
+  async getYearCalendarEvents(year) {
+    return this.client.get(this.url.CALENDAR_YEAR(year));
+  }
+  async getMonthCalendarEvents(year, month) {
+    return this.client.get(this.url.CALENDAR_MONTH(year, month));
+  }
+  async getWeekCalendarEvents(year, month, day, firstDayOfWeek) {
+    return this.client.get(this.url.CALENDAR_WEEK(year, month, day, firstDayOfWeek));
+  }
+  async renameActivity(activityId, newName) {
+    if (!activityId)
+      throw new Error("Missing activityId");
+    if (!newName)
+      throw new Error("Missing newName");
+    await this.client.put(this.url.ACTIVITY_BY_ID(activityId), {
+      activityName: newName
+    });
+  }
+  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;
+  }
+}
+// src/garmin/workout-builder/duration.ts
+class Duration {
+}
+
+class NoDuration extends Duration {
+  build() {
+    throw new Error("Please provide a duration for this step (Other than NoDuration).");
+  }
+}
+
+class TimeDuration extends Duration {
+  durationInSeconds;
+  constructor(durationInSeconds) {
+    super();
+    this.durationInSeconds = durationInSeconds;
+  }
+  static hhmmss(h, m, s) {
+    return new TimeDuration(h * 3600 + m * 60 + s);
+  }
+  static fromHours(h) {
+    return new TimeDuration(h * 3600);
+  }
+  static fromMinutes(m) {
+    return new TimeDuration(m * 60);
+  }
+  static fromSeconds(s) {
+    return new TimeDuration(s);
+  }
+  build() {
+    return {
+      endCondition: {
+        conditionTypeId: 2,
+        conditionTypeKey: "time",
+        displayable: true,
+        displayOrder: 1
+      },
+      endConditionCompare: null,
+      endConditionValue: this.durationInSeconds,
+      endConditionZone: null
+    };
+  }
+}
+
+class DistanceDuration extends Duration {
+  meters;
+  constructor(meters) {
+    super();
+    this.meters = meters;
+  }
+  static fromKilometers(km) {
+    return new DistanceDuration(km * 1000);
+  }
+  static fromMeters(m) {
+    return new DistanceDuration(m);
+  }
+  build() {
+    return {
+      endCondition: {
+        conditionTypeId: 3,
+        conditionTypeKey: "distance",
+        displayOrder: 3,
+        displayable: true
+      },
+      endConditionValue: this.meters,
+      preferredEndConditionUnit: {
+        unitKey: "kilometer"
+      },
+      endConditionCompare: null
+    };
+  }
+}
+
+class LapPressDuration extends Duration {
+  build() {
+    return {
+      endCondition: {
+        conditionTypeId: 1,
+        conditionTypeKey: "lap.button",
+        displayOrder: 1,
+        displayable: true
+      },
+      endConditionValue: null,
+      preferredEndConditionUnit: null,
+      endConditionCompare: null
+    };
+  }
+}
+
+class CaloriesDuration extends Duration {
+  calories;
+  constructor(calories) {
+    super();
+    this.calories = calories;
+  }
+  build() {
+    return {
+      endCondition: {
+        conditionTypeId: 4,
+        conditionTypeKey: "calories",
+        displayOrder: 4,
+        displayable: true
+      },
+      endConditionValue: this.calories
+    };
+  }
+}
+
+class HeartRateDuration extends Duration {
+  bpm;
+  compare;
+  constructor(bpm, compare) {
+    super();
+    this.bpm = bpm;
+    this.compare = compare;
+  }
+  static greaterThan(bpm) {
+    return new HeartRateDuration(bpm, "gt");
+  }
+  static lessThan(bpm) {
+    return new HeartRateDuration(bpm, "lt");
+  }
+  build() {
+    return {
+      endCondition: {
+        conditionTypeId: 6,
+        conditionTypeKey: "heart.rate",
+        displayOrder: 6,
+        displayable: true
+      },
+      endConditionValue: this.bpm,
+      endConditionCompare: this.compare
+    };
+  }
+}
+// src/garmin/workout-builder/target.ts
+class Target {
+}
+
+class NoTarget extends Target {
+  build() {
+    return {
+      targetType: {
+        workoutTargetTypeId: 1,
+        workoutTargetTypeKey: "no.target",
+        displayOrder: 1
+      }
+    };
+  }
+}
+
+class PaceTarget extends Target {
+  minPace;
+  maxPace;
+  constructor(minPace, maxPace) {
+    super();
+    this.minPace = minPace;
+    this.maxPace = maxPace;
+  }
+  static pace(paceMinutes, paceSeconds, margin = 0) {
+    const minPace = paceMinutes * 60 + paceSeconds + margin;
+    const maxPace = paceMinutes * 60 + paceSeconds - margin;
+    return new PaceTarget(1000 / minPace, 1000 / maxPace);
+  }
+  build() {
+    return {
+      targetType: {
+        workoutTargetTypeId: 6,
+        workoutTargetTypeKey: "pace.zone",
+        displayOrder: 6
+      },
+      targetValueOne: this.minPace,
+      targetValueTwo: this.maxPace,
+      targetValueUnit: null
+    };
+  }
+}
+
+class CadenceTarget extends Target {
+  minCadence;
+  maxCadence;
+  constructor(minCadence, maxCadence) {
+    super();
+    this.minCadence = minCadence;
+    this.maxCadence = maxCadence;
+  }
+  static cadence(cadence, margin) {
+    return new CadenceTarget(cadence - margin, cadence + margin);
+  }
+  build() {
+    return {
+      targetType: {
+        workoutTargetTypeId: 3,
+        workoutTargetTypeKey: "cadence",
+        displayOrder: 3
+      },
+      targetValueOne: this.minCadence,
+      targetValueTwo: this.maxCadence,
+      targetValueUnit: null
+    };
+  }
+}
+
+class HrmZoneTarget extends Target {
+  hrmZone;
+  constructor(hrmZone) {
+    super();
+    this.hrmZone = hrmZone;
+  }
+  build() {
+    return {
+      targetType: {
+        workoutTargetTypeId: 4,
+        workoutTargetTypeKey: "heart.rate.zone",
+        displayOrder: 4
+      },
+      zoneNumber: this.hrmZone
+    };
+  }
+}
+
+class HrmTarget extends Target {
+  minHrm;
+  maxHrm;
+  constructor(minHrm, maxHrm) {
+    super();
+    this.minHrm = minHrm;
+    this.maxHrm = maxHrm;
+  }
+  static hrm(hrm, margin) {
+    return new HrmTarget(hrm - margin, hrm + margin);
+  }
+  build() {
+    return {
+      targetType: {
+        workoutTargetTypeId: 4,
+        workoutTargetTypeKey: "heart.rate.zone",
+        displayOrder: 4
+      },
+      targetValueOne: this.minHrm,
+      targetValueTwo: this.maxHrm,
+      targetValueUnit: null
+    };
+  }
+}
+
+class PowerZoneTarget extends Target {
+  powerZone;
+  constructor(powerZone) {
+    super();
+    this.powerZone = powerZone;
+  }
+  build() {
+    return {
+      targetType: {
+        workoutTargetTypeId: 2,
+        workoutTargetTypeKey: "power.zone",
+        displayOrder: 2
+      },
+      zoneNumber: this.powerZone
+    };
+  }
+}
+
+class PowerZone extends Target {
+  minPower;
+  maxPower;
+  constructor(minPower, maxPower) {
+    super();
+    this.minPower = minPower;
+    this.maxPower = maxPower;
+  }
+  static power(power, margin) {
+    return new PowerZone(power - margin, power + margin);
+  }
+  build() {
+    return {
+      targetType: {
+        workoutTargetTypeId: 2,
+        workoutTargetTypeKey: "power.zone",
+        displayOrder: 2
+      },
+      targetValueOne: this.minPower,
+      targetValueTwo: this.maxPower
+    };
+  }
+}
+
+// src/garmin/workout-builder/step.ts
+class Step {
+  stepType;
+  duration;
+  target;
+  notes;
+  constructor(stepType, duration = new NoDuration, target = new NoTarget, notes = "") {
+    this.stepType = stepType;
+    this.duration = duration;
+    this.target = target;
+    this.notes = notes;
+  }
+  build(index) {
+    return {
+      category: null,
+      childStepId: null,
+      description: this.notes,
+      equipmentType: {
+        displayOrder: null,
+        equipmentTypeId: null,
+        equipmentTypeKey: null
+      },
+      exerciseName: null,
+      preferredEndConditionUnit: null,
+      providerExerciseSourceId: null,
+      secondaryTargetType: null,
+      secondaryTargetValueOne: null,
+      secondaryTargetValueTwo: null,
+      secondaryTargetValueUnit: null,
+      secondaryZoneNumber: null,
+      stepAudioNote: null,
+      stepId: index,
+      stepOrder: index,
+      strokeType: {},
+      targetValueOne: null,
+      targetValueTwo: null,
+      targetValueUnit: null,
+      type: "ExecutableStepDTO",
+      weightUnit: null,
+      weightValue: null,
+      workoutProvider: null,
+      zoneNumber: null,
+      ...this.stepType.build(),
+      ...this.duration.build(),
+      ...this.target.build()
+    };
+  }
+}
+
+class StepType {
+  type;
+  stepId;
+  constructor(type, stepId) {
+    this.type = type;
+    this.stepId = stepId;
+  }
+  build() {
+    return {
+      stepType: {
+        stepTypeId: this.stepId,
+        stepTypeKey: this.type,
+        displayOrder: this.stepId
+      }
+    };
+  }
+  static WarmUp = new StepType("warmup", 1);
+  static Run = new StepType("interval", 3);
+  static Recovery = new StepType("recovery", 4);
+  static Rest = new StepType("rest", 5);
+  static Cooldown = new StepType("cooldown", 2);
+  static Other = new StepType("other", 7);
+}
+// src/garmin/workout-builder/workout-builder.ts
+class WorkoutBuilder {
+  workoutType;
+  workoutName;
+  workoutDescription;
+  steps = [];
+  constructor(workoutType, workoutName, workoutDescription = "") {
+    this.workoutType = workoutType;
+    this.workoutName = workoutName;
+    this.workoutDescription = workoutDescription;
+  }
+  addStep(step) {
+    this.steps.push(step);
+    return this;
+  }
+  build() {
+    return {
+      ...this.workoutType.build(),
+      subSportType: null,
+      workoutName: this.workoutName,
+      description: this.workoutDescription,
+      estimatedDistanceUnit: { unitKey: null },
+      workoutSegments: [
+        {
+          segmentOrder: 1,
+          ...this.workoutType.build(),
+          workoutSteps: this.steps.map((step, index) => step.build(index + 1))
+        }
+      ],
+      avgTrainingSpeed: null,
+      estimatedDurationInSecs: 0,
+      estimatedDistanceInMeters: null,
+      estimateType: null,
+      isWheelchair: false
+    };
+  }
+}
+// src/garmin/workout-builder/workout-type.ts
+class WorkoutType {
+  sportTypeKey;
+  sportTypeId;
+  constructor(sportTypeKey, sportTypeId) {
+    this.sportTypeKey = sportTypeKey;
+    this.sportTypeId = sportTypeId;
+  }
+  build() {
+    return {
+      sportType: {
+        sportTypeId: this.sportTypeId,
+        sportTypeKey: this.sportTypeKey,
+        displayOrder: this.sportTypeId
+      }
+    };
+  }
+  static Running = new WorkoutType("running", 1);
+  static Cycling = new WorkoutType("cycling", 2);
+  static Swimming = new WorkoutType("swimming", 4);
+  static Strength = new WorkoutType("strength_training", 5);
+  static Cardio = new WorkoutType("cardio_training", 6);
+}
+export {
+  courseRequestTemplate,
+  WorkoutType,
+  WorkoutBuilder,
+  UploadFileType,
+  TimeDuration,
+  Target,
+  StepType,
+  Step,
+  PowerZoneTarget,
+  PowerZone,
+  PaceTarget,
+  NoTarget,
+  NoDuration,
+  LapPressDuration,
+  HrmZoneTarget,
+  HrmTarget,
+  HeartRateDuration,
+  GpxActivityType,
+  GarminConnect,
+  ExportFileType,
+  Duration,
+  DistanceDuration,
+  CaloriesDuration,
+  CadenceTarget,
+  ActivityType,
+  ActivitySubType
+};