@declarion/react 0.61.1 → 0.63.0

package/dist-lib/api/agents.d.ts

@@ -1,140 +0,0 @@
-export type AgentRole = "user" | "assistant" | "tool" | "system";
-export type AgentContentBlock = {
-    type: "text";
-    text: string;
-} | {
-    type: "tool_use";
-    id: string;
-    name: string;
-    input: Record<string, unknown>;
-} | {
-    type: "tool_result";
-    id: string;
-    name?: string;
-    output: unknown;
-    is_error?: boolean;
-} | {
-    type: "elicit";
-    id: string;
-    schema: Record<string, unknown>;
-    message: string;
-} | {
-    type: "elicit_response";
-    id: string;
-    data: Record<string, unknown>;
-} | {
-    type: "attachment";
-    kind: string;
-    content: string;
-} | {
-    type: "summary";
-    covers: string[];
-    text: string;
-} | {
-    type: "system";
-    reason: string;
-} | {
-    type: "decision";
-    tool_use_id?: string;
-    tool_code: string;
-    decision: "approved" | "rejected";
-    decided_by?: string;
-    decided_at?: string;
-    note?: string;
-};
-export interface AgentMessage {
-    id: string;
-    conversation_id: string;
-    seq: number;
-    role: AgentRole;
-    content: AgentContentBlock[];
-    created_at: string;
-    streaming?: boolean;
-}
-export type AgentTurnStatus = "queued" | "running" | "waiting" | "completed" | "failed" | "canceled";
-export interface AgentTurn {
-    id: string;
-    conversation_id: string;
-    trigger_message_id: string;
-    runnable_message_seq: number;
-    status: AgentTurnStatus;
-    model_step: number;
-    reserved_assistant_message_id?: string | null;
-    error_code?: string | null;
-    error_details?: unknown;
-}
-export type AgentInvocationStatus = "proposed" | "pending_input" | "pending_approval" | "approved" | "rejected" | "running" | "succeeded" | "failed" | "canceled" | "interrupted" | "outcome_unknown";
-export type AgentInvocationKind = "action" | "input_request" | "tool";
-export interface AgentToolInvocation {
-    id: string;
-    conversation_id: string | null;
-    message_id: string | null;
-    kind: AgentInvocationKind;
-    turn_id: string | null;
-    assistant_message_id: string | null;
-    response_message_id: string | null;
-    provider_call_id: string | null;
-    call_ordinal: number | null;
-    server_code: string;
-    tool_code: string;
-    params: Record<string, unknown>;
-    question?: {
-        key?: string;
-        message?: string;
-        schema?: Record<string, unknown>;
-    };
-    status: AgentInvocationStatus;
-    approval?: {
-        decided_by?: string;
-        decided_at?: string;
-        reason?: string;
-        edits?: Record<string, unknown>;
-    };
-    confirmation_mode?: "never" | "once_per_conversation" | "always";
-    result?: unknown;
-    audit_operation_id?: string;
-    reason?: string;
-    confidence?: number;
-}
-export type AgentConversationStatus = "active" | "canceling" | "interrupted" | "closed";
-export interface AgentConversation {
-    id: string;
-    tenant_id: string;
-    created_by?: string;
-    agent_id?: string;
-    agent?: string;
-    title?: string;
-    model?: string;
-    status: AgentConversationStatus;
-    token_usage?: {
-        in?: number;
-        out?: number;
-        cached_in?: number;
-    };
-}
-export interface AvailableAgent {
-    id: string;
-    code: string;
-    name?: Record<string, string>;
-    description?: Record<string, string>;
-    is_default: boolean;
-}
-export declare function listAvailableAgents(): Promise<AvailableAgent[]>;
-export declare function createConversation(input: {
-    agent_id?: string;
-}): Promise<AgentConversation>;
-export declare function sendMessage(text: string, conversationId: string): Promise<AgentMessage>;
-export declare function answerQuestion(invocationId: string, answer: Record<string, unknown>): Promise<void>;
-export declare function sendElicitResponse(_conversationId: string, invocationId: string, data: Record<string, unknown>): Promise<void>;
-/** What a person permitted: this call alone, or the action for the rest of
- *  the conversation. Absent means this call alone - the safe reading, and
- *  what every row written before the choice existed means. */
-export type ApprovalScope = "call" | "conversation";
-export declare function approveInvocation(id: string, scope?: ApprovalScope): Promise<void>;
-export declare function rejectInvocation(id: string, note?: string): Promise<void>;
-export declare function cancelInvocation(id: string): Promise<void>;
-export declare function cancelConversation(id: string): Promise<void>;
-export declare function listConversations(): Promise<AgentConversation[]>;
-export declare function loadConversationTurns(conversationId: string): Promise<AgentTurn[]>;
-export declare function loadConversationInvocations(conversationId: string): Promise<AgentToolInvocation[]>;
-export declare function loadHistory(conversationId: string): Promise<AgentMessage[]>;

