@tryterra/react-native 0.0.0-stage → 2.2.1

package/ios/TerraBridgeCore/Generated/BridgeTypes.swift

@@ -0,0 +1,2050 @@
+// Generated from surface/terra-surface.json by surface/gen. Do not edit by hand.
+// Regenerate with: node surface/gen/src/cli.ts generate
+
+import Foundation
+
+/// The one spelling of an instant on the wire: UTC, and always exactly three fractional digits.
+///
+/// `.iso8601` is not it. `ISO8601DateFormatter` without `.withFractionalSeconds` drops the
+/// sub-second part, and HealthKit stores sub-second, so a round trip through the bridge would
+/// silently move every sample to the nearest whole second. Three digits rather than however many
+/// the source had, so that the same instant produces the same bytes in Swift, Kotlin and
+/// JavaScript - which is what lets a vector be compared rather than interpreted.
+public enum BridgeInstant {
+    /// `ISO8601DateFormatter` is not `Sendable`, and building one per call is not free on a read
+    /// of a month of samples. One pair behind a lock is the cheap end of correct here.
+    private final class Formatters: @unchecked Sendable {
+        let lock = NSLock()
+        let withFraction = ISO8601DateFormatter()
+        let withoutFraction = ISO8601DateFormatter()
+
+        init() {
+            withFraction.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+            withFraction.timeZone = TimeZone(secondsFromGMT: 0)
+            withoutFraction.formatOptions = [.withInternetDateTime]
+            withoutFraction.timeZone = TimeZone(secondsFromGMT: 0)
+        }
+    }
+
+    private static let formatters = Formatters()
+
+    public static func format(_ date: Date) -> String {
+        formatters.lock.lock()
+        defer { formatters.lock.unlock() }
+        return formatters.withFraction.string(from: date)
+    }
+
+    /// Tolerant on the way in: a peer that omitted the fractional part is still understood.
+    public static func parse(_ text: String) -> Date? {
+        formatters.lock.lock()
+        defer { formatters.lock.unlock() }
+        return formatters.withFraction.date(from: text) ?? formatters.withoutFraction.date(from: text)
+    }
+}
+
+/// A JSON value the bridge carries without interpreting: an error's detail bag, an event's payload.
+///
+/// The SDKs already encode those shapes, and re-describing them here would be a second opinion
+/// about a spelling `DiagnosticsWire` and Apple's `Encodable` already agree on.
+public struct BridgeJSON: Codable, Equatable, Sendable {
+    public let storage: [String: BridgeValue]
+    public init(_ storage: [String: BridgeValue]) { self.storage = storage }
+    public init(from decoder: any Decoder) throws {
+        storage = try decoder.singleValueContainer().decode([String: BridgeValue].self)
+    }
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(storage)
+    }
+}
+
+/// `indirect` because the cases hold `BridgeValue`: without it the enum has no finite size and
+/// the file does not compile.
+public indirect enum BridgeValue: Codable, Equatable, Sendable {
+    case string(String)
+    case number(Double)
+    case bool(Bool)
+    case array([BridgeValue])
+    case object([String: BridgeValue])
+    case null
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if container.decodeNil() { self = .null; return }
+        if let value = try? container.decode(Bool.self) { self = .bool(value); return }
+        if let value = try? container.decode(Double.self) { self = .number(value); return }
+        if let value = try? container.decode(String.self) { self = .string(value); return }
+        if let value = try? container.decode([BridgeValue].self) { self = .array(value); return }
+        self = .object(try container.decode([String: BridgeValue].self))
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case .string(let value): try container.encode(value)
+        case .number(let value): try container.encode(value)
+        case .bool(let value): try container.encode(value)
+        case .array(let value): try container.encode(value)
+        case .object(let value): try container.encode(value)
+        case .null: try container.encodeNil()
+        }
+    }
+}
+
+/// A list of enum cases that is a set on the wire: de-duplicated and sorted by wire spelling
+/// whenever it is stored, decoded or encoded, as the Kotlin and TypeScript codecs do.
+@propertyWrapper
+public struct CaseSet<Element: RawRepresentable & Codable & Hashable & Sendable>: Codable, Equatable, Sendable
+where Element.RawValue == String {
+    private var storage: [Element]
+
+    public var wrappedValue: [Element] {
+        get { storage }
+        set { storage = Self.canonical(newValue) }
+    }
+
+    public init(wrappedValue: [Element]) { storage = Self.canonical(wrappedValue) }
+
+    public init(from decoder: any Decoder) throws {
+        storage = Self.canonical(try decoder.singleValueContainer().decode([Element].self))
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(storage)
+    }
+
+    private static func canonical(_ value: [Element]) -> [Element] {
+        Array(Set(value)).sorted { $0.rawValue < $1.rawValue }
+    }
+}
+
+/// A health store the SDK can link. One connection per source per device.
+public enum Source: String, Codable, Sendable, CaseIterable {
+    case health = "health"
+    /// Samsung Health, through the terra-android-samsung add-on. Connect, disconnect, permissions
+    /// and diagnostics take it; reads, writes and change streams are Health Connect's.
+    ///
+    /// Available on android only.
+    case samsungHealth = "samsungHealth"
+}
+
+/// The unit permissions are asked for and changes are reported against.
+public enum DataCategory: String, Codable, Sendable, CaseIterable {
+    case activity = "activity"
+    case body = "body"
+    case daily = "daily"
+    case sleep = "sleep"
+    case nutrition = "nutrition"
+    /// Read-only on both platforms: menstruation.flow reads it and neither SDK has a write route
+    /// for it.
+    case menstruation = "menstruation"
+    /// HealthKit's characteristics; Health Connect has no counterpart.
+    ///
+    /// Available on ios only.
+    case athlete = "athlete"
+}
+
+public enum PermissionStatus: String, Codable, Sendable, CaseIterable {
+    case granted = "granted"
+    case denied = "denied"
+    case notDetermined = "notDetermined"
+    /// A read grant HealthKit will not report. Not an error: it is the documented answer for reads
+    /// on iOS.
+    case notDisclosed = "notDisclosed"
+    case unsupported = "unsupported"
+    /// Android answers unsupported where Apple would answer unavailable.
+    ///
+    /// Available on ios only.
+    case unavailable = "unavailable"
+}
+
+public enum MotionContext: String, Codable, Sendable, CaseIterable {
+    case unknown = "unknown"
+    case sedentary = "sedentary"
+    case active = "active"
+}
+
+/// On both platforms, wire names strip HKQuantityTypeIdentifierDietary from HealthKit
+/// identifiers and lowercase the first letter. Units: kcal for energyConsumed; grams for
+/// protein, carbohydrates, the four fats, sugar and fiber; milligrams for everything else,
+/// never micrograms.
+public enum Nutrient: String, Codable, Sendable, CaseIterable {
+    case energyConsumed = "energyConsumed"
+    case protein = "protein"
+    case carbohydrates = "carbohydrates"
+    case fatTotal = "fatTotal"
+    case fatSaturated = "fatSaturated"
+    case fatMonounsaturated = "fatMonounsaturated"
+    case fatPolyunsaturated = "fatPolyunsaturated"
+    case sugar = "sugar"
+    case fiber = "fiber"
+    case cholesterol = "cholesterol"
+    case sodium = "sodium"
+    case potassium = "potassium"
+    case calcium = "calcium"
+    case iron = "iron"
+    case magnesium = "magnesium"
+    case zinc = "zinc"
+    case phosphorus = "phosphorus"
+    case iodine = "iodine"
+    case manganese = "manganese"
+    case molybdenum = "molybdenum"
+    case selenium = "selenium"
+    case copper = "copper"
+    case chromium = "chromium"
+    case chloride = "chloride"
+    case caffeine = "caffeine"
+    case vitaminA = "vitaminA"
+    case vitaminC = "vitaminC"
+    case vitaminD = "vitaminD"
+    case vitaminE = "vitaminE"
+    case vitaminK = "vitaminK"
+    case vitaminB6 = "vitaminB6"
+    case vitaminB12 = "vitaminB12"
+    case thiamin = "thiamin"
+    case riboflavin = "riboflavin"
+    case niacin = "niacin"
+    case folate = "folate"
+    case biotin = "biotin"
+    case pantothenicAcid = "pantothenicAcid"
+}
+
+/// Which meal a quantity was logged against. unknown is the store's explicit answer, not an
+/// absence: HealthKit has no meal type at all, so every iOS quantity is unknown.
+public enum MealType: String, Codable, Sendable, CaseIterable {
+    case breakfast = "breakfast"
+    case lunch = "lunch"
+    case dinner = "dinner"
+    case snack = "snack"
+    case unknown = "unknown"
+}
+
+/// How heavy a logged day's flow was.
+public enum MenstruationFlow: String, Codable, Sendable, CaseIterable {
+    case unspecified = "unspecified"
+    case light = "light"
+    case medium = "medium"
+    case heavy = "heavy"
+    /// noFlow avoids ambiguity with Optional.none. Health Connect has no constant for it, so
+    /// Android never produces it.
+    case noFlow = "none"
+}
+
+/// Available on ios only.
+public enum BiologicalSex: String, Codable, Sendable, CaseIterable {
+    case female = "female"
+    case male = "male"
+    case other = "other"
+    /// The characteristic exists and holds no value, or reading it failed. The store's explicit
+    /// unknown.
+    case notSet = "notSet"
+}
+
+/// A move-time user's daily totals are minutes rather than active energy.
+///
+/// Available on ios only.
+public enum ActivityMoveMode: String, Codable, Sendable, CaseIterable {
+    case activeEnergy = "activeEnergy"
+    case appleMoveTime = "appleMoveTime"
+}
+
+/// Why background delivery is restricted. Android discloses which; Apple reports the state
+/// without a reason.
+///
+/// Available on android only.
+public enum BackgroundRestrictionReason: String, Codable, Sendable, CaseIterable {
+    case oemRestricted = "oemRestricted"
+    case backgroundReadDenied = "backgroundReadDenied"
+    case healthConnectFeatureUnavailable = "healthConnectFeatureUnavailable"
+    case storeFeatureUnavailable = "storeFeatureUnavailable"
+    case ticksNotRunning = "ticksNotRunning"
+}
+
+public enum DiagnosticsReason: String, Codable, Sendable, CaseIterable {
+    case uploadFailed = "uploadFailed"
+    case backfillAbandoned = "backfillAbandoned"
+    case backgroundObservationUnavailable = "backgroundObservationUnavailable"
+    case backgroundRestricted = "backgroundRestricted"
+    case backgroundRefreshUnscheduled = "backgroundRefreshUnscheduled"
+    case quiet = "quiet"
+    case requested = "requested"
+}
+
+public enum DeviceKeyRevokeOutcome: String, Codable, Sendable, CaseIterable {
+    case revoked = "revoked"
+    case alreadyRevoked = "alreadyRevoked"
+    case routeAbsent = "routeAbsent"
+}
+
+/// The redacted error name an event carries. Deliberately not TerraErrorCode: an event names
+/// the failure without the detail bag, because a support report leaves the device.
+public enum FailureCode: String, Codable, Sendable, CaseIterable {
+    case healthDataUnavailable = "healthDataUnavailable"
+    case notConnected = "notConnected"
+    case tokenUnavailable = "tokenUnavailable"
+    case tokenRejected = "tokenRejected"
+    case tokenProviderFailed = "tokenProviderFailed"
+    case offline = "offline"
+    case timedOut = "timedOut"
+    case serverError = "serverError"
+    case transport = "transport"
+    case malformedResponse = "malformedResponse"
+    case userLimitReached = "userLimitReached"
+    case upgradeRequired = "upgradeRequired"
+    case platform = "platform"
+    case deviceKeyUnavailable = "deviceKeyUnavailable"
+    case signatureRejected = "signatureRejected"
+    case linkRevoked = "linkRevoked"
+    case linkConflict = "linkConflict"
+    case clockSkewed = "clockSkewed"
+    case devIDMismatch = "devIDMismatch"
+    case syncAlreadyRunning = "syncAlreadyRunning"
+    case linkAlreadyRunning = "linkAlreadyRunning"
+    case storeLocked = "storeLocked"
+    case storeUnreadable = "storeUnreadable"
+    case deadlineExceeded = "deadlineExceeded"
+    case permissionDenied = "permissionDenied"
+    case authorizationNotDetermined = "authorizationNotDetermined"
+    case sampleNotFound = "sampleNotFound"
+    case rollbackIncomplete = "rollbackIncomplete"
+    case distanceNotAttributable = "distanceNotAttributable"
+    case bloodPressureIncomplete = "bloodPressureIncomplete"
+    case authorizationUnavailableInExtension = "authorizationUnavailableInExtension"
+    case routeAwaitingConverter = "routeAwaitingConverter"
+    /// Available on android only.
+    case readQuotaExceeded = "readQuotaExceeded"
+    /// Apple's FailureCode carries it; Android's does not, because there is no Android
+    /// planned-workout model.
+    ///
+    /// Available on ios only.
+    case plannedWorkoutUnnamed = "plannedWorkoutUnnamed"
+}
+
+/// Whether Terra's plans can be put on the person's Apple Watch. unsupported before iOS 17 or
+/// where WorkoutKit cannot schedule.
+///
+/// Available on ios only.
+public enum WorkoutSchedulingStatus: String, Codable, Sendable, CaseIterable {
+    case unsupported = "unsupported"
+    case notDetermined = "notDetermined"
+    case denied = "denied"
+    case authorized = "authorized"
+}
+
+/// distance* are metres, *EnergyBurned kilocalories, flightsClimbed a count, and
+/// appleExerciseTime minutes.
+public enum DayTotalMetric: String, Codable, Sendable, CaseIterable {
+    case distanceWalkingRunning = "distanceWalkingRunning"
+    /// Health Connect does not split distance by activity, so only Apple ever answers it.
+    case distanceCycling = "distanceCycling"
+    case distanceSwimming = "distanceSwimming"
+    case distanceWheelchair = "distanceWheelchair"
+    case activeEnergyBurned = "activeEnergyBurned"
+    case basalEnergyBurned = "basalEnergyBurned"
+    case flightsClimbed = "flightsClimbed"
+    /// The exercise ring, in minutes. Health Connect has no such figure: summing session durations
+    /// is a different number.
+    ///
+    /// Available on ios only.
+    case appleExerciseTime = "appleExerciseTime"
+}
+
+/// activeEnergy and basalEnergy are kilocalories, distance metres, floorsClimbed a count.
+public enum IntradayMetric: String, Codable, Sendable, CaseIterable {
+    case activeEnergy = "activeEnergy"
+    /// Health Connect has no basal energy record; its basal metabolic rate is a body measurement
+    /// and is not this.
+    ///
+    /// Available on ios only.
+    case basalEnergy = "basalEnergy"
+    case distance = "distance"
+    case floorsClimbed = "floorsClimbed"
+}
+
+/// speed is metres per second, power watts, cadence pedal revolutions per minute.
+public enum WorkoutIntensityMetric: String, Codable, Sendable, CaseIterable {
+    case speed = "speed"
+    case power = "power"
+    case cadence = "cadence"
+}
+
+/// The body composition figure a measurement carries. weight and leanBodyMass are kilograms,
+/// height centimetres, bodyFatPercentage a fraction in 0..1, bmi dimensionless.
+public enum BodyMetric: String, Codable, Sendable, CaseIterable {
+    case weight = "weight"
+    case height = "height"
+    case bodyFatPercentage = "bodyFatPercentage"
+    case leanBodyMass = "leanBodyMass"
+    /// Health Connect has no BMI record.
+    ///
+    /// Available on ios only.
+    case bmi = "bmi"
+}
+
+/// The unit the writing app chose. Never converted on the device.
+public enum BloodGlucoseUnit: String, Codable, Sendable, CaseIterable {
+    case milligramsPerDecilitre = "mg/dL"
+    case millimolesPerLitre = "mmol/L"
+}
+
+/// unknown is the store saying nothing about the meal, distinct from absent.
+public enum GlucoseMealTime: String, Codable, Sendable, CaseIterable {
+    case preprandial = "preprandial"
+    case postprandial = "postprandial"
+    case unknown = "unknown"
+}
+
+/// interstitial is a continuous monitor.
+public enum GlucoseSpecimen: String, Codable, Sendable, CaseIterable {
+    case capillary = "capillary"
+    case interstitial = "interstitial"
+    case plasma = "plasma"
+    case serum = "serum"
+    case tears = "tears"
+    case wholeBlood = "wholeBlood"
+    case unknown = "unknown"
+}
+
+/// body and basal are absolute; wrist and skin are deltas from a baseline and routinely
+/// negative.
+public enum BodyTemperatureMetric: String, Codable, Sendable, CaseIterable {
+    case body = "body"
+    case basal = "basal"
+    /// HealthKit's sleeping wrist temperature. Health Connect has no such record.
+    ///
+    /// Available on ios only.
+    case wrist = "wrist"
+    case skin = "skin"
+}
+
+/// HealthKit records SDNN only and Health Connect RMSSD only; they are never one series.
+public enum HeartRateVariabilityMetric: String, Codable, Sendable, CaseIterable {
+    case sdnn = "sdnn"
+    case rmssd = "rmssd"
+}
+
+public enum VO2MaxTestType: String, Codable, Sendable, CaseIterable {
+    case maxExercise = "maxExercise"
+    case predictedSubMaxExercise = "predictedSubMaxExercise"
+    case predictedNonExercise = "predictedNonExercise"
+}
+
+public enum MenstrualEventKind: String, Codable, Sendable, CaseIterable {
+    case intermenstrualBleeding = "intermenstrualBleeding"
+    case ovulationTest = "ovulationTest"
+    case cervicalMucus = "cervicalMucus"
+}
+
+/// A `CodingKey` over a plain string, for the dictionary-key conformances below.
+public struct StringCodingKey: CodingKey {
+    public let stringValue: String
+    public var intValue: Int? { nil }
+    public init(_ value: String) { stringValue = value }
+    public init?(stringValue: String) { self.stringValue = stringValue }
+    public init?(intValue: Int) { return nil }
+}
+
+/// So that a `[DataCategory: T]` encodes as a JSON object rather than an alternating array.
+extension DataCategory: CodingKeyRepresentable {
+    public var codingKey: any CodingKey { StringCodingKey(rawValue) }
+    public init?<T: CodingKey>(codingKey: T) {
+        self.init(rawValue: codingKey.stringValue)
+    }
+}
+
+/// The person a connect is for. A stored link is restored only for the person it was made for;
+/// anybody else gets a fresh link. Never sent to Terra as identity.
+public enum EndUser: Codable, Equatable, Sendable {
+    case reference(id: String)
+    case anonymous
+
+    private enum CodingKeys: String, CodingKey {
+        case kind
+        case id
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let tag = try container.decode(String.self, forKey: .kind)
+        switch tag {
+        case "reference":
+            let id = try container.decode(String.self, forKey: .id)
+            self = .reference(id: id)
+        case "anonymous":
+            self = .anonymous
+        default:
+            throw DecodingError.dataCorruptedError(forKey: .kind, in: container, debugDescription: "unknown EndUser \(tag)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .reference(let id):
+            try container.encode("reference", forKey: .kind)
+            try container.encode(id, forKey: .id)
+        case .anonymous:
+            try container.encode("anonymous", forKey: .kind)
+        }
+    }
+}
+
+/// A half-open window [start, end). Resolved against the device's calendar natively.
+public enum TimeRange: Codable, Equatable, Sendable {
+    case lastHours(hours: Int)
+    case lastDays(days: Int)
+    case today
+    case between(start: String, end: String)
+
+    private enum CodingKeys: String, CodingKey {
+        case kind
+        case hours
+        case days
+        case start
+        case end
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let tag = try container.decode(String.self, forKey: .kind)
+        switch tag {
+        case "lastHours":
+            let hours = try container.decode(Int.self, forKey: .hours)
+            self = .lastHours(hours: hours)
+        case "lastDays":
+            let days = try container.decode(Int.self, forKey: .days)
+            self = .lastDays(days: days)
+        case "today":
+            self = .today
+        case "between":
+            let start = try container.decode(String.self, forKey: .start)
+            let end = try container.decode(String.self, forKey: .end)
+            self = .between(start: start, end: end)
+        default:
+            throw DecodingError.dataCorruptedError(forKey: .kind, in: container, debugDescription: "unknown TimeRange \(tag)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .lastHours(let hours):
+            try container.encode("lastHours", forKey: .kind)
+            try container.encode(hours, forKey: .hours)
+        case .lastDays(let days):
+            try container.encode("lastDays", forKey: .kind)
+            try container.encode(days, forKey: .days)
+        case .today:
+            try container.encode("today", forKey: .kind)
+        case .between(let start, let end):
+            try container.encode("between", forKey: .kind)
+            try container.encode(start, forKey: .start)
+            try container.encode(end, forKey: .end)
+        }
+    }
+}
+
+public enum SleepStage: Codable, Equatable, Sendable {
+    case inBed
+    case awake
+    case asleep
+    case light
+    case deep
+    case rem
+    case unknown(raw: String)
+
+    private enum CodingKeys: String, CodingKey {
+        case kind
+        case raw
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let tag = try container.decode(String.self, forKey: .kind)
+        switch tag {
+        case "inBed":
+            self = .inBed
+        case "awake":
+            self = .awake
+        case "asleep":
+            self = .asleep
+        case "light":
+            self = .light
+        case "deep":
+            self = .deep
+        case "rem":
+            self = .rem
+        case "unknown":
+            let raw = try container.decode(String.self, forKey: .raw)
+            self = .unknown(raw: raw)
+        default:
+            throw DecodingError.dataCorruptedError(forKey: .kind, in: container, debugDescription: "unknown SleepStage \(tag)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .inBed:
+            try container.encode("inBed", forKey: .kind)
+        case .awake:
+            try container.encode("awake", forKey: .kind)
+        case .asleep:
+            try container.encode("asleep", forKey: .kind)
+        case .light:
+            try container.encode("light", forKey: .kind)
+        case .deep:
+            try container.encode("deep", forKey: .kind)
+        case .rem:
+            try container.encode("rem", forKey: .kind)
+        case .unknown(let raw):
+            try container.encode("unknown", forKey: .kind)
+            try container.encode(raw, forKey: .raw)
+        }
+    }
+}
+
+public enum WorkoutActivity: Codable, Equatable, Sendable {
+    case running
+    case walking
+    case cycling
+    case swimming
+    case strengthTraining
+    case other(label: String)
+
+    private enum CodingKeys: String, CodingKey {
+        case kind
+        case label
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let tag = try container.decode(String.self, forKey: .kind)
+        switch tag {
+        case "running":
+            self = .running
+        case "walking":
+            self = .walking
+        case "cycling":
+            self = .cycling
+        case "swimming":
+            self = .swimming
+        case "strengthTraining":
+            self = .strengthTraining
+        case "other":
+            let label = try container.decode(String.self, forKey: .label)
+            self = .other(label: label)
+        default:
+            throw DecodingError.dataCorruptedError(forKey: .kind, in: container, debugDescription: "unknown WorkoutActivity \(tag)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .running:
+            try container.encode("running", forKey: .kind)
+        case .walking:
+            try container.encode("walking", forKey: .kind)
+        case .cycling:
+            try container.encode("cycling", forKey: .kind)
+        case .swimming:
+            try container.encode("swimming", forKey: .kind)
+        case .strengthTraining:
+            try container.encode("strengthTraining", forKey: .kind)
+        case .other(let label):
+            try container.encode("other", forKey: .kind)
+            try container.encode(label, forKey: .label)
+        }
+    }
+}
+
+/// What the SDK believes about delivery right now. Wire spelling matches DiagnosticsWire.state
+/// and Apple's DiagnosticsState Encodable.
+public enum DiagnosticsState: Codable, Equatable, Sendable {
+    case healthy
+    case quiet(since: String)
+    case backgroundRestricted(reason: BackgroundRestrictionReason?)
+    case backgroundRefreshUnscheduled
+    case pendingRetry
+    case linkRevoked
+    case devIDMismatch
+
+    private enum CodingKeys: String, CodingKey {
+        case state
+        case since
+        case reason
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let tag = try container.decode(String.self, forKey: .state)
+        switch tag {
+        case "healthy":
+            self = .healthy
+        case "quiet":
+            let since = try container.decode(String.self, forKey: .since)
+            self = .quiet(since: since)
+        case "backgroundRestricted":
+            let reason = try container.decodeIfPresent(BackgroundRestrictionReason.self, forKey: .reason)
+            self = .backgroundRestricted(reason: reason)
+        case "backgroundRefreshUnscheduled":
+            self = .backgroundRefreshUnscheduled
+        case "pendingRetry":
+            self = .pendingRetry
+        case "linkRevoked":
+            self = .linkRevoked
+        case "devIDMismatch":
+            self = .devIDMismatch
+        default:
+            throw DecodingError.dataCorruptedError(forKey: .state, in: container, debugDescription: "unknown DiagnosticsState \(tag)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .healthy:
+            try container.encode("healthy", forKey: .state)
+        case .quiet(let since):
+            try container.encode("quiet", forKey: .state)
+            try container.encode(since, forKey: .since)
+        case .backgroundRestricted(let reason):
+            try container.encode("backgroundRestricted", forKey: .state)
+            try container.encodeIfPresent(reason, forKey: .reason)
+        case .backgroundRefreshUnscheduled:
+            try container.encode("backgroundRefreshUnscheduled", forKey: .state)
+        case .pendingRetry:
+            try container.encode("pendingRetry", forKey: .state)
+        case .linkRevoked:
+            try container.encode("linkRevoked", forKey: .state)
+        case .devIDMismatch:
+            try container.encode("devIDMismatch", forKey: .state)
+        }
+    }
+}
+
+/// What a subscription delivers. A stream can fail or finish, and without saying so the
+/// framework layer has to invent a convention for both - two of those, one per wrapper, is a
+/// contract nobody wrote down.
+public enum StreamMessage: Codable, Equatable, Sendable {
+    case data(element: BridgeJSON)
+    case error(error: TerraErrorPayload)
+    case complete
+
+    private enum CodingKeys: String, CodingKey {
+        case kind
+        case element
+        case error
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let tag = try container.decode(String.self, forKey: .kind)
+        switch tag {
+        case "data":
+            let element = try container.decode(BridgeJSON.self, forKey: .element)
+            self = .data(element: element)
+        case "error":
+            let error = try container.decode(TerraErrorPayload.self, forKey: .error)
+            self = .error(error: error)
+        case "complete":
+            self = .complete
+        default:
+            throw DecodingError.dataCorruptedError(forKey: .kind, in: container, debugDescription: "unknown StreamMessage \(tag)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .data(let element):
+            try container.encode("data", forKey: .kind)
+            try container.encode(element, forKey: .element)
+        case .error(let error):
+            try container.encode("error", forKey: .kind)
+            try container.encode(error, forKey: .error)
+        case .complete:
+            try container.encode("complete", forKey: .kind)
+        }
+    }
+}
+
+/// What a BodyReading measured, with the unit fixed by the variant. Blood glucose alone keeps
+/// the writer's unit.
+public enum BodyReadingKind: Codable, Equatable, Sendable {
+    case measurement(metric: BodyMetric, value: Double)
+    case bloodPressure(systolic: Double, diastolic: Double)
+    case bloodGlucose(value: Double, unit: BloodGlucoseUnit, mealTime: GlucoseMealTime?, specimen: GlucoseSpecimen?)
+    case oxygenSaturation(fraction: Double)
+    case temperature(metric: BodyTemperatureMetric, celsius: Double)
+    case heartRateVariability(metric: HeartRateVariabilityMetric, milliseconds: Double)
+    case respiratoryRate(breathsPerMinute: Double)
+    case vo2Max(millilitresPerKilogramMinute: Double, testType: VO2MaxTestType?)
+
+    private enum CodingKeys: String, CodingKey {
+        case type
+        case metric
+        case value
+        case systolic
+        case diastolic
+        case unit
+        case mealTime
+        case specimen
+        case fraction
+        case celsius
+        case milliseconds
+        case breathsPerMinute
+        case millilitresPerKilogramMinute
+        case testType
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let tag = try container.decode(String.self, forKey: .type)
+        switch tag {
+        case "measurement":
+            let metric = try container.decode(BodyMetric.self, forKey: .metric)
+            let value = try container.decode(Double.self, forKey: .value)
+            self = .measurement(metric: metric, value: value)
+        case "bloodPressure":
+            let systolic = try container.decode(Double.self, forKey: .systolic)
+            let diastolic = try container.decode(Double.self, forKey: .diastolic)
+            self = .bloodPressure(systolic: systolic, diastolic: diastolic)
+        case "bloodGlucose":
+            let value = try container.decode(Double.self, forKey: .value)
+            let unit = try container.decode(BloodGlucoseUnit.self, forKey: .unit)
+            let mealTime = try container.decodeIfPresent(GlucoseMealTime.self, forKey: .mealTime)
+            let specimen = try container.decodeIfPresent(GlucoseSpecimen.self, forKey: .specimen)
+            self = .bloodGlucose(value: value, unit: unit, mealTime: mealTime, specimen: specimen)
+        case "oxygenSaturation":
+            let fraction = try container.decode(Double.self, forKey: .fraction)
+            self = .oxygenSaturation(fraction: fraction)
+        case "temperature":
+            let metric = try container.decode(BodyTemperatureMetric.self, forKey: .metric)
+            let celsius = try container.decode(Double.self, forKey: .celsius)
+            self = .temperature(metric: metric, celsius: celsius)
+        case "heartRateVariability":
+            let metric = try container.decode(HeartRateVariabilityMetric.self, forKey: .metric)
+            let milliseconds = try container.decode(Double.self, forKey: .milliseconds)
+            self = .heartRateVariability(metric: metric, milliseconds: milliseconds)
+        case "respiratoryRate":
+            let breathsPerMinute = try container.decode(Double.self, forKey: .breathsPerMinute)
+            self = .respiratoryRate(breathsPerMinute: breathsPerMinute)
+        case "vo2Max":
+            let millilitresPerKilogramMinute = try container.decode(Double.self, forKey: .millilitresPerKilogramMinute)
+            let testType = try container.decodeIfPresent(VO2MaxTestType.self, forKey: .testType)
+            self = .vo2Max(millilitresPerKilogramMinute: millilitresPerKilogramMinute, testType: testType)
+        default:
+            throw DecodingError.dataCorruptedError(forKey: .type, in: container, debugDescription: "unknown BodyReadingKind \(tag)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .measurement(let metric, let value):
+            try container.encode("measurement", forKey: .type)
+            try container.encode(metric, forKey: .metric)
+            try container.encode(value, forKey: .value)
+        case .bloodPressure(let systolic, let diastolic):
+            try container.encode("bloodPressure", forKey: .type)
+            try container.encode(systolic, forKey: .systolic)
+            try container.encode(diastolic, forKey: .diastolic)
+        case .bloodGlucose(let value, let unit, let mealTime, let specimen):
+            try container.encode("bloodGlucose", forKey: .type)
+            try container.encode(value, forKey: .value)
+            try container.encode(unit, forKey: .unit)
+            try container.encodeIfPresent(mealTime, forKey: .mealTime)
+            try container.encodeIfPresent(specimen, forKey: .specimen)
+        case .oxygenSaturation(let fraction):
+            try container.encode("oxygenSaturation", forKey: .type)
+            try container.encode(fraction, forKey: .fraction)
+        case .temperature(let metric, let celsius):
+            try container.encode("temperature", forKey: .type)
+            try container.encode(metric, forKey: .metric)
+            try container.encode(celsius, forKey: .celsius)
+        case .heartRateVariability(let metric, let milliseconds):
+            try container.encode("heartRateVariability", forKey: .type)
+            try container.encode(metric, forKey: .metric)
+            try container.encode(milliseconds, forKey: .milliseconds)
+        case .respiratoryRate(let breathsPerMinute):
+            try container.encode("respiratoryRate", forKey: .type)
+            try container.encode(breathsPerMinute, forKey: .breathsPerMinute)
+        case .vo2Max(let millilitresPerKilogramMinute, let testType):
+            try container.encode("vo2Max", forKey: .type)
+            try container.encode(millilitresPerKilogramMinute, forKey: .millilitresPerKilogramMinute)
+            try container.encodeIfPresent(testType, forKey: .testType)
+        }
+    }
+}
+
+/// Apple's store is part of the OS, so it is there or the device cannot have it; Health Connect
+/// is an app a person can lack.
+public enum StoreAvailability: Codable, Equatable, Sendable {
+    case available
+    case unsupportedDevice
+    case providerAppMissing
+    case providerAppTooOld(installed: String)
+    case moduleMissing
+    case partnerPolicyMissing
+    case featureUnavailable
+
+    private enum CodingKeys: String, CodingKey {
+        case kind
+        case installed
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let tag = try container.decode(String.self, forKey: .kind)
+        switch tag {
+        case "available":
+            self = .available
+        case "unsupportedDevice":
+            self = .unsupportedDevice
+        case "providerAppMissing":
+            self = .providerAppMissing
+        case "providerAppTooOld":
+            let installed = try container.decode(String.self, forKey: .installed)
+            self = .providerAppTooOld(installed: installed)
+        case "moduleMissing":
+            self = .moduleMissing
+        case "partnerPolicyMissing":
+            self = .partnerPolicyMissing
+        case "featureUnavailable":
+            self = .featureUnavailable
+        default:
+            throw DecodingError.dataCorruptedError(forKey: .kind, in: container, debugDescription: "unknown StoreAvailability \(tag)")
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .available:
+            try container.encode("available", forKey: .kind)
+        case .unsupportedDevice:
+            try container.encode("unsupportedDevice", forKey: .kind)
+        case .providerAppMissing:
+            try container.encode("providerAppMissing", forKey: .kind)
+        case .providerAppTooOld(let installed):
+            try container.encode("providerAppTooOld", forKey: .kind)
+            try container.encode(installed, forKey: .installed)
+        case .moduleMissing:
+            try container.encode("moduleMissing", forKey: .kind)
+        case .partnerPolicyMissing:
+            try container.encode("partnerPolicyMissing", forKey: .kind)
+        case .featureUnavailable:
+            try container.encode("featureUnavailable", forKey: .kind)
+        }
+    }
+}
+
+/// Who recorded a sample. The only stable handle an app has for filtering by app or device.
+public struct SampleSource: Codable, Equatable, Sendable {
+    public var name: String
+    public var bundleId: String
+    public var productType: String?
+    public var deviceType: String?
+
+    public init(name: String, bundleId: String, productType: String? = nil, deviceType: String? = nil) {
+        self.name = name
+        self.bundleId = bundleId
+        self.productType = productType
+        self.deviceType = deviceType
+    }
+}
+
+/// A link record. A value, not a handle: Apple's Connection carries sync and disconnect
+/// methods, and an object with behaviour cannot cross the bridge, so those are ops on the
+/// client.
+public struct Connection: Codable, Equatable, Sendable {
+    public var source: Source
+    public var userId: String
+    /// Android's StoredConnection carries the store-side id. Apple's Connection does not.
+    ///
+    /// Available on android only.
+    public var providerUserId: String?
+
+    public init(source: Source, userId: String, providerUserId: String? = nil) {
+        self.source = source
+        self.userId = userId
+        self.providerUserId = providerUserId
+    }
+}
+
+public struct HeartRateSample: Codable, Equatable, Sendable {
+    public var id: String
+    public var time: String
+    public var beatsPerMinute: Double
+    public var source: SampleSource
+    public var motionContext: MotionContext?
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, time: String, beatsPerMinute: Double, source: SampleSource, motionContext: MotionContext? = nil, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.time = time
+        self.beatsPerMinute = beatsPerMinute
+        self.source = source
+        self.motionContext = motionContext
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+/// A step total over an interval. Apple derives the id from the source and start; Android
+/// carries a RecordId when it has one, so the id is optional on the wire.
+public struct StepCount: Codable, Equatable, Sendable {
+    public var id: String?
+    public var start: String
+    public var end: String
+    public var steps: Int
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String? = nil, start: String, end: String, steps: Int, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.start = start
+        self.end = end
+        self.steps = steps
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+public struct SleepSegment: Codable, Equatable, Sendable {
+    public var id: String
+    public var start: String
+    public var end: String
+    public var stage: SleepStage
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, start: String, end: String, stage: SleepStage, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.start = start
+        self.end = end
+        self.stage = stage
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+/// indoor is optional because Health Connect does not always record it; Apple always has an
+/// answer.
+public struct Workout: Codable, Equatable, Sendable {
+    public var id: String
+    public var start: String
+    public var end: String
+    public var activity: WorkoutActivity
+    public var activityTypeCode: Int
+    public var indoor: Bool?
+    public var activeEnergyKilocalories: Double?
+    public var distanceMeters: Double?
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+    /// ExerciseSessionRecord.title on Android; HKMetadataKeyWorkoutBrandName on Apple, which has no
+    /// title field.
+    public var title: String?
+
+    public init(id: String, start: String, end: String, activity: WorkoutActivity, activityTypeCode: Int, indoor: Bool? = nil, activeEnergyKilocalories: Double? = nil, distanceMeters: Double? = nil, source: SampleSource, userEntered: Bool, timeZone: String? = nil, title: String? = nil) {
+        self.id = id
+        self.start = start
+        self.end = end
+        self.activity = activity
+        self.activityTypeCode = activityTypeCode
+        self.indoor = indoor
+        self.activeEnergyKilocalories = activeEnergyKilocalories
+        self.distanceMeters = distanceMeters
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+        self.title = title
+    }
+}
+
+/// Quantities of one meal share foodCorrelationId.
+public struct DietaryQuantity: Codable, Equatable, Sendable {
+    public var id: String
+    public var nutrient: Nutrient
+    public var value: Double
+    public var start: String
+    public var end: String
+    public var mealType: MealType
+    public var name: String?
+    /// HealthKit's food correlation, absent for a loose quantity. Always set on Android, where it
+    /// is the NutritionRecord's id - the id nutrition.delete takes for a meal this app logged.
+    public var foodCorrelationId: String?
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, nutrient: Nutrient, value: Double, start: String, end: String, mealType: MealType, name: String? = nil, foodCorrelationId: String? = nil, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.nutrient = nutrient
+        self.value = value
+        self.start = start
+        self.end = end
+        self.mealType = mealType
+        self.name = name
+        self.foodCorrelationId = foodCorrelationId
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+/// start and end are the local midnights of that day in timeZone.
+public struct MenstruationFlowDay: Codable, Equatable, Sendable {
+    public var id: String
+    public var start: String
+    public var end: String
+    public var flow: MenstruationFlow
+    public var cycleStart: Bool
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, start: String, end: String, flow: MenstruationFlow, cycleStart: Bool, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.start = start
+        self.end = end
+        self.flow = flow
+        self.cycleStart = cycleStart
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+/// Available on ios only.
+public struct AthleteProfile: Codable, Equatable, Sendable {
+    public var biologicalSex: BiologicalSex
+    /// A calendar day, as HealthKit stores it, never an instant.
+    public var dateOfBirth: String?
+    public var wheelchairUse: Bool?
+    public var activityMoveMode: ActivityMoveMode?
+
+    public init(biologicalSex: BiologicalSex, dateOfBirth: String? = nil, wheelchairUse: Bool? = nil, activityMoveMode: ActivityMoveMode? = nil) {
+        self.biologicalSex = biologicalSex
+        self.dateOfBirth = dateOfBirth
+        self.wheelchairUse = wheelchairUse
+        self.activityMoveMode = activityMoveMode
+    }
+}
+
+/// A day whose data changed. Carries no health value by construction.
+public struct HealthChange: Codable, Equatable, Sendable {
+    public var category: DataCategory
+    public var day: String
+
+    public init(category: DataCategory, day: String) {
+        self.category = category
+        self.day = day
+    }
+}
+
+public struct WorkoutScope: Codable, Equatable, Sendable {
+    public var activity: WorkoutActivity
+    public var energy: Bool
+    public var distance: Bool
+
+    public init(activity: WorkoutActivity, energy: Bool, distance: Bool) {
+        self.activity = activity
+        self.energy = energy
+        self.distance = distance
+    }
+}
+
+/// Lists rather than sets: JSON has no set, so the category lists are marked `set` and every
+/// generated codec de-duplicates and sorts them, so two orderings compare equal.
+public struct HealthAccess: Codable, Equatable, Sendable {
+    @CaseSet public var read: [DataCategory]
+    @CaseSet public var write: [DataCategory]
+    public var workouts: [WorkoutScope]
+
+    public init(read: [DataCategory], write: [DataCategory], workouts: [WorkoutScope]) {
+        self.read = read
+        self.write = write
+        self.workouts = workouts
+    }
+}
+
+public struct HeartRateEntry: Codable, Equatable, Sendable {
+    public var time: String
+    public var beatsPerMinute: Double
+    public var recordId: String?
+
+    public init(time: String, beatsPerMinute: Double, recordId: String? = nil) {
+        self.time = time
+        self.beatsPerMinute = beatsPerMinute
+        self.recordId = recordId
+    }
+}
+
+public struct StepEntry: Codable, Equatable, Sendable {
+    public var start: String
+    public var end: String
+    public var steps: Int
+    public var recordId: String?
+
+    public init(start: String, end: String, steps: Int, recordId: String? = nil) {
+        self.start = start
+        self.end = end
+        self.steps = steps
+        self.recordId = recordId
+    }
+}
+
+public struct SleepEntry: Codable, Equatable, Sendable {
+    public var start: String
+    public var end: String
+    public var stage: SleepStage
+    public var recordId: String?
+
+    public init(start: String, end: String, stage: SleepStage, recordId: String? = nil) {
+        self.start = start
+        self.end = end
+        self.stage = stage
+        self.recordId = recordId
+    }
+}
+
+public struct WorkoutEntry: Codable, Equatable, Sendable {
+    public var start: String
+    public var end: String
+    public var activity: WorkoutActivity
+    public var totalEnergyKilocalories: Double?
+    public var totalDistanceMeters: Double?
+    public var recordId: String?
+
+    public init(start: String, end: String, activity: WorkoutActivity, totalEnergyKilocalories: Double? = nil, totalDistanceMeters: Double? = nil, recordId: String? = nil) {
+        self.start = start
+        self.end = end
+        self.activity = activity
+        self.totalEnergyKilocalories = totalEnergyKilocalories
+        self.totalDistanceMeters = totalDistanceMeters
+        self.recordId = recordId
+    }
+}
+
+public struct BodyEntry: Codable, Equatable, Sendable {
+    public var time: String
+    public var bodyMassKilograms: Double?
+    public var bodyFatPercent: Double?
+    public var bodyMassIndex: Double?
+    public var heightMeters: Double?
+    public var leanBodyMassKilograms: Double?
+    public var bodyTemperatureCelsius: Double?
+    public var oxygenSaturationPercent: Double?
+    public var bloodGlucoseMilligramsPerDeciliter: Double?
+    public var bloodPressureSystolicMillimetersOfMercury: Double?
+    public var bloodPressureDiastolicMillimetersOfMercury: Double?
+    public var recordId: String?
+
+    public init(time: String, bodyMassKilograms: Double? = nil, bodyFatPercent: Double? = nil, bodyMassIndex: Double? = nil, heightMeters: Double? = nil, leanBodyMassKilograms: Double? = nil, bodyTemperatureCelsius: Double? = nil, oxygenSaturationPercent: Double? = nil, bloodGlucoseMilligramsPerDeciliter: Double? = nil, bloodPressureSystolicMillimetersOfMercury: Double? = nil, bloodPressureDiastolicMillimetersOfMercury: Double? = nil, recordId: String? = nil) {
+        self.time = time
+        self.bodyMassKilograms = bodyMassKilograms
+        self.bodyFatPercent = bodyFatPercent
+        self.bodyMassIndex = bodyMassIndex
+        self.heightMeters = heightMeters
+        self.leanBodyMassKilograms = leanBodyMassKilograms
+        self.bodyTemperatureCelsius = bodyTemperatureCelsius
+        self.oxygenSaturationPercent = oxygenSaturationPercent
+        self.bloodGlucoseMilligramsPerDeciliter = bloodGlucoseMilligramsPerDeciliter
+        self.bloodPressureSystolicMillimetersOfMercury = bloodPressureSystolicMillimetersOfMercury
+        self.bloodPressureDiastolicMillimetersOfMercury = bloodPressureDiastolicMillimetersOfMercury
+        self.recordId = recordId
+    }
+}
+
+/// Every field optional and every unit in the name, matching NutritionEntry.Nutrients on both
+/// platforms field for field.
+public struct Nutrients: Codable, Equatable, Sendable {
+    public var energyKilocalories: Double?
+    public var proteinGrams: Double?
+    public var carbohydratesGrams: Double?
+    public var fiberGrams: Double?
+    public var sugarGrams: Double?
+    public var fatTotalGrams: Double?
+    public var fatSaturatedGrams: Double?
+    public var fatMonounsaturatedGrams: Double?
+    public var fatPolyunsaturatedGrams: Double?
+    public var cholesterolMilligrams: Double?
+    public var sodiumMilligrams: Double?
+    public var potassiumMilligrams: Double?
+    public var calciumMilligrams: Double?
+    public var ironMilligrams: Double?
+    public var magnesiumMilligrams: Double?
+    public var zincMilligrams: Double?
+    public var waterLiters: Double?
+    public var caffeineMilligrams: Double?
+    public var vitaminAMicrograms: Double?
+    public var vitaminCMilligrams: Double?
+    public var vitaminDMicrograms: Double?
+    public var vitaminEMilligrams: Double?
+    public var vitaminKMicrograms: Double?
+    public var vitaminB6Milligrams: Double?
+    public var vitaminB12Micrograms: Double?
+    public var folateMicrograms: Double?
+    public var thiaminMilligrams: Double?
+    public var riboflavinMilligrams: Double?
+    public var niacinMilligrams: Double?
+    public var biotinMicrograms: Double?
+    public var pantothenicAcidMilligrams: Double?
+    public var phosphorusMilligrams: Double?
+    public var iodineMicrograms: Double?
+    public var chromiumMicrograms: Double?
+    public var copperMilligrams: Double?
+    public var manganeseMilligrams: Double?
+    public var molybdenumMicrograms: Double?
+    public var seleniumMicrograms: Double?
+    public var chlorideMilligrams: Double?
+
+    public init(energyKilocalories: Double? = nil, proteinGrams: Double? = nil, carbohydratesGrams: Double? = nil, fiberGrams: Double? = nil, sugarGrams: Double? = nil, fatTotalGrams: Double? = nil, fatSaturatedGrams: Double? = nil, fatMonounsaturatedGrams: Double? = nil, fatPolyunsaturatedGrams: Double? = nil, cholesterolMilligrams: Double? = nil, sodiumMilligrams: Double? = nil, potassiumMilligrams: Double? = nil, calciumMilligrams: Double? = nil, ironMilligrams: Double? = nil, magnesiumMilligrams: Double? = nil, zincMilligrams: Double? = nil, waterLiters: Double? = nil, caffeineMilligrams: Double? = nil, vitaminAMicrograms: Double? = nil, vitaminCMilligrams: Double? = nil, vitaminDMicrograms: Double? = nil, vitaminEMilligrams: Double? = nil, vitaminKMicrograms: Double? = nil, vitaminB6Milligrams: Double? = nil, vitaminB12Micrograms: Double? = nil, folateMicrograms: Double? = nil, thiaminMilligrams: Double? = nil, riboflavinMilligrams: Double? = nil, niacinMilligrams: Double? = nil, biotinMicrograms: Double? = nil, pantothenicAcidMilligrams: Double? = nil, phosphorusMilligrams: Double? = nil, iodineMicrograms: Double? = nil, chromiumMicrograms: Double? = nil, copperMilligrams: Double? = nil, manganeseMilligrams: Double? = nil, molybdenumMicrograms: Double? = nil, seleniumMicrograms: Double? = nil, chlorideMilligrams: Double? = nil) {
+        self.energyKilocalories = energyKilocalories
+        self.proteinGrams = proteinGrams
+        self.carbohydratesGrams = carbohydratesGrams
+        self.fiberGrams = fiberGrams
+        self.sugarGrams = sugarGrams
+        self.fatTotalGrams = fatTotalGrams
+        self.fatSaturatedGrams = fatSaturatedGrams
+        self.fatMonounsaturatedGrams = fatMonounsaturatedGrams
+        self.fatPolyunsaturatedGrams = fatPolyunsaturatedGrams
+        self.cholesterolMilligrams = cholesterolMilligrams
+        self.sodiumMilligrams = sodiumMilligrams
+        self.potassiumMilligrams = potassiumMilligrams
+        self.calciumMilligrams = calciumMilligrams
+        self.ironMilligrams = ironMilligrams
+        self.magnesiumMilligrams = magnesiumMilligrams
+        self.zincMilligrams = zincMilligrams
+        self.waterLiters = waterLiters
+        self.caffeineMilligrams = caffeineMilligrams
+        self.vitaminAMicrograms = vitaminAMicrograms
+        self.vitaminCMilligrams = vitaminCMilligrams
+        self.vitaminDMicrograms = vitaminDMicrograms
+        self.vitaminEMilligrams = vitaminEMilligrams
+        self.vitaminKMicrograms = vitaminKMicrograms
+        self.vitaminB6Milligrams = vitaminB6Milligrams
+        self.vitaminB12Micrograms = vitaminB12Micrograms
+        self.folateMicrograms = folateMicrograms
+        self.thiaminMilligrams = thiaminMilligrams
+        self.riboflavinMilligrams = riboflavinMilligrams
+        self.niacinMilligrams = niacinMilligrams
+        self.biotinMicrograms = biotinMicrograms
+        self.pantothenicAcidMilligrams = pantothenicAcidMilligrams
+        self.phosphorusMilligrams = phosphorusMilligrams
+        self.iodineMicrograms = iodineMicrograms
+        self.chromiumMicrograms = chromiumMicrograms
+        self.copperMilligrams = copperMilligrams
+        self.manganeseMilligrams = manganeseMilligrams
+        self.molybdenumMicrograms = molybdenumMicrograms
+        self.seleniumMicrograms = seleniumMicrograms
+        self.chlorideMilligrams = chlorideMilligrams
+    }
+}
+
+public struct NutritionEntry: Codable, Equatable, Sendable {
+    public var start: String
+    public var end: String
+    public var name: String?
+    public var nutrients: Nutrients
+    public var recordId: String?
+
+    public init(start: String, end: String, name: String? = nil, nutrients: Nutrients, recordId: String? = nil) {
+        self.start = start
+        self.end = end
+        self.name = name
+        self.nutrients = nutrients
+        self.recordId = recordId
+    }
+}
+
+/// An error carried as a value rather than thrown, inside a sync result. The same shape the
+/// bridge rejects a promise with.
+public struct TerraErrorPayload: Codable, Equatable, Sendable {
+    public var code: String
+    public var retryable: Bool
+    public var message: String
+    public var source: Source?
+    public var details: BridgeJSON?
+
+    public init(code: String, retryable: Bool, message: String, source: Source? = nil, details: BridgeJSON? = nil) {
+        self.code = code
+        self.retryable = retryable
+        self.message = message
+        self.source = source
+        self.details = details
+    }
+}
+
+/// Available on ios only.
+public struct PlannedWorkout: Codable, Equatable, Sendable {
+    public var id: String
+    public var plannedOn: String
+    public var activity: WorkoutActivity
+    public var title: String?
+    public var completedAt: String?
+
+    public init(id: String, plannedOn: String, activity: WorkoutActivity, title: String? = nil, completedAt: String? = nil) {
+        self.id = id
+        self.plannedOn = plannedOn
+        self.activity = activity
+        self.title = title
+        self.completedAt = completedAt
+    }
+}
+
+/// The flat object both SDKs already emit: `at`, `event`, and whatever keys that kind carries.
+/// Carried through unchanged rather than reshaped, because reshaping it would be a hand-written
+/// second contract on each platform that no vector could pin - and the encoding it would be
+/// translating is one DiagnosticsWire and Apple's Encodable already agree on, and that
+/// EventPrivacyTest already guards against carrying a health value.
+public typealias TerraEvent = BridgeJSON
+
+/// The redacted report, carried as the wire object DiagnosticsWire.report and Apple's
+/// SupportReport.json already produce.
+public struct SupportReport: Codable, Equatable, Sendable {
+    public var sdkVersion: String
+    public var generatedAt: String
+    public var state: DiagnosticsState
+    public var lastDelivery: String?
+    public var isConnected: Bool
+    public var requestedCategories: [String]
+    public var requestedWrites: [String]
+    public var requestedWorkouts: [String]
+    public var recentEvents: [TerraEvent]
+
+    public init(sdkVersion: String, generatedAt: String, state: DiagnosticsState, lastDelivery: String? = nil, isConnected: Bool, requestedCategories: [String], requestedWrites: [String], requestedWorkouts: [String], recentEvents: [TerraEvent]) {
+        self.sdkVersion = sdkVersion
+        self.generatedAt = generatedAt
+        self.state = state
+        self.lastDelivery = lastDelivery
+        self.isConnected = isConnected
+        self.requestedCategories = requestedCategories
+        self.requestedWrites = requestedWrites
+        self.requestedWorkouts = requestedWorkouts
+        self.recentEvents = recentEvents
+    }
+}
+
+/// What the JS side needs to know about the native client it is attaching to. bootstrapped
+/// false is a host setup bug, and the wrapper says so with the exact line to add.
+public struct BootstrapState: Codable, Equatable, Sendable {
+    public var bootstrapped: Bool
+    public var devId: String?
+    public var platform: String
+    public var sdkVersion: String
+    public var backgroundRegistered: Bool
+
+    public init(bootstrapped: Bool, devId: String? = nil, platform: String, sdkVersion: String, backgroundRegistered: Bool) {
+        self.bootstrapped = bootstrapped
+        self.devId = devId
+        self.platform = platform
+        self.sdkVersion = sdkVersion
+        self.backgroundRegistered = backgroundRegistered
+    }
+}
+
+/// The broker asking JS for a link token. Answered by token.resolve or token.reject with the
+/// same requestId.
+public struct TokenRequest: Codable, Equatable, Sendable {
+    public var requestId: String
+
+    public init(requestId: String) {
+        self.requestId = requestId
+    }
+}
+
+/// No request fields, or no response value.
+public struct Empty: Codable, Equatable, Sendable {
+    public init() {}
+}
+
+public struct SourceRequest: Codable, Equatable, Sendable {
+    public var source: Source?
+
+    public init(source: Source? = nil) {
+        self.source = source
+    }
+}
+
+public struct RangeRequest: Codable, Equatable, Sendable {
+    public var range: TimeRange
+
+    public init(range: TimeRange) {
+        self.range = range
+    }
+}
+
+public struct CategoryRequest: Codable, Equatable, Sendable {
+    public var category: DataCategory
+    public var source: Source?
+
+    public init(category: DataCategory, source: Source? = nil) {
+        self.category = category
+        self.source = source
+    }
+}
+
+public struct RecordIdRequest: Codable, Equatable, Sendable {
+    public var id: String
+
+    public init(id: String) {
+        self.id = id
+    }
+}
+
+public struct ConnectRequest: Codable, Equatable, Sendable {
+    public var source: Source?
+    public var endUser: EndUser
+    /// A grant already in hand, from a QR code or a deep link. Absent means the token provider is
+    /// asked.
+    public var token: String?
+
+    public init(source: Source? = nil, endUser: EndUser, token: String? = nil) {
+        self.source = source
+        self.endUser = endUser
+        self.token = token
+    }
+}
+
+public struct PermissionRequest: Codable, Equatable, Sendable {
+    @CaseSet public var read: [DataCategory]
+    @CaseSet public var write: [DataCategory]
+    public var workouts: [WorkoutScope]
+    public var source: Source?
+
+    public init(read: [DataCategory], write: [DataCategory], workouts: [WorkoutScope], source: Source? = nil) {
+        self.read = read
+        self.write = write
+        self.workouts = workouts
+        self.source = source
+    }
+}
+
+/// What the sheet granted. Android answers with the access this call obtained; HealthKit will
+/// not report read grants, so Apple answers nothing at all.
+public struct PermissionGrant: Codable, Equatable, Sendable {
+    /// Available on android only.
+    public var granted: HealthAccess?
+
+    public init(granted: HealthAccess? = nil) {
+        self.granted = granted
+    }
+}
+
+public struct TokenResolveRequest: Codable, Equatable, Sendable {
+    public var requestId: String
+    public var token: String
+
+    public init(requestId: String, token: String) {
+        self.requestId = requestId
+        self.token = token
+    }
+}
+
+public struct TokenRejectRequest: Codable, Equatable, Sendable {
+    public var requestId: String
+    public var message: String
+
+    public init(requestId: String, message: String) {
+        self.requestId = requestId
+        self.message = message
+    }
+}
+
+public struct TokenProviderRequest: Codable, Equatable, Sendable {
+    public var present: Bool
+    public var timeoutMs: Int
+
+    public init(present: Bool, timeoutMs: Int) {
+        self.present = present
+        self.timeoutMs = timeoutMs
+    }
+}
+
+/// Available on ios only.
+public struct MarkCompleteRequest: Codable, Equatable, Sendable {
+    public var id: String
+    public var at: String?
+
+    public init(id: String, at: String? = nil) {
+        self.id = id
+        self.at = at
+    }
+}
+
+public struct BoolResult: Codable, Equatable, Sendable {
+    public var value: Bool
+
+    public init(value: Bool) {
+        self.value = value
+    }
+}
+
+public struct StatusResult: Codable, Equatable, Sendable {
+    public var status: PermissionStatus
+
+    public init(status: PermissionStatus) {
+        self.status = status
+    }
+}
+
+/// Available on android only.
+public struct StatusesResult: Codable, Equatable, Sendable {
+    public var statuses: [DataCategory: PermissionStatus]?
+
+    public init(statuses: [DataCategory: PermissionStatus]? = nil) {
+        self.statuses = statuses
+    }
+}
+
+public struct RecordIdList: Codable, Equatable, Sendable {
+    public var ids: [String]
+
+    public init(ids: [String]) {
+        self.ids = ids
+    }
+}
+
+public struct ConnectionList: Codable, Equatable, Sendable {
+    public var connections: [Connection]
+
+    public init(connections: [Connection]) {
+        self.connections = connections
+    }
+}
+
+public struct HeartRateList: Codable, Equatable, Sendable {
+    public var samples: [HeartRateSample]
+
+    public init(samples: [HeartRateSample]) {
+        self.samples = samples
+    }
+}
+
+public struct StepCountList: Codable, Equatable, Sendable {
+    public var samples: [StepCount]
+
+    public init(samples: [StepCount]) {
+        self.samples = samples
+    }
+}
+
+public struct SleepSegmentList: Codable, Equatable, Sendable {
+    public var samples: [SleepSegment]
+
+    public init(samples: [SleepSegment]) {
+        self.samples = samples
+    }
+}
+
+public struct WorkoutList: Codable, Equatable, Sendable {
+    public var samples: [Workout]
+
+    public init(samples: [Workout]) {
+        self.samples = samples
+    }
+}
+
+public struct DietaryQuantityList: Codable, Equatable, Sendable {
+    public var samples: [DietaryQuantity]
+
+    public init(samples: [DietaryQuantity]) {
+        self.samples = samples
+    }
+}
+
+public struct MenstruationFlowDayList: Codable, Equatable, Sendable {
+    public var samples: [MenstruationFlowDay]
+
+    public init(samples: [MenstruationFlowDay]) {
+        self.samples = samples
+    }
+}
+
+/// A cycle event logged at an instant.
+public struct MenstrualEvent: Codable, Equatable, Sendable {
+    public var id: String
+    public var kind: MenstrualEventKind
+    public var time: String
+    /// ovulationTest: negative, positive, high, indeterminate or luteinizingHormoneSurge.
+    /// cervicalMucus: dry, sticky, creamy, watery, eggWhite or unusual. Absent for
+    /// intermenstrualBleeding, which is a flag.
+    public var value: String?
+    /// The store's own record type, passed through: OvulationTestRecord on Android,
+    /// HKCategoryTypeIdentifierOvulationTestResult on Apple.
+    public var storeIdentifier: String
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, kind: MenstrualEventKind, time: String, value: String? = nil, storeIdentifier: String, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.kind = kind
+        self.time = time
+        self.value = value
+        self.storeIdentifier = storeIdentifier
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+public struct MenstrualEventList: Codable, Equatable, Sendable {
+    public var samples: [MenstrualEvent]
+
+    public init(samples: [MenstrualEvent]) {
+        self.samples = samples
+    }
+}
+
+/// Available on ios only.
+public struct AthleteProfileResult: Codable, Equatable, Sendable {
+    public var profile: AthleteProfile?
+
+    public init(profile: AthleteProfile? = nil) {
+        self.profile = profile
+    }
+}
+
+/// Available on ios only.
+public struct PlannedWorkoutList: Codable, Equatable, Sendable {
+    public var workouts: [PlannedWorkout]
+
+    public init(workouts: [PlannedWorkout]) {
+        self.workouts = workouts
+    }
+}
+
+/// Once authorized, every sync run keeps the Watch schedule in step with Terra.
+///
+/// Available on ios only.
+public struct WorkoutScheduling: Codable, Equatable, Sendable {
+    public var status: WorkoutSchedulingStatus
+
+    public init(status: WorkoutSchedulingStatus) {
+        self.status = status
+    }
+}
+
+public struct LastDeliveryResult: Codable, Equatable, Sendable {
+    public var at: String?
+
+    public init(at: String? = nil) {
+        self.at = at
+    }
+}
+
+public struct HeartRateEntryList: Codable, Equatable, Sendable {
+    public var entries: [HeartRateEntry]
+
+    public init(entries: [HeartRateEntry]) {
+        self.entries = entries
+    }
+}
+
+public struct BodyEntryList: Codable, Equatable, Sendable {
+    public var entries: [BodyEntry]
+
+    public init(entries: [BodyEntry]) {
+        self.entries = entries
+    }
+}
+
+public struct StepEntryList: Codable, Equatable, Sendable {
+    public var entries: [StepEntry]
+
+    public init(entries: [StepEntry]) {
+        self.entries = entries
+    }
+}
+
+public struct SleepEntryList: Codable, Equatable, Sendable {
+    public var entries: [SleepEntry]
+
+    public init(entries: [SleepEntry]) {
+        self.entries = entries
+    }
+}
+
+public struct WorkoutEntryList: Codable, Equatable, Sendable {
+    public var entries: [WorkoutEntry]
+
+    public init(entries: [WorkoutEntry]) {
+        self.entries = entries
+    }
+}
+
+public struct NutritionEntryList: Codable, Equatable, Sendable {
+    public var entries: [NutritionEntry]
+
+    public init(entries: [NutritionEntry]) {
+        self.entries = entries
+    }
+}
+
+/// The store's own total for one local day, from its statistics engine. start and end are that
+/// day's midnights.
+public struct DayTotal: Codable, Equatable, Sendable {
+    public var metric: DayTotalMetric
+    public var start: String
+    public var end: String
+    public var value: Double
+    public var unit: String
+    public var timeZone: String?
+
+    public init(metric: DayTotalMetric, start: String, end: String, value: Double, unit: String, timeZone: String? = nil) {
+        self.metric = metric
+        self.start = start
+        self.end = end
+        self.value = value
+        self.unit = unit
+        self.timeZone = timeZone
+    }
+}
+
+/// One record a day total is made of, as the store holds it. A record crossing midnight is
+/// whole.
+public struct IntradaySample: Codable, Equatable, Sendable {
+    public var id: String
+    public var metric: IntradayMetric
+    public var start: String
+    public var end: String
+    public var value: Double
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, metric: IntradayMetric, start: String, end: String, value: Double, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.metric = metric
+        self.start = start
+        self.end = end
+        self.value = value
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+/// The store's own resting heart rate for a day, never derived from heart rate readings.
+public struct RestingHeartRateSample: Codable, Equatable, Sendable {
+    public var id: String
+    public var start: String
+    public var end: String
+    public var beatsPerMinute: Double
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, start: String, end: String, beatsPerMinute: Double, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.start = start
+        self.end = end
+        self.beatsPerMinute = beatsPerMinute
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+/// A point reading has start equal to end; skin and wrist temperature span a stretch.
+public struct BodyReading: Codable, Equatable, Sendable {
+    public var id: String
+    public var kind: BodyReadingKind
+    public var start: String
+    public var end: String
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, kind: BodyReadingKind, start: String, end: String, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.kind = kind
+        self.start = start
+        self.end = end
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+public struct RoutePoint: Codable, Equatable, Sendable {
+    public var time: String
+    public var latitude: Double
+    public var longitude: Double
+
+    public init(time: String, latitude: Double, longitude: Double) {
+        self.time = time
+        self.latitude = latitude
+        self.longitude = longitude
+    }
+}
+
+/// The GPS track a workout left, thinned to one point a second and at most 5,000 points. start
+/// and end are the first and last point.
+public struct WorkoutRoute: Codable, Equatable, Sendable {
+    public var id: String
+    public var workoutId: String
+    public var start: String
+    public var end: String
+    public var points: [RoutePoint]
+    public var source: SampleSource
+    public var timeZone: String?
+
+    public init(id: String, workoutId: String, start: String, end: String, points: [RoutePoint], source: SampleSource, timeZone: String? = nil) {
+        self.id = id
+        self.workoutId = workoutId
+        self.start = start
+        self.end = end
+        self.points = points
+        self.source = source
+        self.timeZone = timeZone
+    }
+}
+
+/// One speed, power or cadence reading. Android's are instants, so start equals end there.
+public struct WorkoutIntensitySample: Codable, Equatable, Sendable {
+    public var id: String
+    public var metric: WorkoutIntensityMetric
+    /// Set on Apple, where HealthKit stores a reading inside its workout. Health Connect stores
+    /// them free-standing, so Android leaves it absent rather than guessing by time.
+    public var workoutId: String?
+    public var start: String
+    public var end: String
+    public var value: Double
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, metric: WorkoutIntensityMetric, workoutId: String? = nil, start: String, end: String, value: Double, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.metric = metric
+        self.workoutId = workoutId
+        self.start = start
+        self.end = end
+        self.value = value
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+/// One drink, in millilitres.
+public struct HydrationSample: Codable, Equatable, Sendable {
+    public var id: String
+    public var start: String
+    public var end: String
+    public var millilitres: Double
+    public var source: SampleSource
+    public var userEntered: Bool
+    public var timeZone: String?
+
+    public init(id: String, start: String, end: String, millilitres: Double, source: SampleSource, userEntered: Bool, timeZone: String? = nil) {
+        self.id = id
+        self.start = start
+        self.end = end
+        self.millilitres = millilitres
+        self.source = source
+        self.userEntered = userEntered
+        self.timeZone = timeZone
+    }
+}
+
+public struct DayTotalList: Codable, Equatable, Sendable {
+    public var totals: [DayTotal]
+
+    public init(totals: [DayTotal]) {
+        self.totals = totals
+    }
+}
+
+public struct IntradaySampleList: Codable, Equatable, Sendable {
+    public var samples: [IntradaySample]
+
+    public init(samples: [IntradaySample]) {
+        self.samples = samples
+    }
+}
+
+public struct RestingHeartRateList: Codable, Equatable, Sendable {
+    public var samples: [RestingHeartRateSample]
+
+    public init(samples: [RestingHeartRateSample]) {
+        self.samples = samples
+    }
+}
+
+public struct BodyReadingList: Codable, Equatable, Sendable {
+    public var samples: [BodyReading]
+
+    public init(samples: [BodyReading]) {
+        self.samples = samples
+    }
+}
+
+public struct WorkoutRouteList: Codable, Equatable, Sendable {
+    public var routes: [WorkoutRoute]
+
+    public init(routes: [WorkoutRoute]) {
+        self.routes = routes
+    }
+}
+
+public struct WorkoutIntensityList: Codable, Equatable, Sendable {
+    public var samples: [WorkoutIntensitySample]
+
+    public init(samples: [WorkoutIntensitySample]) {
+        self.samples = samples
+    }
+}
+
+public struct HydrationList: Codable, Equatable, Sendable {
+    public var samples: [HydrationSample]
+
+    public init(samples: [HydrationSample]) {
+        self.samples = samples
+    }
+}
+
+public struct AvailabilityResult: Codable, Equatable, Sendable {
+    public var availability: StoreAvailability
+
+    public init(availability: StoreAvailability) {
+        self.availability = availability
+    }
+}
+
+public enum TerraEventEnvelope {
+    public static func validate(_ value: TerraEvent) throws {
+        guard case .string = value.storage["at"] else {
+            throw DecodingError.dataCorrupted(
+                .init(codingPath: [], debugDescription: "TerraEvent.at is not a string")
+            )
+        }
+        guard case .string = value.storage["event"] else {
+            throw DecodingError.dataCorrupted(
+                .init(codingPath: [], debugDescription: "TerraEvent.event is not a string")
+            )
+        }
+    }
+}
+
+public enum SupportReportEnvelope {
+    public static func validate(_ value: SupportReport) throws {
+        for level0 in value.recentEvents {
+            try TerraEventEnvelope.validate(level0)
+        }
+    }
+}
+