@m1kad0/hannah-proto 4.4.0 → 4.6.0

package/dist/v1/user_registry.d.ts

@@ -0,0 +1,187 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { ResidentType } from "./agent";
+export declare const protobufPackage = "hannah.v1";
+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;
+    /**
+     * Keys of automation services (e.g. "telegram_autoresponder") currently enabled for
+     * this user. Presence-based: a key is only listed here when enabled, absent = disabled.
+     */
+    enabledAutomations: 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;
+}
+/**
+ * Issue a one-time link token for a user and service (e.g. Telegram deep link).
+ * Rejected if no adapter that supports linking is connected for the service.
+ */
+export interface CreateLinkTokenRequest {
+    userId: number;
+    service: string;
+}
+export interface CreateLinkTokenResponse {
+    ok: boolean;
+    message: string;
+    token: string;
+    /** adapter's link_url_template with {token} filled in */
+    linkUrl: string;
+    /** Unix timestamp (seconds) */
+    expiresAt: bigint;
+}
+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 SetAutomationRequest {
+    userId: number;
+    /** e.g. "telegram_autoresponder" */
+    automation: string;
+    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[];
+}
+export declare const User: MessageFns<User>;
+export declare const User_LinkedAccountsEntry: MessageFns<User_LinkedAccountsEntry>;
+export declare const GetUsersRequest: MessageFns<GetUsersRequest>;
+export declare const GetUsersResponse: MessageFns<GetUsersResponse>;
+export declare const GetUserRequest: MessageFns<GetUserRequest>;
+export declare const LinkedAccountLookup: MessageFns<LinkedAccountLookup>;
+export declare const UserResponse: MessageFns<UserResponse>;
+export declare const LoginRequest: MessageFns<LoginRequest>;
+export declare const LinkAccountRequest: MessageFns<LinkAccountRequest>;
+export declare const UnlinkAccountRequest: MessageFns<UnlinkAccountRequest>;
+export declare const CreateLinkTokenRequest: MessageFns<CreateLinkTokenRequest>;
+export declare const CreateLinkTokenResponse: MessageFns<CreateLinkTokenResponse>;
+export declare const SetTrustLevelRequest: MessageFns<SetTrustLevelRequest>;
+export declare const SetSystemMessagesRequest: MessageFns<SetSystemMessagesRequest>;
+export declare const SetAutomationRequest: MessageFns<SetAutomationRequest>;
+export declare const CreateUserRequest: MessageFns<CreateUserRequest>;
+export declare const CreateUserResponse: MessageFns<CreateUserResponse>;
+export declare const UpdateUserRequest: MessageFns<UpdateUserRequest>;
+export declare const DeleteUserRequest: MessageFns<DeleteUserRequest>;
+export declare const Resident: MessageFns<Resident>;
+export declare const GetResidentsResponse: MessageFns<GetResidentsResponse>;
+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 {};