@m1kad0/hannah-proto 4.5.0 → 4.6.0

package/dist/v1/wakeword_capture.d.ts

@@ -0,0 +1,101 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "hannah.v1";
+export declare enum CaptureMode {
+    CAPTURE_MODE_UNSPECIFIED = 0,
+    CAPTURE_MODE_PTT = 2,
+    CAPTURE_MODE_PLINK = 3,
+    UNRECOGNIZED = -1
+}
+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;
+}
+/**
+ * Sent by Hannah Core over the CollectorConnect stream to start or stop a
+ * satellite capture — the Collector-side counterpart to RequestSatelliteCapture/
+ * ReleaseSatelliteCapture, pushed proactively instead of polled.
+ * capture_mode is only meaningful when sample_type is hey_hannah.
+ */
+export interface CaptureCommand {
+    deviceId: string;
+    sampleType: SampleType | undefined;
+    captureMode: CaptureMode;
+    stop: boolean;
+}
+/**
+ * Deliberately a oneof of (currently empty) payload messages rather than a plain
+ * enum — leaves room to attach per-sample-type data later without a breaking change.
+ */
+export interface SampleType {
+    noise?: NoiseSample | undefined;
+    heyHannah?: HeyHannahSample | undefined;
+}
+export interface NoiseSample {
+}
+export interface HeyHannahSample {
+}
+/** Sent by the Collector over the CollectorConnect stream. */
+export interface CollectorMessage {
+    /** initial confirmation when stream is established */
+    ack?: CollectorAck | undefined;
+}
+/** Sent once by the Collector after the CollectorConnect stream is established. */
+export interface CollectorAck {
+    /** human-readable status */
+    message: string;
+}
+export declare const SatelliteCaptureRequest: MessageFns<SatelliteCaptureRequest>;
+export declare const TriggerPlinkRequest: MessageFns<TriggerPlinkRequest>;
+export declare const SatelliteCaptureResponse: MessageFns<SatelliteCaptureResponse>;
+export declare const SatelliteAudioChunk: MessageFns<SatelliteAudioChunk>;
+export declare const CaptureCommand: MessageFns<CaptureCommand>;
+export declare const SampleType: MessageFns<SampleType>;
+export declare const NoiseSample: MessageFns<NoiseSample>;
+export declare const HeyHannahSample: MessageFns<HeyHannahSample>;
+export declare const CollectorMessage: MessageFns<CollectorMessage>;
+export declare const CollectorAck: MessageFns<CollectorAck>;
+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 {};