@cosmicdrift/kumiko-renderer 0.384.0 → 0.385.0

package/dist/app/projection-list-body.js

@@ -0,0 +1,245 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from "react";
+import { RenderList } from "../components/render-list.js";
+import { useOptionalDispatcher } from "../context/dispatcher-context.js";
+import { useIsEmbeddedScreen } from "../context/embedded-screen-context.js";
+import { useUserRoles } from "../context/user-roles-context.js";
+import { useListUrlState } from "../hooks/use-list-url-state.js";
+import { useQuery } from "../hooks/use-query.js";
+import { useOptionalTimeZone, useTranslation } from "../i18n.js";
+import { usePrimitives, } from "../primitives.js";
+import { screenFillsHeight } from "../screen-fills-height.js";
+import { DrawerHost, useDrawerAction } from "./action-form-body.js";
+import { useAppFeatures } from "./app-features-context.js";
+import { useClientActionRuntime } from "./client-actions.js";
+import { isListNarrowed, useListEmptyContent } from "./list-empty-content.js";
+import { buildDateRangePayload, buildFilterFacets, buildFilterPayload, clampDateRange, mergeReferenceFacetOptions, readDateRange, resolveDateRangeFacets, resolveProjectionFacetSpecs, } from "./list-facets.js";
+import { useNav } from "./nav.js";
+import { synthesizeProjectionEntity, synthesizeProjectionScreen } from "./projection-list-shim.js";
+import { QueryErrorBanner, QueryLoadingBanner } from "./query-state-banners.js";
+import { ReferenceFacetBridges } from "./reference-facet-bridge.js";
+import { useReturnHost } from "./return-to.js";
+import { buildDefaultEditRowAction, buildProjectionRowActions, buildProjectionToolbarActions, findRowClickAction, runDrawerRowAction, runProjectionRowNavigate, } from "./row-actions.js";
+import { findEditScreenFor } from "./screen-access.js";
+import { buildListQueryPayload, pageSizeOptionsFor } from "./screen-shared.js";
+// ---- projection-list ----
+// Like entityList, but the list query comes DIRECTLY from `screen.query`
+// (instead of being derived from an entity) — cross-feature capable.
+// search/sort/pagination reuse the same URL-state + buildListQueryPayload
+// wiring as EntityListBody; which of them are actually offered is derived
+// from the query handler's Zod schema at buildAppSchema time (fw#2165), not
+// declared here. Pages-mode pagination only — infinite-scroll accumulation
+// isn't wired for projectionList.
+export function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
+    const isEmbeddedScreen = useIsEmbeddedScreen();
+    const { Banner, Text } = usePrimitives();
+    const t = useTranslation();
+    const nav = useNav();
+    const host = useReturnHost();
+    const dispatcher = useOptionalDispatcher();
+    const clientActions = useClientActionRuntime();
+    const effectiveTranslate = translate ?? t;
+    const userRoles = useUserRoles();
+    const appFeatures = useAppFeatures();
+    const { drawerAction, drawerScreen, drawerInitialValues, openDrawer, closeDrawer } = useDrawerAction(schema);
+    const defaultEditScreen = useMemo(() => {
+        const detailFor = screen.detailFor;
+        if (detailFor === undefined)
+            return undefined;
+        return findEditScreenFor(detailFor, appFeatures, userRoles);
+    }, [appFeatures, screen.detailFor, userRoles]);
+    // searchable/sortable/paginated are derived at buildAppSchema time from the
+    // query handler's Zod schema (fw#2165) — not authored on the screen.
+    const searchable = screen.searchable ?? false;
+    const sortable = screen.sortable ?? false;
+    const paginated = screen.paginated ?? false;
+    const entity = useMemo(() => synthesizeProjectionEntity(screen.columns, sortable), [screen.columns, sortable]);
+    const listScreen = useMemo(() => synthesizeProjectionScreen(screen), [screen]);
+    const urlState = useListUrlState(screen.id);
+    // Gated on the derived capability, not just on whether URL-state happens to
+    // carry a value — a stale/hand-crafted URL (?…q=x on a non-searchable
+    // screen) must not smuggle a param the query's Zod schema doesn't accept.
+    const activeSearch = searchable ? urlState.q : "";
+    // Same predicate that makes a header clickable: a stale link onto a
+    // sortable:false/unknown column must not reach the server (it answers 400).
+    const urlSort = urlState.sort;
+    const urlSortField = urlSort === null ? undefined : entity.fields[urlSort.field];
+    const urlSortAllowed = urlSortField !== undefined && "sortable" in urlSortField && urlSortField.sortable === true;
+    const activeSort = sortable
+        ? ((urlSortAllowed ? urlSort : null) ?? screen.defaultSort ?? null)
+        : null;
+    const limit = urlState.pageSize ?? screen.pageSize ?? 50;
+    // Pages-mode only (see header comment) — an author-set pagination:
+    // "infinite" on a paginated projectionList is silently a no-op today.
+    const usePager = paginated && (screen.pagination ?? "pages") === "pages";
+    // Facets (fw#2224) — a projectionList has no entity, so screen.facets is
+    // the only field inventory; resolveProjectionFacetSpecs reshapes +
+    // translates its explicit labels into the same ResolvedFacetSpec the
+    // entityList adapter produces, so both feed the same
+    // buildFilterFacets/buildFilterPayload.
+    const facetSpecs = useMemo(() => resolveProjectionFacetSpecs(screen.facets, effectiveTranslate, schema.featureName), [screen.facets, effectiveTranslate, schema.featureName]);
+    const [projectionReferenceFacetOptions, setProjectionReferenceFacetOptions] = useState({});
+    const handleProjectionFacetOptions = useCallback((field, options) => setProjectionReferenceFacetOptions((prev) => prev[field] === options ? prev : { ...prev, [field]: options }), []);
+    const resolvedFacetSpecs = useMemo(() => mergeReferenceFacetOptions(facetSpecs, projectionReferenceFacetOptions), [facetSpecs, projectionReferenceFacetOptions]);
+    const filterPayload = useMemo(() => buildFilterPayload(urlState.filters, (field) => facetSpecs.find((spec) => spec.field === field)?.type), [urlState.filters, facetSpecs]);
+    // dateRange facets (fw#3104) bypass `filters` entirely — their two bounds
+    // become the top-level query params the facet declares, resolved from a
+    // calendar date to an instant in the viewer's zone.
+    const timeZone = useOptionalTimeZone();
+    const dateRangeSpecs = useMemo(() => resolveDateRangeFacets(screen.facets, effectiveTranslate), [screen.facets, effectiveTranslate]);
+    const dateRangePayload = useMemo(() => buildDateRangePayload(dateRangeSpecs, urlState.filters, timeZone), [dateRangeSpecs, urlState.filters, timeZone]);
+    const queryPayload = useMemo(() => {
+        const payload = buildListQueryPayload({
+            limit,
+            search: activeSearch,
+            sort: activeSort,
+            usePager,
+            page: urlState.page,
+            useInfinite: false,
+            cursor: undefined,
+        });
+        // Gated on screen.filter/screen.facets being declared (not just on
+        // urlState/filterPayload happening to carry a value) — same rule as
+        // activeSearch/activeSort above: a stale URL must not smuggle a param
+        // the bound query's Zod schema doesn't accept (fw#2165 pattern).
+        if (screen.filter !== undefined) {
+            payload["filter"] = screen.filter;
+        }
+        if (screen.facets !== undefined && filterPayload.length > 0) {
+            payload["filters"] = filterPayload;
+        }
+        Object.assign(payload, dateRangePayload);
+        return payload;
+    }, [
+        limit,
+        activeSearch,
+        activeSort,
+        usePager,
+        urlState.page,
+        screen.filter,
+        screen.facets,
+        filterPayload,
+        dateRangePayload,
+    ]);
+    const rowsQuery = useQuery(screen.query, queryPayload, { live: true });
+    const filterFacets = useMemo(() => buildFilterFacets(resolvedFacetSpecs), [resolvedFacetSpecs]);
+    const dateRangeFacets = useMemo(() => dateRangeSpecs.map((spec) => ({
+        field: spec.field,
+        label: spec.label,
+        ...readDateRange(urlState.filters, spec.field),
+    })), [dateRangeSpecs, urlState.filters]);
+    const handleDateRangeChange = useCallback((field, bound, value) => {
+        urlState.setDateRange(field, clampDateRange(readDateRange(urlState.filters, field), bound, value));
+    }, [urlState.setDateRange, urlState.filters]);
+    // Entity-Targets (fw#2228) — see EntityListBody.runNavigate for why the
+    // resolution happens in the NavApi impl. Unlike there: NO row["id"]
+    // fallback — projectionList rows come from an arbitrary query projection
+    // with no guaranteed "id" field. The boot validator therefore enforces an
+    // explicit entityId for projectionList entity targets. Same helper
+    // relatedList's rowActions reuse (related-list-section.tsx) — a
+    // projectionDetail relatedList row has the identical "no guaranteed id"
+    // shape.
+    const runNavigate = useCallback((action, row) => runProjectionRowNavigate(nav, action, row, host), [nav, host]);
+    const defaultEditRowAction = useMemo(() => buildDefaultEditRowAction(defaultEditScreen), [defaultEditScreen]);
+    const rowActions = useMemo(() => buildProjectionRowActions({
+        rowActions: screen.rowActions,
+        translate: effectiveTranslate,
+        dispatcher,
+        nav,
+        refetch: rowsQuery.refetch,
+        openDrawer,
+        defaultEditRowAction,
+        host,
+        clientActions,
+    }), [
+        screen.rowActions,
+        effectiveTranslate,
+        dispatcher,
+        clientActions,
+        nav,
+        rowsQuery.refetch,
+        openDrawer,
+        defaultEditRowAction,
+        host,
+    ]);
+    const toolbarActions = useMemo(() => buildProjectionToolbarActions({
+        toolbarActions: screen.toolbarActions,
+        translate: effectiveTranslate,
+        dispatcher,
+        nav,
+        refetch: rowsQuery.refetch,
+        openDrawer,
+        host,
+        access: { appFeatures, userRoles },
+    }), [
+        screen.toolbarActions,
+        effectiveTranslate,
+        nav,
+        host,
+        dispatcher,
+        rowsQuery.refetch,
+        openDrawer,
+        appFeatures,
+        userRoles,
+    ]);
+    const emptyContent = useListEmptyContent(screen.emptyState, effectiveTranslate, {
+        nav,
+        host,
+        dispatcher,
+        openDrawer,
+        onWriteSuccess: rowsQuery.refetch,
+    });
+    if (rowsQuery.loading && rowsQuery.data === null) {
+        return _jsx(QueryLoadingBanner, {});
+    }
+    if (rowsQuery.error && rowsQuery.data === null) {
+        return (_jsx(QueryErrorBanner, { error: rowsQuery.error, translate: effectiveTranslate, onRetry: rowsQuery.refetch }));
+    }
+    // A failed refetch keeps the last good data on screen.
+    const refetchErrorBanner = rowsQuery.error ? (_jsx(QueryErrorBanner, { error: rowsQuery.error, translate: effectiveTranslate, onRetry: rowsQuery.refetch })) : null;
+    // rowsQuery.data is typed as PagedRows but the query handler is free to
+    // return anything at runtime (fw#2216: a bare array silently rendered an
+    // empty table instead of surfacing the mismatch), so the shape is checked.
+    if (rowsQuery.data !== null && !Array.isArray(rowsQuery.data.rows)) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-projection-list-bad-shape", children: ["Screen ", _jsx(Text, { variant: "code", children: screen.id }), " query", " ", _jsx(Text, { variant: "code", children: screen.query }), " did not return a PagedRows envelope; a projectionList query must return ", _jsx(Text, { variant: "code", children: "{ rows, nextCursor }" }), "."] }));
+    }
+    const rowClickAction = findRowClickAction(screen.rowActions);
+    const wrappedOnRowClick = rowClickAction
+        ? (row) => rowClickAction.kind === "drawer"
+            ? runDrawerRowAction(rowClickAction, openDrawer, row)
+            : runNavigate(rowClickAction, row)
+        : onRowClick !== undefined
+            ? (row) => onRowClick(row, listScreen.entity)
+            : undefined;
+    // Same pager-construction as EntityListBody: no Pager UI until the
+    // server-provided `total` arrives (guards pagination="pages" without
+    // totalCount support, see fw#2165 report on solon's leaseOverviewHandler).
+    const total = rowsQuery.data?.total;
+    const pager = usePager && total !== undefined
+        ? {
+            page: urlState.page,
+            limit,
+            total,
+            onPageChange: urlState.setPage,
+            pageSizeOptions: pageSizeOptionsFor(limit),
+            onPageSizeChange: urlState.setPageSize,
+        }
+        : undefined;
+    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(ReferenceFacetBridges, { specs: facetSpecs, onOptions: handleProjectionFacetOptions }), _jsx(RenderList, { screen: listScreen, entity: entity, rows: rowsQuery.data?.rows ?? [], featureName: schema.featureName, searchable: searchable, narrowed: isListNarrowed(activeSearch, urlState.filters), ...(screen.description !== undefined && {
+                    description: effectiveTranslate(screen.description),
+                }), ...(emptyContent !== undefined && { emptyContent }), searchValue: urlState.q, onSearchChange: urlState.setQ, sort: activeSort, onSortChange: urlState.setSort, ...(isEmbeddedScreen
+                    ? { screenPadding: false, chromeless: true }
+                    : { screenPadding: true }), ...(screenFillsHeight(listScreen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }), ...(toolbarActions !== undefined && { toolbarActions }), ...(translate !== undefined && { translate }), ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }), ...(filterFacets.length > 0 && {
+                    filterFacets,
+                    onFilterChange: urlState.setFilter,
+                }), ...(dateRangeFacets.length > 0 && {
+                    dateRangeFacets,
+                    onDateRangeChange: handleDateRangeChange,
+                }), ...((filterFacets.length > 0 || dateRangeFacets.length > 0) && {
+                    filterValues: urlState.filters,
+                    onFilterReset: urlState.clearFilters,
+                }) }), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
+                    closeDrawer();
+                    void rowsQuery.refetch();
+                } })] }));
+}

