@declarion/react 0.61.1 → 0.63.0

package/dist-lib/hooks/useActionData.d.ts

@@ -1,61 +0,0 @@
-import { type QueryKey } from "@tanstack/react-query";
-/** The canonical list-page envelope a paginated action returns in its `result` -
- *  the same shape `data.list` (ListResponse) produces. */
-export interface ActionListPage<T> {
-    data: T[];
-    meta?: {
-        cursor?: string;
-        has_more?: boolean;
-    };
-}
-/** Query-key root for a one-shot action read. Mirrors the entity root
- *  `entity-data`. */
-export declare const ACTION_DATA_KEY = "action-data";
-/** Query-key root for a cursor (infinite) action read. Mirrors the entity cursor
- *  root `entity-data-cursor`; distinct from the one-shot read so it is
- *  reaped/registered independently. */
-export declare const ACTION_DATA_CURSOR_KEY = "action-data-cursor";
-/**
- * The React Query key for a one-shot action read. Single source of truth for
- * both `useActionData` and a screen registering it as its PRIMARY read with its
- * retained page (`useRegisterRetainedQuery`). `params` is embedded directly;
- * React Query hashes it stably (sorted keys).
- */
-export declare function actionDataQueryKey(actionCode: string | undefined, params: Record<string, unknown>): QueryKey;
-/**
- * Read an arbitrary action ONCE and cache its `result` - the action mirror of
- * `useEntityData`. `T` is whatever the action returns (a summary object, or a
- * plain array that is not cursor-paginated). Returns the raw React Query result;
- * the caller registers the key via `actionDataQueryKey` +
- * `useRegisterRetainedQuery` for retention.
- */
-export declare function useActionData<T>(actionCode: string | undefined, params: Record<string, unknown>, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<T, Error>;
-/**
- * The React Query key for a cursor (infinite) action read. Single source of
- * truth for both `useCursorActionData` and its retained-page registration. The
- * key excludes the cursor (the cursor is the page param, not part of identity).
- */
-export declare function cursorActionDataQueryKey(actionCode: string | undefined, params: Record<string, unknown>): QueryKey;
-/** The accumulated, table-ready result of a cursor action read - mirrors the
- *  shape `useCursorEntityData` feeds a list. */
-export interface CursorActionDataResult<T> {
-    rows: T[];
-    hasMore: boolean;
-    fetchNextPage: () => void;
-    isFetchingNextPage: boolean;
-    isLoading: boolean;
-    isError: boolean;
-    error: Error | null;
-    refetch: () => void;
-    queryKey: QueryKey;
-}
-/**
- * Drive a cursor-paginated table from an action that returns an `ActionListPage`
- * in its `result`. The mirror of `useCursorEntityData`, differing only in the
- * source (an action via `executeAction`, not `EntityClient.list`): it
- * accumulates windows with `useInfiniteQuery`, advancing `meta.cursor` while
- * `meta.has_more`, and exposes the flattened rows. Register the returned
- * `queryKey` with `useRegisterRetainedQuery` so the pages survive a tab switch /
- * Back within the retention window and die with the retained page.
- */
-export declare function useCursorActionData<T>(actionCode: string | undefined, params: Record<string, unknown>, enabled?: boolean): CursorActionDataResult<T>;

package/dist-lib/hooks/useAgentConversation.d.ts

@@ -1,24 +0,0 @@
-import { type ApprovalScope, type AgentConversation, type AgentMessage, type AgentToolInvocation, type AgentTurn, type AvailableAgent } from "../api/agents.d.ts";
-export interface AgentTurnState {
-    streaming: boolean;
-}
-export declare function useAgentConversation(initialConversationId?: string): {
-    conversationId: string | undefined;
-    messages: AgentMessage[];
-    turn: AgentTurnState;
-    turns: AgentTurn[];
-    invocations: AgentToolInvocation[];
-    conversations: AgentConversation[];
-    send: (text: string) => Promise<void>;
-    approve: (invocationId: string, scope?: ApprovalScope) => Promise<void>;
-    reject: (invocationId: string, note?: string) => Promise<void>;
-    submitInput: (invocationId: string, data: Record<string, unknown>) => Promise<void>;
-    cancelInput: (invocationId: string) => Promise<void>;
-    cancel: () => Promise<void>;
-    refreshConversations: () => Promise<void>;
-    startNew: () => void;
-    agents: AvailableAgent[];
-    selectedAgentId: string | undefined;
-    selectAgent: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
-    setConversationId: (id: string | undefined) => void;
-};

package/dist-lib/hooks/useAllEntityData.d.ts

@@ -1,16 +0,0 @@
-import type { ListParams, ListResponse } from "../types/api.d.ts";
-/**
- * Fetches every page of an entity list and concatenates the result into a
- * single ListResponse whose `meta.total` is the true row count.
- *
- * For board / kanban screens that group the entire result set client-side
- * and therefore cannot use one server-capped page. It fetches page 1 to
- * learn `total_pages`, then fetches the remaining pages in parallel and
- * merges their `$refs`.
- *
- * Prefer `useEntityData` for paginated list screens. This hook holds the
- * full result set in memory and is only appropriate for bounded entities.
- * The caller's `page` / `per_page` in `params` are ignored - this hook owns
- * pagination - while `filters`, `search`, `sort`, and `expand` are honored.
- */
-export declare function useAllEntityData(entity: string | undefined, params?: ListParams): import("@tanstack/react-query").UseQueryResult<ListResponse<Record<string, unknown>>, Error>;

package/dist-lib/hooks/useAssociatedData.d.ts

@@ -1,10 +0,0 @@
-import type { V2ListResponse } from "../types/api.d.ts";
-/**
- * useAssociatedData fetches associated (non-aggregate) child entity records
- * with cursor-based pagination, search, and filter support.
- *
- * Uses useInfiniteQuery so that "Load more" accumulates pages rather than
- * replacing data. The query key is compatible with the SSE invalidation
- * predicate (index 0 = ENTITY_CHILDREN_KEY, index 3 = child entity code).
- */
-export declare function useAssociatedData(parentEntity: string, parentId: string, entityCode: string, foreignKey: string, sort?: string, limit?: number, search?: string, filters?: Record<string, string>): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/react-query").InfiniteData<V2ListResponse<Record<string, unknown>>, unknown>, Error>;

package/dist-lib/hooks/useAuth.d.ts

@@ -1,22 +0,0 @@
-export declare function useAuth(): {
-    user: import("..").AuthUser | null;
-    isAuthenticated: boolean;
-    isLoading: boolean;
-    activeTenant: import("..").Tenant | null;
-    tenants: import("..").Tenant[];
-    login: import("@tanstack/react-query").UseMutateFunction<import("..").LoginResponse, Error, {
-        email: string;
-        password: string;
-        remember?: boolean;
-    }, unknown>;
-    signup: import("@tanstack/react-query").UseMutateFunction<import("..").LoginResponse, Error, {
-        email: string;
-        password: string;
-        displayName: string;
-    }, unknown>;
-    switchTenant: import("@tanstack/react-query").UseMutateFunction<import("..").LoginResponse, Error, string, unknown>;
-    logout: () => Promise<void>;
-    isLoginPending: boolean;
-    isSignupPending: boolean;
-    isSwitchingTenant: boolean;
-};

package/dist-lib/hooks/useBranding.d.ts

@@ -1,8 +0,0 @@
-import type { PublicBranding } from "../types/api.d.ts";
-export declare function useBranding(): {
-    branding: PublicBranding | undefined;
-    isLoading: boolean;
-};
-export declare function useBrandingIdentity(): import("../types/api.d.ts").BrandingIdentity | undefined;
-export declare function useBrandingTheme(): import("../types/api.d.ts").BrandingTheme | undefined;
-export declare function useBrandingChromeValue(): import("../types/api.d.ts").BrandingChrome | undefined;

package/dist-lib/hooks/useBrandingChrome.d.ts

@@ -1,59 +0,0 @@
-import { type ResponsiveBreakpoints } from "../lib/viewport-category.d.ts";
-import type { BrandingBreakpoints, BrandingShellFlags, BrandingSurfaceFlags, BrandingViewport } from "../types/api.d.ts";
-export type BrandingChromeSurface = "list" | "detail" | "record_list" | "custom";
-/**
- * The deployment's declared viewport for the CURRENT presentation context.
- *
- * `auto` means derive it from the measured width, which is what a deployment
- * that says nothing gets, and what the SDK has always done. A forced value
- * overrides the width for every consumer of the viewport category at once.
- *
- * The embed context is where this earns its keep: inside an iframe the measured
- * width is the IFRAME's, not the host page's, so a 500-pixel panel on a
- * 2560-pixel desktop is measured as a phone and rendered as one. A host sets
- * `branding.chrome.embed.viewport: desktop` and the whole SDK follows.
- */
-export declare function useBrandingViewport(): BrandingViewport;
-/**
- * The device-class boundaries for the CURRENT presentation context.
- *
- * A deployment overrides one bound at a time; the rest keep the SDK's table.
- * This is the fine-grained counterpart of {@link useBrandingViewport}: that one
- * forces a class outright, this one moves where the classes meet - which is what
- * a deployment on hardware the default table misreads actually needs, without
- * pinning every user of that context to one class.
- */
-export declare function useBrandingBreakpoints(): ResponsiveBreakpoints;
-/**
- * The declared bounds, or the SDK's table where a bound is absent or unusable.
- *
- * The two widths are read TOGETHER because they are ordered: the rule tests
- * `phoneMax` first and `tabletMax` second, so a declaration where the phone
- * bound is not below the tablet bound makes the tablet class unreachable - every
- * viewport is a phone or a desktop and nothing says so. That is the class this
- * refuses. It is also the lever the responsive design nominates as the recovery
- * for a device the default table misreads, so a silently dead override would be
- * discovered by the operator who reached for it in an emergency.
- *
- * Refusing means keeping the pair the SDK ships, which is coherent, and saying
- * so once where a deployment can read it. The height bound is independent of
- * both and is resolved on its own.
- */
-export declare function resolveBreakpoints(declared: BrandingBreakpoints | undefined): ResponsiveBreakpoints;
-export interface ResolvedBrandingChrome extends BrandingSurfaceFlags {
-    isVisible: (key: keyof BrandingSurfaceFlags) => boolean;
-}
-export interface ResolvedBrandingShell extends BrandingShellFlags {
-    isVisible: (key: keyof BrandingShellFlags) => boolean;
-}
-/**
- * Per-surface chrome for the current presentation context. The surface is
- * REQUIRED: shell flags live in {@link useBrandingShell}, a different YAML
- * structure with a different key set.
- */
-export declare function useBrandingChrome(surface: BrandingChromeSurface): ResolvedBrandingChrome;
-/**
- * Shell chrome flags (`branding.chrome.full.shell`). Only `full` has a shell:
- * an embed renders no shell, so there is no embed branch here.
- */
-export declare function useBrandingShell(): ResolvedBrandingShell;

package/dist-lib/hooks/useChildrenData.d.ts

@@ -1,3 +0,0 @@
-import type { ListResponse } from "../types/api.d.ts";
-export declare const ENTITY_CHILDREN_KEY: "entity-children";
-export declare function useChildrenData(parentEntity: string, parentId: string, childCode: string, foreignKey: string | string[], sort?: string, limit?: number): import("@tanstack/react-query").UseQueryResult<ListResponse<Record<string, unknown>>, Error>;

package/dist-lib/hooks/useColumns.d.ts

@@ -1,13 +0,0 @@
-/**
- * useColumns manages visible columns via URL `columns` param.
- * Falls back to screen defaults when no URL param is set.
- */
-export declare function useColumns(availableColumns: string[], defaultColumns: string[]): {
-    visibleColumns: string[];
-    availableColumns: string[];
-    setColumns: (cols: string[]) => void;
-    resetToDefaults: () => void;
-    showAll: () => void;
-    isColumnVisible: (col: string) => boolean;
-    toggleColumn: (col: string) => void;
-};

package/dist-lib/hooks/useCurrentScreen.d.ts

@@ -1,34 +0,0 @@
-import { type ReactNode } from "react";
-import type { Screen } from "../types/schema.d.ts";
-/**
- * The screen a component is currently rendering inside.
- *
- * Standard pages have always been told which screen they are (`SmartListPage`,
- * `SmartDetailPage` and `SmartRecordListPage` all take `screenCode`). A CUSTOM screen
- * was told nothing - it was mounted as a bare `<Component />` - so it could not read
- * its own declaration and had no choice but to hardcode what the schema already said.
- * That is why a screen renamed or translated in YAML kept an English literal in its
- * header while the sidebar followed the schema.
- *
- * This context closes that gap: every routed screen, custom included, is rendered
- * inside it, so any component in the tree can ask what it is looking at without prop
- * drilling. `PageHeader` uses it to default its title and description - which is what
- * makes `<PageHeader />` with no props the correct, complete header for a custom screen.
- */
-export interface CurrentScreen {
-    /** The screen's code in the schema (e.g. `events_compare`). */
-    code: string;
-    /** Its full declaration, or undefined if the schema has not loaded yet. */
-    screen: Screen | undefined;
-}
-export declare function CurrentScreenProvider({ code, children, }: {
-    code: string;
-    children: ReactNode;
-}): import("react").JSX.Element;
-/**
- * The screen this component is rendering inside, or undefined outside a routed screen.
- *
- * Use it to read anything the schema already declares - the localized name, the
- * description, the entity, the route - instead of restating it in the component.
- */
-export declare function useCurrentScreen(): CurrentScreen | undefined;

package/dist-lib/hooks/useCursorEntityData.d.ts

@@ -1,79 +0,0 @@
-import { type QueryKey } from "@tanstack/react-query";
-import type { Refs, V2Meta } from "../types/api.d.ts";
-import type { FilterNode } from "../lib/filters.d.ts";
-/**
- * Query-key root for the cursor (infinite) entity list. Distinct from the
- * offset list's `"entity-data"` so the SSE handler can RESET it (drop pages,
- * refetch window 1) instead of invalidating it - invalidating an infinite query
- * refetches every accumulated page with its now-stale cursor and corrupts the
- * list. See useSSE.ts.
- */
-export declare const CURSOR_ENTITY_DATA_KEY = "entity-data-cursor";
-/**
- * The stable JSON segment of the cursor list's query key (the view-defining
- * params, order-independent). Extracted so both the hook and the key builder
- * compute it identically.
- */
-export declare function cursorEntityStableKey(params: CursorEntityDataParams): string;
-/**
- * The React Query key for the cursor (infinite) entity list. Single source of
- * truth for both `useCursorEntityData` and a screen registering its PRIMARY
- * cursor read with its retained page (`useRegisterRetainedQuery`).
- */
-export declare function cursorEntityDataQueryKey(entity: string | undefined, params: CursorEntityDataParams): QueryKey;
-export interface CursorEntityDataParams {
-    sort?: string;
-    filters?: FilterNode[];
-    search?: string;
-    select?: string[];
-    expand?: string[];
-    includeDeleted?: boolean;
-    screen?: string;
-    preview?: boolean;
-    limit: number;
-}
-/**
- * useCursorEntityData drives the cursor-native admin list for an archive entity
- * whose `list_pagination` is `cursor` (Postgres-hot + ClickHouse-cold). It
- * accumulates windows with `useInfiniteQuery` over `EntityClient.list` (so the
- * stale-cursor `reset` signal is available), requests the estimated count on
- * the FIRST window only, and resets to window 1 when a stale cursor is hit
- * mid-scroll. Realtime resets are driven centrally by the SSE handler via
- * resetQueries on CURSOR_ENTITY_DATA_KEY.
- *
- * `enabled` gates the query so a NON-cursor entity (offset mode) pays nothing -
- * the page calls both this and useEntityData and enables exactly one.
- */
-export declare function useCursorEntityData(entity: string | undefined, params: CursorEntityDataParams, enabled: boolean): {
-    rows: (Record<string, unknown> & import("../api/entities.d.ts").RowHelpers)[];
-    refs: Refs | undefined;
-    total: number | undefined;
-    countMode: string | undefined;
-    countUnknown: boolean;
-    hasMore: boolean;
-    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
-        data: (Record<string, unknown> & import("../api/entities.d.ts").RowHelpers)[];
-        meta: V2Meta;
-        $refs: Refs;
-        reset: boolean;
-    }, unknown>, Error>>;
-    isFetchingNextPage: boolean;
-    isLoading: boolean;
-    isFetching: boolean;
-    isError: boolean;
-    error: Error | null;
-    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
-        data: (Record<string, unknown> & import("../api/entities.d.ts").RowHelpers)[];
-        meta: V2Meta;
-        $refs: Refs;
-        reset: boolean;
-    }, unknown>, Error>>;
-};
-/**
- * CursorEntityDataResult is the public return contract of useCursorEntityData -
- * the digested infinite-list shape (accumulated `rows`, `hasMore` +
- * `fetchNextPage` for scroll, the first-window `total`/`countUnknown`, and the
- * react-query status flags). Named (not inferred) so SDK consumers have a stable
- * type to annotate against. Derived from the hook so it never drifts.
- */
-export type CursorEntityDataResult = ReturnType<typeof useCursorEntityData>;

