@m1kad0/hannah-proto 4.4.0 → 4.6.0

package/dist/v1/logging.d.ts

@@ -0,0 +1,189 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientReadableStream, type ClientUnaryCall, type ClientWritableStream, type handleClientStreamingCall, type handleServerStreamingCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Empty } from "./shared";
+export declare const protobufPackage = "hannah.v1";
+export declare enum LogLevel {
+    LOG_LEVEL_UNSPECIFIED = 0,
+    LOG_LEVEL_DEBUG = 1,
+    LOG_LEVEL_INFO = 2,
+    LOG_LEVEL_WARNING = 3,
+    LOG_LEVEL_ERROR = 4,
+    LOG_LEVEL_CRITICAL = 5,
+    UNRECOGNIZED = -1
+}
+/** Lets an export leave out sensitive content (e.g. before posting it in a forum). */
+export declare enum LogCategory {
+    LOG_CATEGORY_UNSPECIFIED = 0,
+    LOG_CATEGORY_GENERAL = 1,
+    /** LOG_CATEGORY_TRANSCRIPT - speech transcripts / user utterances */
+    LOG_CATEGORY_TRANSCRIPT = 2,
+    /** LOG_CATEGORY_METADATA - room/device names, presence and similar */
+    LOG_CATEGORY_METADATA = 3,
+    UNRECOGNIZED = -1
+}
+export interface ShipMessage {
+    /** exactly once, as the first message */
+    hello?: ShipHello | undefined;
+    entry?: LogEntry | undefined;
+    /** the component's buffer overflowed, entries were dropped */
+    gap?: LogGap | undefined;
+}
+/** Identifies the source of all entries on this stream. */
+export interface ShipHello {
+    /** e.g. "core", "telegram", "voiceid" */
+    component: string;
+    /** distinguishes several instances of the same component */
+    instance: string;
+    /** component version, shown in the export manifest */
+    version: string;
+}
+export interface LogEntry {
+    /** Unix ms at the time of logging in the component, not of receipt */
+    timestampMs: bigint;
+    level: LogLevel;
+    /** e.g. the Python logger name */
+    logger: string;
+    /** secrets are filtered out by the component before sending */
+    message: string;
+    category: LogCategory;
+}
+/**
+ * Entries the component had to drop (buffer overflow while the collector was
+ * unreachable). Listed in the export manifest so gaps are visible.
+ */
+export interface LogGap {
+    dropped: bigint;
+    fromMs: bigint;
+    toMs: bigint;
+}
+export interface ShipAck {
+    /** number of entries stored from this stream */
+    accepted: bigint;
+}
+export interface LogSource {
+    component: string;
+    instance: string;
+    /** from the most recent ShipHello */
+    version: string;
+    oldestMs: bigint;
+    newestMs: bigint;
+    entries: bigint;
+}
+export interface GetSourcesResponse {
+    sources: LogSource[];
+}
+export interface ExportRequest {
+    sinceMs: bigint;
+    /** 0 = now */
+    untilMs: bigint;
+    /** empty = all */
+    components: string[];
+    excludeCategories: LogCategory[];
+}
+export interface ExportChunk {
+    data: Uint8Array;
+}
+export declare const ShipMessage: MessageFns<ShipMessage>;
+export declare const ShipHello: MessageFns<ShipHello>;
+export declare const LogEntry: MessageFns<LogEntry>;
+export declare const LogGap: MessageFns<LogGap>;
+export declare const ShipAck: MessageFns<ShipAck>;
+export declare const LogSource: MessageFns<LogSource>;
+export declare const GetSourcesResponse: MessageFns<GetSourcesResponse>;
+export declare const ExportRequest: MessageFns<ExportRequest>;
+export declare const ExportChunk: MessageFns<ExportChunk>;
+export type LogServiceService = typeof LogServiceService;
+export declare const LogServiceService: {
+    /**
+     * Component → collector. First message is a ShipHello, then any number of
+     * entries/gaps. The stream stays open for as long as the component runs.
+     */
+    readonly ship: {
+        readonly path: "/hannah.v1.LogService/Ship";
+        readonly requestStream: true;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ShipMessage) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ShipMessage;
+        readonly responseSerialize: (value: ShipAck) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ShipAck;
+    };
+    /** Which sources the collector currently holds logs for, and how far back. */
+    readonly getSources: {
+        readonly path: "/hannah.v1.LogService/GetSources";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: Empty) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => Empty;
+        readonly responseSerialize: (value: GetSourcesResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetSourcesResponse;
+    };
+    /**
+     * Archive of the requested logs (tar.gz: one file per source plus a manifest),
+     * split into chunks — the client concatenates ExportChunk.data in order.
+     */
+    readonly export: {
+        readonly path: "/hannah.v1.LogService/Export";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: ExportRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ExportRequest;
+        readonly responseSerialize: (value: ExportChunk) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ExportChunk;
+    };
+};
+export interface LogServiceServer extends UntypedServiceImplementation {
+    /**
+     * Component → collector. First message is a ShipHello, then any number of
+     * entries/gaps. The stream stays open for as long as the component runs.
+     */
+    ship: handleClientStreamingCall<ShipMessage, ShipAck>;
+    /** Which sources the collector currently holds logs for, and how far back. */
+    getSources: handleUnaryCall<Empty, GetSourcesResponse>;
+    /**
+     * Archive of the requested logs (tar.gz: one file per source plus a manifest),
+     * split into chunks — the client concatenates ExportChunk.data in order.
+     */
+    export: handleServerStreamingCall<ExportRequest, ExportChunk>;
+}
+export interface LogServiceClient extends Client {
+    /**
+     * Component → collector. First message is a ShipHello, then any number of
+     * entries/gaps. The stream stays open for as long as the component runs.
+     */
+    ship(callback: (error: ServiceError | null, response: ShipAck) => void): ClientWritableStream<ShipMessage>;
+    ship(metadata: Metadata, callback: (error: ServiceError | null, response: ShipAck) => void): ClientWritableStream<ShipMessage>;
+    ship(options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ShipAck) => void): ClientWritableStream<ShipMessage>;
+    ship(metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ShipAck) => void): ClientWritableStream<ShipMessage>;
+    /** Which sources the collector currently holds logs for, and how far back. */
+    getSources(request: Empty, callback: (error: ServiceError | null, response: GetSourcesResponse) => void): ClientUnaryCall;
+    getSources(request: Empty, metadata: Metadata, callback: (error: ServiceError | null, response: GetSourcesResponse) => void): ClientUnaryCall;
+    getSources(request: Empty, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetSourcesResponse) => void): ClientUnaryCall;
+    /**
+     * Archive of the requested logs (tar.gz: one file per source plus a manifest),
+     * split into chunks — the client concatenates ExportChunk.data in order.
+     */
+    export(request: ExportRequest, options?: Partial<CallOptions>): ClientReadableStream<ExportChunk>;
+    export(request: ExportRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<ExportChunk>;
+}
+export declare const LogServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): LogServiceClient;
+    service: typeof LogServiceService;
+    serviceName: string;
+};
+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 {};