@tryterra/react-native 0.0.0-stage → 2.2.1

package/lib/TerraError.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * The error every rejected op carries, hydrated from the bridge's JSON.
+ *
+ * Hand-written, and one of only two files here that are: the shape is fixed, while the *vocabulary*
+ * it carries is generated. `code` is a `TerraErrorCode`, so a code renamed natively stops a
+ * `switch` over it compiling rather than silently never matching.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraError = void 0;
+const codecs_1 = require("./generated/codecs");
+const errors_1 = require("./generated/errors");
+class TerraError extends Error {
+    constructor(json, options) {
+        super(json.message, options);
+        this.name = "TerraError";
+        const known = isKnownCode(json.code);
+        this.code = known ? json.code : "platform";
+        this.retryable = known ? (json.retryable ?? fallbackRetryable(json.code)) : false;
+        this.source = json.source;
+        this.details = known ? json.details : { ...json.details, unrecognisedCode: json.code };
+    }
+    /**
+     * Rebuilds a `TerraError` from whatever the native module rejected with.
+     *
+     * Anything unrecognisable becomes `platform` rather than being rethrown as-is: a caller that has
+     * to handle both `TerraError` and an arbitrary `Error` ends up handling neither properly, and the
+     * original is kept as `cause` and its text in `message`.
+     */
+    static from(thrown) {
+        if (thrown instanceof TerraError)
+            return thrown;
+        const json = readJSON(thrown);
+        if (json !== undefined)
+            return new TerraError(json, { cause: thrown });
+        return new TerraError({ code: "platform", retryable: false, message: messageOf(thrown) }, { cause: thrown });
+    }
+    /** A response the bridge resolved that this build cannot read: the native side and JS disagree. */
+    static invalidPayload(op, thrown) {
+        return new TerraError({ code: "bridge.invalid_payload", message: `${op}: ${messageOf(thrown)}`, details: { op } }, { cause: thrown });
+    }
+}
+exports.TerraError = TerraError;
+function isKnownCode(code) {
+    return Object.prototype.hasOwnProperty.call(errors_1.retryableByCode, code);
+}
+function messageOf(thrown) {
+    if (thrown instanceof Error)
+        return thrown.message;
+    if (isObject(thrown) && typeof thrown.message === "string")
+        return thrown.message;
+    return String(thrown);
+}
+function fallbackRetryable(code) {
+    return errors_1.retryableByCode[code] === true;
+}
+/** A JSON string preserves payload types across `NSError` and `WritableMap`, unlike a nested map. */
+function readJSON(thrown) {
+    if (typeof thrown !== "object" || thrown === null)
+        return undefined;
+    const candidate = thrown;
+    const userInfo = candidate.userInfo;
+    const encoded = isObject(userInfo) ? userInfo.payload : undefined;
+    return (typeof encoded === "string" ? decode(parse(encoded)) : undefined) ?? decode(userInfo) ?? decode(candidate);
+}
+function parse(encoded) {
+    try {
+        return JSON.parse(encoded);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The generated decoder does the checking: a string code, a boolean flag, a known source. */
+function decode(raw) {
+    if (!isObject(raw) || typeof raw.code !== "string")
+        return undefined;
+    try {
+        // Read field by field: an Error's `message` is not enumerable, so spreading one drops it.
+        const { retryable, ...rest } = (0, codecs_1.decodeTerraErrorPayload)({
+            code: raw.code,
+            retryable: raw.retryable ?? false,
+            message: raw.message,
+            source: raw.source,
+            details: raw.details,
+        });
+        return raw.retryable === undefined ? rest : { ...rest, retryable };
+    }
+    catch {
+        return undefined;
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}

package/lib/createTerra.d.ts

@@ -0,0 +1,8 @@
+import { Terra, type TerraOptions } from "./Terra";
+/**
+ * Attaches this JavaScript runtime to the native client the app built at launch.
+ *
+ * Call it once, at module scope. The native client outlives a reload, so a reload attaches again
+ * rather than building a second client.
+ */
+export declare function createTerra(options?: TerraOptions): Terra;

package/lib/createTerra.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTerra = createTerra;
+const react_native_1 = require("react-native");
+const NativeTerraBridge_1 = require("./NativeTerraBridge");
+const Terra_1 = require("./Terra");
+/**
+ * Attaches this JavaScript runtime to the native client the app built at launch.
+ *
+ * Call it once, at module scope. The native client outlives a reload, so a reload attaches again
+ * rather than building a second client.
+ */
+function createTerra(options = {}) {
+    const platform = react_native_1.Platform.OS;
+    if (platform !== "ios" && platform !== "android") {
+        throw new Error(`@tryterra/react-native runs on iOS and Android, not ${platform}`);
+    }
+    return new Terra_1.Terra(NativeTerraBridge_1.default, platform, options);
+}

package/lib/generated/client.d.ts

@@ -0,0 +1,128 @@
+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 {
+    invoke(op: OpId, payload: string): Promise<string>;
+}
+/**
+ * One generated method per op, and nothing else.
+ *
+ * The `op` string exists only between this file and the generated native dispatch, and a vector
+ * in `vectors/bridge` pins the two to each other. A caller never sees it.
+ */
+export declare class GeneratedClient {
+    protected readonly invoker: Invoker;
+    constructor(invoker: Invoker);
+    private call;
+    /**
+     * Reports the native client the JS side is attaching to. Idempotent, and safe to call after a
+     * JS reload.
+     */
+    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
+     * there and waits out the timeout.
+     */
+    tokenSetProviderPresent(request: TokenProviderRequest): Promise<Empty>;
+    /**
+     * An unknown or already-settled requestId is ignored rather than rejected, so a reload cannot
+     * fail a link that has already moved on.
+     */
+    tokenResolve(request: TokenResolveRequest): Promise<Empty>;
+    tokenReject(request: TokenRejectRequest): Promise<Empty>;
+    permissionsRequest(request: PermissionRequest): Promise<PermissionGrant>;
+    permissionsStatus(request: CategoryRequest): Promise<StatusResult>;
+    permissionsWriteStatus(request: CategoryRequest): Promise<StatusResult>;
+    permissionsRequested(request: SourceRequest): Promise<HealthAccess>;
+    /** Available on android only. */
+    permissionsStatuses(request: SourceRequest): Promise<StatusesResult>;
+    /** Available on android only. */
+    permissionsBackgroundReadStatus(request: SourceRequest): Promise<StatusResult>;
+    /** Available on android only. */
+    permissionsHistoryReadStatus(request: SourceRequest): Promise<StatusResult>;
+    diagnosticsState(request: SourceRequest): Promise<DiagnosticsState>;
+    diagnosticsLastDelivery(request: SourceRequest): Promise<LastDeliveryResult>;
+    diagnosticsReport(request: SourceRequest): Promise<SupportReport>;
+    diagnosticsSend(request: SourceRequest): Promise<Empty>;
+    /**
+     * False means bootstrap did not run. The SDK reports the same thing independently as
+     * backgroundRefreshUnscheduled.
+     */
+    backgroundIsRegistered(request: Empty): Promise<BoolResult>;
+    /** 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. */
+    plannedWorkoutsMarkComplete(request: MarkCompleteRequest): Promise<Empty>;
+    /** Available on ios only. */
+    plannedWorkoutsDelete(request: RecordIdRequest): Promise<Empty>;
+    /**
+     * Never prompts.
+     *
+     * Available on ios only.
+     */
+    plannedWorkoutsSchedulingStatus(request: Empty): Promise<WorkoutScheduling>;
+    /**
+     * Shows WorkoutKit's sheet if the person has not been asked, and reconciles straight away once
+     * authorized.
+     *
+     * Available on ios only.
+     */
+    plannedWorkoutsRequestScheduling(request: Empty): Promise<WorkoutScheduling>;
+}

package/lib/generated/client.js

@@ -0,0 +1,256 @@
+"use strict";
+// Generated from surface/terra-surface.json by surface/gen. Do not edit by hand.
+// Regenerate with: node surface/gen/src/cli.ts generate
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedClient = void 0;
+const codecs_1 = require("./codecs");
+const TerraError_1 = require("../TerraError");
+/**
+ * One generated method per op, and nothing else.
+ *
+ * The `op` string exists only between this file and the generated native dispatch, and a vector
+ * in `vectors/bridge` pins the two to each other. A caller never sees it.
+ */
+class GeneratedClient {
+    constructor(invoker) {
+        this.invoker = invoker;
+    }
+    async call(op, encode, decode) {
+        let payload;
+        try {
+            payload = JSON.stringify(encode());
+        }
+        catch (thrown) {
+            throw TerraError_1.TerraError.invalidPayload(op, thrown);
+        }
+        let text;
+        try {
+            text = await this.invoker.invoke(op, payload);
+        }
+        catch (thrown) {
+            throw TerraError_1.TerraError.from(thrown);
+        }
+        try {
+            return decode(JSON.parse(text));
+        }
+        catch (thrown) {
+            throw TerraError_1.TerraError.invalidPayload(op, thrown);
+        }
+    }
+    /**
+     * Reports the native client the JS side is attaching to. Idempotent, and safe to call after a
+     * JS reload.
+     */
+    async clientAttach(request) {
+        return this.call("client.attach", () => (0, codecs_1.encodeEmpty)(request), (raw) => (0, codecs_1.decodeBootstrapState)(raw, "BootstrapState"));
+    }
+    async clientConnect(request) {
+        return this.call("client.connect", () => (0, codecs_1.encodeConnectRequest)(request), (raw) => (0, codecs_1.decodeConnection)(raw, "Connection"));
+    }
+    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"));
+    }
+    /**
+     * Tells the broker whether JS can answer at all. Without it a link asks a provider that is not
+     * there and waits out the timeout.
+     */
+    async tokenSetProviderPresent(request) {
+        return this.call("token.setProviderPresent", () => (0, codecs_1.encodeTokenProviderRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    /**
+     * An unknown or already-settled requestId is ignored rather than rejected, so a reload cannot
+     * fail a link that has already moved on.
+     */
+    async tokenResolve(request) {
+        return this.call("token.resolve", () => (0, codecs_1.encodeTokenResolveRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    async tokenReject(request) {
+        return this.call("token.reject", () => (0, codecs_1.encodeTokenRejectRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    async permissionsRequest(request) {
+        return this.call("permissions.request", () => (0, codecs_1.encodePermissionRequest)(request), (raw) => (0, codecs_1.decodePermissionGrant)(raw, "PermissionGrant"));
+    }
+    async permissionsStatus(request) {
+        return this.call("permissions.status", () => (0, codecs_1.encodeCategoryRequest)(request), (raw) => (0, codecs_1.decodeStatusResult)(raw, "StatusResult"));
+    }
+    async permissionsWriteStatus(request) {
+        return this.call("permissions.writeStatus", () => (0, codecs_1.encodeCategoryRequest)(request), (raw) => (0, codecs_1.decodeStatusResult)(raw, "StatusResult"));
+    }
+    async permissionsRequested(request) {
+        return this.call("permissions.requested", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeHealthAccess)(raw, "HealthAccess"));
+    }
+    /** Available on android only. */
+    async permissionsStatuses(request) {
+        return this.call("permissions.statuses", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeStatusesResult)(raw, "StatusesResult"));
+    }
+    /** Available on android only. */
+    async permissionsBackgroundReadStatus(request) {
+        return this.call("permissions.backgroundReadStatus", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeStatusResult)(raw, "StatusResult"));
+    }
+    /** Available on android only. */
+    async permissionsHistoryReadStatus(request) {
+        return this.call("permissions.historyReadStatus", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeStatusResult)(raw, "StatusResult"));
+    }
+    async diagnosticsState(request) {
+        return this.call("diagnostics.state", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeDiagnosticsState)(raw, "DiagnosticsState"));
+    }
+    async diagnosticsLastDelivery(request) {
+        return this.call("diagnostics.lastDelivery", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeLastDeliveryResult)(raw, "LastDeliveryResult"));
+    }
+    async diagnosticsReport(request) {
+        return this.call("diagnostics.report", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeSupportReport)(raw, "SupportReport"));
+    }
+    async diagnosticsSend(request) {
+        return this.call("diagnostics.send", () => (0, codecs_1.encodeSourceRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    /**
+     * False means bootstrap did not run. The SDK reports the same thing independently as
+     * backgroundRefreshUnscheduled.
+     */
+    async backgroundIsRegistered(request) {
+        return this.call("background.isRegistered", () => (0, codecs_1.encodeEmpty)(request), (raw) => (0, codecs_1.decodeBoolResult)(raw, "BoolResult"));
+    }
+    /** Available on android only. */
+    async backgroundCancel(request) {
+        return this.call("background.cancel", () => (0, codecs_1.encodeEmpty)(request), (raw) => (0, codecs_1.decodeBoolResult)(raw, "BoolResult"));
+    }
+    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"));
+    }
+    async bodyLog(request) {
+        return this.call("body.log", () => (0, codecs_1.encodeBodyEntryList)(request), (raw) => (0, codecs_1.decodeRecordIdList)(raw, "RecordIdList"));
+    }
+    async bodyDelete(request) {
+        return this.call("body.delete", () => (0, codecs_1.encodeRecordIdRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    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"));
+    }
+    async dailyDelete(request) {
+        return this.call("daily.delete", () => (0, codecs_1.encodeRecordIdRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    async sleepSegments(request) {
+        return this.call("sleep.segments", () => (0, codecs_1.encodeRangeRequest)(request), (raw) => (0, codecs_1.decodeSleepSegmentList)(raw, "SleepSegmentList"));
+    }
+    async sleepLog(request) {
+        return this.call("sleep.log", () => (0, codecs_1.encodeSleepEntryList)(request), (raw) => (0, codecs_1.decodeRecordIdList)(raw, "RecordIdList"));
+    }
+    async sleepDelete(request) {
+        return this.call("sleep.delete", () => (0, codecs_1.encodeRecordIdRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    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"));
+    }
+    /** Available on ios only. */
+    async plannedWorkoutsMarkComplete(request) {
+        return this.call("plannedWorkouts.markComplete", () => (0, codecs_1.encodeMarkCompleteRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    /** Available on ios only. */
+    async plannedWorkoutsDelete(request) {
+        return this.call("plannedWorkouts.delete", () => (0, codecs_1.encodeRecordIdRequest)(request), (raw) => (0, codecs_1.decodeEmpty)(raw, "Empty"));
+    }
+    /**
+     * Never prompts.
+     *
+     * Available on ios only.
+     */
+    async plannedWorkoutsSchedulingStatus(request) {
+        return this.call("plannedWorkouts.schedulingStatus", () => (0, codecs_1.encodeEmpty)(request), (raw) => (0, codecs_1.decodeWorkoutScheduling)(raw, "WorkoutScheduling"));
+    }
+    /**
+     * Shows WorkoutKit's sheet if the person has not been asked, and reconciles straight away once
+     * authorized.
+     *
+     * Available on ios only.
+     */
+    async plannedWorkoutsRequestScheduling(request) {
+        return this.call("plannedWorkouts.requestScheduling", () => (0, codecs_1.encodeEmpty)(request), (raw) => (0, codecs_1.decodeWorkoutScheduling)(raw, "WorkoutScheduling"));
+    }
+}
+exports.GeneratedClient = GeneratedClient;