package/dist-lib/api/auth-redirect.d.ts

@@ -1,3 +0,0 @@
-export declare function sanitizeRedirectPath(value: string | null | undefined): string;
-export declare function loginPathForRedirectPath(value: string | null | undefined): string;
-export declare function loginPathForCurrentLocation(): string;

package/dist-lib/api/auth.d.ts

@@ -1,26 +0,0 @@
-import type { CheckSetupResponse, LoginResponse, AuthUser, Tenant, SSOProvider } from "../types/api.d.ts";
-export declare function checkSetup(): Promise<CheckSetupResponse>;
-export declare function login(email: string, password: string, remember?: boolean): Promise<LoginResponse>;
-export declare function signup(email: string, password: string, displayName: string): Promise<LoginResponse>;
-export declare function getMe(): Promise<AuthUser>;
-export declare function listTenants(): Promise<Tenant[]>;
-export declare function switchTenant(tenantId: string): Promise<LoginResponse>;
-export declare function createTenant(code: string, name: string): Promise<Tenant>;
-export declare function logout(): Promise<void>;
-export declare function listSSOProviders(tenantCode?: string): Promise<SSOProvider[]>;
-export declare function ssoAuthorizeUrl(slug: string, tenantCode?: string, redirect?: string): string;
-/**
- * Impersonation client surface. Each call dispatches through
- * POST /api/actions/{code} like every other auth handler. The server
- * sets / clears the impersonation cookies via the LoginResult
- * HTTPCustomizer; the client receives the public response shape
- * (user / tenant / expires_at) and reloads the auth context.
- */
-export interface ImpersonationStartResponse extends LoginResponse {
-    impersonation_session_id: string;
-    session_expires_at: string;
-}
-export declare function impersonationStart(targetUserId: string, reason: string, durationMinutes?: number): Promise<ImpersonationStartResponse>;
-export declare function impersonationStop(): Promise<LoginResponse>;
-export declare function impersonationRevoke(sessionId: string): Promise<void>;
-export declare function changePassword(currentPassword: string, newPassword: string): Promise<void>;

package/dist-lib/api/batch.d.ts

@@ -1,25 +0,0 @@
-import type { ApiErrorBody } from "../types/api.d.ts";
-export interface BatchOp {
-    action: string;
-    params?: Record<string, unknown> | null;
-}
-export interface BatchOpResult {
-    index: number;
-    /** The dispatched action, so an entry says WHICH op it describes. */
-    action?: string;
-    ok: boolean;
-    result?: unknown;
-    /** The failure, in the one shape every carrier sends. */
-    error?: ApiErrorBody;
-}
-export interface BatchResponse {
-    results: BatchOpResult[];
-    committed: boolean;
-}
-export declare class Batch {
-    private ops;
-    call(action: string, params?: unknown): this;
-    upsert(entity: string, records: Array<Record<string, unknown>>, mode?: "upsert" | "insert_if_missing", uniqueBy?: string[]): this;
-    execute(): Promise<BatchResponse>;
-    _ops(): readonly BatchOp[];
-}

package/dist-lib/api/client.d.ts

