@m1kad0/hannah-proto 0.0.0

package/dist/agent.d.ts

@@ -0,0 +1,307 @@
+export declare const protobufPackage = "hannah";
+export declare enum ResidentType {
+    RESIDENT_TYPE_UNSPECIFIED = 0,
+    ROOMIE = 1,
+    GUEST = 2,
+    PET = 3,
+    UNRECOGNIZED = -1
+}
+/** Sent by the HannahAgent ioBroker adapter over the AgentConnect stream. */
+export interface AgentMessage {
+    /** any ioBroker state changed */
+    stateUpdate?: AgentStateUpdate | undefined;
+    /** residents adapter presence changed */
+    residentUpdate?: AgentResident | undefined;
+    /** text command state changed */
+    textCommand?: AgentTextCommand | undefined;
+    /** satellite control command */
+    satelliteControl?: AgentSatelliteControl | undefined;
+    /** initial snapshot with all states */
+    sendSnapshot?: AgentDeviceSnapshot | undefined;
+    /** initial snapshot with all residents */
+    sendResidents?: AgentResidentSnapshot | undefined;
+    /** ask Resident via Hannah */
+    askResident?: AgentAskResident | undefined;
+    /** full room catalog, independent of devices */
+    sendRooms?: AgentRoomSnapshot | undefined;
+}
+/**
+ * Adapter instructs Hannah to control satellites in a room or a specific satellite.
+ * room: room_id (enum ID segment) or "all" for all rooms.
+ * device_id: if non-empty, only the named satellite is targeted (volume/mute only);
+ *            room is still required (used for room-scoped commands and as fallback).
+ */
+export interface AgentSatelliteControl {
+    room: string;
+    /** optional: target a specific satellite instead of the whole room */
+    deviceId: string;
+    /** set do-not-disturb */
+    dnd?: boolean | undefined;
+    /** mute/unmute microphone */
+    mute?: boolean | undefined;
+    /** set volume (0–100) */
+    volume?: number | undefined;
+    /** speak plain-text announcement (verbatim) */
+    announcement?: string | undefined;
+    /** speak SSML announcement */
+    announcementSsml?: string | undefined;
+    /** speak announcement, text rephrased by LLM first */
+    announcementRephrase?: string | undefined;
+}
+/**
+ * An ioBroker state change event. ack=true means the device confirmed the value
+ * (as opposed to ack=false which is the "desired" value). Hannah uses this to
+ * verify that a SetState command was executed successfully.
+ */
+export interface AgentStateUpdate {
+    /** full ioBroker state ID, e.g. "javascript.0.virtualDevice.Licht.EG.Wohnzimmer.DeckeSeite.on" */
+    stateId: string;
+    /** JSON-encoded value: "true", "42", "\"text\"" */
+    value: string;
+    /** true = confirmed by device */
+    ack: boolean;
+    /** Unix timestamp in milliseconds */
+    ts: number;
+}
+/** The text-command state in ioBroker changed — treat as a SubmitText call. */
+export interface AgentTextCommand {
+    text: string;
+}
+/** Sent by Hannah Core over the AgentConnect stream. */
+export interface AgentCommand {
+    /** Hannah wants to control an ioBroker device */
+    setState?: AgentSetState | undefined;
+    /** Hannah needs additional states streamed */
+    watchMore?: AgentWatchMore | undefined;
+    /** Hannah wants to set a resident's presence state */
+    setResident?: AgentSetResident | undefined;
+    /** a satellite registered or disconnected */
+    satelliteUpdate?: AgentSatelliteUpdate | undefined;
+    /** Hannah's answer to a text command */
+    textAnswer?: AgentTextAnswer | undefined;
+    /** satellite firmware version update */
+    firmwareEvent?: AgentFirmwareEvent | undefined;
+    /** BLE tag location changed */
+    bleUpdate?: AgentBleUpdate | undefined;
+    /** satellite sensor reading */
+    sensorUpdate?: AgentSensorUpdate | undefined;
+    /** answer to an ask_resident request */
+    residentAnswered?: AgentResidentAnswered | undefined;
+    /** Hannah Core deleted a satellite — adapter must remove its object tree */
+    satelliteDeleted?: AgentSatelliteDeleted | undefined;
+    /** Hannah wants to set a resident's mood, independent of presence */
+    setResidentMood?: AgentSetResidentMood | undefined;
+}
+export interface AgentFirmwareEvent {
+    device: string;
+    version: string;
+    /** true = newer version pending, false = current version report */
+    updateAvailable: boolean;
+}
+/**
+ * Hannah instructs the adapter to set an ioBroker state.
+ * The adapter calls setForeignState(); the resulting ack=true AgentStateUpdate
+ * confirms execution back to Hannah.
+ */
+export interface AgentSetState {
+    /** ioBroker state ID to write */
+    stateId: string;
+    /** JSON-encoded value */
+    value: string;
+}
+/**
+ * Hannah requests additional state IDs to be included in the AgentStateUpdate stream.
+ * Used by the trigger engine at runtime when triggers reference arbitrary state IDs
+ * (e.g. unless.state: "0_userdata.0.feeded") that aren't covered by enum discovery.
+ */
+export interface AgentWatchMore {
+    stateIds: string[];
+}
+/**
+ * Hannah instructs the adapter to set a resident's presence state in the residents adapter.
+ * type determines whether the target path is .roomie./.guest./.pet.
+ */
+export interface AgentSetResident {
+    /** e.g. "leonie", "hannah" */
+    residentId: string;
+    /** residents adapter presence value (0=absent, 1=home, …) */
+    presenceState: number;
+    type: ResidentType;
+}
+/**
+ * Hannah instructs the adapter to set a resident's mood — separate command from
+ * AgentSetResident so it can fire independent of any presence change (e.g. when a
+ * Hannah User's linked mood changes without an arrival/departure).
+ */
+export interface AgentSetResidentMood {
+    /** e.g. "leonie", "hannah" */
+    residentId: string;
+    mood: number;
+    type: ResidentType;
+}
+/**
+ * Hannah notifies the adapter that a satellite registered or disconnected,
+ * or that a satellite's volume or mute state changed.
+ * The adapter updates hannah.<instance>.satellites.rooms.<room_id>.* states accordingly.
+ */
+export interface AgentSatelliteUpdate {
+    /** satellite device_id (== eFuse MAC since v0.34); adapter uses as ioBroker object-ID */
+    deviceId: string;
+    /** room_id: stable enum ID segment (e.g. "wohnzimmer"); adapter uses as ioBroker path segment */
+    room: string;
+    /** UDP address (empty if not applicable) */
+    address: string;
+    /** true = registered/online, false = gone/offline */
+    online: boolean;
+    /** current volume level (0–100); absent = no change */
+    volume?: number | undefined;
+    /** current mute state; absent = no change */
+    mute?: boolean | undefined;
+    /** human-readable name from Core DB (empty = fall back to device_id) */
+    displayName: string;
+}
+/**
+ * Hannah Core deleted a satellite (RoomManager.delete_satellite()) — the adapter
+ * must remove the satellite's full object tree (and its sensor tree), mirroring
+ * the room cleanup AgentSatelliteUpdate already does for online/offline changes.
+ */
+export interface AgentSatelliteDeleted {
+    /** satellite device_id being deleted */
+    deviceId: string;
+    /** room_id the satellite was assigned to, for room-container cleanup */
+    room: string;
+}
+/**
+ * Hannah sends the answer to a text command back to the adapter.
+ * The adapter sets hannah.<instance>.textAnswer accordingly.
+ */
+export interface AgentTextAnswer {
+    /** plain-text answer */
+    text: string;
+    /** detected intent name */
+    intent: string;
+}
+/**
+ * A notification from the ioBroker adapter.
+ * direct=true: skip LLM, play text unchanged (severity ignored).
+ * direct=false: LLM reformulates text; severity controls tone ("alert"|"notify"|"info").
+ */
+export interface AgentNotification {
+    text: string;
+    direct: boolean;
+    /** "alert" | "notify" | "info" — only used when direct=false */
+    severity: string;
+}
+export interface AgentStateValue {
+    value: string;
+    ack: boolean;
+}
+/** A device from the ioBroker adapter */
+export interface AgentDevice {
+    stateId: string;
+    floor: string;
+    /** room_id: stable enum ID segment, e.g. "wohnzimmer" or "living_room" */
+    room: string;
+    device: string;
+    deviceType: string;
+    functions: string[];
+    value: AgentStateValue | undefined;
+    /** all display names from ioBroker enum, e.g. {"de": "Wohnzimmer", "en": "Living Room"} */
+    roomNames: {
+        [key: string]: string;
+    };
+}
+export interface AgentDevice_RoomNamesEntry {
+    key: string;
+    value: string;
+}
+/** a list with all known devices from the ioBroker adapter */
+export interface AgentDeviceSnapshot {
+    devices: AgentDevice[];
+}
+/**
+ * A room from the ioBroker adapter's enum.rooms.* catalog — independent of devices,
+ * so rooms without any device yet are still known to Hannah (e.g. before the first
+ * satellite is provisioned into a brand-new room).
+ */
+export interface AgentRoom {
+    /** enum ID segment, e.g. "wohnzimmer" */
+    roomId: string;
+    /** all display names from ioBroker enum, e.g. {"de": "Wohnzimmer", "en": "Living Room"} */
+    displayNames: {
+        [key: string]: string;
+    };
+}
+export interface AgentRoom_DisplayNamesEntry {
+    key: string;
+    value: string;
+}
+/**
+ * Full room catalog from the ioBroker adapter. Sent on AgentConnect and whenever
+ * enum.rooms.* changes, independent of AgentDeviceSnapshot.
+ */
+export interface AgentRoomSnapshot {
+    rooms: AgentRoom[];
+}
+/** A resident from the ioBroker adapter */
+export interface AgentResident {
+    roomieId: string;
+    name: string;
+    type: ResidentType;
+    moodLevel?: number | undefined;
+    presenceState: number;
+}
+/** a list with all known residents */
+export interface AgentResidentSnapshot {
+    residents: AgentResident[];
+}
+export interface AgentAskResident {
+    correlationId: string;
+    room: string;
+    question: string;
+}
+export interface AgentResidentAnswered {
+    correlationId: string;
+    answer: string;
+}
+/**
+ * Hannah notifies the adapter that a BLE tag's location has changed.
+ * The adapter creates/updates states under hannah.<instance>.ble.<label>.*.
+ * room and satellite are empty when the tag is no longer visible.
+ */
+export interface AgentBleUpdate {
+    /** human-readable tag name (from config, used as state path) */
+    label: string;
+    /** MAC address (lowercase, colon-separated) */
+    mac: string;
+    /** room name (empty = tag not visible / stale) */
+    room: string;
+    /** satellite device ID that last detected the tag */
+    satellite: string;
+    /** last known RSSI in dBm (0 when room is empty) */
+    rssi: number;
+}
+/**
+ * Hannah notifies the adapter of a satellite's sensor reading.
+ * The adapter creates/updates states under hannah.<instance>.satellites.<device>.sensors.*.
+ * gas_resistance is omitted (0.0) when not available (BMP280+AHT20 hardware).
+ * iaq/co2_equiv/voc_equiv are omitted (0.0) when BSEC2 is not calibrated yet.
+ */
+export interface AgentSensorUpdate {
+    /** satellite device ID */
+    device: string;
+    /** °C */
+    temperature: number;
+    /** hPa */
+    pressure: number;
+    /** % relative humidity (0 when not available) */
+    humidity: number;
+    /** IAQ 0–500 (BSEC2); 0 when not calibrated */
+    iaq: number;
+    /** 0=uncertain 1=low 2=medium 3=high */
+    iaqAccuracy: number;
+    /** CO₂ equivalent ppm (BSEC2); 0 when not available */
+    co2Equiv: number;
+    /** breath VOC equivalent ppm (BSEC2); 0 when not available */
+    vocEquiv: number;
+}

