@mdbase-dev/sdk 0.0.0-stage → 0.1.0-beta.153

package/dist/wire.d.ts

@@ -0,0 +1,857 @@
+/**
+ * Replica client API messages (`docs/contracts/replica-client-api.md`), typed.
+ *
+ * Mirrors `crates/wire/src/client.rs` and the operations of `crates/wire/src/intent.rs`.
+ * Property names are the Rust field names in camelCase. Golden fixtures in
+ * `conformance/wire/client/` and `conformance/wire/mutation/` check both sides agree.
+ */
+import type { CborValue } from "./cbor.js";
+import { type RuntimeOp } from "./runtime-wire.js";
+import { type AttachmentContentV1 } from "./attachment-wire.js";
+import { b16, b32, Codec } from "./codec.js";
+export type Uuid = string;
+/** `sha256:<64 lowercase hex>`. */
+export type Hash = string;
+/** A frontmatter or app value; data maps are `Map`s (order is data). */
+export type Value = CborValue;
+export type FmMap = Map<string, Value>;
+export interface Version {
+    major: number;
+    minor: number;
+}
+export declare const version: Codec<Version>;
+export declare const RECOVERY: readonly ["fix_request", "refresh", "resolve_conflict", "reauthorize", "repair_collection", "retry", "free_space", "upgrade", "resolve_outcome", "none", "contact_support"];
+export type Recovery = (typeof RECOVERY)[number];
+export declare const recovery: Codec<"none" | "fix_request" | "refresh" | "resolve_conflict" | "reauthorize" | "repair_collection" | "retry" | "free_space" | "upgrade" | "resolve_outcome" | "contact_support"> & {
+    values: readonly ("none" | "fix_request" | "refresh" | "resolve_conflict" | "reauthorize" | "repair_collection" | "retry" | "free_space" | "upgrade" | "resolve_outcome" | "contact_support")[];
+};
+export declare const severity: Codec<"error" | "warning"> & {
+    values: readonly ("error" | "warning")[];
+};
+export interface Issue {
+    code: string;
+    severity: "warning" | "error";
+    message: string;
+    details?: Value;
+}
+export declare const issue: Codec<Issue>;
+export interface Problem {
+    code: string;
+    recovery: Recovery;
+    message: string;
+    reason?: string;
+    details?: Value;
+    retryAfterMs?: number;
+    issues?: Issue[];
+    traceId?: string;
+}
+export declare const problem: Codec<Problem>;
+export type ClientFrame = {
+    kind: "request";
+    id: number;
+    method: string;
+    params: CborValue;
+} | {
+    kind: "response";
+    id: number;
+    result?: CborValue;
+    problem?: Problem;
+} | {
+    kind: "push";
+    type: string;
+    payload: CborValue;
+};
+export declare const clientFrame: Codec<ClientFrame>;
+export interface HelloParams {
+    versions: Version[];
+    clientName: string;
+    clientVersion: string;
+    features?: string[];
+    timezone?: string;
+}
+export declare const helloParams: Codec<HelloParams>;
+export declare const ROLES: readonly ["viewer", "editor", "owner"];
+export type Role = (typeof ROLES)[number];
+export declare const role: Codec<"viewer" | "editor" | "owner"> & {
+    values: readonly ("viewer" | "editor" | "owner")[];
+};
+export interface GrantInfo {
+    grant?: Uuid;
+    capabilities: string[];
+    role: Role;
+    /** The account the session acts for (absent: local-only, or a service device). */
+    account?: Uuid;
+    /** The grant's folder scope of the file namespace (API 1.2; absent: unrestricted).
+     * Before API 1.2 absence says nothing: use `fileGrant`. */
+    fileFolders?: string[];
+}
+export declare const grantInfo: Codec<GrantInfo>;
+export declare const INCIDENT_KINDS: readonly ["upgrade_required", "waiting_for_key", "integrity", "access_revoked", "quota_exceeded", "read_only", "verification_mismatch", "voided_items", "key_inconsistent", "foreign_sync_tool", "gone", "lost_entries", "log_regressed"];
+export type IncidentKind = (typeof INCIDENT_KINDS)[number];
+export interface Incident {
+    kind: IncidentKind;
+    details?: Value;
+}
+export declare const incident: Codec<Incident>;
+export interface Progress {
+    done: number;
+    total: number;
+}
+export declare const progress: Codec<Progress>;
+/** Allocated lost-tail repair phases; progress metadata confers no authority. */
+export type ResyncPhase = "probing" | "repairing" | "rolling_back" | "awaiting_control";
+export interface Resyncing {
+    phase: ResyncPhase;
+    /** Positions still to restore (not ordinary pending mutations). */
+    positions: number;
+}
+export declare const resyncing: Codec<Resyncing>;
+export type SyncMode = "local_only" | "synced";
+export type Connection = "online" | "connecting" | "offline";
+/** Confirmed-only prefix facts. Decoding is neither authentication nor a readiness gate. */
+export interface ConfirmedHead {
+    seq: number;
+    chain: Hash;
+    policyGeneration: Hash;
+    catalogGeneration: Hash;
+}
+export declare const confirmedHead: Codec<ConfirmedHead>;
+/** Historical position to compare under the existing authenticated READ session. */
+export interface AppliedPrefixParams {
+    seq: number;
+}
+export declare const appliedPrefixParams: Codec<AppliedPrefixParams>;
+/** Historical chain at the echoed seq, NOT the local current chain/generations. */
+export interface AppliedPrefix {
+    appliedThrough: number;
+    seq: number;
+    /** Absent for zero, behind, unretained or ineligible. Remain hosted. */
+    chain?: Hash;
+}
+export declare const appliedPrefix: Codec<AppliedPrefix>;
+/** "Confirmed through N, plus pending" (§7). */
+export interface SyncStatus {
+    mode: SyncMode;
+    confirmedThrough: number;
+    headKnown: number;
+    pending: number;
+    oldestPending?: number;
+    holds: number;
+    unresolved: number;
+    connection: Connection;
+    installing?: Progress;
+    incidents: Incident[];
+    /** Present only while device-local lost-tail repair is active. */
+    resyncing?: Resyncing;
+    /** Optional confirmed-only fence. Absence is NOT permission to infer one. */
+    confirmedHead?: ConfirmedHead;
+    /** Current role-effective session grant (API 1.3). Older replicas omit it. */
+    grant?: GrantInfo;
+}
+export declare const syncStatus: Codec<SyncStatus>;
+export interface HelloResult {
+    version: Version;
+    runtimeVersion: string;
+    sem: Version;
+    collection: Uuid;
+    grant: GrantInfo;
+    status: SyncStatus;
+    features: string[];
+    /** The replica's latest signed head witness (log-entry.md §11), remote sessions. */
+    headWitness?: Uint8Array;
+}
+export declare const helloResult: Codec<HelloResult>;
+export interface BlobRef {
+    plainHash: Hash;
+    size: number;
+    blobId: Uint8Array;
+    idEpoch: number;
+    partSize: number;
+}
+export declare const blobRef: Codec<BlobRef>;
+/** Binary Hold content retains the COMPLETE typed manifest/content identity. */
+export interface AttachmentHoldContent {
+    form: "attachment";
+    content: AttachmentContentV1;
+}
+/** Text/legacy BlobRef bytes are unchanged. Attachment is a closed critical arm,
+ * used only by Holds, never a UTF8/text or snapshot-record fallback. */
+export type TextOrBlob = string | BlobRef | AttachmentHoldContent;
+export declare const textOrBlob: Codec<TextOrBlob>;
+export declare const HOLD_REASONS: readonly ["conflict", "unknown_provenance", "deleted_elsewhere", "read_only", "editor_busy", "suspect_write"];
+export type HoldReason = (typeof HOLD_REASONS)[number];
+export declare const holdReason: Codec<"conflict" | "read_only" | "unknown_provenance" | "deleted_elsewhere" | "editor_busy" | "suspect_write"> & {
+    values: readonly ("conflict" | "read_only" | "unknown_provenance" | "deleted_elsewhere" | "editor_busy" | "suspect_write")[];
+};
+export interface HoldRef {
+    id: Uuid;
+    reason: HoldReason;
+}
+export declare const holdRef: Codec<HoldRef>;
+export interface Hold {
+    id: Uuid;
+    path: string;
+    reason: HoldReason;
+    since: number;
+    base?: TextOrBlob;
+    mine: TextOrBlob;
+    theirs?: TextOrBlob;
+    saves: number;
+}
+export declare const hold: Codec<Hold>;
+export declare const HOLD_RESOLUTIONS: readonly ["keep_mine", "take_theirs", "use", "delete", "keep_both"];
+export type HoldResolution = (typeof HOLD_RESOLUTIONS)[number];
+export declare const holdResolution: Codec<"delete" | "keep_mine" | "take_theirs" | "use" | "keep_both"> & {
+    values: readonly ("delete" | "keep_mine" | "take_theirs" | "use" | "keep_both")[];
+};
+export interface RecordState {
+    state: "confirmed" | "pending";
+    confirmedSeq: number;
+    hold?: HoldRef;
+    unresolved?: number;
+}
+export declare const recordState: Codec<RecordState>;
+export type LinkTargetKind = "record" | "file" | "ambiguous" | "not_found" | "invalid";
+export interface LinkResolution {
+    kind: LinkTargetKind;
+    target?: Uuid;
+    path?: string;
+}
+export declare const linkResolution: Codec<LinkResolution>;
+/** An outgoing link or embed, resolved at the local view (§3.1). */
+export interface LinkView {
+    raw: string;
+    embed: boolean;
+    resolution: LinkResolution;
+    /** The frontmatter field holding it (absent: the body). */
+    field?: string;
+}
+export declare const linkView: Codec<LinkView>;
+/**
+ * Who wrote a change (§3.2). Show `account` as the author and `grant` as
+ * "via <app>". `grantAccount` is present only when the hosted replica signed, and only
+ * the hosted replica vouches for it.
+ */
+export interface AuthorRef {
+    account: Uuid;
+    device: Uuid;
+    grant?: Uuid;
+    grantAccount?: Uuid;
+}
+export declare const authorRef: Codec<AuthorRef>;
+export interface RecordView {
+    id: Uuid;
+    path: string;
+    revision: Hash;
+    frontmatter: FmMap;
+    effective?: FmMap;
+    body?: string;
+    document?: string;
+    types: string[];
+    state: RecordState;
+    diagnostics?: Issue[];
+    /** `select` outputs by output name (queries with `select`). */
+    values?: FmMap;
+    /** Capture time of the last change to the bytes (§3.1); not a device file mtime. */
+    mtime?: number;
+    /** Outgoing links and embeds (include `links`). */
+    links?: LinkView[];
+    /** Who created the record (absent in local-only collections). */
+    createdBy?: AuthorRef;
+    /** Who last changed it. */
+    modifiedBy?: AuthorRef;
+}
+export declare const fmMap: Codec<Map<string, CborValue>>;
+export declare const recordView: Codec<RecordView>;
+export interface Include {
+    effective?: boolean;
+    body?: boolean;
+    document?: boolean;
+    diagnostics?: boolean;
+    links?: boolean;
+}
+export declare const include: Codec<Include>;
+export interface ViewRef {
+    path: string;
+    view: string;
+}
+export declare const viewRef: Codec<ViewRef>;
+/** Complete pre-window grouping tuple and native summary results. */
+export interface QueryGroup {
+    values: FmMap;
+    count: number;
+    summaries?: FmMap;
+}
+export declare const queryGroup: Codec<QueryGroup>;
+/** Full metadata replacement bound to the enclosing live update's asOf. */
+export interface QueryMetadata {
+    /** Selection order is this array's order, never FM-map iteration order. */
+    columns?: string[];
+    totalCount?: number;
+    diagnostics?: Issue[];
+    view?: ViewRef;
+    groups?: QueryGroup[];
+    hasMore?: boolean;
+}
+export declare const queryMetadata: Codec<QueryMetadata>;
+export interface QueryResult {
+    records: RecordView[];
+    cursor?: string;
+    complete: boolean;
+    asOf: number;
+    /** `select` output names in selection order. */
+    columns?: string[];
+    /** Matches before pagination. */
+    totalCount?: number;
+    /** Per-record evaluation warnings. */
+    diagnostics?: Issue[];
+    /** The named view executed (`execute_view`). */
+    view?: ViewRef;
+    /** Complete native groups/summary results before pagination. */
+    groups?: QueryGroup[];
+    /** Flat matching records remain after the requested window. */
+    hasMore?: boolean;
+}
+export declare const queryResult: Codec<QueryResult>;
+export type UpdateKind = "snapshot" | "diff" | "reset";
+export interface QueryUpdate {
+    sub: number;
+    kind: UpdateKind;
+    added?: RecordView[];
+    changed?: RecordView[];
+    removed?: Uuid[];
+    order?: Uuid[];
+    complete: boolean;
+    asOf: number;
+    /** Full replacement, not a patch; absence does not mean zero/empty results. */
+    metadata?: QueryMetadata;
+}
+export declare const queryUpdate: Codec<QueryUpdate>;
+export interface Change {
+    id: Uuid;
+    path: string;
+    kind: "put" | "remove";
+    version: number;
+    author?: AuthorRef;
+    /** What changed (API 1.2). Absent when the producer cannot tell, as for a
+     * removal that left no tombstone; older producers never send it. */
+    entity?: "record" | "file";
+    /** A record's types (its last ones, for a removal). Absent for files and
+     * from older producers. */
+    types?: string[];
+}
+export declare const change: Codec<Change>;
+export interface ChangesResult {
+    changes: Change[];
+    cursor: string;
+    reset: boolean;
+}
+export declare const changesResult: Codec<ChangesResult>;
+export declare const MEDIA_CLASSES: readonly ["image", "audio", "video", "pdf", "other"];
+export type MediaClass = (typeof MEDIA_CLASSES)[number];
+export declare const mediaClass: Codec<"other" | "image" | "audio" | "video" | "pdf"> & {
+    values: readonly ("other" | "image" | "audio" | "video" | "pdf")[];
+};
+export type ConflictMode = "record" | "reject";
+export declare const conflictMode: Codec<ConflictMode> & {
+    values: readonly ConflictMode[];
+};
+/** `[key]` (the key was missing) or `[key, observed]`. */
+export interface BaseField {
+    key: string;
+    observed?: Value;
+}
+export declare const baseField: Codec<BaseField>;
+/** `[start, end, insert]`, offsets in Unicode scalar values of the base body. */
+export type BodyEdit = [start: number, end: number, insert: string];
+export declare const bodyEdit: Codec<BodyEdit>;
+export interface DocVersion {
+    path: string;
+    doc: string;
+}
+export declare const docVersion: Codec<DocVersion>;
+export interface FileInclusion {
+    include: MediaClass[];
+    exclude?: string[];
+    maxSize?: number;
+}
+export declare const fileInclusion: Codec<FileInclusion>;
+export type Op = {
+    kind: "create";
+    id: Uuid;
+    path?: string;
+    type?: string;
+    frontmatter?: FmMap;
+    body?: string;
+    document?: string;
+} | {
+    kind: "update";
+    id: Uuid;
+    patch?: FmMap;
+    unset?: string[];
+    add?: Map<string, Value[]>;
+    remove?: Map<string, Value[]>;
+    body?: string;
+    bodyEdits?: BodyEdit[];
+    bodyBase?: Hash;
+    bodyBaseText?: string;
+    base?: BaseField[];
+    ifRevision?: Hash;
+    updateRefs?: boolean;
+} | {
+    kind: "document";
+    id: Uuid;
+    base?: DocVersion;
+    new?: DocVersion;
+    ifRevision?: Hash;
+} | {
+    kind: "delete";
+    id: Uuid;
+    baseRevision?: Hash;
+    ifRevision?: Hash;
+} | {
+    kind: "rename";
+    id: Uuid;
+    from: string;
+    to: string;
+    updateRefs: boolean;
+    ifRevision?: Hash;
+} | {
+    kind: "resource_put";
+    path: string;
+    doc: string;
+    baseRevision?: Hash;
+    mustNotExist?: boolean;
+} | {
+    kind: "resource_delete";
+    path: string;
+    baseRevision?: Hash;
+} | {
+    kind: "file_put";
+    id: Uuid;
+    path: string;
+    blob: BlobRef;
+    ifRevision?: Hash;
+    base?: Hash;
+} | {
+    kind: "file_delete";
+    id: Uuid;
+    ifRevision?: Hash;
+    base?: Hash;
+} | {
+    kind: "file_move";
+    id: Uuid;
+    from: string;
+    to: string;
+    updateRefs: boolean;
+    ifRevision?: Hash;
+} | {
+    kind: "conflict_dismiss";
+    mutation: Uuid;
+    record: Uuid;
+} | {
+    kind: "sync_settings";
+    inclusion: FileInclusion;
+};
+export declare const op: Codec<Op>;
+export interface SubmitParams {
+    ops: Op[];
+    mutationId?: Uuid;
+    conflictMode?: ConflictMode;
+    timezone?: string;
+    allowPartial?: boolean;
+    mutationIds?: Uuid[];
+    dryRun?: boolean;
+    include?: Include;
+    wait?: "pending" | "confirmed" | "published";
+}
+export declare const submitParams: Codec<SubmitParams>;
+export type ConflictValue = {
+    form: "missing";
+} | {
+    form: "value";
+    value: Value;
+} | {
+    form: "text";
+    text: string;
+} | {
+    form: "blob";
+    blob: BlobRef;
+} | {
+    form: "deleted";
+};
+export declare const conflictValue: Codec<ConflictValue>;
+export type ConflictKind = "field" | "frontmatter" | "body" | "path" | "delete" | "file";
+export interface Conflict {
+    kind: ConflictKind;
+    id: Uuid;
+    field?: string;
+    base?: ConflictValue;
+    kept: ConflictValue;
+    lost: ConflictValue;
+}
+export declare const conflict: Codec<Conflict>;
+export type ReceiptState = "pending" | "confirmed" | "rejected" | "unknown";
+export type EntryStatus = "applied" | "merged" | "conflicted";
+/** Local file publication, independent of log confirmation. */
+export type PublishState = "publishing" | "published" | "not_published";
+export declare const publishState: Codec<PublishState> & {
+    values: readonly PublishState[];
+};
+export interface LinkRewrite {
+    record: Uuid;
+    path: string;
+    from: string;
+    to: string;
+    field?: string;
+}
+export interface BrokenLink {
+    record: Uuid;
+    path: string;
+    raw: string;
+    target: Uuid;
+    field?: string;
+}
+/** What a rename or delete dialog shows (dry run only, §5). */
+export interface Preflight {
+    rewrites: LinkRewrite[];
+    broken: BrokenLink[];
+}
+export declare const preflight: Codec<Preflight>;
+export interface Receipt {
+    mutation: Uuid;
+    state: ReceiptState;
+    seq?: number;
+    status?: EntryStatus;
+    conflicts?: Conflict[];
+    records?: RecordView[];
+    problem?: Problem;
+    /** Present on file-backed replicas; not a confirmation/custody authority. */
+    published?: PublishState;
+    /** Dry run only. */
+    preflight?: Preflight;
+    /** Earlier confirmed position after acknowledged-intent resurrection. */
+    relocatedFrom?: number;
+}
+export declare const receipt: Codec<Receipt>;
+export declare const submitResult: Codec<Receipt[]>;
+export interface ConflictEntry {
+    mutation: Uuid;
+    seq: number;
+    conflict: Conflict;
+}
+export declare const conflictEntry: Codec<ConflictEntry>;
+export type FileState = "materialized" | "remote" | "fetching" | "pending_upload";
+/** Actual persisted file kind and content representation (§10.1), never inferred from the path. */
+export type FileContentProfile = "ordinary_blob" | "ordinary_attachment_v1" | "unindexed_markdown_blob" | "unindexed_markdown_attachment_v1";
+export interface FileView {
+    id: Uuid;
+    path: string;
+    size: number;
+    digest: Hash;
+    media: MediaClass;
+    state: FileState;
+    confirmedSeq: number;
+    hold?: HoldRef;
+    /** Capture time of the last change to the content (§3.1). */
+    mtime?: number;
+    /** IANA media type from the path's extension (Core-derived, never sniffed); absent when unknown or from an older replica. */
+    mediaType?: string;
+    /** Actual persisted kind and content representation; absent means unknown. */
+    contentProfile?: FileContentProfile;
+}
+/** A future optional profile is unknown metadata, not an unreadable FileView. */
+export declare const fileView: Codec<FileView>;
+export interface ListFilesResult {
+    files: FileView[];
+    cursor?: string;
+    complete: boolean;
+}
+export declare const listFilesResult: Codec<ListFilesResult>;
+export interface OpenUploadParams {
+    transfer: Uuid;
+    path: string;
+    size: number;
+    digest?: Hash;
+    fileId?: Uuid;
+    ifRevision?: Hash;
+    mutationId?: Uuid;
+}
+export declare const openUploadParams: Codec<OpenUploadParams>;
+export interface OpenUploadResult {
+    transfer: Uuid;
+    chunkSize: number;
+    received: number[];
+    expiresAt: number;
+    /** Native-owned file identity (API 1.1); absent on older producers. */
+    fileId?: Uuid;
+}
+export declare const openUploadResult: Codec<OpenUploadResult>;
+export interface UploadChunkParams {
+    transfer: Uuid;
+    index: number;
+    bytes: Uint8Array;
+}
+export declare const uploadChunkParams: Codec<UploadChunkParams>;
+export interface FileChunk {
+    stream: number;
+    offset: number;
+    bytes: Uint8Array;
+    last: boolean;
+}
+export declare const fileChunk: Codec<FileChunk>;
+export declare const TRANSFER_PHASES: readonly ["receiving", "sealing", "uploading", "appending", "confirmed", "fetching", "streaming", "done"];
+export type TransferPhase = (typeof TRANSFER_PHASES)[number];
+/** Upload transfers are identified by UUID, download streams by number. */
+export interface TransferProgress {
+    id: Uuid | number;
+    phase: TransferPhase;
+    done: number;
+    total: number;
+}
+export declare const transferProgress: Codec<TransferProgress>;
+export interface Materialization {
+    mode: "all" | "on_demand";
+    pinned?: string[];
+    media?: MediaClass[];
+    maxSize?: number;
+}
+export declare const materialization: Codec<Materialization>;
+export interface Peer {
+    /** Opaque per-session pseudonym (16 bytes). */
+    session: Uint8Array;
+    account?: Uuid;
+    app?: string;
+    state: Value;
+    lastSeen: number;
+}
+export declare const peer: Codec<Peer>;
+export interface PresencePush {
+    record: Uuid;
+    peers: Peer[];
+}
+export declare const presencePush: Codec<PresencePush>;
+export interface FenceApply {
+    path: string;
+    base: Hash;
+    edits: BodyEdit[];
+    expected: Hash;
+}
+export declare const fenceApply: Codec<FenceApply>;
+export interface FenceReportEntry {
+    path: string;
+    dirty: boolean;
+    buffer: Hash;
+}
+export declare const fenceReport: Codec<{
+    open: FenceReportEntry[];
+}>;
+export declare const fenceResult: Codec<{
+    outcome: "applied" | "not_open" | "buffer_changed";
+    buffer?: string;
+}>;
+/** Codecs for the push types of the API, keyed by push type. */
+export declare const PUSH_CODECS: Record<string, Codec<any>>;
+export { b16, b32 };
+export interface OpClock {
+    instant: number;
+    tz: string;
+    localDate: string;
+}
+export declare const opClock: Codec<OpClock>;
+export interface Mutation {
+    id: Uuid;
+    origin: Uuid;
+    baseSeq: number;
+    clock: OpClock;
+    seed: Uint8Array;
+    source: "api" | "external";
+    ops: Op[];
+    onBehalf?: Uuid;
+    conflictMode?: ConflictMode;
+    validatedAt?: "off" | "warn" | "error";
+    room?: {
+        stream: Uint8Array;
+        state: Hash;
+    };
+}
+/**
+ * A captured mutation. Clients never build these (the replica captures them); the
+ * codec exists so the SDK runs the `conformance/wire/mutation/` fixtures.
+ */
+export declare const mutation: Codec<Mutation>;
+/** A resource: `mdbase.yaml`, a type file or a contract file (§4.1). */
+export interface ResourceView {
+    path: string;
+    /** Pass as `baseRevision` to `resource_put` / `resource_delete` for CAS. */
+    revision: Hash;
+    size: number;
+    state: "confirmed" | "pending";
+    text?: string;
+}
+export declare const resourceView: Codec<ResourceView>;
+/** One inventory page. A continuation is opaque and bound to its original read.
+ * Only a terminal page has complete=true; callers needing a snapshot must retain
+ * every page and refuse cursor errors rather than silently restart. */
+export interface ListResourcesResult {
+    resources: ResourceView[];
+    complete: boolean;
+    cursor?: string;
+}
+export declare const listResourcesResult: Codec<ListResourcesResult>;
+export interface Backlink {
+    record: RecordView;
+    links: LinkView[];
+}
+export interface BacklinksResult {
+    backlinks: Backlink[];
+    cursor?: string;
+    complete: boolean;
+    asOf: number;
+}
+export declare const backlinksResult: Codec<BacklinksResult>;
+export interface ViewProperty {
+    key: string;
+    label?: string;
+    description?: string;
+    format?: string;
+    hidden?: boolean;
+}
+export interface ViewDescriptor {
+    id: string;
+    name: string;
+    properties: ViewProperty[];
+    presentation?: Value;
+}
+export interface ViewSource {
+    record: Uuid;
+    id: string;
+    name: string;
+    source: {
+        path: string;
+        format: string;
+        revision: Hash;
+        writable: boolean;
+    };
+    views: ViewDescriptor[];
+}
+export declare const listViewsResult: Codec<{
+    sources: ViewSource[];
+    diagnostics: Issue[];
+    complete: boolean;
+}>;
+export interface ViewSourceDocument {
+    path: string;
+    format: string;
+    revision: Hash;
+    document: string;
+    record: Uuid;
+}
+export declare const viewSourceDocument: Codec<ViewSourceDocument>;
+export interface ContractImplementation {
+    contract: string;
+    version: string;
+    /** Contract field reference → record field reference. */
+    fields: Map<string, string>;
+    binding?: Value;
+    /** Implementation digest (spec 05A). Its type version is the owning summary's `version`. */
+    digest?: Hash;
+}
+export interface TypeSummary {
+    name: string;
+    path: string;
+    implements: ContractImplementation[];
+    /** The type's declared `version`. */
+    version?: number;
+    /** Revision of the type source in the local view; equals `resources.get(path).revision`. */
+    revision?: Hash;
+    /** The whole type frontmatter; only with `describe({ definitions: true })`. */
+    definition?: Value;
+    /** The resolved schema the type validates with; only with `describe({ definitions: true })`. */
+    schema?: Value;
+}
+export interface ContractSummary {
+    id: string;
+    version: string;
+    path: string;
+    digest: Hash;
+    contractType: string;
+    implementedBy: string[];
+    /** Resolved schemas by member (`record_schema`, ...); only with `describe({ definitions: true })`. */
+    schemas?: Map<string, Value>;
+}
+/** Where a new type file goes (`new_type_file`), derived by Core from its source. */
+export interface NewTypeFile {
+    name: string;
+    path: string;
+}
+export declare const newTypeFile: Codec<NewTypeFile>;
+export interface DescribeResult {
+    specVersion: string;
+    types: TypeSummary[];
+    settings: Value;
+    inclusion: FileInclusion;
+    issues: Issue[];
+    contracts: ContractSummary[];
+}
+export declare const describeResult: Codec<DescribeResult>;
+export interface PendingMutation {
+    receipt: Receipt;
+    captured: number;
+    /** Actual capture evidence, not legacy Submit admission. */
+    ops: RuntimeOp[];
+}
+export declare const listPendingResult: Codec<{
+    pending: PendingMutation[];
+    next?: Uuid;
+}>;
+/** A record or file by ID (uuid bytes) or path (text). */
+export declare const target: Codec<Uuid | {
+    path: string;
+}>;
+export interface QueryParams {
+    query: Value;
+    include?: Include;
+    contract?: string;
+}
+export declare const queryParams: Codec<QueryParams>;
+export interface ExecuteViewParams {
+    source: Uuid | {
+        path: string;
+    };
+    view: string;
+    context?: Uuid | {
+        path: string;
+    };
+    limit?: number;
+    offset?: number;
+    timezone?: string;
+    include?: Include;
+}
+export declare const executeViewParams: Codec<ExecuteViewParams>;
+/**
+ * Core's `temporal_hint`: `date` / `date_time` only when every requested type declares
+ * the same `format` at that top-level field; any unknown type, nested path or
+ * disagreement is `none`. Plain strings stay text even if they look like dates.
+ */
+export declare const TEMPORAL_HINTS: readonly ["none", "date", "date_time"];
+export type TemporalHint = (typeof TEMPORAL_HINTS)[number];
+export declare const temporalHint: Codec<"date" | "none" | "date_time"> & {
+    values: readonly ("date" | "none" | "date_time")[];
+};
+export interface TypingEntry {
+    /** The requested top-level field, verbatim. */
+    path: string;
+    hint: TemporalHint;
+}
+export interface DescribeTypingResult {
+    /** The catalog generation the answer was computed at; discard it across a catalog change. */
+    catalogGeneration: number;
+    /** One entry per requested path, in request order. */
+    fields: TypingEntry[];
+}
+export declare const typingEntry: Codec<TypingEntry>;
+export declare const describeTypingResult: Codec<DescribeTypingResult>;
+/** Request bounds (`too_large` beyond them on the replica; refused locally first). */
+export declare const DESCRIBE_TYPING_MAX_TYPES = 64;
+export declare const DESCRIBE_TYPING_MAX_PATHS = 256;