package/dist/app/projection-list-shim.d.ts

@@ -1,4 +1,5 @@
 import type { EntityDefinition, EntityListScreenDefinition, ListColumnSpec, ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+export declare const SYNTHESIZED_FIELD_PII_REASON = "synthesized display field, not stored entity data";
 /** Minimal EntityDefinition from the column list: every field is a text
  *  field. `sortable` applies to all columns — buildAppSchema derives it from
  *  the query's Zod schema (`screen.sortable`, fw#2165); the query itself has
@@ -6,7 +7,7 @@ import type { EntityDefinition, EntityListScreenDefinition, ListColumnSpec, Proj
  *  `sortable: false` when the handler cannot order by it.
  *  computeListViewModel only reads `fields[<col>].type` — text is enough,
  *  presentation comes from the column renderer + explicit label. */
-export declare function synthesizeProjectionEntity(columns: readonly ListColumnSpec[], sortable: boolean): EntityDefinition;
+export declare function synthesizeProjectionEntity(columns: readonly ListColumnSpec[], sortable: boolean): Pick<EntityDefinition, "fields">;
 /** Wandelt ein ProjectionListScreenDefinition in die EntityListScreen-Shape die
  *  RenderList erwartet. `type` = "entityList" + Pseudo-Entity halten den Type-
  *  Constraint; RenderList branched nicht auf `type` und liest `entity` nur für

package/dist/app/projection-list-shim.js

@@ -15,6 +15,9 @@
 // query-native ListView-Komponente.
 import { normalizeListColumn } from "@cosmicdrift/kumiko-framework/ui-types";
 const PROJECTION_PSEUDO_ENTITY = "__projection__";
+// Satisfies the text-field PII stance of the entity field type; these synthesized
+// fields describe query columns and never map to stored entity data.
+export const SYNTHESIZED_FIELD_PII_REASON = "synthesized display field, not stored entity data";
 /** Minimal EntityDefinition from the column list: every field is a text
  *  field. `sortable` applies to all columns — buildAppSchema derives it from
  *  the query's Zod schema (`screen.sortable`, fw#2165); the query itself has
@@ -28,6 +31,7 @@ export function synthesizeProjectionEntity(columns, sortable) {
         const normalized = normalizeListColumn(col);
         fields[normalized.field] = {
             type: "text",
+            allowPlaintext: SYNTHESIZED_FIELD_PII_REASON,
             sortable: sortable && normalized.sortable !== false,
         };
     }

package/dist/app/reference-facet-bridge.js

@@ -2,6 +2,7 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 // One bridge component per reference facet, mirroring ReferenceLookupBridge —
 // facet count varies per screen, so the hook can't be called in a loop.
 import { useEffect } from "react";
+import { rendererWarn } from "../dev-console.js";
 import { REFERENCE_LIST_LOOKUP_LIMIT } from "../hooks/reference-limits.js";
 import { useReferenceLookup } from "../hooks/use-reference-lookup.js";
 function ReferenceFacetOptionsBridge({ field, refEntity, refFeature, labelField, onOptions, }) {
@@ -12,8 +13,7 @@ function ReferenceFacetOptionsBridge({ field, refEntity, refFeature, labelField,
         // The lookup is one capped list fetch; a full page means the facet may be
         // missing values the user wants to filter by.
         if (lookup.map.size >= REFERENCE_LIST_LOOKUP_LIMIT) {
-            // biome-ignore lint/suspicious/noConsole: dev-warning, facet options are silently truncated
-            console.warn(`[kumiko] reference facet "${field}" shows only the first ${REFERENCE_LIST_LOOKUP_LIMIT} ${refEntity} rows; further values cannot be filtered by`);
+            rendererWarn(`[kumiko] reference facet "${field}" shows only the first ${REFERENCE_LIST_LOOKUP_LIMIT} ${refEntity} rows; further values cannot be filtered by`);
         }
         onOptions(field, [...lookup.map.entries()].map(([value, label]) => ({ value, label })));
     }, [lookup.loading, lookup.map, field, refEntity, onOptions]);

package/dist/app/row-actions.js

@@ -1,5 +1,6 @@
 import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
 import { resolveActionIcon } from "@cosmicdrift/kumiko-types/action-icon";
+import { rendererError, rendererWarn } from "../dev-console.js";
 import { runClientAction } from "./client-actions.js";
 import { lastSegment } from "./qn.js";
 import { navigateWithReturnTo } from "./return-to.js";
@@ -57,8 +58,7 @@ export function navigateActionSearchParams(action, values) {
 }
 export async function refetchAfterWrite(refetch) {
     await refetch().catch((err) => {
-        // biome-ignore lint/suspicious/noConsole: refetch must not poison the write-action error path
-        console.error("kumiko-screen: refetch after write action failed", err);
+        rendererError("kumiko-screen: refetch after write action failed", err);
     });
 }
 // Navigate execution for query-driven rows (projectionList, and relatedList
@@ -118,8 +118,7 @@ function warnDrawerActionDropped(actionKind, actionId) {
     if (warnedDrawerActionIds.has(key))
         return;
     warnedDrawerActionIds.add(key);
-    // biome-ignore lint/suspicious/noConsole: dev-warning for a setup error
-    console.warn(`[kumiko] ${actionKind} "${actionId}" is kind:"drawer", but the host did not wire openDrawer (RelatedListSection: pass onOpenDrawer) — it will not render.`);
+    rendererWarn(`[kumiko] ${actionKind} "${actionId}" is kind:"drawer", but the host did not wire openDrawer (RelatedListSection: pass onOpenDrawer) — it will not render.`);
 }
 export function runDrawerRowAction(action, openDrawer, row) {
     openDrawer(action, action.params !== undefined ? evalRowExtractor(action.params, row.values) : undefined);

package/dist/app/screen-shared.d.ts

@@ -0,0 +1,72 @@
+import type { ActionFormRedirect, ActionFormScreenDefinition, ActionFormSuccessLink, ScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import { type ReactNode } from "react";
+import type { Dispatcher, Translate } from "../headless/index.ts";
+import { type ListSort } from "../hooks/use-list-url-state.ts";
+import type { ResolvedSuccessLink } from "./action-form-support.tsx";
+import type { FeatureSchema } from "./feature-schema.ts";
+import { type NavApi, type ScreenTarget } from "./nav.tsx";
+/** Empty state for a screen QN that is not in the schema (feature disabled for
+ *  the tenant, stale link, miswired screen). The QN only goes to the console. */
+export declare function ScreenMissingState({ screenQn, homeScreenId, testId, }: {
+    readonly screenQn: string;
+    readonly homeScreenId?: string;
+    readonly testId?: string;
+}): ReactNode;
+export declare function ScreenAccessDeniedBanner({ screenQn, testId, }: {
+    readonly screenQn: string;
+    readonly testId: string;
+}): ReactNode;
+export declare function entityWriteCommand(featureName: string, entity: string, verb: "create" | "update" | "delete"): string;
+export declare function findEntityListScreen(schema: FeatureSchema, entityName: string): ScreenDefinition | undefined;
+export declare function RecordNotFoundState({ translate, onBack, }: {
+    readonly translate: Translate;
+    readonly onBack?: () => void;
+}): ReactNode;
+export declare function useNavigateToListAfter(schema: FeatureSchema, entityName: string): () => void;
+export declare function pageSizeOptionsFor(currentLimit: number): readonly number[];
+export declare function useNavigateToCreateFor(schema: FeatureSchema, entityName: string, createScreen?: string, createUnavailable?: boolean): (() => void) | undefined;
+export declare function formatSummaryParams(prefill: Readonly<Record<string, unknown>> | undefined, locale: string): Record<string, string>;
+export declare function resolveSuccessMessageParams(screen: ActionFormScreenDefinition, featureName: string, values: Readonly<Record<string, unknown>>, dispatcher: Dispatcher, locale: string): Promise<Record<string, string>>;
+export declare function resolveActionFormSummary(summary: ActionFormScreenDefinition["summary"], prefill: Readonly<Record<string, unknown>> | undefined, translate: Translate, locale: string): {
+    readonly title: string;
+    readonly subtitle?: string;
+} | undefined;
+export declare function entityQueryCommand(featureName: string, entity: string, verb: "list"): string;
+export type PagedRows = {
+    readonly rows: Readonly<Record<string, unknown>>[];
+    readonly nextCursor: string | null;
+    readonly total?: number;
+};
+export declare function buildListQueryPayload(state: {
+    readonly limit: number;
+    readonly search: string;
+    readonly sort: ListSort | null;
+    readonly usePager: boolean;
+    readonly page: number;
+    readonly useInfinite: boolean;
+    readonly cursor: string | undefined;
+}): Record<string, unknown>;
+type RedirectSpec = string | ActionFormRedirect | ActionFormSuccessLink;
+export declare function redirectScreenTarget(redirect: RedirectSpec): string;
+export declare function isEntityEditScreenOfEntity(entity: string | undefined, targetScreen: string, schema: FeatureSchema, appFeatures: readonly FeatureSchema[]): boolean;
+export declare function isEntityEditScreenOfOtherEntity(entity: string, targetScreen: string, schema: FeatureSchema, appFeatures: readonly FeatureSchema[]): boolean;
+export declare function returnToWinsOverRedirect(returnTarget: ScreenTarget | undefined, redirect: string | ActionFormRedirect, schema: FeatureSchema, appFeatures: readonly FeatureSchema[]): returnTarget is ScreenTarget;
+export declare function resolveRedirectTarget(redirect: RedirectSpec, submittedData: unknown, schema: FeatureSchema, appFeatures: readonly FeatureSchema[], fallbackRecord?: Readonly<Record<string, unknown>>): ResolvedRedirectTarget;
+type ResolvedRedirectTarget = {
+    readonly screenId: string;
+    readonly entityId: string | undefined;
+    readonly tab: string | undefined;
+};
+export declare function navigateToRedirectTarget(nav: NavApi, target: ResolvedRedirectTarget): void;
+export declare function resolveSuccessLinks(links: readonly ActionFormSuccessLink[] | undefined, data: unknown, schema: FeatureSchema, appFeatures: readonly FeatureSchema[], nav: NavApi, translate: Translate): readonly ResolvedSuccessLink[];
+export declare function navigateAfterRedirect(options: {
+    readonly nav: NavApi;
+    readonly schema: FeatureSchema;
+    readonly appFeatures: readonly FeatureSchema[];
+    readonly returnTarget: ScreenTarget | undefined;
+    readonly redirect: string | ActionFormRedirect;
+    readonly resultData: unknown;
+    readonly record: Readonly<Record<string, unknown>>;
+}): void;
+export declare function overlayUpdatedProjection(record: Readonly<Record<string, unknown>>, resultData: unknown): Readonly<Record<string, unknown>>;
+export {};