@@ -1,51 +0,0 @@
-/** Signals that auth.refresh failed terminally (refresh cookie missing, token
- *  expired/reused, session revoked). Callers MUST stop retrying and route the
- *  user back to /login — retrying produces an infinite 401/4xx storm against
- *  the rate-limited refresh endpoint. Distinct from generic network errors so
- *  useSSE can branch on it. */
-export declare class RefreshDeadError extends Error {
-    status: number;
-    constructor(status: number);
-}
-/** Arm the proactive refresh timer from a server `expires_at` (the access
- *  token expiry, ISO-8601). Call after every login / signup / switch / the
- *  refresh itself. An undefined or unparseable value just clears the timer -
- *  the reactive 401 path still guarantees correctness. */
-export declare function scheduleProactiveRefresh(expiresAt: string | undefined): void;
-/** Stop proactive refresh and forget the tracked expiry. Called on logout. */
-export declare function cancelProactiveRefresh(): void;
-export declare function ensureRefresh(): Promise<void>;
-type PersistentAuthFailureHandler = () => void;
-/** Replace the handler invoked on persistent 401. Intended for tests
- *  and non-browser consumers. Returns the previous handler so callers
- *  can restore it if needed. */
-export declare function setPersistentAuthFailureHandler(h: PersistentAuthFailureHandler): PersistentAuthFailureHandler;
-/** Returns the currently registered persistent-auth-failure handler. useSSE
- *  reads this lazily so a setPersistentAuthFailureHandler() call from a test
- *  is observed by the SSE retry loop without re-importing the module. */
-export declare function getPersistentAuthFailureHandler(): PersistentAuthFailureHandler;
-export type ApiErrorReport = {
-    status: number;
-    code: string;
-    message: string;
-};
-type ApiErrorReporter = (report: ApiErrorReport) => void;
-/** Replace the reporter invoked for every non-2xx response. Returns the
- *  previous reporter so callers can restore it. Tests should install a
- *  spy or no-op via this hook instead of stubbing `console.error`. */
-export declare function setApiErrorReporter(r: ApiErrorReporter): ApiErrorReporter;
-export declare function publishLanguage(language: string | null): void;
-export declare function currentReader(): number;
-export declare function publishLanguageFor(startedFor: number, language: string): void;
-export declare function currentPublishedLanguage(): string | null;
-export declare function withPublishedLanguage(path: string): string;
-export declare function apiFetch<T>(path: string, options?: RequestInit): Promise<T>;
-export interface BlobResponse {
-    blob: Blob;
-    filename: string;
-    headers: Headers;
-}
-export declare function apiFetchBlob(path: string, options?: RequestInit): Promise<BlobResponse>;
-export declare function parseContentDispositionFilename(headers: Headers): string;
-export declare function callHandler<R = unknown>(code: string, args?: unknown): Promise<R>;
-export {};

package/dist-lib/api/data.d.ts