package/dist/agent.js

@@ -0,0 +1,18 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: agent.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResidentType = exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";
+var ResidentType;
+(function (ResidentType) {
+    ResidentType[ResidentType["RESIDENT_TYPE_UNSPECIFIED"] = 0] = "RESIDENT_TYPE_UNSPECIFIED";
+    ResidentType[ResidentType["ROOMIE"] = 1] = "ROOMIE";
+    ResidentType[ResidentType["GUEST"] = 2] = "GUEST";
+    ResidentType[ResidentType["PET"] = 3] = "PET";
+    ResidentType[ResidentType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ResidentType || (exports.ResidentType = ResidentType = {}));

package/dist/car_state.d.ts

@@ -0,0 +1,49 @@
+export declare const protobufPackage = "hannah";
+export interface CarStateResponse {
+    /** false if no MQTT data received yet */
+    available: boolean;
+    state: CarStateProto | undefined;
+}
+export interface GetAllCarStatesResponse {
+    states: CarStateProto[];
+}
+export interface CarStateProto {
+    /** position */
+    latitude: number;
+    longitude: number;
+    address: string;
+    isMoving: boolean;
+    /** Unix timestamp (seconds) */
+    positionDate: number;
+    /** status */
+    odometer: number;
+    totalRange: number;
+    isCarLocked: boolean;
+    doorLockStatus: string;
+    overallStatus: string;
+    /** doors/windows: name → true (closed) / false (open) */
+    doors: {
+        [key: string]: boolean;
+    };
+    windows: {
+        [key: string]: boolean;
+    };
+    /** Roomie-ID des Fahrzeughalters (leer = kein Owner-Filter) */
+    ownerRoomie: string;
+    /** Metadaten */
+    displayName: string;
+    /** Nummernschild */
+    plate: string;
+    /** Fahrzeug-Identifikationsnummer */
+    vin: string;
+    /** Heimadresse für "steht zu Hause"-Erkennung */
+    homeAddress: string;
+}
+export interface CarStateProto_DoorsEntry {
+    key: string;
+    value: boolean;
+}
+export interface CarStateProto_WindowsEntry {
+    key: string;
+    value: boolean;
+}

package/dist/car_state.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: car_state.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/control.d.ts

@@ -0,0 +1,343 @@
+export declare const protobufPackage = "hannah";
+export interface SubmitTextRequest {
+    text: string;
+    /**
+     * Identifies the calling service and its user, so Hannah can look up
+     * the corresponding roomie via linked_accounts.
+     */
+    sourceService: string;
+    /** e.g. Telegram chat_id as string */
+    sourceUserId: string;
+}
+export interface SubmitTextResponse {
+    /** text to send back to the user */
+    answer: string;
+    /** e.g. "WeatherQuery", "TurnOn", "Unknown" */
+    intentName: string;
+}
+export interface SubmitVoiceRequest {
+    /** OGG/Opus audio bytes (from Telegram voice message) */
+    audio: Uint8Array;
+    /** e.g. "telegram" */
+    sourceService: string;
+    /** e.g. Telegram chat_id as string */
+    sourceUserId: string;
+}
+export interface SubmitVoiceResponse {
+    /** STT result (for display / caption) */
+    transcript: string;
+    /** text answer from Hannah */
+    answer: string;
+    /** e.g. "CarQuery" — caller may enrich the text reply */
+    intentName: string;
+    /** OGG/Opus TTS response (empty if TTS disabled or failed) */
+    audioOgg: Uint8Array;
+}
+export interface AnnounceRequest {
+    text: string;
+    /** satellite device name, or "all" for broadcast — legacy path, ignored if room_id or user_id is set */
+    device: string;
+    /**
+     * #31: target by room and/or Person (User) instead of a specific device. Both set = AND
+     * (only the satellite that is both in that room AND owned by that Person), not OR.
+     */
+    roomId: string;
+    /** 0 = not set */
+    userId: number;
+}
+export interface Satellite {
+    deviceId: string;
+    /** live-reported room (UDP/proxy registration); empty if not connected */
+    room: string;
+    /** IP:port of the UDP satellite; empty if not connected */
+    address: string;
+    /** human-readable name from Core DB (empty if not provisioned) */
+    displayName: string;
+    /** room assigned in Core DB, "" = unassigned */
+    roomId: string;
+    /** display name of room_id */
+    roomDisplayName: string;
+    /** UTC "YYYY-MM-DD HH:MM:SS" from Core DB, "" = never seen */
+    lastSeen: string;
+    /** true if currently live (UDP or proxy) */
+    connected: boolean;
+    /** true if connected and live room differs from room_id */
+    roomMismatch: boolean;
+    /** Person (User) assigned as owner in Core DB, 0 = unassigned. #31 */
+    ownerUserId: number;
+    /** display name of owner_user_id, "" if unassigned */
+    ownerDisplayName: string;
+}
+export interface GetSatellitesResponse {
+    satellites: Satellite[];
+}
+export interface SetSatelliteRoomRequest {
+    deviceId: string;
+    /** "" = unassign */
+    roomId: string;
+    /** requestor */
+    requestorId: number;
+}
+export interface SetSatelliteDisplayNameRequest {
+    deviceId: string;
+    displayName: string;
+    /** requestor */
+    requestorId: number;
+}
+export interface SetSatelliteOwnerRequest {
+    deviceId: string;
+    /** 0 = unassign */
+    userId: number;
+    /** requestor */
+    requestorId: number;
+}
+export interface DeleteSatelliteRequest {
+    deviceId: string;
+    /** requestor */
+    requestorId: number;
+}
+export interface Room {
+    roomId: string;
+    displayName: string;
+}
+export interface GetRoomsResponse {
+    rooms: Room[];
+}
+export interface Group {
+    groupId: string;
+    displayName: string;
+    rooms: Room[];
+}
+export interface GetGroupsResponse {
+    groups: Group[];
+}
+export interface CreateGroupRequest {
+    groupId: string;
+    displayName: string;
+}
+export interface UpdateGroupRequest {
+    groupId: string;
+    displayName: string;
+}
+export interface DeleteGroupRequest {
+    groupId: string;
+}
+export interface SetGroupRoomsRequest {
+    groupId: string;
+    roomIds: string[];
+}
+export interface Routine {
+    id: number;
+    name: string;
+    triggers: string[];
+    /** JSON list[{topic,value} | {say,room}] */
+    actionsJson: string;
+    reply: string;
+}
+export interface GetRoutinesResponse {
+    routines: Routine[];
+}
+export interface CreateRoutineRequest {
+    name: string;
+    triggers: string[];
+    actionsJson: string;
+    reply: string;
+}
+export interface CreateRoutineResponse {
+    ok: boolean;
+    /** server-assigned, only valid when ok == true */
+    id: number;
+    message: string;
+}
+export interface UpdateRoutineRequest {
+    id: number;
+    name: string;
+    triggers: string[];
+    actionsJson: string;
+    reply: string;
+}
+export interface DeleteRoutineRequest {
+    id: number;
+}
+export interface Trigger {
+    /** client-assigned slug, e.g. "aussentuer_abend" */
+    id: string;
+    /** JSON condition object or list (OR'd), see trigger_engine.py */
+    whenJson: string;
+    /** JSON condition object, "" = none */
+    cancelWhenJson: string;
+    /** JSON list of response rules, "" = none */
+    onResponseJson: string;
+    /** legacy single announcement, "" once actions_json is used */
+    say: string;
+    ask: string;
+    rephrase: boolean;
+    room: string;
+    cooldown: number;
+    /** duration string e.g. "5h"/"30m"/"90s", "" = none */
+    delay: string;
+    /** JSON list[{say,room} | {set_state:{id,value}}], "" = none (falls back to say) */
+    actionsJson: string;
+}
+export interface GetTriggersResponse {
+    triggers: Trigger[];
+}
+export interface CreateTriggerRequest {
+    id: string;
+    whenJson: string;
+    cancelWhenJson: string;
+    onResponseJson: string;
+    say: string;
+    ask: string;
+    rephrase: boolean;
+    room: string;
+    cooldown: number;
+    delay: string;
+    actionsJson: string;
+}
+export interface UpdateTriggerRequest {
+    id: string;
+    whenJson: string;
+    cancelWhenJson: string;
+    onResponseJson: string;
+    say: string;
+    ask: string;
+    rephrase: boolean;
+    room: string;
+    cooldown: number;
+    delay: string;
+    actionsJson: string;
+}
+export interface DeleteTriggerRequest {
+    id: string;
+}
+export interface Alarm {
+    id: number;
+    satelliteId: string;
+    /** "HH:MM" */
+    time: string;
+    /** 0=Mo..6=So; leer = One-off */
+    weekdays: number[];
+    /** ISO-Daten, aus einer wiederkehrenden Serie ausgeschlossen */
+    skipDates: string[];
+    /** ISO-Datum; nur relevant wenn weekdays leer ist */
+    oneShotDate: string;
+    enabled: boolean;
+    label: string;
+    userId: number;
+}
+export interface GetAlarmsResponse {
+    alarms: Alarm[];
+}
+export interface CreateAlarmRequest {
+    satelliteId: string;
+    time: string;
+    weekdays: number[];
+    oneShotDate: string;
+    label: string;
+    userId: number;
+}
+export interface CreateAlarmResponse {
+    ok: boolean;
+    id: number;
+    message: string;
+}
+export interface UpdateAlarmRequest {
+    id: number;
+    satelliteId: string;
+    time: string;
+    weekdays: number[];
+    skipDates: string[];
+    oneShotDate: string;
+    enabled: boolean;
+    label: string;
+}
+export interface DeleteAlarmRequest {
+    id: number;
+}
+export interface Category {
+    id: number;
+    /** voller Punkt-Pfad, z.B. "ble.tags" */
+    name: string;
+    /** 0 = keine Eltern-Kategorie (Root) */
+    parentId: number;
+}
+export interface Setting {
+    id: number;
+    categoryId: number;
+    name: string;
+    /** JSON-encoded */
+    value: string;
+}
+export interface GetSettingsResponse {
+    categories: Category[];
+    settings: Setting[];
+}
+export interface SettingUpdate {
+    settingId: number;
+    /** JSON-encoded */
+    value: string;
+}
+export interface UpdateConfigRequest {
+    updates: SettingUpdate[];
+}
+export interface BleTag {
+    id: number;
+    macAddress: string;
+    label: string;
+    /** 0 = kein Owner zugeordnet */
+    userId: number;
+}
+export interface GetBleTagsResponse {
+    tags: BleTag[];
+}
+export interface CreateBleTagRequest {
+    macAddress: string;
+    label: string;
+    userId: number;
+}
+export interface CreateBleTagResponse {
+    ok: boolean;
+    id: number;
+    message: string;
+}
+export interface UpdateBleTagRequest {
+    id: number;
+    macAddress: string;
+    label: string;
+    userId: number;
+}
+export interface DeleteBleTagRequest {
+    id: number;
+}
+export interface Car {
+    id: number;
+    topicPrefix: string;
+    homeAddress: string;
+    ownerUserIds: number[];
+    name: string;
+}
+export interface GetCarsResponse {
+    cars: Car[];
+}
+export interface CreateCarRequest {
+    topicPrefix: string;
+    homeAddress: string;
+    ownerUserIds: number[];
+    name: string;
+}
+export interface CreateCarResponse {
+    ok: boolean;
+    id: number;
+    message: string;
+}
+export interface UpdateCarRequest {
+    id: number;
+    topicPrefix: string;
+    homeAddress: string;
+    ownerUserIds: number[];
+    name: string;
+}
+export interface DeleteCarRequest {
+    id: number;
+}

package/dist/control.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: control.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/device_control_menu.d.ts

@@ -0,0 +1,37 @@
+export declare const protobufPackage = "hannah";
+export interface DeviceInfo {
+    /** full device prefix, e.g. "javascript.0.virtualDevice.Licht.EG.Wohnzimmer.DeckeSeite" */
+    id: string;
+    /** display name, e.g. "DeckeSeite" */
+    name: string;
+    /** e.g. "Licht", "Stecker", "Temperaturen" */
+    category: string;
+    /** available state keys: "on", "level", "color", … */
+    states: string[];
+    /** current values as strings, e.g. {"on": "true", "level": "75"} */
+    current: {
+        [key: string]: string;
+    };
+}
+export interface DeviceInfo_CurrentEntry {
+    key: string;
+    value: string;
+}
+export interface RoomInfo {
+    /** room_id (lowercase), e.g. "wohnzimmer" */
+    key: string;
+    /** display name, e.g. "Wohnzimmer" */
+    name: string;
+    devices: DeviceInfo[];
+}
+export interface GetDevicesResponse {
+    rooms: RoomInfo[];
+}
+export interface ControlDeviceRequest {
+    /** DeviceInfo.id */
+    deviceId: string;
+    /** state key: "on", "level", "color" */
+    state: string;
+    /** string-serialised value: "true", "false", "50", "#FF0000" */
+    value: string;
+}

package/dist/device_control_menu.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: device_control_menu.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/event_stream.d.ts

@@ -0,0 +1,33 @@
+import { CarStateProto } from "./car_state";
+export declare const protobufPackage = "hannah";
+export interface EventFilter {
+    /** If empty, subscribe to all event types. */
+    eventTypes: string[];
+}
+export interface HannahEvent {
+    /** "car.parked" | "resident.arrived" | "resident.departed" | "system.notification" | "satellite.firmware" */
+    eventType: string;
+    /** ISO 8601 UTC */
+    timestamp: string;
+    carState?: CarStateProto | undefined;
+    residentEvent?: ResidentEventProto | undefined;
+    systemNotification?: SystemNotificationEvent | undefined;
+    firmwareEvent?: FirmwareEventProto | undefined;
+}
+export interface SystemNotificationEvent {
+    /** LLM-reformulierter Benachrichtigungstext */
+    text: string;
+}
+export interface FirmwareEventProto {
+    device: string;
+    version: string;
+}
+export interface TriggerFirmwareUpdateRequest {
+    device: string;
+}
+export interface ResidentEventProto {
+    roomieId: string;
+    displayName: string;
+    /** "arrived" | "departed" */
+    event: string;
+}

package/dist/event_stream.js

@@ -0,0 +1,9 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: event_stream.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+exports.protobufPackage = "hannah";

package/dist/hannah.d.ts

@@ -0,0 +1 @@
+export declare const protobufPackage = "hannah";

package/dist/hannah.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: hannah.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/satellite_provisioning.d.ts

@@ -0,0 +1,14 @@
+export declare const protobufPackage = "hannah";
+/**
+ * Sent by the ioBroker adapter (WebFlasher) before flashing a satellite.
+ * Hannah stores the seed + pre-config; when the satellite first connects with
+ * this seed, Hannah links the hardware serial to the pre-config and clears the seed.
+ */
+export interface ProvisionSatelliteRequest {
+    /** random UUID, also written to NVS during flash */
+    seed: string;
+    /** pre-configured display name */
+    displayName: string;
+    /** optional: pre-configured room (room_id from ioBroker) */
+    roomId: string;
+}

package/dist/satellite_provisioning.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: satellite_provisioning.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/satellite_proxy.d.ts

@@ -0,0 +1,80 @@
+export declare const protobufPackage = "hannah";
+/** Sent by the proxy periodically to keep the RegisterProxy stream alive. */
+export interface ProxyHeartbeat {
+    /** human-readable identifier, e.g. "hannah-proxy-living-room" */
+    proxyId: string;
+    /**
+     * UDP address the proxy is listening on for satellite connections.
+     * When set, Hannah publishes this address to the discovery topic so
+     * satellites connect to the proxy instead of Hannah's own UDP server.
+     */
+    udpHost: string;
+    /** UDP port, e.g. 7775 */
+    udpPort: number;
+}
+/** Sent by Hannah to the proxy over the RegisterProxy stream. */
+export interface ProxyCommand {
+    /** initial confirmation when stream is established */
+    ack?: ProxyAck | undefined;
+    /** Hannah wants the proxy to play TTS on a satellite */
+    playAudio?: PlayAudioCommand | undefined;
+}
+/** Sent once by Hannah after RegisterProxy stream is established. */
+export interface ProxyAck {
+    /** true = Hannah has disabled its own UDP server */
+    udpDisabled: boolean;
+    /** human-readable status, e.g. "UDP server stopped" */
+    message: string;
+}
+/**
+ * Hannah instructs the proxy to play TTS audio on a specific satellite.
+ * Used for announcements and other server-initiated audio.
+ * For streaming: Hannah sends multiple PlayAudioCommands with chunks of PCM.
+ * is_last=true on the final chunk signals the proxy to send tts_end to the satellite.
+ */
+export interface PlayAudioCommand {
+    /** satellite device name (as registered via UDP or proxy) */
+    deviceId: string;
+    /** raw PCM, 16-bit signed mono */
+    audioPcm: Uint8Array;
+    /** e.g. 24000 (Azure) or 16000 (Piper) */
+    sampleRate: number;
+    /** true on the last chunk of a TTS response */
+    isLast: boolean;
+}
+/** Sent by the proxy when a satellite has finished recording an utterance. */
+export interface SubmitSatelliteAudioRequest {
+    /** satellite device name */
+    deviceId: string;
+    /** room name (from proxy registration / config) */
+    room: string;
+    /** raw PCM, 16-bit signed mono, 16000 Hz */
+    audioPcm: Uint8Array;
+    /** sample rate of the audio (typically 16000) */
+    sampleRate: number;
+    /**
+     * Optional: speaker identity (Hannah users.id) provided by an upstream speaker-ID service.
+     * Empty = anonymous (Hannah treats as unknown user).
+     */
+    speakerUserId: string;
+}
+export interface SubmitSatelliteAudioResponse {
+    /** STT result */
+    transcript: string;
+    /** text answer from Hannah */
+    answer: string;
+    /** e.g. "TurnOn", "CarQuery", "Unknown" */
+    intentName: string;
+    /** TTS response as raw PCM, 16-bit signed mono */
+    audioPcm: Uint8Array;
+    /** sample rate of audio_pcm */
+    sampleRate: number;
+}
+export interface SatelliteRegistration {
+    /** satellite device_id (== eFuse MAC since v0.34), e.g. "e072a1d01adc" */
+    deviceId: string;
+    /** IP of the UDP satellite as seen by the proxy, e.g. "192.168.8.42" */
+    address: string;
+    /** one-time pairing token from NVS (empty after successful pairing) */
+    seed: string;
+}

package/dist/satellite_proxy.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: satellite_proxy.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/shared.d.ts

@@ -0,0 +1,7 @@
+export declare const protobufPackage = "hannah";
+export interface Empty {
+}
+export interface StatusResponse {
+    ok: boolean;
+    message: string;
+}

package/dist/shared.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: shared.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/speaker_enrollment.d.ts

@@ -0,0 +1,9 @@
+export declare const protobufPackage = "hannah";
+export interface EnrollVoiceprintRequest {
+    /** Hannah user this voice sample belongs to (users.id, stable) */
+    userId: string;
+    /** raw PCM, 16-bit signed mono */
+    audioPcm: Uint8Array;
+    /** e.g. 16000 */
+    sampleRate: number;
+}

package/dist/speaker_enrollment.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: speaker_enrollment.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/timer_service.d.ts

@@ -0,0 +1,101 @@
+export declare const protobufPackage = "hannah";
+/** Sent by Hannah Core over the TimerConnect stream. */
+export interface TimerCommand {
+    /** create a new timer */
+    create?: TimerCreate | undefined;
+    /** cancel an existing timer */
+    cancel?: TimerCancel | undefined;
+    /** request current timer list */
+    list?: TimerListRequest | undefined;
+    /** Hannah is ready to receive pending fired events */
+    ready?: TimerReady | undefined;
+    /** Hannah is temporarily unable to process timer firings */
+    notReady?: TimerNotReady | undefined;
+}
+/**
+ * Hannah signals that she is ready to receive queued TimerFired events.
+ * Sent after startup once ioBroker states are loaded. The service flushes
+ * any TimerFired events that occurred while Hannah was offline, in order.
+ */
+export interface TimerReady {
+}
+/**
+ * Hannah signals a temporary degraded state — the Timer Service should hold
+ * any TimerFired events in its queue until a subsequent TimerReady is received.
+ * Hannah sends this when core subsystems are unavailable (e.g. ioBroker disconnected).
+ */
+export interface TimerNotReady {
+    /** human-readable reason, e.g. "ioBroker disconnected" */
+    reason?: string | undefined;
+}
+/** Hannah instructs the timer service to create a new timer. */
+export interface TimerCreate {
+    /** UUID assigned by Hannah */
+    timerId: string;
+    /** human-readable label, e.g. "Spazieren gehen" */
+    label: string;
+    /** Unix timestamp (seconds) when to fire */
+    fireAt: number;
+    /** opaque to the Timer Service — e.g. "room", "roomie_id", "trigger_id" */
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface TimerCreate_MetadataEntry {
+    key: string;
+    value: string;
+}
+/** Hannah instructs the timer service to cancel a timer. */
+export interface TimerCancel {
+    timerId: string;
+}
+/** Hannah requests the current list of active timers (e.g. "welche Timer habe ich?"). */
+export interface TimerListRequest {
+}
+/** Sent by the Timer Service over the TimerConnect stream. */
+export interface TimerMessage {
+    /** initial confirmation when stream is established */
+    ack?: TimerAck | undefined;
+    /** a timer has expired */
+    fired?: TimerFired | undefined;
+    /** response to TimerListRequest */
+    list?: TimerListResponse | undefined;
+}
+/** Sent once by the Timer Service after TimerConnect stream is established. */
+export interface TimerAck {
+    /** human-readable status */
+    message: string;
+    /** number of timers currently tracked */
+    activeTimers: number;
+}
+/** Timer Service notifies Hannah that a timer has expired. */
+export interface TimerFired {
+    timerId: string;
+    /** convenience copy for logging */
+    label: string;
+    /** echoed verbatim from TimerCreate */
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface TimerFired_MetadataEntry {
+    key: string;
+    value: string;
+}
+/** Response to TimerListRequest — used for sync and "welche Timer habe ich?" queries. */
+export interface TimerListResponse {
+    timers: TimerInfo[];
+}
+export interface TimerInfo {
+    timerId: string;
+    label: string;
+    /** Unix timestamp (seconds) */
+    fireAt: number;
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface TimerInfo_MetadataEntry {
+    key: string;
+    value: string;
+}

package/dist/timer_service.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: timer_service.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/dist/user_registry.d.ts

@@ -0,0 +1,120 @@
+import { ResidentType } from "./agent";
+export declare const protobufPackage = "hannah";
+export interface User {
+    id: number;
+    userName: string;
+    displayName: string;
+    trustLevel: number;
+    active: boolean;
+    /** linked_accounts: service → account_id  (e.g. "telegram" → "123456789") */
+    linkedAccounts: {
+        [key: string]: string;
+    };
+    /** receives ioBroker/system notifications via Telegram */
+    systemMessages: boolean;
+    /** #27 Phase 6 */
+    email: string;
+    /** "roomie" | "guest" | "pet", #27 Phase 6 */
+    type: string;
+}
+export interface User_LinkedAccountsEntry {
+    key: string;
+    value: string;
+}
+export interface GetUsersRequest {
+    includeInactive: boolean;
+}
+export interface GetUsersResponse {
+    users: User[];
+}
+/** Exactly one of the lookup fields should be set. */
+export interface GetUserRequest {
+    userName?: string | undefined;
+    id?: number | undefined;
+    linkedAccount?: LinkedAccountLookup | undefined;
+    /**
+     * Only meaningful together with roomie_id: roomie_id alone is not unique across
+     * types (a Guest and a Roomie can share a name). Leave UNSPECIFIED if there's no
+     * collision; required when one exists, otherwise the RPC fails with
+     * FAILED_PRECONDITION naming the colliding types.
+     */
+    type: ResidentType;
+}
+export interface LinkedAccountLookup {
+    provider: string;
+    externalId: string;
+}
+export interface UserResponse {
+    found: boolean;
+    /** only valid when found == true */
+    user: User | undefined;
+}
+export interface LoginRequest {
+    username: string;
+    password: string;
+}
+export interface LinkAccountRequest {
+    userId: number;
+    service: string;
+    accountId: string;
+    providerPayload: string;
+}
+export interface UnlinkAccountRequest {
+    userId: number;
+    service: string;
+    accountId: string;
+    requestorId: number;
+}
+export interface SetTrustLevelRequest {
+    userId: number;
+    /** clamped to [0, 10] */
+    level: number;
+}
+export interface SetSystemMessagesRequest {
+    /**
+     * Always called by the user for themselves, identified beforehand via a unique
+     * linked-account lookup (GetUserRequest.linked_account) — id is already known
+     * and unambiguous, unlike roomie_id which can collide across resident types.
+     */
+    userId: number;
+    enabled: boolean;
+}
+export interface CreateUserRequest {
+    username: string;
+    /** Klartext, wird serverseitig gehasht — gleicher akzeptierter Constraint wie LoginRequest */
+    password: string;
+    email: string;
+    displayName: string;
+    /** "roomie" | "guest" | "pet" */
+    type: string;
+}
+export interface CreateUserResponse {
+    ok: boolean;
+    /** server-assigned, only valid when ok == true */
+    id: number;
+    message: string;
+}
+export interface UpdateUserRequest {
+    userId: number;
+    displayName: string;
+    email: string;
+    type: string;
+    isActive: boolean;
+    /** Klartext, "" = unverändert */
+    password: string;
+}
+export interface DeleteUserRequest {
+    userId: number;
+}
+export interface Resident {
+    /** z.B. "leonie_roomie" — roomie_id + "_" + type */
+    id: string;
+    roomieId: string;
+    displayName: string;
+    /** "roomie" | "guest" | "pet" */
+    type: string;
+    home: boolean;
+}
+export interface GetResidentsResponse {
+    residents: Resident[];
+}

package/dist/user_registry.js

@@ -0,0 +1,9 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: user_registry.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+exports.protobufPackage = "hannah";

package/dist/wakeword_capture.d.ts

@@ -0,0 +1,33 @@
+export declare const protobufPackage = "hannah";
+export interface SatelliteCaptureRequest {
+    deviceId: string;
+    /**
+     * "noise" (default) or "hey_hannah" — controls ESP streaming behaviour.
+     * noise: continuous auto-flush every 5 s.
+     * hey_hannah: stream only while PTT is held, flush on PTT release.
+     */
+    sampleType: string;
+}
+export interface TriggerPlinkRequest {
+    deviceId: string;
+    /** seconds to hold virtual PTT after plink (default 3.0) */
+    recordDuration: number;
+}
+/** ok=false when the satellite is unknown or already captured by another client. */
+export interface SatelliteCaptureResponse {
+    ok: boolean;
+    error: string;
+}
+/**
+ * A single audio chunk streamed from a captured satellite to the collector.
+ * end_of_utterance=true marks a PTT-release boundary — the collector should
+ * finalise and save the accumulated audio as a labelled sample at that point.
+ */
+export interface SatelliteAudioChunk {
+    /** raw PCM, 16-bit signed mono */
+    pcm: Uint8Array;
+    /** Hz, typically 16000 */
+    sampleRate: number;
+    /** true = PTT released, utterance boundary */
+    endOfUtterance: boolean;
+}

package/dist/wakeword_capture.js

@@ -0,0 +1,10 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               unknown
+// source: wakeword_capture.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "hannah";

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@m1kad0/hannah-proto",
+  "version": "0.0.0",
+  "description": "Generated TypeScript types for the Hannah voice assistant proto schema",
+  "license": "UNLICENSED",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "ts-proto": "^2.12.0",
+    "typescript": "^5.6.0"
+  }
+}