technogym-js 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,606 @@
+/**
+ * Base class of every error this library throws, so `instanceof TechnogymError` catches them all.
+ * `name` is the concrete subclass's name.
+ */
+declare class TechnogymError extends Error {
+    /** `options.cause` is the underlying error, if any. */
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Login failed, there is no session, or mywellness rejected the session token (HTTP 401/403 or an
+ * auth-looking error in the response envelope). Sign in again.
+ */
+declare class TechnogymAuthError extends TechnogymError {
+}
+/** Network failure or timeout, after retries. */
+declare class TechnogymConnectionError extends TechnogymError {
+}
+/** 429. `retryAfter` is seconds, taken from the Retry-After header when present. */
+declare class TechnogymRateLimitError extends TechnogymError {
+    /** Seconds to wait before retrying, from the `Retry-After` header; absent without one. */
+    readonly retryAfter?: number | undefined;
+    /** Thrown by the transport on a 429. */
+    constructor(message: string, 
+    /** Seconds to wait before retrying, from the `Retry-After` header; absent without one. */
+    retryAfter?: number | undefined, options?: {
+        cause?: unknown;
+    });
+}
+/** Any other non-2xx response. */
+declare class TechnogymHttpError extends TechnogymError {
+    /** The HTTP status code. */
+    readonly status: number;
+    /** The URL that was requested, without its query string. */
+    readonly url: string;
+    /** The response body, as text. */
+    readonly body: string;
+    /** Thrown by the transport for a non-2xx response that no other error class covers. */
+    constructor(message: string, 
+    /** The HTTP status code. */
+    status: number, 
+    /** The URL that was requested, without its query string. */
+    url: string, 
+    /** The response body, as text. */
+    body: string, options?: {
+        cause?: unknown;
+    });
+}
+/** One entry of the `errors` array mywellness puts in a 200 response when a call fails. */
+interface MywellnessErrorEntry {
+    /** Machine-readable reason, e.g. `ClientApplicationNotTrusted`. */
+    details?: string;
+    /** Human-readable message, when there is one. */
+    errorMessage?: string;
+    /** Alternative message field some endpoints use. */
+    message?: string;
+    [key: string]: unknown;
+}
+/**
+ * mywellness answered 200 with a non-empty `errors` array that is not about the session. `errors`
+ * is that array, untouched.
+ */
+declare class TechnogymApiError extends TechnogymError {
+    /** The endpoint's last path segment, e.g. `ActivityHistory`. */
+    readonly action: string;
+    /** The envelope's `errors` array. */
+    readonly errors: readonly MywellnessErrorEntry[];
+    /** Thrown when a 200 response's envelope carries errors. */
+    constructor(message: string, 
+    /** The endpoint's last path segment, e.g. `ActivityHistory`. */
+    action: string, 
+    /** The envelope's `errors` array. */
+    errors: readonly MywellnessErrorEntry[], options?: {
+        cause?: unknown;
+    });
+}
+/** The requested session, exercise or analytics record does not exist. */
+declare class TechnogymNotFoundError extends TechnogymError {
+}
+
+/**
+ * Parsed shapes of mywellness responses. Every parsed object has a `*Raw` twin method on
+ * `Technogym` that returns the untouched payload, for anything these types do not model.
+ *
+ * Localised strings (exercise names, units, `formatted` values) come back in the account's culture.
+ */
+/** A gym the account belongs to. `url` is the slug every training endpoint path starts with. */
+interface Facility {
+    id: string;
+    url: string;
+    name: string;
+}
+/** The signed-in account, from the login response's `userContext` and `facilities`. */
+interface UserInfo {
+    userId: string;
+    firstName: string;
+    lastName: string;
+    nickName: string;
+    /** e.g. `Metric`. */
+    measurementSystem: string;
+    /** e.g. `nb-NO`; localised strings in every response follow it. */
+    culture: string;
+    facilities: Facility[];
+}
+/**
+ * One measured or prescribed property, normalised from mywellness's two row shapes. `value` is in
+ * the API's base unit (seconds, metres, kg), `displayValue` is in `unit` (the unit the console shows),
+ * and `formatted` is the localised display string. On CardioLog rows `value` and `displayValue`
+ * are the same number.
+ */
+interface Property {
+    value: unknown;
+    displayValue: unknown;
+    unit: string;
+    formatted: unknown;
+}
+/** Properties keyed by their mywellness name (`Calories`, `AvgSpeed`, `IsoWeight`, ...). */
+type PropertyMap = Record<string, Property>;
+/** A row of `listSessions`. `sessionId` and `date` together address the session's detail calls. */
+interface SessionSummary {
+    /** The session's `idCr`. */
+    sessionId: string;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    /** `HH:MM`, local to the gym. */
+    time: string;
+    name: string;
+    /** `WorkoutSession`, `HRWorkout`, ... */
+    type: string;
+    durationMin: number | null;
+    moves: number | null;
+    calories: number | null;
+    exercisesDone: number | null;
+    exercisesPlanned: number | null;
+    userWorkoutSessionId: string;
+    facilityId: string;
+    workoutEffectiveness: number | null;
+    workoutCompliance: number | null;
+}
+/** One performed or prescribed set of an exercise. */
+interface SetData {
+    /** 1-based. */
+    setNumber: number;
+    /** `IsoReps`, else `Reps`. */
+    reps: number | null;
+    /** `IsoWeight`, else `Weight`. */
+    weightKg: number | null;
+    restSec: number | null;
+    durationSec: number | null;
+    /** Every raw property of the step. */
+    properties: PropertyMap;
+}
+/** Allowed workload range for one property on this machine. */
+interface WorkloadRange {
+    min: unknown;
+    max: unknown;
+    step: unknown;
+    readOnly: boolean;
+    visibility: unknown;
+}
+/** One exercise of a workout session. */
+interface Exercise {
+    /** `performedPhysicalActivity.id`. */
+    activityId: string;
+    /** Pass to `getExerciseAnalytics` for the per-second data. */
+    analyticsId: string;
+    name: string;
+    /** The equipment's name, e.g. `Leg press #40`. */
+    machine: string;
+    equipmentType: string;
+    /** `StrengthLoad`, `Cardio`, ... (`physicalActivityType`). */
+    type: string;
+    isCardio: boolean;
+    status: string;
+    doneOn: string;
+    position: number | null;
+    /** Localised display strings, e.g. `6 min.`. */
+    duration: string;
+    calories: string;
+    moves: string;
+    muscles: string[];
+    /**
+     * Every summary property the machine reported (cardio: AvgSpeed, AvgRunningCadence,
+     * AvgRunningPower, Pace...; strength: Rm1, TotalIsoWeight...).
+     */
+    summary: PropertyMap;
+    sets: SetData[];
+    prescribedSets: SetData[];
+    shortName: string;
+    activityCode: number | null;
+    activityTypeId: string;
+    equipmentCode: number | null;
+    /** What the exercise was set to: `Duration`, `Distance`, `Calories`, ... */
+    targetType: string;
+    /** `Added`, `Prescribed`, ... */
+    doneAs: string;
+    manuallyDone: boolean;
+    hasAdjustments: boolean;
+    donePartially: boolean;
+    progress: number | null;
+    /** Prescribed or estimated figures, to compare with what was done. */
+    estimated: {
+        duration: unknown;
+        calories: unknown;
+        moves: unknown;
+    };
+    workloadRanges: Record<string, WorkloadRange>;
+    /** Non-empty console `extData`, with the `mwc_` prefix removed. */
+    extData: Record<string, unknown>;
+}
+/** Full detail of one workout session. */
+interface WorkoutSession {
+    sessionId: string;
+    /** `YYYY-MM-DD`, from `startedOn`. */
+    date: string;
+    startedOn: string;
+    closedOn: string;
+    name: string;
+    type: string;
+    status: string;
+    duration: string;
+    durationPlanned: string;
+    calories: string;
+    moves: string;
+    efficacy: number | null;
+    efficacyQuality: string;
+    efficacyDescription: string;
+    /** Muscle name to score. */
+    muscleScores: Record<string, number>;
+    /** Only exercises that were performed. */
+    exercises: Exercise[];
+    fromTgCoach: boolean;
+    facilityId: string;
+    userWorkoutSessionId: string;
+    clientApplication: string;
+    /** Every session-level total. */
+    doneSummary: PropertyMap;
+}
+interface HrZone {
+    name: string;
+    lowerBound: number | null;
+    upperBound: number | null;
+    secondsInZone: number;
+}
+/** One second of an exercise: `t` plus one value per machine channel (`Speed`, `Power`, ...). */
+interface AnalyticsSample {
+    t: number;
+    [channel: string]: number | null;
+}
+/** A console auto-lap (every km on a treadmill). */
+interface Lap {
+    n: number | null;
+    lapDistanceM: number | null;
+    lapTimeSec: number | null;
+    totalDistanceM: number | null;
+    totalTimeSec: number | null;
+}
+/** Per-second analytics of one exercise: machine channels, heart rate and laps. */
+interface ExerciseAnalytics {
+    analyticsId: string;
+    name: string;
+    equipmentType: string;
+    /** Channel names in descriptor order. Strength machines have none. */
+    channels: string[];
+    samples: AnalyticsSample[];
+    hr: {
+        t: number;
+        hr: number;
+    }[];
+    hrZones: HrZone[];
+    summary: PropertyMap;
+    /** As the API formats it, e.g. `09.09.2026`. */
+    date: string;
+    target: string;
+    activityTypeId: string;
+    activityName: string;
+    laps: Lap[];
+}
+/** The whole-session heart-rate trace. */
+interface HrSession {
+    sessionId: string;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    /** Duration, avg/min/max HR, calories, MOVEs, METs. */
+    summary: PropertyMap;
+    hrSamples: {
+        timestamp: string;
+        hr: number;
+    }[];
+    hrZones: HrZone[];
+}
+/** A raw payload, passed through untouched. */
+type RawPayload = Record<string, unknown>;
+
+/** A signed-in mywellness session: the bearer token and the account it belongs to. */
+interface Session {
+    /** The bearer token sent with every request. */
+    token: string;
+    /** The account, as the login response described it. */
+    user: UserInfo;
+    /** When the session was created or its token last rotated, in epoch milliseconds. */
+    savedAt: number;
+}
+/**
+ * Persists a client's session between runs. Implement it to keep sessions in a database or a
+ * secret store; `FileSessionStore` and `MemorySessionStore` are ready-made.
+ */
+interface SessionStore {
+    /** The saved session, or `null` when there is none. */
+    load(): Promise<Session | null>;
+    /** Saves a session, replacing any saved before. */
+    save(session: Session): Promise<void>;
+    /** Removes the saved session. */
+    clear(): Promise<void>;
+}
+/** Keeps the session in memory only, so it is lost when the process exits. The client's default. */
+declare class MemorySessionStore implements SessionStore {
+    #private;
+    load(): Promise<Session | null>;
+    save(session: Session): Promise<void>;
+    clear(): Promise<void>;
+}
+/** Stores the session as `session.json` (mode 0600) in `dir`, which is created on the first save. */
+declare class FileSessionStore implements SessionStore {
+    private readonly dir;
+    constructor(dir: string);
+    load(): Promise<Session | null>;
+    save(session: Session): Promise<void>;
+    clear(): Promise<void>;
+}
+
+/** An email and password for mywellness. */
+interface Credentials {
+    email: string;
+    password: string;
+}
+/** Options for `new TechnogymClient(...)`. Every field is optional. */
+interface TechnogymClientOptions {
+    /** Where the session is loaded from and saved to. Default: a `MemorySessionStore`. */
+    sessionStore?: SessionStore;
+    /**
+     * Sign in lazily on the first call and again whenever mywellness rejects the token. Without
+     * them, call `login` or `loadSession` first, and a rejected token throws `TechnogymAuthError`.
+     * Credentials passed to `login()` are also kept (in memory only) for the same purpose.
+     */
+    credentials?: Credentials;
+    /**
+     * Which facility's url prefixes training paths, matched against a facility's `id` or `url`.
+     * Default: the account's first facility.
+     */
+    facility?: string;
+    /** Per-request timeout in ms. Default 30000. */
+    timeoutMs?: number;
+    /** How many times a transient failure of a read is retried. Default 3. */
+    retries?: number;
+    /** Delay before the first retry in ms, doubled on each retry after it. Default 500. */
+    backoffMs?: number;
+    /** A `fetch` to use instead of the global one, e.g. a mock in tests. */
+    fetchImpl?: typeof fetch;
+}
+/** Options for one raw `services` call. */
+interface ServiceOptions {
+    /** Per-request timeout, overriding the client's default. */
+    timeoutMs?: number;
+    /**
+     * Retry on a 5xx or network error. Default `true`: every mywellness read is a POST, and this
+     * library only reads. Pass `false` for a POST that changes something.
+     */
+    retry?: boolean;
+}
+/** Whether an envelope's `errors` describe a rejected session. */
+declare function isAuthErrorEntry(errors: readonly MywellnessErrorEntry[]): boolean;
+/**
+ * The authenticated HTTP transport: signs in to mywellness, keeps the session, and sends
+ * requests to `services.mywellness.com/{facility}`. Wrap it in a `Technogym` to call the API.
+ */
+declare class TechnogymClient {
+    #private;
+    /** Where this client loads and saves its session. */
+    readonly sessionStore: SessionStore;
+    /** Creates a client that is not signed in yet. */
+    constructor(options?: TechnogymClientOptions);
+    /**
+     * Signs in with email and password and saves the session to the store. The credentials are
+     * kept in memory so a rejected token can be renewed without asking again. Throws
+     * `TechnogymAuthError` when mywellness refuses them.
+     */
+    login(email: string, password: string): Promise<Session>;
+    /** Loads the saved session. Returns false when the store holds none. */
+    loadSession(): Promise<boolean>;
+    /** Uses this session from now on. Does not save it to the store. */
+    setSession(session: Session): void;
+    /** The session currently held in memory, or `null` before a login or `loadSession()`. */
+    getSession(): Session | null;
+    /** Forgets the session and the in-memory credentials, and clears the store. */
+    logout(): Promise<void>;
+    /**
+     * The signed-in account. Signs in first when the client was given credentials and holds no
+     * session yet; otherwise throws `TechnogymAuthError`.
+     */
+    user(): Promise<UserInfo>;
+    /**
+     * The facility training paths are sent to (see `TechnogymClientOptions.facility`), or `null` for
+     * an account with no facility. Live on 2026-10-31, an account whose login listed no facilities
+     * got the same answers with no facility prefix as with any prefix, so paths go out unprefixed.
+     */
+    facilityOf(user: UserInfo): Facility | null;
+    /**
+     * POSTs `body` to a training endpoint and returns the envelope's `data` (or the whole body when
+     * it has none). `path` is relative to the facility, e.g. `/Training/User/{userId}/MyMovergy`;
+     * `{userId}` is replaced with the signed-in user's id. For endpoints `Technogym` has no method for.
+     *
+     * A rejected session is renewed once, when the client has credentials, and the call repeated.
+     */
+    services<T = unknown>(path: string, body?: unknown, options?: ServiceOptions): Promise<T | null>;
+}
+
+/**
+ * Derived views over `ExerciseAnalytics.samples`: per-channel stats and interval / lap / window
+ * segments. Pure functions, no HTTP. The mywellness summary block omits most machine channels
+ * (RunningCadence and RunningPower on a Skillrun, for one), so these fill that gap.
+ */
+/** Channels that accumulate over the exercise: only the final value means anything, not the average. */
+declare const CUMULATIVE_CHANNELS: ReadonlySet<string>;
+/**
+ * Channels SET on the console rather than measured. A change in any of them starts a new interval
+ * on a treadmill or bike programme.
+ */
+declare const SETPOINT_CHANNELS: readonly ["Speed", "Grade", "Level", "Resistance", "Incline", "Rpm_Target"];
+/**
+ * Aggregates of one channel. Measured channels get `avg` and `minNonzero` over the non-zero
+ * readings (the machine reports 0 while the belt is stopped); cumulative channels get `final`.
+ */
+interface ChannelStats {
+    max: number;
+    samples: number;
+    avg?: number;
+    minNonzero?: number;
+    final?: number;
+}
+/** A cumulative channel within one segment: the amount covered in it, and its value at the end. */
+interface CumulativeDelta {
+    delta: number;
+    end: number;
+}
+type SegmentMode = "workload" | "laps" | "fixed";
+/** `auto`: workload intervals when there are at least two, else laps, else fixed windows. */
+type SegmentBy = SegmentMode | "auto";
+interface Segment {
+    startSec: number;
+    endSec: number;
+    durationSec: number;
+    /** 1-based, on `workload` segments. */
+    interval?: number;
+    /** The constant setpoint values of a `workload` segment. */
+    setpoint?: Record<string, number>;
+    /** On `laps` segments. */
+    lap?: number | null;
+    lapDistanceM?: number | null;
+    /** From the average `Speed` (km/h), when there is one. */
+    paceMinPerKm?: number;
+    channels: Record<string, ChannelStats | CumulativeDelta>;
+}
+interface SegmentOptions {
+    /** Default `auto`. */
+    segmentBy?: SegmentBy;
+    /** Window length for `fixed`, at least 10. Default 300. */
+    segmentSeconds?: number;
+}
+/** Per-channel aggregates over `samples`. Channels with no numeric reading are left out. */
+declare function channelStats(samples: readonly AnalyticsSample[], channels: readonly string[]): Record<string, ChannelStats>;
+/**
+ * Splits an exercise into segments and aggregates every channel per segment. Cumulative channels
+ * report the distance (or calories, MOVEs) covered within the segment. A segment covers samples
+ * with `startSec < t <= endSec`.
+ */
+declare function segmentAnalytics(samples: readonly AnalyticsSample[], channels: readonly string[], laps: readonly Lap[], options?: SegmentOptions): {
+    mode: SegmentMode;
+    segments: Segment[];
+};
+/** Rows with `fromSec <= t <= toSec`; `toSec` of 0 or less means no upper bound. */
+declare function windowSamples<T extends {
+    t: number;
+}>(rows: readonly T[], fromSec?: number, toSec?: number): T[];
+/** Every `step`th row, starting with the first. */
+declare function downsample<T>(rows: readonly T[], step: number): T[];
+
+/** Options for `listSessions`. */
+interface ListSessionsOptions {
+    /**
+     * Only gym-floor workout sessions (`justThisType: WorkoutSession`). Default `true`; `false`
+     * includes every activity type (classes, outdoor, ...).
+     */
+    onlyWorkouts?: boolean;
+}
+/** `getExerciseAnalytics` plus the derived stats and segments of `analyzeExercise`. */
+interface AnalyzedExercise extends ExerciseAnalytics {
+    /** Per-channel avg / max / min over the full 1 Hz data. */
+    channelStats: Record<string, ChannelStats>;
+    segmentMode: SegmentMode;
+    segments: Segment[];
+}
+/**
+ * The Technogym mywellness API, one method per endpoint. Wraps a `TechnogymClient`:
+ *
+ * ```ts
+ * const client = new TechnogymClient({ sessionStore: new FileSessionStore("./session") });
+ * await client.login(email, password);
+ * const technogym = new Technogym(client);
+ * const sessions = await technogym.listSessions("2026-09-01", "2026-09-30");
+ * ```
+ *
+ * A session is addressed by its `sessionId` AND its date: the API partitions sessions by day.
+ * Dates accept a `YYYY-MM-DD` string or a `Date` (its local calendar day). Read-only: there is
+ * no method that changes anything on the account.
+ */
+declare class Technogym {
+    #private;
+    /** The client every request goes through. */
+    readonly client: TechnogymClient;
+    /** Wraps a client. It signs in on first use when it was given credentials. */
+    constructor(
+    /** The client every request goes through. */
+    client: TechnogymClient);
+    /** The signed-in account: user id, name, culture and facilities. No HTTP call once signed in. */
+    getUser(): Promise<UserInfo>;
+    /** The account's current Movergy score, or `null` when mywellness has none. */
+    getMovergy(): Promise<number | null>;
+    /** The untouched `ActivityHistory` payload for a date range (bounds in either order). */
+    getActivityHistoryRaw(from: string | Date, to: string | Date, options?: ListSessionsOptions): Promise<RawPayload | null>;
+    /** Sessions between two dates (inclusive, either order), newest first. An overview only. */
+    listSessions(from: string | Date, to: string | Date, options?: ListSessionsOptions): Promise<SessionSummary[]>;
+    /**
+     * The date of a session, found by scanning the last `lookbackDays` (default 365) of history
+     * across every activity type. Throws `TechnogymNotFoundError` when it is not there.
+     */
+    findSessionDate(sessionId: string | number, lookbackDays?: number): Promise<string>;
+    /** The untouched `GetPerformedWorkoutSessionByIdCr` payload. Pass `date`; see `getWorkoutSession`. */
+    getWorkoutSessionRaw(sessionId: string | number, date?: string | Date): Promise<RawPayload>;
+    /**
+     * Every exercise of a session with machine, sets (performed and prescribed), the machine's full
+     * summary and workload ranges, plus efficacy, muscle scores and totals. Summaries are averages
+     * and maxima only: for splits and time series, call `getExerciseAnalytics` with an exercise's
+     * `analyticsId`. `date` is strongly recommended; without it the last year is scanned for it.
+     */
+    getWorkoutSession(sessionId: string | number, date?: string | Date): Promise<WorkoutSession>;
+    /**
+     * Every workout session of the last `days` days (1-365, default 14), fully loaded, newest first.
+     * One request for the list plus one per session.
+     */
+    getRecentWorkouts(days?: number): Promise<WorkoutSession[]>;
+    /** The untouched `CardioLog/{analyticsId}/Details` payload. */
+    getExerciseAnalyticsRaw(analyticsId: string): Promise<RawPayload>;
+    /**
+     * Per-second analytics of one exercise: the machine's channels (Skillrun: Speed, Grade,
+     * HDistance, RunningCadence, RunningPower; bikes: Power, Rpm...), heart rate, HR zones, laps and
+     * summary. Strength machines have no time series; use the sets of `getWorkoutSession`.
+     */
+    getExerciseAnalytics(analyticsId: string): Promise<ExerciseAnalytics>;
+    /**
+     * `getExerciseAnalytics` plus per-channel stats and segments: by default one per interval
+     * detected from setpoint changes (speed / grade / level), else per console lap, else fixed
+     * windows. See `segmentAnalytics` to run the same analysis on samples you already have.
+     */
+    analyzeExercise(analyticsId: string, options?: SegmentOptions): Promise<AnalyzedExercise>;
+    /** The untouched `GetHrSession` payload. */
+    getSessionHeartRateRaw(sessionId: string | number, date?: string | Date): Promise<RawPayload>;
+    /** The whole-session heart-rate trace: timestamped samples, HR zones and avg/min/max HR. */
+    getSessionHeartRate(sessionId: string | number, date?: string | Date): Promise<HrSession>;
+}
+
+/** Account and login host. */
+declare const CORE_URL = "https://core.mywellness.com";
+/** Training-data host; every path under it starts with the facility's url slug. */
+declare const SERVICES_URL = "https://services.mywellness.com";
+/**
+ * App id and name of the official end-user web app (endusernext.mywellness.com). Without these
+ * headers the API answers `ClientApplicationNotTrusted`.
+ */
+declare const APP_ID = "EC1D38D7-D359-48D0-A60C-D8C0B8FB9DF9";
+declare const APP_NAME = "enduserweb";
+
+/** The login response's account, or `null` when it has no `userContext.id`. */
+declare function parseUser(data: unknown): UserInfo | null;
+/** One `ActivityHistory` item. */
+declare function parseSessionSummary(item: unknown): SessionSummary;
+/**
+ * Normalises mywellness property rows. Two shapes exist: session and HR rows carry `value` in the
+ * base unit plus `displayValue` in `unitOfMeasureShortString`; CardioLog rows carry `rawValue`
+ * already in the display unit (`uM`) and `value` as a formatted string.
+ */
+declare function parseProperties(rows: unknown): PropertyMap;
+/** One `physicalActivities` entry of a session. */
+declare function parseExercise(activity: unknown): Exercise;
+/** A `GetPerformedWorkoutSessionByIdCr` payload. Exercises never performed are left out. */
+declare function parseWorkoutSession(data: unknown, sessionId: string): WorkoutSession;
+/**
+ * A `CardioLog/{id}/Details` payload. The API spells the block `analitics`; `analytics` is
+ * accepted too. Samples with an empty value vector are dropped.
+ */
+declare function parseExerciseAnalytics(data: unknown, analyticsId: string): ExerciseAnalytics;
+/** A `GetHrSession` payload. */
+declare function parseHrSession(data: unknown, sessionId: string, date: string): HrSession;
+
+export { APP_ID, APP_NAME, type AnalyticsSample, type AnalyzedExercise, CORE_URL, CUMULATIVE_CHANNELS, type ChannelStats, type Credentials, type CumulativeDelta, type Exercise, type ExerciseAnalytics, type Facility, FileSessionStore, type HrSession, type HrZone, type Lap, type ListSessionsOptions, MemorySessionStore, type MywellnessErrorEntry, type Property, type PropertyMap, type RawPayload, SERVICES_URL, SETPOINT_CHANNELS, type Segment, type SegmentBy, type SegmentMode, type SegmentOptions, type ServiceOptions, type Session, type SessionStore, type SessionSummary, type SetData, Technogym, TechnogymApiError, TechnogymAuthError, TechnogymClient, type TechnogymClientOptions, TechnogymConnectionError, TechnogymError, TechnogymHttpError, TechnogymNotFoundError, TechnogymRateLimitError, type UserInfo, type WorkloadRange, type WorkoutSession, channelStats, downsample, isAuthErrorEntry, parseExercise, parseExerciseAnalytics, parseHrSession, parseProperties, parseSessionSummary, parseUser, parseWorkoutSession, segmentAnalytics, windowSamples };