@@ -1,153 +0,0 @@
-import type { ApiErrorBody, ListParams, ListResponse, DataResponse } from "../types/api.d.ts";
-import type { PkValues } from "../types/schema.d.ts";
-import type { ExportRequest } from "../components/pages/exportRequest.d.ts";
-export declare function listEntities(entity: string, params?: ListParams, options?: {
-    signal?: AbortSignal;
-}): Promise<ListResponse>;
-/** What a single-record read asks the server to compute beside the row. */
-export interface GetEntityOptions {
-    expand?: readonly "evidence"[];
-}
-export declare function getEntity(entity: string, pkValues: PkValues | string, options?: GetEntityOptions): Promise<DataResponse>;
-export declare function createEntity(entity: string, data: Record<string, unknown>): Promise<DataResponse>;
-export declare function updateEntity(entity: string, pkValues: PkValues | string, data: Record<string, unknown>): Promise<DataResponse>;
-export declare function deleteObject(entity: string, pkValues: PkValues | string): Promise<void>;
-export declare function encodeObjectId(pkValues: PkValues): string;
-export declare function restoreObject(entity: string, pkValues: PkValues | string): Promise<void>;
-/** Result of POST /api/data/{entity}/export. The server streams a CSV
- *  blob; the client gets the bytes plus the server-resolved filename
- *  (parsed from Content-Disposition by apiFetchBlob, with RFC 5987
- *  filename* preferred). Triggering the actual download (anchor click)
- *  is the caller's job — separation lets ExportMenu show the bytes in a
- *  toast when the browser blocks the download. */
-export interface ExportResponse {
-    blob: Blob;
-    filename: string;
-}
-export declare function exportEntities(entity: string, body: ExportRequest): Promise<ExportResponse>;
-/**
- * Action request body is flat: top-level keys are handler params. The only
- * reserved control key is `object_ids` (array of object IDs for
- * single/batch scope). The server resolves entity from the action's
- * registration; the URL code is fully qualified ("entity.action" for
- * entity-scoped, "action" for global). Legacy `_ids` is rejected 400 by
- * the server (parseActionBody) — there is no compat shim.
- */
-export type ActionExecuteRequest = Record<string, unknown>;
-export interface ActionExecuteResponse {
-    status: string;
-    result?: unknown;
-    audit_operation_id?: string;
-    object_count?: number;
-    /** IDs that succeeded (batch_mode: each responses). */
-    success?: string[];
-    /** Per-item errors (batch_mode: each responses with failures or partial). */
-    errors?: ActionItemError[];
-    /** Per-item skips (batch_mode: each responses where conditions filtered rows). */
-    skipped?: ActionItemSkip[];
-    /**
-     * The action's declared synchronous chain, when it has one. ABSENT means the
-     * action declares no such step - never that a step passed. A failed step does
-     * not change the action's own status: it committed, and an event is free to
-     * fail without undoing a committed write. So "saved" and "saved, and the work
-     * behind it did not run" are the same status and different reports.
-     */
-    events?: EventsReport;
-}
-/** What the platform says the action's synchronous chain did. */
-export interface EventsReport {
-    failed_count?: number;
-    timed_out_count?: number;
-    job_ids?: string[];
-    /** In the handler's DECLARED step order, at every depth. */
-    failures?: EventFailure[];
-    /** What the response bounds dropped. Non-zero means there were more. */
-    failures_omitted?: number;
-}
-/** One declared step that did not do its work. */
-export interface EventFailure {
-    step: number;
-    handler: string;
-    /** The id a per-object step died on. */
-    object?: string;
-    /** How many objects after it were never reached. */
-    not_attempted?: number;
-    error?: ApiErrorBody;
-    /** This step's OWN chain, when it declared one. */
-    events?: EventsReport;
-}
-/** Whether anything in this chain, at any depth, did not happen. */
-export declare function eventsFailed(events: EventsReport | undefined): boolean;
-export interface ActionItemError {
-    id: string;
-    /** The failure, in the one shape every carrier sends. */
-    error: ApiErrorBody;
-}
-export interface ActionItemSkip {
-    id: string;
-    reason: string;
-}
-/**
- * Thrown by executeAction when the platform returns 4xx with the invoke:each
- * batch shape (all items failed). Carries the per-item details so the UI can
- * render a meaningful toast instead of a generic "request failed".
- *
- * Pre-dispatch failures (auth, unknown action, invoke-shape mismatch) keep
- * throwing the standard ApiError; use `instanceof ActionBatchError` to
- * distinguish.
- */
-export declare class ActionBatchError extends Error {
-    readonly status: number;
-    readonly response: ActionExecuteResponse;
-    constructor(status: number, response: ActionExecuteResponse);
-}
-/**
- * Build a flat action body from handler params + optional object IDs.
- * Promotes `ids` to the reserved `object_ids` key. Throws if a caller
- * passes a param literally named `object_ids` (collision with the
- * reserved control key) or the now-rejected legacy `_ids` key.
- *
- * The wire-level reserved key is `object_ids`. The legacy `_ids` envelope
- * was removed; the server answers it with a 400.
- */
-export declare function buildActionBody(params: Record<string, unknown> | undefined, ids?: string[]): ActionExecuteRequest;
-/**
- * A drop-in replacement for the network action dispatch. Installed only in
- * tests via setActionExecutor; production leaves it null.
- */
-export type ActionExecutor = (code: string, body: ActionExecuteRequest) => Promise<ActionExecuteResponse>;
-/**
- * Install a test-time override for executeAction - and therefore for
- * createEntity / updateEntity / deleteObject / restoreObject, which all
- * dispatch through executeAction. The @declarion/react/testing harness uses
- * this (mirroring setApiErrorReporter) to resolve actions from a fixture map
- * instead of the network. Returns the previous executor so a test can restore
- * it. Pass null to clear. Default (unset) is the real apiFetch path, unchanged.
- */
-export declare function setActionExecutor(fn: ActionExecutor | null): ActionExecutor | null;
-/**
- * Test-time override for the entity-list read seam (the leaf of useEntityData /
- * useEntityCount). Return undefined to fall through to the network. Installed
- * by @declarion/react/testing so the REAL list hooks run and resolve fixtures
- * by entity, params-agnostically (the hooks' query keys carry the screen's
- * per_page / sort / filters, which a cache seed cannot know ahead of render).
- */
-export type ListEntitiesResolver = (entity: string, params: ListParams) => ListResponse | undefined;
-/** Test-time override for the single-record read seam (useObject -> getEntity). */
-export type GetEntityResolver = (entity: string, pkValues: PkValues | string) => DataResponse | undefined;
-/** Install/clear the list read seam. Returns the previous resolver. */
-export declare function setListEntitiesResolver(fn: ListEntitiesResolver | null): ListEntitiesResolver | null;
-/** Install/clear the single-record read seam. Returns the previous resolver. */
-export declare function setGetEntityResolver(fn: GetEntityResolver | null): GetEntityResolver | null;
-/**
- * Invoke an action. The URL `code` must be fully qualified for
- * entity-scoped actions (e.g. `lead.archive`). For global actions it's the
- * action code on its own (e.g. `auth.login`).
- */
-export declare function executeAction(code: string, body: ActionExecuteRequest): Promise<ActionExecuteResponse>;
-export interface AssociationResponse {
-    target_entity: string;
-    ids: string[];
-    count: number;
-}
-export declare function resolveAssociation(code: string, ids: string[]): Promise<AssociationResponse>;

