@tryterra/react-native 2.1.0 → 2.2.1

package/ios/TerraBridgeCore/TerraBridgeOpsImpl.swift

@@ -43,6 +43,11 @@ struct TerraBridgeOpsImpl: TerraBridgeOps {
         ConnectionList(connections: try await terra.connections.map(Conversions.connection))
     }
 
+    func clientAvailability(_ request: SourceRequest) async throws -> AvailabilityResult {
+        AvailabilityResult(availability: Conversions.availability(
+            await terra.availability(for: try Conversions.source(request.source))))
+    }
+
     func clientDisconnect(_ request: SourceRequest) async throws -> Empty {
         try await connection(request.source).disconnect()
         return Empty()
@@ -127,6 +132,16 @@ struct TerraBridgeOpsImpl: TerraBridgeOps {
             .map(Conversions.heartRate))
     }
 
+    func bodyRestingHeartRate(_ request: RangeRequest) async throws -> RestingHeartRateList {
+        RestingHeartRateList(samples: try await terra.body.restingHeartRate(in: Conversions.timeRange(request.range, at: "$.range"))
+            .map(Conversions.restingHeartRate))
+    }
+
+    func bodyReadings(_ request: RangeRequest) async throws -> BodyReadingList {
+        BodyReadingList(samples: try await terra.body.readings(in: Conversions.timeRange(request.range, at: "$.range"))
+            .compactMap(Conversions.bodyReading))
+    }
+
     func bodyLogHeartRate(_ request: HeartRateEntryList) async throws -> RecordIdList {
         ids(try await terra.body.log(entries(request.entries, Conversions.entry)))
     }
@@ -147,6 +162,16 @@ struct TerraBridgeOpsImpl: TerraBridgeOps {
             .map(Conversions.steps))
     }
 
+    func dailyTotals(_ request: RangeRequest) async throws -> DayTotalList {
+        DayTotalList(totals: try await terra.daily.totals(in: Conversions.timeRange(request.range, at: "$.range"))
+            .compactMap(Conversions.dayTotal))
+    }
+
+    func dailyIntraday(_ request: RangeRequest) async throws -> IntradaySampleList {
+        IntradaySampleList(samples: try await terra.daily.intraday(in: Conversions.timeRange(request.range, at: "$.range"))
+            .compactMap(Conversions.intraday))
+    }
+
     func dailyLog(_ request: StepEntryList) async throws -> RecordIdList {
         ids(try await terra.daily.log(entries(request.entries, Conversions.entry)))
     }
@@ -179,6 +204,16 @@ struct TerraBridgeOpsImpl: TerraBridgeOps {
             .map(Conversions.workout))
     }
 
+    func activityRoutes(_ request: RangeRequest) async throws -> WorkoutRouteList {
+        WorkoutRouteList(routes: try await terra.activity.routes(in: Conversions.timeRange(request.range, at: "$.range"))
+            .map(Conversions.route))
+    }
+
+    func activityIntensity(_ request: RangeRequest) async throws -> WorkoutIntensityList {
+        WorkoutIntensityList(samples: try await terra.activity.intensity(in: Conversions.timeRange(request.range, at: "$.range"))
+            .compactMap(Conversions.intensity))
+    }
+
     func activityLog(_ request: WorkoutEntryList) async throws -> RecordIdList {
         ids(try await terra.activity.log(entries(request.entries, Conversions.entry)))
     }
