import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
/**
 * Identifies the replay daemon producing this status. Static across the
 * daemon's lifetime; populated on every sample so clients can discover and
 * label replayers via the broadcast alone (no separate RPC needed).
 */
export interface DaemonInfo {
    $type: "keelson.DaemonInfo";
    /** keelson SDK version, e.g. "0.5.1" */
    version: string;
    hostname: string;
    startedAt: Date | undefined;
    baseDirectory: string;
}
export interface ReplayStatus {
    $type: "keelson.ReplayStatus";
    state: ReplayStatus_State;
    /** Current playhead position in the loaded file. */
    currentTime: Date | undefined;
    /** Start and end timestamps of the loaded file. */
    startTime: Date | undefined;
    endTime: Date | undefined;
    /** Playback speed multiplier (1.0 = real time). */
    playbackSpeed: number;
    /** Path of the currently loaded MCAP file, or empty if none loaded. */
    loadedFile: string;
    /** Number of messages already emitted since the file was loaded. */
    playedMessageCount: number;
    /** Total number of messages in the loaded file. */
    totalMessageCount: number;
    /** Progress through the file as a percentage in [0.0, 100.0]. */
    progressPct: number;
    /** Whether the replayer is configured to loop on end-of-file. */
    loop: boolean;
    /** Identification of the daemon producing this sample. See DaemonInfo above. */
    daemon: DaemonInfo | undefined;
    /** Progress of an in-flight load_file, 0..100. Zero outside of LOADING. */
    loadProgressPct: number;
    /**
     * Most-recent load_file failure, surfaced through the broadcast because
     * the RPC reply has already returned OK by the time the worker fails.
     * Cleared on a successful load. Empty if the most recent load succeeded.
     */
    lastLoadError: string;
}
export declare enum ReplayStatus_State {
    STOPPED = 0,
    PLAYING = 1,
    PAUSED = 2,
    LOADING = 3,
    UNRECOGNIZED = -1
}
export declare function replayStatus_StateFromJSON(object: any): ReplayStatus_State;
export declare function replayStatus_StateToJSON(object: ReplayStatus_State): string;
export declare const DaemonInfo: MessageFns<DaemonInfo, "keelson.DaemonInfo">;
export declare const ReplayStatus: MessageFns<ReplayStatus, "keelson.ReplayStatus">;
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
type DeepPartial<T> = 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 Exclude<keyof T, "$type">]?: DeepPartial<T[K]>;
} : Partial<T>;
type KeysOfUnion<T> = T extends T ? keyof T : never;
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> | "$type">]: never;
};
interface MessageFns<T, V extends string> {
    readonly $type: V;
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}
export {};