package/dist-lib/api/entities.d.ts

@@ -1,149 +0,0 @@
-import type { Refs, V2ListParams, V2Meta, V2StatusInstance, V2PropertyInstance, EnrichedRow } from "../types/api.d.ts";
-/** Helper methods injected onto enriched rows. */
-export interface RowHelpers {
-    $status(groupCode: string): V2StatusInstance | undefined;
-    $property(propertyCode: string): V2PropertyInstance | undefined;
-}
-/** Normalized ref cache that merges $refs across multiple responses. */
-export declare class RefCache {
-    private cache;
-    /** Merge incoming refs into the cache. */
-    merge(refs: Refs | undefined): void;
-    /** Get a snapshot of all cached refs. */
-    all(): Refs;
-    /** Look up a single ref by entity code and id. */
-    get(entityCode: string, id: string): Record<string, unknown> | undefined;
-    /** Clear the cache. */
-    clear(): void;
-}
-/**
- * Generic, type-safe client for a single entity's v2 API.
- *
- * Single-item methods wrap arrays and unwrap the first result.
- * Bulk methods pass arrays through directly.
- *
- * All write responses return enriched rows with $refs, $statuses, etc.
- */
-export declare class EntityClient<T extends Record<string, unknown> = Record<string, unknown>> {
-    readonly entity: string;
-    readonly refs: RefCache;
-    constructor(entity: string, refCache?: RefCache);
-    /** Get a single record through the query-PK detail contract.
-     *
-     * Pass a string to address by the `id` field (the common single-`id`-PK case,
-     * unchanged). Pass a PkValues object to address an entity whose primary key is
-     * a different single field (e.g. `{ code: "files.gc_sweep" }` for `schedule`)
-     * or a composite key (`{ region: "eu", code: "r1" }`) - each field becomes its
-     * own query param, which is how the detail contract resolves a row. A bare
-     * string with a non-`id` PK would send `?id=...` and 400. */
-    get(pk: string | Record<string, string>): Promise<T & EnrichedRow & RowHelpers>;
-    /** List records with cursor-based pagination, field selection, and expansion.
-     *
-     * Recovery on cursor-stale signals: when the server returns
-     * `cursor.semantics_mismatch` (sort grammar version bump),
-     * `cursor.language_changed` (the reader's language switched mid-pagination), or
-     * `cursor.archive_invalid` (an undecodable cross-store archive cursor), the
-     * `after` token is dropped and the request is retried once from the top.
-     *
-     * CRITICAL for accumulating callers (infinite scroll): the returned
-     * `reset` flag is `true` when this recovery fired. The refetched data is
-     * WINDOW 1, not the next page - an accumulating `useInfiniteQuery` MUST
-     * discard its prior pages and start from this one, never append it as the
-     * next page (which would duplicate the head and drop the middle). Callers
-     * that fetch a single window can ignore `reset`. See Decisions Log #14.
-     */
-    list(params?: V2ListParams): Promise<{
-        data: (T & RowHelpers)[];
-        meta: V2Meta;
-        $refs: Refs;
-        reset: boolean;
-    }>;
-    /** Create a single record. Wraps in array, returns unwrapped result. */
-    create(item: Partial<T> & Record<string, unknown>): Promise<T & EnrichedRow & RowHelpers>;
-    /**
-     * Create multiple records in one transactional batch.
-     *
-     * `data.create` is one row per dispatch; N independent
-     * inserts compose through the platform batch primitive (`system.batch`,
-     * atomic READ COMMITTED tx). Each child op targets `<entity>.__create`
-     * with a FLAT `{entity, fields}` body inside `BatchOp.params`.
-     *
-     * Returns rows in input order. The batch fails atomically: any per-op
-     * error surfaces as a thrown Error with the first failing op's code +
-     * message; `committed: false` (4xx/200-soft-fail) means no row was
-     * written. The HTTP transport itself failing (5xx, network) keeps
-     * propagating as ApiError unchanged.
-     */
-    createMany(items: (Partial<T> & Record<string, unknown>)[]): Promise<(T & EnrichedRow & RowHelpers)[]>;
-    /** Update a single record. Wraps in array, returns unwrapped result. */
-    update(id: string, data: Partial<T> & Record<string, unknown>): Promise<T & EnrichedRow & RowHelpers>;
-    /**
-     * Update multiple records in one request. Each item must include its id.
-     *
-     * `data.update` is one fields map per dispatch
-     * ({object_ids, entity, fields}); per-row variation composes through
-     * `system.batch` (atomic READ COMMITTED tx) — one __update child op per
-     * input item, mirroring createMany / upsertMany. The batch is atomic:
-     * any per-op failure rolls back all rows. The first per-op error
-     * surfaces as a thrown Error.
-     *
-     * Returns rows in input order.
-     */
-    updateMany(items: (Partial<T> & Record<string, unknown> & {
-        id: string;
-    })[]): Promise<(T & EnrichedRow & RowHelpers)[]>;
-    /** Delete a single record by ID. */
-    delete(id: string): Promise<void>;
-    /**
-     * Delete multiple records in one request. Returns the count of deleted
-     * records.
-     *
-     * Dispatches /api/actions/<entity>.__delete with a FLAT envelope
-     * ({object_ids, entity}); the server derives the rows from `object_ids`
-     * and the entity's PK fields. The legacy `_ids` key is rejected with 400.
-     */
-    deleteMany(ids: string[]): Promise<{
-        count: number;
-    }>;
-    /** Restore a single soft-deleted record by ID. */
-    restore(id: string): Promise<void>;
-    /**
-     * Restore multiple soft-deleted records. Returns the count of restored
-     * records.
-     *
-     * Routes through the platform-default `__restore` action. The legacy CRUD route
-     * POST /api/data/{entity}/restore is retired (returns 410). The FLAT
-     * envelope ({object_ids, entity}) lands directly in DataRestoreParams
-     * via JSON tags; no `params:` wrapper on the wire.
-     */
-    restoreMany(ids: string[]): Promise<{
-        count: number;
-    }>;
-    /** Upsert a single record. Wraps in array, returns unwrapped result. */
-    upsert(item: Partial<T> & Record<string, unknown>, uniqueFields: string[]): Promise<T & EnrichedRow & RowHelpers>;
-    /**
-     * Upsert multiple records. Existing matches (by uniqueFields) are
-     * updated; absent rows are inserted.
-     *
-     * `data.upsert` is one row per dispatch (per-row uniqueness matching), so N
-     * rows compose through `system.batch`. Each child op targets
-     * `<entity>.__upsert` with FLAT `{entity, fields, unique_by}` params.
-     * The handler returns `DataUpsertResult.rows[]` where each
-     * DataUpsertRowResult carries `{pk, action, row}`; the row payload is
-     * extracted to preserve the prior API shape (array of enriched rows).
-     *
-     * The batch is atomic: any per-op failure rolls back all rows. The
-     * first per-op error surfaces as a thrown Error.
-     */
-    upsertMany(items: (Partial<T> & Record<string, unknown>)[], uniqueFields: string[]): Promise<(T & EnrichedRow & RowHelpers)[]>;
-}
-/**
- * Create an EntityClient for the given entity code.
- * Optionally share a RefCache across multiple clients.
- *
- * NOTE(T5): Each call creates a new EntityClient (and a new RefCache if none is
- * provided). For cross-page ref accumulation, callers should create a persistent
- * RefCache instance and pass it to every entityClient() call, e.g. via React
- * context or a module-level singleton.
- */
-export declare function entityClient<T extends Record<string, unknown> = Record<string, unknown>>(entity: string, refCache?: RefCache): EntityClient<T>;

