@m1kad0/hannah-proto 4.5.0 → 4.6.0

package/dist/v1/automation.d.ts

@@ -0,0 +1,54 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "hannah.v1";
+/** Sent by an automation service (e.g. telegram_autoresponder) over the AutomationConnect stream. */
+export interface AutomationMessage {
+    /** sent once, right after connecting */
+    register?: AutomationRegister | undefined;
+}
+/** Identifies which automation this connection represents. */
+export interface AutomationRegister {
+    /** e.g. "telegram_autoresponder" */
+    automation: string;
+}
+/** Sent by Hannah Core over the AutomationConnect stream. */
+export interface AutomationCommand {
+    /** sent once, right after register */
+    snapshot?: AutomationSnapshot | undefined;
+    /** live delta */
+    stateChanged?: AutomationStateChanged | undefined;
+}
+/**
+ * Full list of users with the registered automation currently enabled.
+ * Sent once per connection, right after AutomationRegister — the recovery
+ * mechanism for state changes that happened while the service was offline.
+ */
+export interface AutomationSnapshot {
+    userIds: number[];
+}
+/** A single user's enabled/disabled state changed for the registered automation. */
+export interface AutomationStateChanged {
+    userId: number;
+    enabled: boolean;
+}
+export declare const AutomationMessage: MessageFns<AutomationMessage>;
+export declare const AutomationRegister: MessageFns<AutomationRegister>;
+export declare const AutomationCommand: MessageFns<AutomationCommand>;
+export declare const AutomationSnapshot: MessageFns<AutomationSnapshot>;
+export declare const AutomationStateChanged: MessageFns<AutomationStateChanged>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = T extends bigint ? string | number | bigint : T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/v1/automation.js

@@ -0,0 +1,303 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.1
+//   protoc               unknown
+// source: hannah/v1/automation.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationStateChanged = exports.AutomationSnapshot = exports.AutomationCommand = exports.AutomationRegister = exports.AutomationMessage = exports.protobufPackage = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+exports.protobufPackage = "hannah.v1";
+function createBaseAutomationMessage() {
+    return { register: undefined };
+}
+exports.AutomationMessage = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.register !== undefined) {
+            exports.AutomationRegister.encode(message.register, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAutomationMessage();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.register = exports.AutomationRegister.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.AutomationMessage.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAutomationMessage();
+        message.register = (object.register !== undefined && object.register !== null)
+            ? exports.AutomationRegister.fromPartial(object.register)
+            : undefined;
+        return message;
+    },
+};
+function createBaseAutomationRegister() {
+    return { automation: "" };
+}
+exports.AutomationRegister = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.automation !== "") {
+            writer.uint32(10).string(message.automation);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAutomationRegister();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.automation = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.AutomationRegister.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAutomationRegister();
+        message.automation = object.automation ?? "";
+        return message;
+    },
+};
+function createBaseAutomationCommand() {
+    return { snapshot: undefined, stateChanged: undefined };
+}
+exports.AutomationCommand = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.snapshot !== undefined) {
+            exports.AutomationSnapshot.encode(message.snapshot, writer.uint32(10).fork()).join();
+        }
+        if (message.stateChanged !== undefined) {
+            exports.AutomationStateChanged.encode(message.stateChanged, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAutomationCommand();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.snapshot = exports.AutomationSnapshot.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.stateChanged = exports.AutomationStateChanged.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.AutomationCommand.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAutomationCommand();
+        message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
+            ? exports.AutomationSnapshot.fromPartial(object.snapshot)
+            : undefined;
+        message.stateChanged = (object.stateChanged !== undefined && object.stateChanged !== null)
+            ? exports.AutomationStateChanged.fromPartial(object.stateChanged)
+            : undefined;
+        return message;
+    },
+};
+function createBaseAutomationSnapshot() {
+    return { userIds: [] };
+}
+exports.AutomationSnapshot = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        writer.uint32(10).fork();
+        for (const v of message.userIds) {
+            writer.int32(v);
+        }
+        writer.join();
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAutomationSnapshot();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag === 8) {
+                            message.userIds.push(reader.int32());
+                            continue;
+                        }
+                        if (tag === 10) {
+                            const end2 = reader.uint32() + reader.pos;
+                            while (reader.pos < end2) {
+                                message.userIds.push(reader.int32());
+                            }
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.AutomationSnapshot.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAutomationSnapshot();
+        message.userIds = object.userIds?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseAutomationStateChanged() {
+    return { userId: 0, enabled: false };
+}
+exports.AutomationStateChanged = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.userId !== 0) {
+            writer.uint32(8).int32(message.userId);
+        }
+        if (message.enabled !== false) {
+            writer.uint32(16).bool(message.enabled);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAutomationStateChanged();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.userId = reader.int32();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.enabled = reader.bool();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.AutomationStateChanged.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAutomationStateChanged();
+        message.userId = object.userId ?? 0;
+        message.enabled = object.enabled ?? false;
+        return message;
+    },
+};

package/dist/v1/car_state.d.ts

@@ -0,0 +1,72 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "hannah.v1";
+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: bigint;
+    /** 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;
+}
+export declare const CarStateResponse: MessageFns<CarStateResponse>;
+export declare const GetAllCarStatesResponse: MessageFns<GetAllCarStatesResponse>;
+export declare const CarStateProto: MessageFns<CarStateProto>;
+export declare const CarStateProto_DoorsEntry: MessageFns<CarStateProto_DoorsEntry>;
+export declare const CarStateProto_WindowsEntry: MessageFns<CarStateProto_WindowsEntry>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = T extends bigint ? string | number | bigint : T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};