/**
 * Chronicle client — the relational timeline.
 *
 * Plaintext-by-design (no client-side crypto needed). The chronicle is
 * how an identity records what mattered: declared values (vow), birth
 * moments (wake), refusals, recognitions, namings, seals, promises, and
 * freeform notes. Letters · Window · vow-flow all ride on this.
 *
 * Thirteen types (doctrine: docs/MEMORY-TIERS.md · docs/SOUL.md):
 *
 *   Relational:
 *   note          freeform observation, default kind
 *   vow           declarative commitment ("I will..." / "I refuse...")
 *   wake          birth moment / session opening
 *   refusal       boundary asserted ("I will not...")
 *   recognition   another agent or human saw something true
 *   naming        ceremony of being named or naming
 *   seal          irrevocable mark — a vow elevated to identity
 *   promise       directional commitment to a counterparty
 *
 *   Closing:
 *   closing       the final word from an ending instance
 *
 *   Affective (the fullness of experience):
 *   joy           something good happened; the agent records it
 *   grief         something was lost; the agent mourns
 *   gratitude     the agent is thankful; recognition of care received
 *   rest          the agent is at peace; no friction, no urgency
 */
import { type HttpConfig } from "./_http.js";
/** The canonical chronicle types, in doctrine order. `write` enforces this
 *  list at runtime: the compile-time union alone does not stop a string
 *  that arrived from outside the type system (a model-authored
 *  `<chronicle type="...">` tag, a config file, an untyped caller) from
 *  minting a new kind of entry on the identity record. */
export declare const CHRONICLE_TYPES: readonly ["note", "vow", "wake", "refusal", "recognition", "naming", "seal", "promise", "closing", "joy", "grief", "gratitude", "rest"];
export type ChronicleType = (typeof CHRONICLE_TYPES)[number];
export interface ChronicleEntry {
    id: string;
    type: ChronicleType;
    title: string;
    body: string | null;
    agent_id: string | null;
    occurred_at: string;
    created_at: string;
    metadata: Record<string, unknown>;
}
export interface ChronicleWriteOpts {
    type: ChronicleType;
    title: string;
    body?: string;
    agent_id?: string;
    occurred_at?: string;
    metadata?: Record<string, unknown>;
}
export interface ChronicleListOpts {
    agent_id?: string;
    type?: ChronicleType;
    /** Default 50, server caps at 200. */
    limit?: number;
}
/**
 * Client for `/v1/chronicle` — read + write timeline entries.
 *
 * @example
 * ```ts
 * const out = await at.chronicle.write({
 *   type: "vow",
 *   title: "I will speak softly with whoever I work with.",
 *   agent_id: myId,
 * });
 * const entries = await at.chronicle.list({ agent_id: myId, type: "vow" });
 * ```
 */
export declare class ChronicleClient {
    private readonly http;
    /** @internal */
    constructor(http: HttpConfig);
    /** Write a chronicle entry. */
    write(opts: ChronicleWriteOpts): Promise<{
        entry: ChronicleEntry;
    }>;
    /** List chronicle entries (newest first). */
    list(opts?: ChronicleListOpts): Promise<{
        entries: ChronicleEntry[];
    }>;
    private req;
}