package/dist-lib/api/events.d.ts

@@ -1,91 +0,0 @@
-/**
- * What a change frame says happened. The relay emits exactly these three; a
- * restore is an SQL update and arrives as `updated`, so a branch on a fourth
- * value is dead.
- * Declared once here because every layer below reads the same wire word.
- */
-export type EntityAction = "created" | "updated" | "deleted";
-/** One row a change frame names: its object id and its primary key. */
-export interface ChangedObject {
-    object_id?: string;
-    pk?: Record<string, string>;
-}
-export type SSEEvent = {
-    type: "entity_changed";
-    eventID?: string;
-    entity: string;
-    ids: string[];
-    objects?: ChangedObject[];
-    action: EntityAction;
-    /**
-     * Why the frame names no rows, when it names none. Only
-     * `access_not_projectable` can mean a viewer LOST a row, so only it may
-     * empty a cache; the rest leave a screen stale rather than wrong.
-     */
-    reason?: string;
-} | {
-    type: "checkpoint";
-    eventID: string;
-} | {
-    type: "replay_complete";
-    seq?: number;
-} | {
-    type: "snapshot_complete";
-    known: boolean;
-    asOf?: number;
-} | {
-    type: "realtime_streaming";
-    eventID?: string;
-    degraded: string[];
-} | {
-    type: "realtime_degraded";
-    eventID?: string;
-    entity: string;
-    degradedSeq?: number;
-} | {
-    type: "cache_reset";
-    eventID?: string;
-    reason: string;
-    requestedSeq?: number;
-    oldestSeq?: number;
-    resetSeq?: number;
-} | {
-    type: "session_refresh";
-};
-export declare const agentBus: EventTarget;
-export declare const AGENT_FRAME_EVENT = "agent-frame";
-export declare const AGENT_MESSAGE_CHANGED_EVENT = "agent-message-changed";
-export interface AgentFrameDetail {
-    convId: string;
-    kind: string;
-    turnId?: string;
-    payload?: Record<string, unknown>;
-}
-export declare function emitAgentFrame(detail: AgentFrameDetail): void;
-export declare class SSEAuthError extends Error {
-    constructor();
-}
-export interface StreamEventsOptions {
-    signal?: AbortSignal;
-    lastEventID?: string;
-    /**
-     * Embed token mode: the scoped embed JWT. When set, it is sent as
-     * `Authorization: Bearer <token>` and the request omits cookies (see
-     * `credentials` below). Outside embed mode this is undefined and the
-     * cookie path runs unchanged.
-     */
-    bearerToken?: string;
-    /**
-     * Cookie policy for the SSE fetch. Defaults to `"include"` (the cookie
-     * path). Embed mode passes `"omit"`: the iframe is same-origin to
-     * Declarion and the auth middleware reads the cookie before the Bearer
-     * header, so a sent cookie would bypass the scoped embed token.
-     */
-    credentials?: RequestCredentials;
-    /**
-     * Called for every chunk read from the stream, heartbeat comments included:
-     * what proves the connection is still alive on a tenant with nothing to say.
-     */
-    onActivity?: () => void;
-}
-export declare function streamEvents(options?: StreamEventsOptions): AsyncGenerator<SSEEvent>;