package/dist-lib/hooks/useDebounce.d.ts

@@ -1 +0,0 @@
-export declare function useDebounce<T>(value: T, delay: number): T;

package/dist-lib/hooks/useEntity.d.ts

@@ -1,2 +0,0 @@
-import type { Entity } from "../types/schema.d.ts";
-export declare function useEntity(entityCode: string | undefined): Entity | undefined;

package/dist-lib/hooks/useEntityData.d.ts

@@ -1,41 +0,0 @@
-import { type QueryKey } from "@tanstack/react-query";
-import type { ListParams, ListResponse } from "../types/api.d.ts";
-/**
- * The React Query key for an entity list-window read. The single source of
- * truth for both `useEntityData` and a screen registering its PRIMARY read with
- * its retained page (`useRegisterRetainedQuery`), so the registered key matches
- * the live query exactly. See hooks/usePageStateRuntime.ts.
- */
-export declare function entityDataQueryKey(entity: string | undefined, params: ListParams): QueryKey;
-/**
- * useEntityData fetches one page-window of entity rows.
- *
- * Decoupled-count contract:
- * this hook issues the WINDOW request only - `count: "window"`, so the
- * server returns the page of rows and never blocks on a COUNT(*). The total
- * is fetched separately by `useEntityCount`; the table renders rows the
- * moment this query resolves, independent of count latency.
- */
-export declare function useEntityData(entity: string | undefined, params: ListParams, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<ListResponse<Record<string, unknown>>, Error>;
-/**
- * The React Query key for an entity's count read, built from the same list
- * params its window takes, so a list's window and count are named from one
- * place. The page-window knobs are stripped: the count describes the whole
- * filtered set, and must not refetch when only the page or sort moves.
- */
-export declare function entityCountQueryKey(entity: string | undefined, params: ListParams): QueryKey;
-/**
- * useEntityCount fetches the total row count for a list view in a SEPARATE
- * request from the window (`count: "only"` - the server skips the data
- * query entirely and returns just `meta.total` + `meta.count_mode`).
- *
- * The count is page-independent: `page` and `sort` are stripped from the
- * params so a page change or a re-sort does not refetch the count - only a
- * filter / search / screen / include_deleted change invalidates it.
- *
- * The server picks exact vs estimated per the entity's declared `count`
- * strategy; the resolved `meta.count_mode` tells the caller which precision
- * to render. A count failure does NOT break the table: callers treat a
- * failed/absent count as "unknown" and fall back to the loaded row count.
- */
-export declare function useEntityCount(entity: string | undefined, params: ListParams, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<ListResponse<Record<string, unknown>>, Error>;

package/dist-lib/hooks/useFilters.d.ts

@@ -1,14 +0,0 @@
-import { type FilterNode } from "../lib/filters.d.ts";
-interface FiltersInput {
-    defaults?: FilterNode[];
-}
-/** `filters=[]` and an absent parameter are different states: the first says
- *  the caller removed every condition, the second says `defaults` apply. */
-export declare function useFilters({ defaults }?: FiltersInput): {
-    filters: FilterNode[];
-    filterError: string | null;
-    activeCount: number;
-    setFilters: (newFilters: FilterNode[]) => void;
-    clearFilters: () => void;
-};
-export {};

package/dist-lib/hooks/useImpersonation.d.ts

@@ -1,23 +0,0 @@
-/**
- * useImpersonation centralizes the three lifecycle calls (start, stop,
- * revoke) and re-hydrates auth state on success so the topbar / banner /
- * viewport frame react in lockstep.
- *
- * isImpersonating is derived from auth.me's impersonation field which the
- * server populates only when the request was issued under an active
- * impersonation session. Direct human action and agent flows (without an
- * impersonation channel) leave it null.
- */
-export declare function useImpersonation(): {
-    info: import("../types/api").ImpersonationInfo | null;
-    isImpersonating: boolean;
-    start: import("@tanstack/react-query").UseMutateFunction<import("../api/auth.d.ts").ImpersonationStartResponse, Error, {
-        targetUserId: string;
-        reason: string;
-        durationMinutes?: number;
-    }, unknown>;
-    stop: import("@tanstack/react-query").UseMutateFunction<import("..").LoginResponse, Error, void, unknown>;
-    revoke: import("@tanstack/react-query").UseMutateFunction<void, Error, string, unknown>;
-    isStarting: boolean;
-    isStopping: boolean;
-};

package/dist-lib/hooks/useLanguage.d.ts

@@ -1,4 +0,0 @@
-import type { QueryClient } from "@tanstack/react-query";
-export declare function useLanguage(): string;
-export declare function useDeploymentLanguage(): string;
-export declare function reresolveLanguage(queryClient: QueryClient): Promise<void>;

package/dist-lib/hooks/useLiveObject.d.ts

@@ -1,9 +0,0 @@
-import type { UseQueryResult } from "@tanstack/react-query";
-import { type DataResponse, type EnrichedRow } from "../types/api.d.ts";
-import type { PkValues } from "../types/schema.d.ts";
-export type LiveObjectResult<T extends Record<string, unknown> = EnrichedRow> = UseQueryResult<DataResponse<T>, Error> & {
-    object: T | undefined;
-    isLive: boolean;
-    isNotFound: boolean;
-};
-export declare function useLiveObject<T extends Record<string, unknown> = EnrichedRow>(entity: string | undefined, pkValues: PkValues | string | undefined): LiveObjectResult<T>;

package/dist-lib/hooks/useLongPress.d.ts

@@ -1,29 +0,0 @@
-import type { PointerEvent as ReactPointerEvent } from "react";
-export interface UseLongPress {
-    /** Spread onto the row surface. */
-    handlers: {
-        onPointerDown: (event: ReactPointerEvent) => void;
-        onPointerMove: (event: ReactPointerEvent) => void;
-        onPointerUp: () => void;
-        onPointerCancel: () => void;
-        onPointerLeave: () => void;
-    };
-    /**
-     * True when the click now arriving is the tail of a long press that already
-     * fired. Reading it clears it, so the row's own click handler calls this once
-     * and skips navigating when it answers true.
-     */
-    consumePressFired: () => boolean;
-}
-/**
- * Binds the long-press gesture to a row surface and calls `onLongPress` with the
- * press point when it completes.
- *
- * Mouse presses are ignored: a fine pointer has right-click, which is the same
- * Row Menu through the same composition path, and holding a mouse button down
- * over a row is not a gesture anyone means.
- */
-export declare function useLongPress(onLongPress: (point: {
-    x: number;
-    y: number;
-}) => void): UseLongPress;

package/dist-lib/hooks/useMutations.d.ts

@@ -1,13 +0,0 @@
-import { type PkValues } from "../types/schema.d.ts";
-import type { ActionExecuteRequest } from "../api/data.d.ts";
-export declare function useCreateObject(entityCode: string): import("@tanstack/react-query").UseMutationResult<import("..").DataResponse<Record<string, unknown>>, Error, Record<string, unknown>, unknown>;
-export declare function useUpdateObject(entityCode: string): import("@tanstack/react-query").UseMutationResult<import("..").DataResponse<Record<string, unknown>>, Error, {
-    pkValues: PkValues | string;
-    data: Record<string, unknown>;
-}, unknown>;
-export declare function useDeleteObject(entityCode: string): import("@tanstack/react-query").UseMutationResult<void, Error, string | PkValues, unknown>;
-export declare function useRestoreEntity(entityCode: string): import("@tanstack/react-query").UseMutationResult<void, Error, string | PkValues, unknown>;
-export declare function useExecuteAction(entityCode?: string): import("@tanstack/react-query").UseMutationResult<import("../api/data.d.ts").ActionExecuteResponse, Error, {
-    actionCode: string;
-    body: ActionExecuteRequest;
-}, unknown>;

package/dist-lib/hooks/useObject.d.ts

@@ -1,11 +0,0 @@
-import { type QueryKey } from "@tanstack/react-query";
-import { type GetEntityOptions } from "../api/data.d.ts";
-import type { PkValues } from "../types/schema.d.ts";
-/**
- * The React Query key for a single-record read. Single source of truth for both
- * `useObject` and a detail screen registering its PRIMARY read with its
- * retained page (`useRegisterRetainedQuery`). For a string PK uses it directly;
- * for a composite PK sorts the parts so key order does not fork the cache.
- */
-export declare function objectQueryKey(entity: string | undefined, pkValues: PkValues | string | undefined, options?: GetEntityOptions): QueryKey;
-export declare function useObject(entity: string | undefined, pkValues: PkValues | string | undefined, options?: GetEntityOptions): import("@tanstack/react-query").UseQueryResult<import("..").DataResponse<Record<string, unknown>>, Error>;

package/dist-lib/hooks/useObjectStatus.d.ts

@@ -1,5 +0,0 @@
-export declare function useSetStatus(entity: string | undefined, id: string | undefined): import("@tanstack/react-query").UseMutationResult<import("..").StatusInfo, Error, {
-    groupCode: string;
-    statusCode: string;
-    note?: string;
-}, unknown>;

package/dist-lib/hooks/usePageState.d.ts

@@ -1,32 +0,0 @@
-/** A `useState`-style setter accepting a value or an updater. */
-export type PageStateSetter<T> = (next: T | ((prev: T) => T)) => void;
-/**
- * How coarsely a value is keyed.
- *   - `"url"` (default): keyed by the full canonical URL, so it FORKS when
- *     filters/sort/sub-view change (per-view memory - e.g. scroll position,
- *     expanded rows). A filter change is a new view with its own value.
- *   - `"path"`: keyed by the screen pathname only, so it PERSISTS across
- *     in-screen query changes (e.g. row selection, which survives a filter or
- *     column change and is pruned to the visible rows, not reset).
- */
-export type PageStateScope = "url" | "path";
-export interface PageStateOptions {
-    scope?: PageStateScope;
-}
-/**
- * Bind a deep value to the current screen's retained page.
- *
- * Returns `[value, setValue]`:
- *   - `value` is the stored value for the live canonical URL, or `defaultValue`
- *     when absent / reaped / retention disabled. Re-renders only when THIS
- *     pageKey's value for THIS key changes.
- *   - `setValue` writes through to the store under the LIVE canonical URL
- *     (tracked via a per-render ref, so the stable setter always targets the
- *     currently-mounted view - never a key captured at mount, never the
- *     destination's after a navigation). Accepts a value or an updater.
- *
- * Writes are immediate (write-through), so there is no deferred unmount flush to
- * lose: a value set while mounted at a URL is already stored under that URL when
- * the screen unmounts. The retained page is created lazily on first write.
- */
-export declare function usePageState<T>(key: string, defaultValue: T, opts?: PageStateOptions): [T, PageStateSetter<T>];

package/dist-lib/hooks/usePageStateRuntime.d.ts

@@ -1,27 +0,0 @@
-import { type QueryClient, type QueryKey } from "@tanstack/react-query";
-/**
- * Apply `gcTime` to every retained-read query-key prefix. Exported so app.tsx
- * can seed the DEFAULT floor on the QueryClient at module load - BEFORE the
- * first screen renders and creates its reads - so even that first screen's data
- * is not GC'd at React Query's 5-min default within the retention window. The
- * runtime then overrides with the resolved per-tenant value for later reads.
- */
-export declare function applyRetainedReadGcTime(client: QueryClient, gcTime: number): void;
-/**
- * Mount once (Layout) to drive the retained-page lifecycle from the resolved
- * `ui_page_state_ttl_ms`. Idempotent and inert beyond its three effects.
- */
-export declare function usePageStateRuntime(): void;
-/**
- * Register a screen's PRIMARY heavy read (its list or detail query key) with the
- * current retained page, so a kill/sweep `removeQueries` releases the cached
- * data alongside the deep state. Call from the standard pages (and custom
- * screens) with the key from the matching key-builder (`entityDataQueryKey` /
- * `cursorEntityDataQueryKey` / `objectQueryKey`).
- *
- * Pass ONLY primary heavy reads - never a shared ref/lookup query, or a
- * sibling screen that shares its key would lose it on this page's eviction.
- * `enabled` (default true) lets the cursor/offset pages register exactly the
- * read they actually use.
- */
-export declare function useRegisterRetainedQuery(queryKey: QueryKey | undefined, enabled?: boolean): void;

package/dist-lib/hooks/usePageStateTtl.d.ts

@@ -1,11 +0,0 @@
-/** The platform parameter governing retained-page retention. Declared in
- *  modules/declarion-core/schema/core_parameters.yaml (int, category `ui`,
- *  `[tenant]`, env `DECLARION_UI_PAGE_STATE_TTL_MS`). */
-export declare const PAGE_STATE_TTL_PARAM = "ui_page_state_ttl_ms";
-/**
- * Resolve the retention window in milliseconds. Returns the per-tenant value
- * once the parameter loads, the YAML-mirrored default before then, and clamps a
- * malformed value to the default (never NaN/negative). `0` is honored as
- * "retention disabled".
- */
-export declare function usePageStateTtl(): number;

package/dist-lib/hooks/useParams.d.ts

@@ -1,49 +0,0 @@
-import type { ParamLookup, ParamOverride, ResolvedParam } from "../types/api.d.ts";
-/** `$params` subresource key on a carrier's PK-detail / write payload. */
-export declare const PARAMS_KEY = "$params";
-/**
- * `$params` is a FULL-SET write: a loaded detail without the key is an error
- * (`missingParams`), never an empty set, which would delete every override.
- */
-export declare function useCarrierParamOverrides({ carrierEntityCode, rowId, enabled, onWritten, }: {
-    /** Carrier entity code (the write target, e.g. "profile", "my_tenant"). */
-    carrierEntityCode: string;
-    /** Carrier row id ($params writes ride object_ids: [rowId]). */
-    rowId: string;
-    enabled?: boolean;
-    /** Called after a successful write (e.g. close the edit dialog). */
-    onWritten?: () => void;
-}): {
-    overrides: ParamOverride[];
-    overrideByCode: Map<string, ParamOverride>;
-    /** True when the loaded detail carries no `$params` key - a hard error. */
-    missingParams: boolean;
-    isLoading: boolean;
-    /** Last write failure, cleared on the next write attempt or clearError. */
-    error: string | null;
-    /** Clears the write error (e.g. when opening or cancelling the edit dialog). */
-    clearError: () => void;
-    save: (param: ResolvedParam, value: unknown) => Promise<void>;
-    reset: (param: ResolvedParam) => Promise<void>;
-};
-/** `resolution: "tenant"` reads the tenant baseline, without role and user overrides. */
-export declare function useAllParams(resolution?: "tenant"): import("@tanstack/react-query").UseQueryResult<ResolvedParam[], Error>;
-export declare function usePublicParams(): import("@tanstack/react-query").UseQueryResult<import("../types/api.d.ts").PublicParamsResponse, Error>;
-export declare function useResolvedParam(code: string, options?: {
-    enabled?: boolean;
-}): import("@tanstack/react-query").UseQueryResult<ParamLookup, Error>;
-export declare function useEffectiveParam<T = unknown>(code: string): {
-    value: T | undefined;
-    found: boolean;
-    source: ParamLookup["source"] | "public" | undefined;
-    loading: boolean;
-    error: Error | null;
-};
-/** A failed read returns the default AND `error`; a gate on anything sensitive checks `error`. */
-export declare function useParam<T>(code: string, defaultValue: T): {
-    value: T;
-    found: boolean;
-    source: ParamLookup["source"] | undefined;
-    loading: boolean;
-    error: Error | null;
-};