@tryterra/react-native 0.0.0-stage → 2.1.0

package/src/generated/codecs.ts

@@ -0,0 +1,1287 @@
+// Generated from surface/terra-surface.json by surface/gen. Do not edit by hand.
+// Regenerate with: node surface/gen/src/cli.ts generate
+
+import type { Source, DataCategory, PermissionStatus, MotionContext, BackgroundRestrictionReason, DiagnosticsReason, DeviceKeyRevokeOutcome, FailureCode, WorkoutSchedulingStatus, EndUser, TimeRange, SleepStage, WorkoutActivity, DiagnosticsState, StreamMessage, SampleSource, Connection, HeartRateSample, StepCount, SleepSegment, Workout, HealthChange, WorkoutScope, HealthAccess, HeartRateEntry, StepEntry, SleepEntry, WorkoutEntry, BodyEntry, Nutrients, NutritionEntry, TerraErrorPayload, PlannedWorkout, TerraEvent, SupportReport, BootstrapState, TokenRequest, Empty, SourceRequest, RangeRequest, CategoryRequest, RecordIdRequest, ConnectRequest, PermissionRequest, PermissionGrant, TokenResolveRequest, TokenRejectRequest, TokenProviderRequest, MarkCompleteRequest, BoolResult, StatusResult, StatusesResult, RecordIdList, ConnectionList, HeartRateList, StepCountList, SleepSegmentList, WorkoutList, PlannedWorkoutList, WorkoutScheduling, LastDeliveryResult, HeartRateEntryList, BodyEntryList, StepEntryList, SleepEntryList, WorkoutEntryList, NutritionEntryList } from "./types";
+
+function encodeInstant(value: Date): string {
+  return value.toISOString();
+}
+
+function decodeInstant(value: unknown, at: string): Date {
+  if (typeof value !== 'string') throw new TypeError(`${at}: expected an ISO 8601 string`);
+  // `new Date` reads a string with no offset as device-local time and shifts the instant.
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value)) {
+    throw new TypeError(`${at}: not a millisecond UTC instant`);
+  }
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== value) {
+    throw new TypeError(`${at}: not a valid instant`);
+  }
+  return parsed;
+}
+
+function asObject(value: unknown, at: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new TypeError(`${at}: expected an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function asArray(value: unknown, at: string): readonly unknown[] {
+  if (!Array.isArray(value)) throw new TypeError(`${at}: expected an array`);
+  return value;
+}
+
+/**
+ * Checked rather than cast.
+ *
+ * `value as number` on a string produces a `number`-typed value that is a string, and the
+ * failure then happens in the caller's arithmetic with no mention of the bridge. Rejecting at
+ * the boundary names the field that was wrong.
+ */
+function asNumber(value: unknown, at: string): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw new TypeError(`${at}: expected a number`);
+  }
+  return value;
+}
+
+function asInteger(value: unknown, at: string): number {
+  if (typeof value !== 'number' || !Number.isInteger(value)) {
+    throw new TypeError(`${at}: expected an integer`);
+  }
+  return value;
+}
+
+function caseSet<T extends string>(items: readonly T[]): T[] {
+  return [...new Set(items)].sort();
+}
+
+function asBoolean(value: unknown, at: string): boolean {
+  if (typeof value !== 'boolean') throw new TypeError(`${at}: expected a boolean`);
+  return value;
+}
+
+function asString(value: unknown, at: string): string {
+  if (typeof value !== 'string') throw new TypeError(`${at}: expected a string`);
+  return value;
+}
+
+function optional<T>(value: unknown, read: (value: unknown) => T): T | undefined {
+  return value === undefined || value === null ? undefined : read(value);
+}
+
+const SourceCases: ReadonlySet<string> = new Set(["health", "samsungHealth"]);
+
+/** Narrows an untyped value to Source, or throws naming the field. */
+export function asSource(value: unknown, at = "Source"): Source {
+  if (typeof value !== "string" || !SourceCases.has(value)) {
+    throw new TypeError(`${at}: ${String(value)} is not a Source`);
+  }
+  return value as Source;
+}
+
+const DataCategoryCases: ReadonlySet<string> = new Set(["activity", "body", "daily", "sleep", "nutrition"]);
+
+/** Narrows an untyped value to DataCategory, or throws naming the field. */
+export function asDataCategory(value: unknown, at = "DataCategory"): DataCategory {
+  if (typeof value !== "string" || !DataCategoryCases.has(value)) {
+    throw new TypeError(`${at}: ${String(value)} is not a DataCategory`);
+  }
+  return value as DataCategory;
+}
+
+const PermissionStatusCases: ReadonlySet<string> = new Set(["granted", "denied", "notDetermined", "notDisclosed", "unsupported", "unavailable"]);
+
+/** Narrows an untyped value to PermissionStatus, or throws naming the field. */
+export function asPermissionStatus(value: unknown, at = "PermissionStatus"): PermissionStatus {
+  if (typeof value !== "string" || !PermissionStatusCases.has(value)) {
+    throw new TypeError(`${at}: ${String(value)} is not a PermissionStatus`);
+  }
+  return value as PermissionStatus;
+}
+
+const MotionContextCases: ReadonlySet<string> = new Set(["unknown", "sedentary", "active"]);
+
+/** Narrows an untyped value to MotionContext. A string it does not name is `unknown`; anything else throws. */
+export function asMotionContext(value: unknown, at = "MotionContext"): MotionContext {
+  if (typeof value !== "string") {
+    throw new TypeError(`${at}: ${String(value)} is not a MotionContext`);
+  }
+  if (!MotionContextCases.has(value)) return "unknown";
+  return value as MotionContext;
+}
+
+const BackgroundRestrictionReasonCases: ReadonlySet<string> = new Set(["oemRestricted", "backgroundReadDenied", "healthConnectFeatureUnavailable", "storeFeatureUnavailable", "ticksNotRunning"]);
+
+/** Narrows an untyped value to BackgroundRestrictionReason, or throws naming the field. */
+export function asBackgroundRestrictionReason(value: unknown, at = "BackgroundRestrictionReason"): BackgroundRestrictionReason {
+  if (typeof value !== "string" || !BackgroundRestrictionReasonCases.has(value)) {
+    throw new TypeError(`${at}: ${String(value)} is not a BackgroundRestrictionReason`);
+  }
+  return value as BackgroundRestrictionReason;
+}
+
+const DiagnosticsReasonCases: ReadonlySet<string> = new Set(["uploadFailed", "backfillAbandoned", "backgroundObservationUnavailable", "backgroundRestricted", "backgroundRefreshUnscheduled", "quiet", "requested"]);
+
+/** Narrows an untyped value to DiagnosticsReason, or throws naming the field. */
+export function asDiagnosticsReason(value: unknown, at = "DiagnosticsReason"): DiagnosticsReason {
+  if (typeof value !== "string" || !DiagnosticsReasonCases.has(value)) {
+    throw new TypeError(`${at}: ${String(value)} is not a DiagnosticsReason`);
+  }
+  return value as DiagnosticsReason;
+}
+
+const DeviceKeyRevokeOutcomeCases: ReadonlySet<string> = new Set(["revoked", "alreadyRevoked", "routeAbsent"]);
+
+/** Narrows an untyped value to DeviceKeyRevokeOutcome, or throws naming the field. */
+export function asDeviceKeyRevokeOutcome(value: unknown, at = "DeviceKeyRevokeOutcome"): DeviceKeyRevokeOutcome {
+  if (typeof value !== "string" || !DeviceKeyRevokeOutcomeCases.has(value)) {
+    throw new TypeError(`${at}: ${String(value)} is not a DeviceKeyRevokeOutcome`);
+  }
+  return value as DeviceKeyRevokeOutcome;
+}
+
+const FailureCodeCases: ReadonlySet<string> = new Set(["healthDataUnavailable", "notConnected", "tokenUnavailable", "tokenRejected", "tokenProviderFailed", "offline", "timedOut", "serverError", "transport", "malformedResponse", "userLimitReached", "upgradeRequired", "platform", "deviceKeyUnavailable", "signatureRejected", "linkRevoked", "linkConflict", "clockSkewed", "devIDMismatch", "syncAlreadyRunning", "linkAlreadyRunning", "storeLocked", "storeUnreadable", "deadlineExceeded", "permissionDenied", "authorizationNotDetermined", "sampleNotFound", "rollbackIncomplete", "distanceNotAttributable", "bloodPressureIncomplete", "authorizationUnavailableInExtension", "routeAwaitingConverter", "readQuotaExceeded", "plannedWorkoutUnnamed"]);
+
+/** Narrows an untyped value to FailureCode, or throws naming the field. */
+export function asFailureCode(value: unknown, at = "FailureCode"): FailureCode {
+  if (typeof value !== "string" || !FailureCodeCases.has(value)) {
+    throw new TypeError(`${at}: ${String(value)} is not a FailureCode`);
+  }
+  return value as FailureCode;
+}
+
+const WorkoutSchedulingStatusCases: ReadonlySet<string> = new Set(["unsupported", "notDetermined", "denied", "authorized"]);
+
+/** Narrows an untyped value to WorkoutSchedulingStatus, or throws naming the field. */
+export function asWorkoutSchedulingStatus(value: unknown, at = "WorkoutSchedulingStatus"): WorkoutSchedulingStatus {
+  if (typeof value !== "string" || !WorkoutSchedulingStatusCases.has(value)) {
+    throw new TypeError(`${at}: ${String(value)} is not a WorkoutSchedulingStatus`);
+  }
+  return value as WorkoutSchedulingStatus;
+}
+
+export function encodeSampleSource(value: SampleSource): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.name = value.name;
+  out.bundleId = value.bundleId;
+  if (value.productType !== undefined) out.productType = value.productType;
+  if (value.deviceType !== undefined) out.deviceType = value.deviceType;
+  return out;
+}
+
+export function decodeSampleSource(raw: unknown, at$ = "SampleSource"): SampleSource {
+  const object = asObject(raw, at$);
+  const name = asString(object.name, `${at$}.name`);
+  const bundleId = asString(object.bundleId, `${at$}.bundleId`);
+  const productType = optional(object.productType, (value) => asString(value, `${at$}.productType`));
+  const deviceType = optional(object.deviceType, (value) => asString(value, `${at$}.deviceType`));
+  return { name, bundleId, productType, deviceType };
+}
+
+export function encodeConnection(value: Connection): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.source = value.source;
+  out.userId = value.userId;
+  if (value.providerUserId !== undefined) out.providerUserId = value.providerUserId;
+  return out;
+}
+
+export function decodeConnection(raw: unknown, at$ = "Connection"): Connection {
+  const object = asObject(raw, at$);
+  const source = asSource(object.source, `${at$}.source`);
+  const userId = asString(object.userId, `${at$}.userId`);
+  const providerUserId = optional(object.providerUserId, (value) => asString(value, `${at$}.providerUserId`));
+  return { source, userId, providerUserId };
+}
+
+export function encodeHeartRateSample(value: HeartRateSample): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.id = value.id;
+  out.time = encodeInstant(value.time);
+  out.beatsPerMinute = value.beatsPerMinute;
+  out.source = encodeSampleSource(value.source);
+  if (value.motionContext !== undefined) out.motionContext = value.motionContext;
+  out.userEntered = value.userEntered;
+  if (value.timeZone !== undefined) out.timeZone = value.timeZone;
+  return out;
+}
+
+export function decodeHeartRateSample(raw: unknown, at$ = "HeartRateSample"): HeartRateSample {
+  const object = asObject(raw, at$);
+  const id = asString(object.id, `${at$}.id`);
+  const time = decodeInstant(object.time, `${at$}.time`);
+  const beatsPerMinute = asNumber(object.beatsPerMinute, `${at$}.beatsPerMinute`);
+  const source = decodeSampleSource(object.source, `${at$}.source`);
+  const motionContext = optional(object.motionContext, (value) => asMotionContext(value, `${at$}.motionContext`));
+  const userEntered = asBoolean(object.userEntered, `${at$}.userEntered`);
+  const timeZone = optional(object.timeZone, (value) => asString(value, `${at$}.timeZone`));
+  return { id, time, beatsPerMinute, source, motionContext, userEntered, timeZone };
+}
+
+export function encodeStepCount(value: StepCount): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (value.id !== undefined) out.id = value.id;
+  out.start = encodeInstant(value.start);
+  out.end = encodeInstant(value.end);
+  out.steps = value.steps;
+  out.source = encodeSampleSource(value.source);
+  out.userEntered = value.userEntered;
+  if (value.timeZone !== undefined) out.timeZone = value.timeZone;
+  return out;
+}
+
+export function decodeStepCount(raw: unknown, at$ = "StepCount"): StepCount {
+  const object = asObject(raw, at$);
+  const id = optional(object.id, (value) => asString(value, `${at$}.id`));
+  const start = decodeInstant(object.start, `${at$}.start`);
+  const end = decodeInstant(object.end, `${at$}.end`);
+  const steps = asInteger(object.steps, `${at$}.steps`);
+  const source = decodeSampleSource(object.source, `${at$}.source`);
+  const userEntered = asBoolean(object.userEntered, `${at$}.userEntered`);
+  const timeZone = optional(object.timeZone, (value) => asString(value, `${at$}.timeZone`));
+  return { id, start, end, steps, source, userEntered, timeZone };
+}
+
+export function encodeSleepSegment(value: SleepSegment): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.id = value.id;
+  out.start = encodeInstant(value.start);
+  out.end = encodeInstant(value.end);
+  out.stage = encodeSleepStage(value.stage);
+  out.source = encodeSampleSource(value.source);
+  out.userEntered = value.userEntered;
+  if (value.timeZone !== undefined) out.timeZone = value.timeZone;
+  return out;
+}
+
+export function decodeSleepSegment(raw: unknown, at$ = "SleepSegment"): SleepSegment {
+  const object = asObject(raw, at$);
+  const id = asString(object.id, `${at$}.id`);
+  const start = decodeInstant(object.start, `${at$}.start`);
+  const end = decodeInstant(object.end, `${at$}.end`);
+  const stage = decodeSleepStage(object.stage, `${at$}.stage`);
+  const source = decodeSampleSource(object.source, `${at$}.source`);
+  const userEntered = asBoolean(object.userEntered, `${at$}.userEntered`);
+  const timeZone = optional(object.timeZone, (value) => asString(value, `${at$}.timeZone`));
+  return { id, start, end, stage, source, userEntered, timeZone };
+}
+
+export function encodeWorkout(value: Workout): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.id = value.id;
+  out.start = encodeInstant(value.start);
+  out.end = encodeInstant(value.end);
+  out.activity = encodeWorkoutActivity(value.activity);
+  out.activityTypeCode = value.activityTypeCode;
+  if (value.indoor !== undefined) out.indoor = value.indoor;
+  if (value.activeEnergyKilocalories !== undefined) out.activeEnergyKilocalories = value.activeEnergyKilocalories;
+  if (value.distanceMeters !== undefined) out.distanceMeters = value.distanceMeters;
+  out.source = encodeSampleSource(value.source);
+  out.userEntered = value.userEntered;
+  if (value.timeZone !== undefined) out.timeZone = value.timeZone;
+  return out;
+}
+
+export function decodeWorkout(raw: unknown, at$ = "Workout"): Workout {
+  const object = asObject(raw, at$);
+  const id = asString(object.id, `${at$}.id`);
+  const start = decodeInstant(object.start, `${at$}.start`);
+  const end = decodeInstant(object.end, `${at$}.end`);
+  const activity = decodeWorkoutActivity(object.activity, `${at$}.activity`);
+  const activityTypeCode = asInteger(object.activityTypeCode, `${at$}.activityTypeCode`);
+  const indoor = optional(object.indoor, (value) => asBoolean(value, `${at$}.indoor`));
+  const activeEnergyKilocalories = optional(object.activeEnergyKilocalories, (value) => asNumber(value, `${at$}.activeEnergyKilocalories`));
+  const distanceMeters = optional(object.distanceMeters, (value) => asNumber(value, `${at$}.distanceMeters`));
+  const source = decodeSampleSource(object.source, `${at$}.source`);
+  const userEntered = asBoolean(object.userEntered, `${at$}.userEntered`);
+  const timeZone = optional(object.timeZone, (value) => asString(value, `${at$}.timeZone`));
+  return { id, start, end, activity, activityTypeCode, indoor, activeEnergyKilocalories, distanceMeters, source, userEntered, timeZone };
+}
+
+export function encodeHealthChange(value: HealthChange): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.category = value.category;
+  out.day = value.day;
+  return out;
+}
+
+export function decodeHealthChange(raw: unknown, at$ = "HealthChange"): HealthChange {
+  const object = asObject(raw, at$);
+  const category = asDataCategory(object.category, `${at$}.category`);
+  const day = asString(object.day, `${at$}.day`);
+  return { category, day };
+}
+
+export function encodeWorkoutScope(value: WorkoutScope): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.activity = encodeWorkoutActivity(value.activity);
+  out.energy = value.energy;
+  out.distance = value.distance;
+  return out;
+}
+
+export function decodeWorkoutScope(raw: unknown, at$ = "WorkoutScope"): WorkoutScope {
+  const object = asObject(raw, at$);
+  const activity = decodeWorkoutActivity(object.activity, `${at$}.activity`);
+  const energy = asBoolean(object.energy, `${at$}.energy`);
+  const distance = asBoolean(object.distance, `${at$}.distance`);
+  return { activity, energy, distance };
+}
+
+export function encodeHealthAccess(value: HealthAccess): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.read = caseSet(value.read);
+  out.write = caseSet(value.write);
+  out.workouts = value.workouts.map((item) => encodeWorkoutScope(item));
+  return out;
+}
+
+export function decodeHealthAccess(raw: unknown, at$ = "HealthAccess"): HealthAccess {
+  const object = asObject(raw, at$);
+  const read = caseSet(asArray(object.read, `${at$}.read`).map((item, index) => asDataCategory(item, `${`${at$}.read`}[${index}]`)));
+  const write = caseSet(asArray(object.write, `${at$}.write`).map((item, index) => asDataCategory(item, `${`${at$}.write`}[${index}]`)));
+  const workouts = asArray(object.workouts, `${at$}.workouts`).map((item, index) => decodeWorkoutScope(item, `${`${at$}.workouts`}[${index}]`));
+  return { read, write, workouts };
+}
+
+export function encodeHeartRateEntry(value: HeartRateEntry): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.time = encodeInstant(value.time);
+  out.beatsPerMinute = value.beatsPerMinute;
+  if (value.recordId !== undefined) out.recordId = value.recordId;
+  return out;
+}
+
+export function decodeHeartRateEntry(raw: unknown, at$ = "HeartRateEntry"): HeartRateEntry {
+  const object = asObject(raw, at$);
+  const time = decodeInstant(object.time, `${at$}.time`);
+  const beatsPerMinute = asNumber(object.beatsPerMinute, `${at$}.beatsPerMinute`);
+  const recordId = optional(object.recordId, (value) => asString(value, `${at$}.recordId`));
+  return { time, beatsPerMinute, recordId };
+}
+
+export function encodeStepEntry(value: StepEntry): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.start = encodeInstant(value.start);
+  out.end = encodeInstant(value.end);
+  out.steps = value.steps;
+  if (value.recordId !== undefined) out.recordId = value.recordId;
+  return out;
+}
+
+export function decodeStepEntry(raw: unknown, at$ = "StepEntry"): StepEntry {
+  const object = asObject(raw, at$);
+  const start = decodeInstant(object.start, `${at$}.start`);
+  const end = decodeInstant(object.end, `${at$}.end`);
+  const steps = asInteger(object.steps, `${at$}.steps`);
+  const recordId = optional(object.recordId, (value) => asString(value, `${at$}.recordId`));
+  return { start, end, steps, recordId };
+}
+
+export function encodeSleepEntry(value: SleepEntry): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.start = encodeInstant(value.start);
+  out.end = encodeInstant(value.end);
+  out.stage = encodeSleepStage(value.stage);
+  if (value.recordId !== undefined) out.recordId = value.recordId;
+  return out;
+}
+
+export function decodeSleepEntry(raw: unknown, at$ = "SleepEntry"): SleepEntry {
+  const object = asObject(raw, at$);
+  const start = decodeInstant(object.start, `${at$}.start`);
+  const end = decodeInstant(object.end, `${at$}.end`);
+  const stage = decodeSleepStage(object.stage, `${at$}.stage`);
+  const recordId = optional(object.recordId, (value) => asString(value, `${at$}.recordId`));
+  return { start, end, stage, recordId };
+}
+
+export function encodeWorkoutEntry(value: WorkoutEntry): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.start = encodeInstant(value.start);
+  out.end = encodeInstant(value.end);
+  out.activity = encodeWorkoutActivity(value.activity);
+  if (value.totalEnergyKilocalories !== undefined) out.totalEnergyKilocalories = value.totalEnergyKilocalories;
+  if (value.totalDistanceMeters !== undefined) out.totalDistanceMeters = value.totalDistanceMeters;
+  if (value.recordId !== undefined) out.recordId = value.recordId;
+  return out;
+}
+
+export function decodeWorkoutEntry(raw: unknown, at$ = "WorkoutEntry"): WorkoutEntry {
+  const object = asObject(raw, at$);
+  const start = decodeInstant(object.start, `${at$}.start`);
+  const end = decodeInstant(object.end, `${at$}.end`);
+  const activity = decodeWorkoutActivity(object.activity, `${at$}.activity`);
+  const totalEnergyKilocalories = optional(object.totalEnergyKilocalories, (value) => asNumber(value, `${at$}.totalEnergyKilocalories`));
+  const totalDistanceMeters = optional(object.totalDistanceMeters, (value) => asNumber(value, `${at$}.totalDistanceMeters`));
+  const recordId = optional(object.recordId, (value) => asString(value, `${at$}.recordId`));
+  return { start, end, activity, totalEnergyKilocalories, totalDistanceMeters, recordId };
+}
+
+export function encodeBodyEntry(value: BodyEntry): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.time = encodeInstant(value.time);
+  if (value.bodyMassKilograms !== undefined) out.bodyMassKilograms = value.bodyMassKilograms;
+  if (value.bodyFatPercent !== undefined) out.bodyFatPercent = value.bodyFatPercent;
+  if (value.bodyMassIndex !== undefined) out.bodyMassIndex = value.bodyMassIndex;
+  if (value.heightMeters !== undefined) out.heightMeters = value.heightMeters;
+  if (value.leanBodyMassKilograms !== undefined) out.leanBodyMassKilograms = value.leanBodyMassKilograms;
+  if (value.bodyTemperatureCelsius !== undefined) out.bodyTemperatureCelsius = value.bodyTemperatureCelsius;
+  if (value.oxygenSaturationPercent !== undefined) out.oxygenSaturationPercent = value.oxygenSaturationPercent;
+  if (value.bloodGlucoseMilligramsPerDeciliter !== undefined) out.bloodGlucoseMilligramsPerDeciliter = value.bloodGlucoseMilligramsPerDeciliter;
+  if (value.bloodPressureSystolicMillimetersOfMercury !== undefined) out.bloodPressureSystolicMillimetersOfMercury = value.bloodPressureSystolicMillimetersOfMercury;
+  if (value.bloodPressureDiastolicMillimetersOfMercury !== undefined) out.bloodPressureDiastolicMillimetersOfMercury = value.bloodPressureDiastolicMillimetersOfMercury;
+  if (value.recordId !== undefined) out.recordId = value.recordId;
+  return out;
+}
+
+export function decodeBodyEntry(raw: unknown, at$ = "BodyEntry"): BodyEntry {
+  const object = asObject(raw, at$);
+  const time = decodeInstant(object.time, `${at$}.time`);
+  const bodyMassKilograms = optional(object.bodyMassKilograms, (value) => asNumber(value, `${at$}.bodyMassKilograms`));
+  const bodyFatPercent = optional(object.bodyFatPercent, (value) => asNumber(value, `${at$}.bodyFatPercent`));
+  const bodyMassIndex = optional(object.bodyMassIndex, (value) => asNumber(value, `${at$}.bodyMassIndex`));
+  const heightMeters = optional(object.heightMeters, (value) => asNumber(value, `${at$}.heightMeters`));
+  const leanBodyMassKilograms = optional(object.leanBodyMassKilograms, (value) => asNumber(value, `${at$}.leanBodyMassKilograms`));
+  const bodyTemperatureCelsius = optional(object.bodyTemperatureCelsius, (value) => asNumber(value, `${at$}.bodyTemperatureCelsius`));
+  const oxygenSaturationPercent = optional(object.oxygenSaturationPercent, (value) => asNumber(value, `${at$}.oxygenSaturationPercent`));
+  const bloodGlucoseMilligramsPerDeciliter = optional(object.bloodGlucoseMilligramsPerDeciliter, (value) => asNumber(value, `${at$}.bloodGlucoseMilligramsPerDeciliter`));
+  const bloodPressureSystolicMillimetersOfMercury = optional(object.bloodPressureSystolicMillimetersOfMercury, (value) => asNumber(value, `${at$}.bloodPressureSystolicMillimetersOfMercury`));
+  const bloodPressureDiastolicMillimetersOfMercury = optional(object.bloodPressureDiastolicMillimetersOfMercury, (value) => asNumber(value, `${at$}.bloodPressureDiastolicMillimetersOfMercury`));
+  const recordId = optional(object.recordId, (value) => asString(value, `${at$}.recordId`));
+  return { time, bodyMassKilograms, bodyFatPercent, bodyMassIndex, heightMeters, leanBodyMassKilograms, bodyTemperatureCelsius, oxygenSaturationPercent, bloodGlucoseMilligramsPerDeciliter, bloodPressureSystolicMillimetersOfMercury, bloodPressureDiastolicMillimetersOfMercury, recordId };
+}
+
+export function encodeNutrients(value: Nutrients): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (value.energyKilocalories !== undefined) out.energyKilocalories = value.energyKilocalories;
+  if (value.proteinGrams !== undefined) out.proteinGrams = value.proteinGrams;
+  if (value.carbohydratesGrams !== undefined) out.carbohydratesGrams = value.carbohydratesGrams;
+  if (value.fiberGrams !== undefined) out.fiberGrams = value.fiberGrams;
+  if (value.sugarGrams !== undefined) out.sugarGrams = value.sugarGrams;
+  if (value.fatTotalGrams !== undefined) out.fatTotalGrams = value.fatTotalGrams;
+  if (value.fatSaturatedGrams !== undefined) out.fatSaturatedGrams = value.fatSaturatedGrams;
+  if (value.fatMonounsaturatedGrams !== undefined) out.fatMonounsaturatedGrams = value.fatMonounsaturatedGrams;
+  if (value.fatPolyunsaturatedGrams !== undefined) out.fatPolyunsaturatedGrams = value.fatPolyunsaturatedGrams;
+  if (value.cholesterolMilligrams !== undefined) out.cholesterolMilligrams = value.cholesterolMilligrams;
+  if (value.sodiumMilligrams !== undefined) out.sodiumMilligrams = value.sodiumMilligrams;
+  if (value.potassiumMilligrams !== undefined) out.potassiumMilligrams = value.potassiumMilligrams;
+  if (value.calciumMilligrams !== undefined) out.calciumMilligrams = value.calciumMilligrams;
+  if (value.ironMilligrams !== undefined) out.ironMilligrams = value.ironMilligrams;
+  if (value.magnesiumMilligrams !== undefined) out.magnesiumMilligrams = value.magnesiumMilligrams;
+  if (value.zincMilligrams !== undefined) out.zincMilligrams = value.zincMilligrams;
+  if (value.waterLiters !== undefined) out.waterLiters = value.waterLiters;
+  if (value.caffeineMilligrams !== undefined) out.caffeineMilligrams = value.caffeineMilligrams;
+  if (value.vitaminAMicrograms !== undefined) out.vitaminAMicrograms = value.vitaminAMicrograms;
+  if (value.vitaminCMilligrams !== undefined) out.vitaminCMilligrams = value.vitaminCMilligrams;
+  if (value.vitaminDMicrograms !== undefined) out.vitaminDMicrograms = value.vitaminDMicrograms;
+  if (value.vitaminEMilligrams !== undefined) out.vitaminEMilligrams = value.vitaminEMilligrams;
+  if (value.vitaminKMicrograms !== undefined) out.vitaminKMicrograms = value.vitaminKMicrograms;
+  if (value.vitaminB6Milligrams !== undefined) out.vitaminB6Milligrams = value.vitaminB6Milligrams;
+  if (value.vitaminB12Micrograms !== undefined) out.vitaminB12Micrograms = value.vitaminB12Micrograms;
+  if (value.folateMicrograms !== undefined) out.folateMicrograms = value.folateMicrograms;
+  if (value.thiaminMilligrams !== undefined) out.thiaminMilligrams = value.thiaminMilligrams;
+  if (value.riboflavinMilligrams !== undefined) out.riboflavinMilligrams = value.riboflavinMilligrams;
+  if (value.niacinMilligrams !== undefined) out.niacinMilligrams = value.niacinMilligrams;
+  if (value.biotinMicrograms !== undefined) out.biotinMicrograms = value.biotinMicrograms;
+  if (value.pantothenicAcidMilligrams !== undefined) out.pantothenicAcidMilligrams = value.pantothenicAcidMilligrams;
+  if (value.phosphorusMilligrams !== undefined) out.phosphorusMilligrams = value.phosphorusMilligrams;
+  if (value.iodineMicrograms !== undefined) out.iodineMicrograms = value.iodineMicrograms;
+  if (value.chromiumMicrograms !== undefined) out.chromiumMicrograms = value.chromiumMicrograms;
+  if (value.copperMilligrams !== undefined) out.copperMilligrams = value.copperMilligrams;
+  if (value.manganeseMilligrams !== undefined) out.manganeseMilligrams = value.manganeseMilligrams;
+  if (value.molybdenumMicrograms !== undefined) out.molybdenumMicrograms = value.molybdenumMicrograms;
+  if (value.seleniumMicrograms !== undefined) out.seleniumMicrograms = value.seleniumMicrograms;
+  if (value.chlorideMilligrams !== undefined) out.chlorideMilligrams = value.chlorideMilligrams;
+  return out;
+}
+
+export function decodeNutrients(raw: unknown, at$ = "Nutrients"): Nutrients {
+  const object = asObject(raw, at$);
+  const energyKilocalories = optional(object.energyKilocalories, (value) => asNumber(value, `${at$}.energyKilocalories`));
+  const proteinGrams = optional(object.proteinGrams, (value) => asNumber(value, `${at$}.proteinGrams`));
+  const carbohydratesGrams = optional(object.carbohydratesGrams, (value) => asNumber(value, `${at$}.carbohydratesGrams`));
+  const fiberGrams = optional(object.fiberGrams, (value) => asNumber(value, `${at$}.fiberGrams`));
+  const sugarGrams = optional(object.sugarGrams, (value) => asNumber(value, `${at$}.sugarGrams`));
+  const fatTotalGrams = optional(object.fatTotalGrams, (value) => asNumber(value, `${at$}.fatTotalGrams`));
+  const fatSaturatedGrams = optional(object.fatSaturatedGrams, (value) => asNumber(value, `${at$}.fatSaturatedGrams`));
+  const fatMonounsaturatedGrams = optional(object.fatMonounsaturatedGrams, (value) => asNumber(value, `${at$}.fatMonounsaturatedGrams`));
+  const fatPolyunsaturatedGrams = optional(object.fatPolyunsaturatedGrams, (value) => asNumber(value, `${at$}.fatPolyunsaturatedGrams`));
+  const cholesterolMilligrams = optional(object.cholesterolMilligrams, (value) => asNumber(value, `${at$}.cholesterolMilligrams`));
+  const sodiumMilligrams = optional(object.sodiumMilligrams, (value) => asNumber(value, `${at$}.sodiumMilligrams`));
+  const potassiumMilligrams = optional(object.potassiumMilligrams, (value) => asNumber(value, `${at$}.potassiumMilligrams`));
+  const calciumMilligrams = optional(object.calciumMilligrams, (value) => asNumber(value, `${at$}.calciumMilligrams`));
+  const ironMilligrams = optional(object.ironMilligrams, (value) => asNumber(value, `${at$}.ironMilligrams`));
+  const magnesiumMilligrams = optional(object.magnesiumMilligrams, (value) => asNumber(value, `${at$}.magnesiumMilligrams`));
+  const zincMilligrams = optional(object.zincMilligrams, (value) => asNumber(value, `${at$}.zincMilligrams`));
+  const waterLiters = optional(object.waterLiters, (value) => asNumber(value, `${at$}.waterLiters`));
+  const caffeineMilligrams = optional(object.caffeineMilligrams, (value) => asNumber(value, `${at$}.caffeineMilligrams`));
+  const vitaminAMicrograms = optional(object.vitaminAMicrograms, (value) => asNumber(value, `${at$}.vitaminAMicrograms`));
+  const vitaminCMilligrams = optional(object.vitaminCMilligrams, (value) => asNumber(value, `${at$}.vitaminCMilligrams`));
+  const vitaminDMicrograms = optional(object.vitaminDMicrograms, (value) => asNumber(value, `${at$}.vitaminDMicrograms`));
+  const vitaminEMilligrams = optional(object.vitaminEMilligrams, (value) => asNumber(value, `${at$}.vitaminEMilligrams`));
+  const vitaminKMicrograms = optional(object.vitaminKMicrograms, (value) => asNumber(value, `${at$}.vitaminKMicrograms`));
+  const vitaminB6Milligrams = optional(object.vitaminB6Milligrams, (value) => asNumber(value, `${at$}.vitaminB6Milligrams`));
+  const vitaminB12Micrograms = optional(object.vitaminB12Micrograms, (value) => asNumber(value, `${at$}.vitaminB12Micrograms`));
+  const folateMicrograms = optional(object.folateMicrograms, (value) => asNumber(value, `${at$}.folateMicrograms`));
+  const thiaminMilligrams = optional(object.thiaminMilligrams, (value) => asNumber(value, `${at$}.thiaminMilligrams`));
+  const riboflavinMilligrams = optional(object.riboflavinMilligrams, (value) => asNumber(value, `${at$}.riboflavinMilligrams`));
+  const niacinMilligrams = optional(object.niacinMilligrams, (value) => asNumber(value, `${at$}.niacinMilligrams`));
+  const biotinMicrograms = optional(object.biotinMicrograms, (value) => asNumber(value, `${at$}.biotinMicrograms`));
+  const pantothenicAcidMilligrams = optional(object.pantothenicAcidMilligrams, (value) => asNumber(value, `${at$}.pantothenicAcidMilligrams`));
+  const phosphorusMilligrams = optional(object.phosphorusMilligrams, (value) => asNumber(value, `${at$}.phosphorusMilligrams`));
+  const iodineMicrograms = optional(object.iodineMicrograms, (value) => asNumber(value, `${at$}.iodineMicrograms`));
+  const chromiumMicrograms = optional(object.chromiumMicrograms, (value) => asNumber(value, `${at$}.chromiumMicrograms`));
+  const copperMilligrams = optional(object.copperMilligrams, (value) => asNumber(value, `${at$}.copperMilligrams`));
+  const manganeseMilligrams = optional(object.manganeseMilligrams, (value) => asNumber(value, `${at$}.manganeseMilligrams`));
+  const molybdenumMicrograms = optional(object.molybdenumMicrograms, (value) => asNumber(value, `${at$}.molybdenumMicrograms`));
+  const seleniumMicrograms = optional(object.seleniumMicrograms, (value) => asNumber(value, `${at$}.seleniumMicrograms`));
+  const chlorideMilligrams = optional(object.chlorideMilligrams, (value) => asNumber(value, `${at$}.chlorideMilligrams`));
+  return { energyKilocalories, proteinGrams, carbohydratesGrams, fiberGrams, sugarGrams, fatTotalGrams, fatSaturatedGrams, fatMonounsaturatedGrams, fatPolyunsaturatedGrams, cholesterolMilligrams, sodiumMilligrams, potassiumMilligrams, calciumMilligrams, ironMilligrams, magnesiumMilligrams, zincMilligrams, waterLiters, caffeineMilligrams, vitaminAMicrograms, vitaminCMilligrams, vitaminDMicrograms, vitaminEMilligrams, vitaminKMicrograms, vitaminB6Milligrams, vitaminB12Micrograms, folateMicrograms, thiaminMilligrams, riboflavinMilligrams, niacinMilligrams, biotinMicrograms, pantothenicAcidMilligrams, phosphorusMilligrams, iodineMicrograms, chromiumMicrograms, copperMilligrams, manganeseMilligrams, molybdenumMicrograms, seleniumMicrograms, chlorideMilligrams };
+}
+
+export function encodeNutritionEntry(value: NutritionEntry): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.start = encodeInstant(value.start);
+  out.end = encodeInstant(value.end);
+  if (value.name !== undefined) out.name = value.name;
+  out.nutrients = encodeNutrients(value.nutrients);
+  if (value.recordId !== undefined) out.recordId = value.recordId;
+  return out;
+}
+
+export function decodeNutritionEntry(raw: unknown, at$ = "NutritionEntry"): NutritionEntry {
+  const object = asObject(raw, at$);
+  const start = decodeInstant(object.start, `${at$}.start`);
+  const end = decodeInstant(object.end, `${at$}.end`);
+  const name = optional(object.name, (value) => asString(value, `${at$}.name`));
+  const nutrients = decodeNutrients(object.nutrients, `${at$}.nutrients`);
+  const recordId = optional(object.recordId, (value) => asString(value, `${at$}.recordId`));
+  return { start, end, name, nutrients, recordId };
+}
+
+export function encodeTerraErrorPayload(value: TerraErrorPayload): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.code = value.code;
+  out.retryable = value.retryable;
+  out.message = value.message;
+  if (value.source !== undefined) out.source = value.source;
+  if (value.details !== undefined) out.details = value.details;
+  return out;
+}
+
+export function decodeTerraErrorPayload(raw: unknown, at$ = "TerraErrorPayload"): TerraErrorPayload {
+  const object = asObject(raw, at$);
+  const code = asString(object.code, `${at$}.code`);
+  const retryable = asBoolean(object.retryable, `${at$}.retryable`);
+  const message = asString(object.message, `${at$}.message`);
+  const source = optional(object.source, (value) => asSource(value, `${at$}.source`));
+  const details = optional(object.details, (value) => asObject(value, `${at$}.details`));
+  return { code, retryable, message, source, details };
+}
+
+export function encodePlannedWorkout(value: PlannedWorkout): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.id = value.id;
+  out.plannedOn = value.plannedOn;
+  out.activity = encodeWorkoutActivity(value.activity);
+  if (value.title !== undefined) out.title = value.title;
+  if (value.completedAt !== undefined) out.completedAt = encodeInstant(value.completedAt);
+  return out;
+}
+
+export function decodePlannedWorkout(raw: unknown, at$ = "PlannedWorkout"): PlannedWorkout {
+  const object = asObject(raw, at$);
+  const id = asString(object.id, `${at$}.id`);
+  const plannedOn = asString(object.plannedOn, `${at$}.plannedOn`);
+  const activity = decodeWorkoutActivity(object.activity, `${at$}.activity`);
+  const title = optional(object.title, (value) => asString(value, `${at$}.title`));
+  const completedAt = optional(object.completedAt, (value) => decodeInstant(value, `${at$}.completedAt`));
+  return { id, plannedOn, activity, title, completedAt };
+}
+
+export function encodeTerraEvent(value: TerraEvent): Record<string, unknown> {
+  return value;
+}
+
+export function decodeTerraEvent(raw: unknown, at$ = "TerraEvent"): TerraEvent {
+  const object = asObject(raw, at$);
+  if (!(typeof object["at"] === "string")) {
+    throw new TypeError(`${at$}: at is not a string`);
+  }
+  if (!(typeof object["event"] === "string")) {
+    throw new TypeError(`${at$}: event is not a string`);
+  }
+  return object;
+}
+
+export function encodeSupportReport(value: SupportReport): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.sdkVersion = value.sdkVersion;
+  out.generatedAt = encodeInstant(value.generatedAt);
+  out.state = encodeDiagnosticsState(value.state);
+  if (value.lastDelivery !== undefined) out.lastDelivery = encodeInstant(value.lastDelivery);
+  out.isConnected = value.isConnected;
+  out.requestedCategories = value.requestedCategories;
+  out.requestedWrites = value.requestedWrites;
+  out.requestedWorkouts = value.requestedWorkouts;
+  out.recentEvents = value.recentEvents.map((item) => encodeTerraEvent(item));
+  return out;
+}
+
+export function decodeSupportReport(raw: unknown, at$ = "SupportReport"): SupportReport {
+  const object = asObject(raw, at$);
+  const sdkVersion = asString(object.sdkVersion, `${at$}.sdkVersion`);
+  const generatedAt = decodeInstant(object.generatedAt, `${at$}.generatedAt`);
+  const state = decodeDiagnosticsState(object.state, `${at$}.state`);
+  const lastDelivery = optional(object.lastDelivery, (value) => decodeInstant(value, `${at$}.lastDelivery`));
+  const isConnected = asBoolean(object.isConnected, `${at$}.isConnected`);
+  const requestedCategories = asArray(object.requestedCategories, `${at$}.requestedCategories`).map((item, index) => asString(item, `${`${at$}.requestedCategories`}[${index}]`));
+  const requestedWrites = asArray(object.requestedWrites, `${at$}.requestedWrites`).map((item, index) => asString(item, `${`${at$}.requestedWrites`}[${index}]`));
+  const requestedWorkouts = asArray(object.requestedWorkouts, `${at$}.requestedWorkouts`).map((item, index) => asString(item, `${`${at$}.requestedWorkouts`}[${index}]`));
+  const recentEvents = asArray(object.recentEvents, `${at$}.recentEvents`).map((item, index) => decodeTerraEvent(item, `${`${at$}.recentEvents`}[${index}]`));
+  return { sdkVersion, generatedAt, state, lastDelivery, isConnected, requestedCategories, requestedWrites, requestedWorkouts, recentEvents };
+}
+
+export function encodeBootstrapState(value: BootstrapState): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.bootstrapped = value.bootstrapped;
+  if (value.devId !== undefined) out.devId = value.devId;
+  out.platform = value.platform;
+  out.sdkVersion = value.sdkVersion;
+  out.backgroundRegistered = value.backgroundRegistered;
+  return out;
+}
+
+export function decodeBootstrapState(raw: unknown, at$ = "BootstrapState"): BootstrapState {
+  const object = asObject(raw, at$);
+  const bootstrapped = asBoolean(object.bootstrapped, `${at$}.bootstrapped`);
+  const devId = optional(object.devId, (value) => asString(value, `${at$}.devId`));
+  const platform = asString(object.platform, `${at$}.platform`);
+  const sdkVersion = asString(object.sdkVersion, `${at$}.sdkVersion`);
+  const backgroundRegistered = asBoolean(object.backgroundRegistered, `${at$}.backgroundRegistered`);
+  return { bootstrapped, devId, platform, sdkVersion, backgroundRegistered };
+}
+
+export function encodeTokenRequest(value: TokenRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.requestId = value.requestId;
+  return out;
+}
+
+export function decodeTokenRequest(raw: unknown, at$ = "TokenRequest"): TokenRequest {
+  const object = asObject(raw, at$);
+  const requestId = asString(object.requestId, `${at$}.requestId`);
+  return { requestId };
+}
+
+export function encodeEmpty(_value: Empty): Record<string, unknown> {
+  return {};
+}
+
+export function decodeEmpty(raw: unknown, at$ = "Empty"): Empty {
+  asObject(raw, at$);
+  return {} as never;
+}
+
+export function encodeSourceRequest(value: SourceRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (value.source !== undefined) out.source = value.source;
+  return out;
+}
+
+export function decodeSourceRequest(raw: unknown, at$ = "SourceRequest"): SourceRequest {
+  const object = asObject(raw, at$);
+  const source = optional(object.source, (value) => asSource(value, `${at$}.source`));
+  return { source };
+}
+
+export function encodeRangeRequest(value: RangeRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.range = encodeTimeRange(value.range);
+  return out;
+}
+
+export function decodeRangeRequest(raw: unknown, at$ = "RangeRequest"): RangeRequest {
+  const object = asObject(raw, at$);
+  const range = decodeTimeRange(object.range, `${at$}.range`);
+  return { range };
+}
+
+export function encodeCategoryRequest(value: CategoryRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.category = value.category;
+  if (value.source !== undefined) out.source = value.source;
+  return out;
+}
+
+export function decodeCategoryRequest(raw: unknown, at$ = "CategoryRequest"): CategoryRequest {
+  const object = asObject(raw, at$);
+  const category = asDataCategory(object.category, `${at$}.category`);
+  const source = optional(object.source, (value) => asSource(value, `${at$}.source`));
+  return { category, source };
+}
+
+export function encodeRecordIdRequest(value: RecordIdRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.id = value.id;
+  return out;
+}
+
+export function decodeRecordIdRequest(raw: unknown, at$ = "RecordIdRequest"): RecordIdRequest {
+  const object = asObject(raw, at$);
+  const id = asString(object.id, `${at$}.id`);
+  return { id };
+}
+
+export function encodeConnectRequest(value: ConnectRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (value.source !== undefined) out.source = value.source;
+  out.endUser = encodeEndUser(value.endUser);
+  if (value.token !== undefined) out.token = value.token;
+  return out;
+}
+
+export function decodeConnectRequest(raw: unknown, at$ = "ConnectRequest"): ConnectRequest {
+  const object = asObject(raw, at$);
+  const source = optional(object.source, (value) => asSource(value, `${at$}.source`));
+  const endUser = decodeEndUser(object.endUser, `${at$}.endUser`);
+  const token = optional(object.token, (value) => asString(value, `${at$}.token`));
+  return { source, endUser, token };
+}
+
+export function encodePermissionRequest(value: PermissionRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.read = caseSet(value.read);
+  out.write = caseSet(value.write);
+  out.workouts = value.workouts.map((item) => encodeWorkoutScope(item));
+  if (value.source !== undefined) out.source = value.source;
+  return out;
+}
+
+export function decodePermissionRequest(raw: unknown, at$ = "PermissionRequest"): PermissionRequest {
+  const object = asObject(raw, at$);
+  const read = caseSet(asArray(object.read, `${at$}.read`).map((item, index) => asDataCategory(item, `${`${at$}.read`}[${index}]`)));
+  const write = caseSet(asArray(object.write, `${at$}.write`).map((item, index) => asDataCategory(item, `${`${at$}.write`}[${index}]`)));
+  const workouts = asArray(object.workouts, `${at$}.workouts`).map((item, index) => decodeWorkoutScope(item, `${`${at$}.workouts`}[${index}]`));
+  const source = optional(object.source, (value) => asSource(value, `${at$}.source`));
+  return { read, write, workouts, source };
+}
+
+export function encodePermissionGrant(value: PermissionGrant): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (value.granted !== undefined) out.granted = encodeHealthAccess(value.granted);
+  return out;
+}
+
+export function decodePermissionGrant(raw: unknown, at$ = "PermissionGrant"): PermissionGrant {
+  const object = asObject(raw, at$);
+  const granted = optional(object.granted, (value) => decodeHealthAccess(value, `${at$}.granted`));
+  return { granted };
+}
+
+export function encodeTokenResolveRequest(value: TokenResolveRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.requestId = value.requestId;
+  out.token = value.token;
+  return out;
+}
+
+export function decodeTokenResolveRequest(raw: unknown, at$ = "TokenResolveRequest"): TokenResolveRequest {
+  const object = asObject(raw, at$);
+  const requestId = asString(object.requestId, `${at$}.requestId`);
+  const token = asString(object.token, `${at$}.token`);
+  return { requestId, token };
+}
+
+export function encodeTokenRejectRequest(value: TokenRejectRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.requestId = value.requestId;
+  out.message = value.message;
+  return out;
+}
+
+export function decodeTokenRejectRequest(raw: unknown, at$ = "TokenRejectRequest"): TokenRejectRequest {
+  const object = asObject(raw, at$);
+  const requestId = asString(object.requestId, `${at$}.requestId`);
+  const message = asString(object.message, `${at$}.message`);
+  return { requestId, message };
+}
+
+export function encodeTokenProviderRequest(value: TokenProviderRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.present = value.present;
+  out.timeoutMs = value.timeoutMs;
+  return out;
+}
+
+export function decodeTokenProviderRequest(raw: unknown, at$ = "TokenProviderRequest"): TokenProviderRequest {
+  const object = asObject(raw, at$);
+  const present = asBoolean(object.present, `${at$}.present`);
+  const timeoutMs = asInteger(object.timeoutMs, `${at$}.timeoutMs`);
+  return { present, timeoutMs };
+}
+
+export function encodeMarkCompleteRequest(value: MarkCompleteRequest): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.id = value.id;
+  if (value.at !== undefined) out.at = encodeInstant(value.at);
+  return out;
+}
+
+export function decodeMarkCompleteRequest(raw: unknown, at$ = "MarkCompleteRequest"): MarkCompleteRequest {
+  const object = asObject(raw, at$);
+  const id = asString(object.id, `${at$}.id`);
+  const at = optional(object.at, (value) => decodeInstant(value, `${at$}.at`));
+  return { id, at };
+}
+
+export function encodeBoolResult(value: BoolResult): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.value = value.value;
+  return out;
+}
+
+export function decodeBoolResult(raw: unknown, at$ = "BoolResult"): BoolResult {
+  const object = asObject(raw, at$);
+  const value = asBoolean(object.value, `${at$}.value`);
+  return { value };
+}
+
+export function encodeStatusResult(value: StatusResult): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.status = value.status;
+  return out;
+}
+
+export function decodeStatusResult(raw: unknown, at$ = "StatusResult"): StatusResult {
+  const object = asObject(raw, at$);
+  const status = asPermissionStatus(object.status, `${at$}.status`);
+  return { status };
+}
+
+export function encodeStatusesResult(value: StatusesResult): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.statuses = value.statuses;
+  return out;
+}
+
+export function decodeStatusesResult(raw: unknown, at$ = "StatusesResult"): StatusesResult {
+  const object = asObject(raw, at$);
+  const statuses = Object.fromEntries(Object.entries(asObject(object.statuses, `${at$}.statuses`)).map(([key, item]) => [asDataCategory(key, `${at$}.statuses`), asPermissionStatus(item, `${at$}.statuses`)])) as never;
+  return { statuses };
+}
+
+export function encodeRecordIdList(value: RecordIdList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.ids = value.ids;
+  return out;
+}
+
+export function decodeRecordIdList(raw: unknown, at$ = "RecordIdList"): RecordIdList {
+  const object = asObject(raw, at$);
+  const ids = asArray(object.ids, `${at$}.ids`).map((item, index) => asString(item, `${`${at$}.ids`}[${index}]`));
+  return { ids };
+}
+
+export function encodeConnectionList(value: ConnectionList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.connections = value.connections.map((item) => encodeConnection(item));
+  return out;
+}
+
+export function decodeConnectionList(raw: unknown, at$ = "ConnectionList"): ConnectionList {
+  const object = asObject(raw, at$);
+  const connections = asArray(object.connections, `${at$}.connections`).map((item, index) => decodeConnection(item, `${`${at$}.connections`}[${index}]`));
+  return { connections };
+}
+
+export function encodeHeartRateList(value: HeartRateList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.samples = value.samples.map((item) => encodeHeartRateSample(item));
+  return out;
+}
+
+export function decodeHeartRateList(raw: unknown, at$ = "HeartRateList"): HeartRateList {
+  const object = asObject(raw, at$);
+  const samples = asArray(object.samples, `${at$}.samples`).map((item, index) => decodeHeartRateSample(item, `${`${at$}.samples`}[${index}]`));
+  return { samples };
+}
+
+export function encodeStepCountList(value: StepCountList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.samples = value.samples.map((item) => encodeStepCount(item));
+  return out;
+}
+
+export function decodeStepCountList(raw: unknown, at$ = "StepCountList"): StepCountList {
+  const object = asObject(raw, at$);
+  const samples = asArray(object.samples, `${at$}.samples`).map((item, index) => decodeStepCount(item, `${`${at$}.samples`}[${index}]`));
+  return { samples };
+}
+
+export function encodeSleepSegmentList(value: SleepSegmentList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.samples = value.samples.map((item) => encodeSleepSegment(item));
+  return out;
+}
+
+export function decodeSleepSegmentList(raw: unknown, at$ = "SleepSegmentList"): SleepSegmentList {
+  const object = asObject(raw, at$);
+  const samples = asArray(object.samples, `${at$}.samples`).map((item, index) => decodeSleepSegment(item, `${`${at$}.samples`}[${index}]`));
+  return { samples };
+}
+
+export function encodeWorkoutList(value: WorkoutList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.samples = value.samples.map((item) => encodeWorkout(item));
+  return out;
+}
+
+export function decodeWorkoutList(raw: unknown, at$ = "WorkoutList"): WorkoutList {
+  const object = asObject(raw, at$);
+  const samples = asArray(object.samples, `${at$}.samples`).map((item, index) => decodeWorkout(item, `${`${at$}.samples`}[${index}]`));
+  return { samples };
+}
+
+export function encodePlannedWorkoutList(value: PlannedWorkoutList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.workouts = value.workouts.map((item) => encodePlannedWorkout(item));
+  return out;
+}
+
+export function decodePlannedWorkoutList(raw: unknown, at$ = "PlannedWorkoutList"): PlannedWorkoutList {
+  const object = asObject(raw, at$);
+  const workouts = asArray(object.workouts, `${at$}.workouts`).map((item, index) => decodePlannedWorkout(item, `${`${at$}.workouts`}[${index}]`));
+  return { workouts };
+}
+
+export function encodeWorkoutScheduling(value: WorkoutScheduling): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.status = value.status;
+  return out;
+}
+
+export function decodeWorkoutScheduling(raw: unknown, at$ = "WorkoutScheduling"): WorkoutScheduling {
+  const object = asObject(raw, at$);
+  const status = asWorkoutSchedulingStatus(object.status, `${at$}.status`);
+  return { status };
+}
+
+export function encodeLastDeliveryResult(value: LastDeliveryResult): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (value.at !== undefined) out.at = encodeInstant(value.at);
+  return out;
+}
+
+export function decodeLastDeliveryResult(raw: unknown, at$ = "LastDeliveryResult"): LastDeliveryResult {
+  const object = asObject(raw, at$);
+  const at = optional(object.at, (value) => decodeInstant(value, `${at$}.at`));
+  return { at };
+}
+
+export function encodeHeartRateEntryList(value: HeartRateEntryList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.entries = value.entries.map((item) => encodeHeartRateEntry(item));
+  return out;
+}
+
+export function decodeHeartRateEntryList(raw: unknown, at$ = "HeartRateEntryList"): HeartRateEntryList {
+  const object = asObject(raw, at$);
+  const entries = asArray(object.entries, `${at$}.entries`).map((item, index) => decodeHeartRateEntry(item, `${`${at$}.entries`}[${index}]`));
+  return { entries };
+}
+
+export function encodeBodyEntryList(value: BodyEntryList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.entries = value.entries.map((item) => encodeBodyEntry(item));
+  return out;
+}
+
+export function decodeBodyEntryList(raw: unknown, at$ = "BodyEntryList"): BodyEntryList {
+  const object = asObject(raw, at$);
+  const entries = asArray(object.entries, `${at$}.entries`).map((item, index) => decodeBodyEntry(item, `${`${at$}.entries`}[${index}]`));
+  return { entries };
+}
+
+export function encodeStepEntryList(value: StepEntryList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.entries = value.entries.map((item) => encodeStepEntry(item));
+  return out;
+}
+
+export function decodeStepEntryList(raw: unknown, at$ = "StepEntryList"): StepEntryList {
+  const object = asObject(raw, at$);
+  const entries = asArray(object.entries, `${at$}.entries`).map((item, index) => decodeStepEntry(item, `${`${at$}.entries`}[${index}]`));
+  return { entries };
+}
+
+export function encodeSleepEntryList(value: SleepEntryList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.entries = value.entries.map((item) => encodeSleepEntry(item));
+  return out;
+}
+
+export function decodeSleepEntryList(raw: unknown, at$ = "SleepEntryList"): SleepEntryList {
+  const object = asObject(raw, at$);
+  const entries = asArray(object.entries, `${at$}.entries`).map((item, index) => decodeSleepEntry(item, `${`${at$}.entries`}[${index}]`));
+  return { entries };
+}
+
+export function encodeWorkoutEntryList(value: WorkoutEntryList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.entries = value.entries.map((item) => encodeWorkoutEntry(item));
+  return out;
+}
+
+export function decodeWorkoutEntryList(raw: unknown, at$ = "WorkoutEntryList"): WorkoutEntryList {
+  const object = asObject(raw, at$);
+  const entries = asArray(object.entries, `${at$}.entries`).map((item, index) => decodeWorkoutEntry(item, `${`${at$}.entries`}[${index}]`));
+  return { entries };
+}
+
+export function encodeNutritionEntryList(value: NutritionEntryList): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  out.entries = value.entries.map((item) => encodeNutritionEntry(item));
+  return out;
+}
+
+export function decodeNutritionEntryList(raw: unknown, at$ = "NutritionEntryList"): NutritionEntryList {
+  const object = asObject(raw, at$);
+  const entries = asArray(object.entries, `${at$}.entries`).map((item, index) => decodeNutritionEntry(item, `${`${at$}.entries`}[${index}]`));
+  return { entries };
+}
+
+export function encodeEndUser(value: EndUser): Record<string, unknown> {
+  switch (value.kind) {
+    case "reference":
+      return { kind: "reference", id: value.id };
+    case "anonymous":
+      return { kind: "anonymous" };
+  }
+}
+
+export function decodeEndUser(raw: unknown, at$ = "EndUser"): EndUser {
+  const object = asObject(raw, at$);
+  const tag = object.kind;
+  switch (tag) {
+    case "reference": {
+      return { kind: "reference", id: asString(object.id, `${at$}.id`) };
+    }
+    case "anonymous": {
+      return { kind: "anonymous" };
+    }
+    default:
+      throw new TypeError(`${at$}: unknown kind ${String(tag)}`);
+  }
+}
+
+export function encodeTimeRange(value: TimeRange): Record<string, unknown> {
+  switch (value.kind) {
+    case "lastHours":
+      return { kind: "lastHours", hours: value.hours };
+    case "lastDays":
+      return { kind: "lastDays", days: value.days };
+    case "today":
+      return { kind: "today" };
+    case "between":
+      return { kind: "between", start: encodeInstant(value.start), end: encodeInstant(value.end) };
+  }
+}
+
+export function decodeTimeRange(raw: unknown, at$ = "TimeRange"): TimeRange {
+  const object = asObject(raw, at$);
+  const tag = object.kind;
+  switch (tag) {
+    case "lastHours": {
+      return { kind: "lastHours", hours: asInteger(object.hours, `${at$}.hours`) };
+    }
+    case "lastDays": {
+      return { kind: "lastDays", days: asInteger(object.days, `${at$}.days`) };
+    }
+    case "today": {
+      return { kind: "today" };
+    }
+    case "between": {
+      return { kind: "between", start: decodeInstant(object.start, `${at$}.start`), end: decodeInstant(object.end, `${at$}.end`) };
+    }
+    default:
+      throw new TypeError(`${at$}: unknown kind ${String(tag)}`);
+  }
+}
+
+export function encodeSleepStage(value: SleepStage): Record<string, unknown> {
+  switch (value.kind) {
+    case "inBed":
+      return { kind: "inBed" };
+    case "awake":
+      return { kind: "awake" };
+    case "asleep":
+      return { kind: "asleep" };
+    case "light":
+      return { kind: "light" };
+    case "deep":
+      return { kind: "deep" };
+    case "rem":
+      return { kind: "rem" };
+    case "unknown":
+      return { kind: "unknown", raw: value.raw };
+  }
+}
+
+export function decodeSleepStage(raw: unknown, at$ = "SleepStage"): SleepStage {
+  const object = asObject(raw, at$);
+  const tag = object.kind;
+  switch (tag) {
+    case "inBed": {
+      return { kind: "inBed" };
+    }
+    case "awake": {
+      return { kind: "awake" };
+    }
+    case "asleep": {
+      return { kind: "asleep" };
+    }
+    case "light": {
+      return { kind: "light" };
+    }
+    case "deep": {
+      return { kind: "deep" };
+    }
+    case "rem": {
+      return { kind: "rem" };
+    }
+    case "unknown": {
+      return { kind: "unknown", raw: asString(object.raw, `${at$}.raw`) };
+    }
+    default:
+      if (typeof tag === "string") return { kind: "unknown", raw: tag };
+      throw new TypeError(`${at$}: unknown kind ${String(tag)}`);
+  }
+}
+
+export function encodeWorkoutActivity(value: WorkoutActivity): Record<string, unknown> {
+  switch (value.kind) {
+    case "running":
+      return { kind: "running" };
+    case "walking":
+      return { kind: "walking" };
+    case "cycling":
+      return { kind: "cycling" };
+    case "swimming":
+      return { kind: "swimming" };
+    case "strengthTraining":
+      return { kind: "strengthTraining" };
+    case "other":
+      return { kind: "other", label: value.label };
+  }
+}
+
+export function decodeWorkoutActivity(raw: unknown, at$ = "WorkoutActivity"): WorkoutActivity {
+  const object = asObject(raw, at$);
+  const tag = object.kind;
+  switch (tag) {
+    case "running": {
+      return { kind: "running" };
+    }
+    case "walking": {
+      return { kind: "walking" };
+    }
+    case "cycling": {
+      return { kind: "cycling" };
+    }
+    case "swimming": {
+      return { kind: "swimming" };
+    }
+    case "strengthTraining": {
+      return { kind: "strengthTraining" };
+    }
+    case "other": {
+      return { kind: "other", label: asString(object.label, `${at$}.label`) };
+    }
+    default:
+      if (typeof tag === "string") return { kind: "other", label: tag };
+      throw new TypeError(`${at$}: unknown kind ${String(tag)}`);
+  }
+}
+
+export function encodeDiagnosticsState(value: DiagnosticsState): Record<string, unknown> {
+  switch (value.state) {
+    case "healthy":
+      return { state: "healthy" };
+    case "quiet":
+      return { state: "quiet", since: encodeInstant(value.since) };
+    case "backgroundRestricted":
+      return { state: "backgroundRestricted", reason: value.reason };
+    case "backgroundRefreshUnscheduled":
+      return { state: "backgroundRefreshUnscheduled" };
+    case "pendingRetry":
+      return { state: "pendingRetry" };
+    case "linkRevoked":
+      return { state: "linkRevoked" };
+    case "devIDMismatch":
+      return { state: "devIDMismatch" };
+  }
+}
+
+export function decodeDiagnosticsState(raw: unknown, at$ = "DiagnosticsState"): DiagnosticsState {
+  const object = asObject(raw, at$);
+  const tag = object.state;
+  switch (tag) {
+    case "healthy": {
+      return { state: "healthy" };
+    }
+    case "quiet": {
+      return { state: "quiet", since: decodeInstant(object.since, `${at$}.since`) };
+    }
+    case "backgroundRestricted": {
+      return { state: "backgroundRestricted", reason: optional(object.reason, (value) => asBackgroundRestrictionReason(value, `${at$}.reason`)) };
+    }
+    case "backgroundRefreshUnscheduled": {
+      return { state: "backgroundRefreshUnscheduled" };
+    }
+    case "pendingRetry": {
+      return { state: "pendingRetry" };
+    }
+    case "linkRevoked": {
+      return { state: "linkRevoked" };
+    }
+    case "devIDMismatch": {
+      return { state: "devIDMismatch" };
+    }
+    default:
+      throw new TypeError(`${at$}: unknown state ${String(tag)}`);
+  }
+}
+
+export function encodeStreamMessage(value: StreamMessage): Record<string, unknown> {
+  switch (value.kind) {
+    case "data":
+      return { kind: "data", element: value.element };
+    case "error":
+      return { kind: "error", error: encodeTerraErrorPayload(value.error) };
+    case "complete":
+      return { kind: "complete" };
+  }
+}
+
+export function decodeStreamMessage(raw: unknown, at$ = "StreamMessage"): StreamMessage {
+  const object = asObject(raw, at$);
+  const tag = object.kind;
+  switch (tag) {
+    case "data": {
+      return { kind: "data", element: asObject(object.element, `${at$}.element`) };
+    }
+    case "error": {
+      return { kind: "error", error: decodeTerraErrorPayload(object.error, `${at$}.error`) };
+    }
+    case "complete": {
+      return { kind: "complete" };
+    }
+    default:
+      throw new TypeError(`${at$}: unknown kind ${String(tag)}`);
+  }
+}
+