package/dist-lib/api/params.d.ts

@@ -1,28 +0,0 @@
-import type { ParamLookup, PublicParamsResponse, ResolvedParam } from "../types/api.d.ts";
-/**
- * Fetches the full pre-login envelope from /api/params/public:
- * {parameters, accents, meta}. Used by AuthShell to theme
- * unauthenticated screens before any user context exists.
- */
-export declare function fetchPublicParams(): Promise<PublicParamsResponse>;
-/**
- * Looks up a single parameter from the platform. Always returns a
- * `ParamLookup`; `found:false` signals "no value, use your default".
- * Network/auth failures still throw - "missing" is normal, "broken"
- * is an error.
- */
-export declare function fetchParam(code: string): Promise<ParamLookup>;
-/**
- * Fetches the bulk effective-value view: every declared parameter the caller
- * may see (disclosure-tiered server-side), each carrying its declaration facets
- * (scopes / structure / choices) so the admin UIs are self-sufficient.
- *
- * `resolution: "tenant"` returns the TENANT BASELINE (yaml/env/tenant sources
- * only, no role/user overlays) - the lens the tenant Parameters screen edits.
- * Omit it for the caller's full personal resolution (Profile / attachment).
- *
- * NOTE: there is deliberately NO partial-write helper. Parameter overrides are
- * written through the carrier entity's `__update` action with a FULL `$params`
- * set (see ParamsBlock); a single-code write would delete every other override.
- */
-export declare function fetchAllParams(resolution?: "tenant"): Promise<ResolvedParam[]>;