@@ -190,6 +225,11 @@ struct TerraBridgeOpsImpl: TerraBridgeOps {
 
     // MARK: nutrition
 
+    func nutritionQuantities(_ request: RangeRequest) async throws -> DietaryQuantityList {
+        DietaryQuantityList(samples: try await terra.nutrition.quantities(in: Conversions.timeRange(request.range, at: "$.range"))
+            .compactMap(Conversions.quantity))
+    }
+
     func nutritionLog(_ request: NutritionEntryList) async throws -> RecordIdList {
         ids(try await terra.nutrition.log(entries(request.entries, Conversions.entry)))
     }
@@ -199,6 +239,30 @@ struct TerraBridgeOpsImpl: TerraBridgeOps {
         return Empty()
     }
 
+    func nutritionHydration(_ request: RangeRequest) async throws -> HydrationList {
+        HydrationList(samples: try await terra.nutrition.hydration(in: Conversions.timeRange(request.range, at: "$.range"))
+            .map(Conversions.hydration))
+    }
+
+    // MARK: menstruation
+
+    func menstruationFlow(_ request: RangeRequest) async throws -> MenstruationFlowDayList {
+        MenstruationFlowDayList(samples: try await terra.menstruation.flow(in: Conversions.timeRange(request.range, at: "$.range"))
+            .map(Conversions.flowDay))
+    }
+
+    func menstruationEvents(_ request: RangeRequest) async throws -> MenstrualEventList {
+        MenstrualEventList(samples: try await terra.menstruation.events(in: Conversions.timeRange(request.range, at: "$.range"))
+            .compactMap(Conversions.menstrualEvent))
+    }
+
+    // MARK: athlete
+
+    func athleteProfile(_ request: Empty) async throws -> AthleteProfileResult {
+        AthleteProfileResult(profile: try await terra.athlete.profile()
+            .map { Conversions.athleteProfile($0, zone: .current) })
+    }
+
     // MARK: planned workouts
 
     func plannedWorkoutsPlanned(_ request: Empty) async throws -> PlannedWorkoutList {

package/lib/Terra.d.ts

@@ -8,7 +8,7 @@
  * here, so this file cannot quietly fall behind the surface the way the 1.x wrapper did.
  */
 import { TerraError } from "./TerraError";
-import type { BodyEntry, BootstrapState, Connection, DataCategory, DiagnosticsState, EndUser, HealthAccess, HealthChange, HeartRateEntry, HeartRateSample, NutritionEntry, PermissionStatus, PlannedWorkout, WorkoutSchedulingStatus, SleepEntry, SleepSegment, Source, StepCount, StepEntry, SupportReport, TerraEvent, TimeRange, Workout, WorkoutEntry } from "./generated/types";
+import type { AthleteProfile, BodyEntry, BodyReading, BootstrapState, Connection, DataCategory, DayTotal, DiagnosticsState, DietaryQuantity, EndUser, HealthAccess, HealthChange, HeartRateEntry, HeartRateSample, HydrationSample, IntradaySample, MenstrualEvent, MenstruationFlowDay, NutritionEntry, PermissionStatus, PlannedWorkout, RestingHeartRateSample, StoreAvailability, WorkoutSchedulingStatus, SleepEntry, SleepSegment, Source, StepCount, StepEntry, SupportReport, TerraEvent, TimeRange, Workout, WorkoutEntry, WorkoutIntensitySample, WorkoutRoute } from "./generated/types";
 /** What the facade needs from the native module. `NativeTerraBridge` satisfies it; so does a double. */
 export interface NativeBridge {
     invoke(op: string, payload: string): Promise<string>;
@@ -77,12 +77,31 @@ interface Changes {
 }
 export interface BodyMetrics extends Changes {
     heartRate(range: TimeRange): Promise<readonly HeartRateSample[]>;
+    /**
+     * The store's own resting heart rate, one per day it computed, never derived from `heartRate`.
+     * Health Connect grants it under `daily`, so on Android ask for `daily` as well as `body`.
+     */
+    restingHeartRate(range: TimeRange): Promise<readonly RestingHeartRateSample[]>;
+    /**
+     * Weight, height, BMI (iOS), body fat, lean mass, heart rate variability, VO2 max, blood pressure,
+     * blood glucose, oxygen saturation, temperature and respiratory rate. Each reading's `kind` says
+     * what it measured and fixes the unit; blood glucose keeps the unit its writer chose.
+     */
+    readings(range: TimeRange): Promise<readonly BodyReading[]>;
     logHeartRate(entries: readonly HeartRateEntry[]): Promise<readonly string[]>;
     log(entries: readonly BodyEntry[]): Promise<readonly string[]>;
     delete(id: string): Promise<void>;
 }
 export interface DailyMetrics extends Changes {
     steps(range: TimeRange): Promise<readonly StepCount[]>;
+    /**
+     * The store's own total for each whole local day the range touches: distance, active and basal
+     * energy, flights climbed and, on iOS, exercise minutes. A day with nothing recorded has no total
+     * rather than a zero. Steps are `steps`, which keeps writers apart.
+     */
+    totals(range: TimeRange): Promise<readonly DayTotal[]>;
+    /** The active energy, basal energy (iOS), distance and floors records the totals are made of. */
+    intraday(range: TimeRange): Promise<readonly IntradaySample[]>;
     log(entries: readonly StepEntry[]): Promise<readonly string[]>;
     delete(id: string): Promise<void>;
 }
@@ -93,14 +112,47 @@ export interface SleepMetrics extends Changes {
 }
 export interface ActivityMetrics extends Changes {
     workouts(range: TimeRange): Promise<readonly Workout[]>;
+    /** The GPS tracks of the workouts in the range, each naming its workout by `workoutId`. */
+    routes(range: TimeRange): Promise<readonly WorkoutRoute[]>;
+    /**
+     * Speed, power and cycling cadence readings in the range. iOS names each one's workout; Health
+     * Connect stores them free-standing, so on Android `workoutId` is absent and `start` equals `end`.
+     */
+    intensity(range: TimeRange): Promise<readonly WorkoutIntensitySample[]>;
     log(entries: readonly WorkoutEntry[]): Promise<readonly string[]>;
     delete(id: string): Promise<void>;
 }
-/** Write-only on both platforms. */
 export interface NutritionMetrics {
+    /**
+     * One quantity per nutrient a meal recorded in the range, not grouped into meals. Quantities of
+     * one meal share `foodCorrelationId`. Water is not among them. Each `value` is in its nutrient's
+     * fixed unit: kcal for `energyConsumed`, grams for the macronutrients, milligrams for the rest.
+     */
+    quantities(range: TimeRange): Promise<readonly DietaryQuantity[]>;
+    /** Water drunk in the range, one sample per drink, in millilitres. */
+    hydration(range: TimeRange): Promise<readonly HydrationSample[]>;
     log(entries: readonly NutritionEntry[]): Promise<readonly string[]>;
     delete(id: string): Promise<void>;
 }
+/** Read-only on both platforms: neither SDK has a write route for menstruation. */
+export interface MenstruationMetrics {
+    /**
+     * Logged flow days overlapping the range, one per day, each bounded by that day's local
+     * midnights. A day logged with no flow comes back as `none` rather than being left out.
+     */
+    flow(range: TimeRange): Promise<readonly MenstruationFlowDay[]>;
+    /** Ovulation tests, cervical mucus and intermenstrual bleeding logged in the range. */
+    events(range: TimeRange): Promise<readonly MenstrualEvent[]>;
+}
+/** iOS only, and read-only. */
+export interface AthleteMetrics {
+    /**
+     * HealthKit's characteristics as one snapshot. No range, because characteristics have no
+     * history. `undefined` where the store has no notion of them at all; a store that has them and
+     * holds no values answers a profile whose `biologicalSex` is `notSet`.
+     */
+    profile(): Promise<AthleteProfile | undefined>;
+}
 /** iOS only. */
 export interface PlannedWorkouts {
     planned(): Promise<readonly PlannedWorkout[]>;
@@ -124,12 +176,20 @@ export declare class Terra {
     readonly sleep: SleepMetrics;
     readonly activity: ActivityMetrics;
     readonly nutrition: NutritionMetrics;
+    readonly menstruation: MenstruationMetrics;
+    /** `undefined` on Android, which has no characteristics to read. */
+    readonly athlete: AthleteMetrics | undefined;
     /** `undefined` on Android, which has no planned workouts. */
     readonly plannedWorkouts: PlannedWorkouts | undefined;
     private readonly ops;
     private readonly streams;
-    /** Settles once the token provider, when there is one, can be asked. */
-    private readonly tokensReady;
+    private readonly tokenProvider;
+    private readonly tokenTimeoutMs;
+    /**
+     * The provider's registration, in flight or done. `undefined` before it starts and after it failed
+     * or its stream ended, so the next connect that needs it registers again.
+     */
+    private tokenSetup;
     constructor(native: NativeBridge, platform: Platform, options?: TerraOptions);
     /**
      * The native client this runtime is attached to. Rejects with `bridge.not_bootstrapped`, carrying
@@ -148,7 +208,16 @@ export declare class Terra {
     }): Promise<Connection>;
     connections(): Promise<readonly Connection[]>;
     disconnect(source?: Source): Promise<void>;
-    /** Answers the native broker's token requests with `provider`, for the lifetime of this runtime. */
+    /**
+     * Whether the device can serve `source` at all, and if not, why. Needs no connection and prompts
+     * for nothing, so an app can decide whether to offer the link before `connect`. iOS answers
+     * `available` or `unsupportedDevice`; Android names the reason, such as `providerAppMissing` when
+     * Health Connect needs installing.
+     */
+    availability(source?: Source): Promise<StoreAvailability>;
+    /** Settles once the token provider, when there is one, can be asked. */
+    private tokensReady;
+    /** Answers the native broker's token requests with `provider` until the stream ends. */
     private answerTokens;
 }
 export {};

package/lib/Terra.js

@@ -21,11 +21,11 @@ class Terra {
         const ops = new client_1.GeneratedClient(invoker);
         this.ops = ops;
         this.streams = new StreamHub(native);
-        this.tokensReady = options.tokenProvider === undefined
-            ? Promise.resolve()
-            : this.answerTokens(options.tokenProvider, options.tokenTimeoutMs ?? 30000);
-        // The runtime can report an unhandled rejection before a later call awaits this promise.
-        this.tokensReady.catch(() => undefined);
+        this.tokenProvider = options.tokenProvider;
+        this.tokenTimeoutMs = options.tokenTimeoutMs ?? 30000;
+        // Registered now, so the provider is in place before anything asks. A failure here is reported
+        // to the connect that needs the provider, which also tries again.
+        void this.tokensReady();
         const on = (op) => ops_1.availableOn[op].includes(platform);
         const stream = (id) => (listener, onError) => this.streams.subscribe(id, listener, onError);
         this.permissions = {
@@ -66,6 +66,8 @@ class Terra {
         };
         this.body = {
             heartRate: async (range) => (await ops.bodyHeartRate({ range })).samples,
+            restingHeartRate: async (range) => (await ops.bodyRestingHeartRate({ range })).samples,
+            readings: async (range) => (await ops.bodyReadings({ range })).samples,
             logHeartRate: async (entries) => (await ops.bodyLogHeartRate({ entries })).ids,
             log: async (entries) => (await ops.bodyLog({ entries })).ids,
             delete: async (id) => {
@@ -75,6 +77,8 @@ class Terra {
         };
         this.daily = {
             steps: async (range) => (await ops.dailySteps({ range })).samples,
+            totals: async (range) => (await ops.dailyTotals({ range })).totals,
+            intraday: async (range) => (await ops.dailyIntraday({ range })).samples,
             log: async (entries) => (await ops.dailyLog({ entries })).ids,
             delete: async (id) => {
                 await ops.dailyDelete({ id });
@@ -91,6 +95,8 @@ class Terra {
         };
         this.activity = {
             workouts: async (range) => (await ops.activityWorkouts({ range })).samples,
+            routes: async (range) => (await ops.activityRoutes({ range })).routes,
+            intensity: async (range) => (await ops.activityIntensity({ range })).samples,
             log: async (entries) => (await ops.activityLog({ entries })).ids,
             delete: async (id) => {
                 await ops.activityDelete({ id });
@@ -98,11 +104,20 @@ class Terra {
             changes: stream("activity.changes"),
         };
         this.nutrition = {
+            quantities: async (range) => (await ops.nutritionQuantities({ range })).samples,
+            hydration: async (range) => (await ops.nutritionHydration({ range })).samples,
             log: async (entries) => (await ops.nutritionLog({ entries })).ids,
             delete: async (id) => {
                 await ops.nutritionDelete({ id });
             },
         };
+        this.menstruation = {
+            flow: async (range) => (await ops.menstruationFlow({ range })).samples,
+            events: async (range) => (await ops.menstruationEvents({ range })).samples,
+        };
+        this.athlete = on("athlete.profile")
+            ? { profile: async () => (await ops.athleteProfile({})).profile }
+            : undefined;
         this.plannedWorkouts = on("plannedWorkouts.planned")
             ? {
                 planned: async () => (await ops.plannedWorkoutsPlanned({})).workouts,
@@ -132,7 +147,9 @@ class Terra {
      * the `tokenProvider` is asked, and only when a new link is actually needed.
      */
     async connect(source, endUser, options = {}) {
-        await this.tokensReady;
+        // A connect that carries its token never asks the provider, so it does not wait on it either.
+        if (options.token === undefined)
+            await this.tokensReady();
         return this.ops.clientConnect({ source, endUser, token: options.token });
     }
     async connections() {
@@ -141,9 +158,36 @@ class Terra {
     async disconnect(source) {
         await this.ops.clientDisconnect({ source });
     }
-    /** Answers the native broker's token requests with `provider`, for the lifetime of this runtime. */
-    async answerTokens(provider, timeoutMs) {
-        await this.streams.open("bridge.tokenRequest", ({ requestId }) => {
+    /**
+     * Whether the device can serve `source` at all, and if not, why. Needs no connection and prompts
+     * for nothing, so an app can decide whether to offer the link before `connect`. iOS answers
+     * `available` or `unsupportedDevice`; Android names the reason, such as `providerAppMissing` when
+     * Health Connect needs installing.
+     */
+    async availability(source) {
+        return (await this.ops.clientAvailability({ source })).availability;
+    }
+    /** Settles once the token provider, when there is one, can be asked. */
+    tokensReady() {
+        const provider = this.tokenProvider;
+        if (provider === undefined)
+            return Promise.resolve();
+        if (this.tokenSetup !== undefined)
+            return this.tokenSetup;
+        const forget = () => {
+            if (this.tokenSetup === setup)
+                this.tokenSetup = undefined;
+        };
+        const setup = this.answerTokens(provider, this.tokenTimeoutMs, forget);
+        this.tokenSetup = setup;
+        // Handles the failure, so it is never an unhandled rejection, and forgets the setup so the next
+        // connect tries again rather than rethrowing a failure that may have passed.
+        setup.catch(forget);
+        return setup;
+    }
+    /** Answers the native broker's token requests with `provider` until the stream ends. */
+    async answerTokens(provider, timeoutMs, onEnd) {
+        const id = await this.streams.open("bridge.tokenRequest", ({ requestId }) => {
             void (async () => {
                 let token;
                 try {
@@ -156,8 +200,15 @@ class Terra {
                 }
                 await this.ops.tokenResolve({ requestId, token }).catch(() => undefined);
             })();
-        });
-        await this.ops.tokenSetProviderPresent({ present: true, timeoutMs });
+        }, undefined, onEnd);
+        try {
+            await this.ops.tokenSetProviderPresent({ present: true, timeoutMs });
+        }
+        catch (failed) {
+            // A provider the broker was never told about answers nothing, so its stream is let go of.
+            this.streams.close(id);
+            throw failed;
+        }
     }
 }
 exports.Terra = Terra;
@@ -168,8 +219,11 @@ class StreamHub {
         this.early = new Map();
         this.pending = 0;
     }
-    /** Subscribes and answers once the native stream is open. */
-    async open(stream, listener, onError) {
+    /**
+     * Subscribes and answers once the native stream is open. `onEnd` runs once the stream ends from the
+     * native side, by error or by completing; not when it is closed from here.
+     */
+    async open(stream, listener, onError, onEnd) {
         this.listen();
         this.pending += 1;
         let id;
@@ -189,9 +243,11 @@ class StreamHub {
                 case "error":
                     this.ended(id);
                     onError?.(new TerraError_1.TerraError(delivery.error));
+                    onEnd?.();
                     return;
                 case "complete":
                     this.ended(id);
+                    onEnd?.();
                     return;
             }
         };

package/lib/generated/client.d.ts

@@ -1,4 +1,4 @@
-import type { BodyEntryList, BoolResult, BootstrapState, CategoryRequest, ConnectRequest, Connection, ConnectionList, DiagnosticsState, Empty, HealthAccess, HeartRateEntryList, HeartRateList, LastDeliveryResult, MarkCompleteRequest, NutritionEntryList, PermissionGrant, PermissionRequest, PlannedWorkoutList, RangeRequest, RecordIdList, RecordIdRequest, SleepEntryList, SleepSegmentList, SourceRequest, StatusResult, StatusesResult, StepCountList, StepEntryList, SupportReport, TokenProviderRequest, TokenRejectRequest, TokenResolveRequest, WorkoutEntryList, WorkoutList, WorkoutScheduling } from "./types";
+import type { AthleteProfileResult, AvailabilityResult, BodyEntryList, BodyReadingList, BoolResult, BootstrapState, CategoryRequest, ConnectRequest, Connection, ConnectionList, DayTotalList, DiagnosticsState, DietaryQuantityList, Empty, HealthAccess, HeartRateEntryList, HeartRateList, HydrationList, IntradaySampleList, LastDeliveryResult, MarkCompleteRequest, MenstrualEventList, MenstruationFlowDayList, NutritionEntryList, PermissionGrant, PermissionRequest, PlannedWorkoutList, RangeRequest, RecordIdList, RecordIdRequest, RestingHeartRateList, SleepEntryList, SleepSegmentList, SourceRequest, StatusResult, StatusesResult, StepCountList, StepEntryList, SupportReport, TokenProviderRequest, TokenRejectRequest, TokenResolveRequest, WorkoutEntryList, WorkoutIntensityList, WorkoutList, WorkoutRouteList, WorkoutScheduling } from "./types";
 import type { OpId } from "./ops";
 /** What the facade needs from the native module. The TurboModule spec satisfies it; so does a test double. */
 export interface Invoker {
@@ -21,6 +21,8 @@ export declare class GeneratedClient {
     clientAttach(request: Empty): Promise<BootstrapState>;
     clientConnect(request: ConnectRequest): Promise<Connection>;
     clientConnections(request: Empty): Promise<ConnectionList>;
+    /** Whether the device can serve the source at all. Needs no connection and prompts for nothing. */
+    clientAvailability(request: SourceRequest): Promise<AvailabilityResult>;
     clientDisconnect(request: SourceRequest): Promise<Empty>;
     /**
      * Tells the broker whether JS can answer at all. Without it a link asks a provider that is not
@@ -55,21 +57,55 @@ export declare class GeneratedClient {
     /** Available on android only. */
     backgroundCancel(request: Empty): Promise<BoolResult>;
     bodyHeartRate(request: RangeRequest): Promise<HeartRateList>;
+    /**
+     * The store's own daily figures. Health Connect grants them under daily, so Android answers
+     * authorization_not_determined where only body was asked for.
+     */
+    bodyRestingHeartRate(request: RangeRequest): Promise<RestingHeartRateList>;
+    bodyReadings(request: RangeRequest): Promise<BodyReadingList>;
     /** Its own op rather than an overload: Swift overloads log by element type and JS cannot. */
     bodyLogHeartRate(request: HeartRateEntryList): Promise<RecordIdList>;
     bodyLog(request: BodyEntryList): Promise<RecordIdList>;
     bodyDelete(request: RecordIdRequest): Promise<Empty>;
     dailySteps(request: RangeRequest): Promise<StepCountList>;
+    /**
+     * One total per metric per whole local day the range touches. A day with nothing recorded has
+     * no total, not a zero.
+     */
+    dailyTotals(request: RangeRequest): Promise<DayTotalList>;
+    /** The active energy, basal energy, distance and floors records the totals are made of. */
+    dailyIntraday(request: RangeRequest): Promise<IntradaySampleList>;
     dailyLog(request: StepEntryList): Promise<RecordIdList>;
     dailyDelete(request: RecordIdRequest): Promise<Empty>;
     sleepSegments(request: RangeRequest): Promise<SleepSegmentList>;
     sleepLog(request: SleepEntryList): Promise<RecordIdList>;
     sleepDelete(request: RecordIdRequest): Promise<Empty>;
     activityWorkouts(request: RangeRequest): Promise<WorkoutList>;
+    /** The GPS tracks of the workouts in the range, each naming its workout. */
+    activityRoutes(request: RangeRequest): Promise<WorkoutRouteList>;
+    /** Speed, power and cycling cadence readings in the range. */
+    activityIntensity(request: RangeRequest): Promise<WorkoutIntensityList>;
     activityLog(request: WorkoutEntryList): Promise<RecordIdList>;
     activityDelete(request: RecordIdRequest): Promise<Empty>;
+    /** One quantity per nutrient a meal recorded, not grouped into meals. Water is not among them. */
+    nutritionQuantities(request: RangeRequest): Promise<DietaryQuantityList>;
     nutritionLog(request: NutritionEntryList): Promise<RecordIdList>;
     nutritionDelete(request: RecordIdRequest): Promise<Empty>;
+    /** Water drunk in the range, one sample per drink. */
+    nutritionHydration(request: RangeRequest): Promise<HydrationList>;
+    /**
+     * Logged flow days overlapping the range, one per day. A day logged with no flow is noFlow,
+     * not left out.
+     */
+    menstruationFlow(request: RangeRequest): Promise<MenstruationFlowDayList>;
+    /** Ovulation tests, cervical mucus and intermenstrual bleeding logged in the range. */
+    menstruationEvents(request: RangeRequest): Promise<MenstrualEventList>;
+    /**
+     * Characteristics have no history.
+     *
+     * Available on ios only.
+     */
+    athleteProfile(request: Empty): Promise<AthleteProfileResult>;
     /** Available on ios only. */
     plannedWorkoutsPlanned(request: Empty): Promise<PlannedWorkoutList>;
     /** Available on ios only. */

package/lib/generated/client.js

@@ -50,6 +50,10 @@ class GeneratedClient {
     async clientConnections(request) {
         return this.call("client.connections", () => (0, codecs_1.encodeEmpty)(request), (raw) => (0, codecs_1.decodeConnectionList)(raw, "ConnectionList"));
     }
+    /** Whether the device can serve the source at all. Needs no connection and prompts for nothing. */
+    async clientAvailability(request) {
+        return this.call("client.availability", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeAvailabilityResult)(raw, "AvailabilityResult"));
+    }
     async clientDisconnect(request) {
         return this.call("client.disconnect", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
     }
@@ -120,6 +124,16 @@ class GeneratedClient {
     async bodyHeartRate(request) {
         return this.call("body.heartRate", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeHeartRateList)(raw, "HeartRateList"));
     }
+    /**
+     * The store's own daily figures. Health Connect grants them under daily, so Android answers
+     * authorization_not_determined where only body was asked for.
+     */
+    async bodyRestingHeartRate(request) {
+        return this.call("body.restingHeartRate", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeRestingHeartRateList)(raw, "RestingHeartRateList"));
+    }
+    async bodyReadings(request) {
+        return this.call("body.readings", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeBodyReadingList)(raw, "BodyReadingList"));
+    }
     /** Its own op rather than an overload: Swift overloads log by element type and JS cannot. */
     async bodyLogHeartRate(request) {
         return this.call("body.logHeartRate", () => (0, codecs_1.encodeHeartRateEntryList)(request), (raw) => (0, codecs_1.decodeRecordIdList)(raw, "RecordIdList"));
@@ -133,6 +147,17 @@ class GeneratedClient {
     async dailySteps(request) {
         return this.call("daily.steps", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeStepCountList)(raw, "StepCountList"));
     }
+    /**
+     * One total per metric per whole local day the range touches. A day with nothing recorded has
+     * no total, not a zero.
+     */
+    async dailyTotals(request) {
+        return this.call("daily.totals", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeDayTotalList)(raw, "DayTotalList"));
+    }
+    /** The active energy, basal energy, distance and floors records the totals are made of. */
+    async dailyIntraday(request) {
+        return this.call("daily.intraday", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeIntradaySampleList)(raw, "IntradaySampleList"));
+    }
     async dailyLog(request) {
         return this.call("daily.log", () => (0, codecs_1.encodeStepEntryList)(request), (raw) => (0, codecs_1.decodeRecordIdList)(raw, "RecordIdList"));
     }
@@ -151,18 +176,53 @@ class GeneratedClient {
     async activityWorkouts(request) {
         return this.call("activity.workouts", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeWorkoutList)(raw, "WorkoutList"));
     }
+    /** The GPS tracks of the workouts in the range, each naming its workout. */
+    async activityRoutes(request) {
+        return this.call("activity.routes", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeWorkoutRouteList)(raw, "WorkoutRouteList"));
+    }
+    /** Speed, power and cycling cadence readings in the range. */
+    async activityIntensity(request) {
+        return this.call("activity.intensity", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeWorkoutIntensityList)(raw, "WorkoutIntensityList"));
+    }
     async activityLog(request) {
         return this.call("activity.log", () => (0, codecs_1.encodeWorkoutEntryList)(request), (raw) => (0, codecs_1.decodeRecordIdList)(raw, "RecordIdList"));
     }
     async activityDelete(request) {
         return this.call("activity.delete", () => (0, codecs_1.encodeRecordIdRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
     }
+    /** One quantity per nutrient a meal recorded, not grouped into meals. Water is not among them. */
+    async nutritionQuantities(request) {
+        return this.call("nutrition.quantities", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeDietaryQuantityList)(raw, "DietaryQuantityList"));
+    }
     async nutritionLog(request) {
         return this.call("nutrition.log", () => (0, codecs_1.encodeNutritionEntryList)(request), (raw) => (0, codecs_1.decodeRecordIdList)(raw, "RecordIdList"));
     }
     async nutritionDelete(request) {
         return this.call("nutrition.delete", () => (0, codecs_1.encodeRecordIdRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
     }
+    /** Water drunk in the range, one sample per drink. */
+    async nutritionHydration(request) {
+        return this.call("nutrition.hydration", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeHydrationList)(raw, "HydrationList"));
+    }
+    /**
+     * Logged flow days overlapping the range, one per day. A day logged with no flow is noFlow,
+     * not left out.
+     */
+    async menstruationFlow(request) {
+        return this.call("menstruation.flow", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeMenstruationFlowDayList)(raw, "MenstruationFlowDayList"));
+    }
+    /** Ovulation tests, cervical mucus and intermenstrual bleeding logged in the range. */
+    async menstruationEvents(request) {
+        return this.call("menstruation.events", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeMenstrualEventList)(raw, "MenstrualEventList"));
+    }
+    /**
+     * Characteristics have no history.
+     *
+     * Available on ios only.
+     */
+    async athleteProfile(request) {
+        return this.call("athlete.profile", () => (0, codecs_1.encodeEmpty)(request), (raw) => (0, codecs_1.decodeAthleteProfileResult)(raw, "AthleteProfileResult"));
+    }
     /** Available on ios only. */
     async plannedWorkoutsPlanned(request) {
         return this.call("plannedWorkouts.planned", () => (0, codecs_1.encodeEmpty)(request), (raw) => (0, codecs_1.decodePlannedWorkoutList)(raw, "PlannedWorkoutList"));