@rise-maritime/keelson-js 0.5.3 → 0.6.0-alpha.202.dev.1

package/dist/payloads/WarrantRecord.d.ts

@@ -0,0 +1,168 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * WarrantRecord is the append-only audit stream for claim standings: the
+ * record of why a conclusion held, reduced or lapsed, produced by any
+ * evaluator aboard that maintains justification for its conclusions. The
+ * warrant_aggregator connector is its first producer; the subject is
+ * deliberately producer-neutral and the source_id names the evaluator:
+ *
+ *   {base_path}/@v0/{entity_id}/pubsub/warrant_record/{source_id}
+ *
+ * so the entity's entire justification record is one subject family and an
+ * auditor or recorder watches one place, however many evaluators run.
+ *
+ * This stream is a reconstruction artifact, never a control input:
+ * statements, warrants, backing and evidence are strings by design, and
+ * consumers that act on determinations use the typed subjects the producing
+ * evaluator also publishes (the warrant_aggregator publishes
+ * operational_authority). Durability is a router storage_manager
+ * responsibility, not a payload one (protocol-specification.md section 6.3).
+ * Events are immutable once published: any future attestation must sign the
+ * stored Envelope bytes, never re-serialized state (section 6.3.1).
+ */
+export interface WarrantRecord {
+    $type: "keelson.WarrantRecord";
+    /** The source timestamp of the event. */
+    timestamp: Date | undefined;
+    standingTransition?: WarrantRecord_StandingTransition | undefined;
+    snapshot?: WarrantRecord_Snapshot | undefined;
+}
+/**
+ * The standing of a claim. Every claim starts WITHDRAWN: standing must
+ * be positively established, and absence of evidence counts against a
+ * claim, never for it.
+ */
+export declare enum WarrantRecord_Standing {
+    STANDING_UNSPECIFIED = 0,
+    STANDING_WITHDRAWN = 1,
+    STANDING_REDUCED = 2,
+    STANDING_LICENSED = 3,
+    UNRECOGNIZED = -1
+}
+export declare function warrantRecord_StandingFromJSON(object: any): WarrantRecord_Standing;
+export declare function warrantRecord_StandingToJSON(object: WarrantRecord_Standing): string;
+/** A rebuttal condition that fired, with the evidence that fired it. */
+export interface WarrantRecord_RebuttalFired {
+    $type: "keelson.WarrantRecord.RebuttalFired";
+    id: string;
+    description: string;
+    /** Human-readable rendering of the evidence at firing time. */
+    evidence: string;
+    /**
+     * The health level of the evidence when determinable (the
+     * HealthLevel enum name from EntityHealth.proto), empty when the
+     * rebuttal fired on absence of evidence.
+     */
+    evidenceLevel: string;
+}
+/** The standing of one ground at evaluation time. */
+export interface WarrantRecord_GroundStanding {
+    $type: "keelson.WarrantRecord.GroundStanding";
+    claimId: string;
+    standing: WarrantRecord_Standing;
+}
+/**
+ * One claim changed standing. Lean by design: justification prose lives
+ * in the periodic Snapshot, which makes the stream self-contained.
+ */
+export interface WarrantRecord_StandingTransition {
+    $type: "keelson.WarrantRecord.StandingTransition";
+    claimId: string;
+    fromStanding: WarrantRecord_Standing;
+    toStanding: WarrantRecord_Standing;
+    rebuttalsFired: WarrantRecord_RebuttalFired[];
+    grounds: WarrantRecord_GroundStanding[];
+}
+/** The full state of one claim, carried in snapshots. */
+export interface WarrantRecord_ClaimState {
+    $type: "keelson.WarrantRecord.ClaimState";
+    claimId: string;
+    standing: WarrantRecord_Standing;
+    /**
+     * When this claim last entered `standing`, never when this snapshot
+     * was taken. Snapshots are not on a fixed cadence (see
+     * target_standing), so a reader that treats this as a snapshot time
+     * reports hold durations as snapshot intervals.
+     */
+    since: Date | undefined;
+    rebuttalsFired: WarrantRecord_RebuttalFired[];
+    grounds: WarrantRecord_GroundStanding[];
+    /**
+     * The configured justification, carried for legibility so the
+     * stream reconstructs without access to the evaluator's config.
+     */
+    statement: string;
+    warrant: string;
+    backing: string;
+    /**
+     * The standing the rule assigns on current evidence, before the
+     * requalification hold is applied. Equal to `standing` except while
+     * an upgrade is being held, where `standing` is the published value
+     * and this is what the evidence already supports. Without it a held
+     * claim and an unsupported claim are indistinguishable in the record,
+     * and a reader reconstructing mid-hold reads the previous snapshot's
+     * value and concludes the evidence did not support an upgrade, which
+     * is a denial rather than a silence.
+     *
+     * STANDING_UNSPECIFIED means a producer that did not record it, not
+     * equality with `standing`.
+     *
+     * Derived claims cannot be held at all: they are evaluated after
+     * their grounds and transition immediately in both directions, so
+     * for them the two are always equal. Only source claims are held.
+     *
+     * The producer emits a snapshot whenever the set of claims in this
+     * condition changes, so a hold is on the wire when it opens and when
+     * it closes rather than only at the periodic cadence. That makes the
+     * snapshot rate depend on how volatile the evidence is, which on a
+     * bounded channel trades against completeness: a producer that can
+     * drop records must say so rather than leave a silent gap.
+     *
+     * The ladder level has a hold of its own and is NOT covered here.
+     * The level rides operational_authority, not this stream, so a held
+     * level still cannot be told from an unsupported one.
+     */
+    targetStanding: WarrantRecord_Standing;
+}
+/**
+ * Periodic full state, so reconstruction needs only the stream: the
+ * state at any instant is the latest snapshot at or before it plus the
+ * transitions since.
+ */
+export interface WarrantRecord_Snapshot {
+    $type: "keelson.WarrantRecord.Snapshot";
+    claims: WarrantRecord_ClaimState[];
+    /**
+     * Identify the evaluator policy and configuration that produced
+     * this state, for replay and audit (same convention as
+     * OperationalAuthority).
+     */
+    policyConfigDigest?: Uint8Array | undefined;
+    policyId?: string | undefined;
+}
+export declare const WarrantRecord: MessageFns<WarrantRecord, "keelson.WarrantRecord">;
+export declare const WarrantRecord_RebuttalFired: MessageFns<WarrantRecord_RebuttalFired, "keelson.WarrantRecord.RebuttalFired">;
+export declare const WarrantRecord_GroundStanding: MessageFns<WarrantRecord_GroundStanding, "keelson.WarrantRecord.GroundStanding">;
+export declare const WarrantRecord_StandingTransition: MessageFns<WarrantRecord_StandingTransition, "keelson.WarrantRecord.StandingTransition">;
+export declare const WarrantRecord_ClaimState: MessageFns<WarrantRecord_ClaimState, "keelson.WarrantRecord.ClaimState">;
+export declare const WarrantRecord_Snapshot: MessageFns<WarrantRecord_Snapshot, "keelson.WarrantRecord.Snapshot">;
+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 {};