@cohesivesystems/presentation-core 0.1.0-alpha.1

package/dist/collection-chrome-slot-renderer-registry.js

@@ -0,0 +1,136 @@
+import { collectionChromeSlotKindLabels, collectionChromeSlotPlacementLabels, } from '@cohesivesystems/presentation-contracts';
+/**
+ * Placement token used by collection chrome renderer keys that apply to any
+ * placement for a slot kind.
+ */
+export const collectionChromeSlotAnyPlacement = '*';
+/**
+ * Builds a normalized collection chrome slot renderer registry from declarative
+ * bindings.
+ *
+ * Later bindings with the same normalized key overwrite earlier bindings.
+ *
+ * @param bindings Slot renderer bindings to index by kind and placement.
+ * @returns Registry suitable for resolver and key-inspection helpers.
+ */
+export function createCollectionChromeSlotRendererRegistry(bindings) {
+    return Object.fromEntries(bindings.map((binding) => [
+        createCollectionChromeSlotRendererKey(binding.kind, binding.placement),
+        binding.render,
+    ]));
+}
+/**
+ * Creates the canonical registry key for a collection chrome slot kind and
+ * placement.
+ *
+ * Generated enum values, enum labels, and string values are normalized into the
+ * same lowercase alphanumeric token so backend-generated contracts and
+ * handwritten adapters can use the same registry.
+ *
+ * @param kind Collection chrome slot kind.
+ * @param placement Optional slot placement. `null` and `undefined` become the
+ * any-placement fallback token.
+ */
+export function createCollectionChromeSlotRendererKey(kind, placement) {
+    return `${normalizeCollectionChromeSlotKind(kind)}:${placement == null
+        ? collectionChromeSlotAnyPlacement
+        : normalizeCollectionChromeSlotPlacement(placement)}`;
+}
+/**
+ * Returns the normalized keys currently registered in a collection chrome slot
+ * renderer registry.
+ */
+export function getCollectionChromeSlotRendererRegistryKeys(registry) {
+    return Object.keys(registry ?? {});
+}
+/**
+ * Checks whether a precomputed key set contains a renderer that could satisfy
+ * the provided collection chrome slot.
+ *
+ * This uses the same candidate-key order as
+ * {@link resolveCollectionChromeSlotRenderer}.
+ */
+export function hasCollectionChromeSlotRendererBinding(keys, slot) {
+    return getCollectionChromeSlotRendererCandidateKeys(slot).some((key) => keys.includes(key));
+}
+/**
+ * Resolves the renderer for a collection chrome slot.
+ *
+ * Exact kind-and-placement bindings are preferred. If no exact binding exists,
+ * the resolver falls back to a kind-level any-placement binding.
+ *
+ * @param registry Registry to resolve from. `null` and `undefined` are treated
+ * as empty registries.
+ * @param slot Projected collection chrome slot definition.
+ * @returns Matching renderer, or `null` when no binding can satisfy the slot.
+ */
+export function resolveCollectionChromeSlotRenderer(registry, slot) {
+    const renderers = registry ?? {};
+    for (const key of getCollectionChromeSlotRendererCandidateKeys(slot)) {
+        const renderer = renderers[key];
+        if (renderer) {
+            return renderer;
+        }
+    }
+    return null;
+}
+/**
+ * Checks whether a collection chrome slot is assigned to the provided
+ * placement, using the same normalization rules as renderer keys.
+ */
+export function isCollectionChromeSlotPlacement(slot, placement) {
+    return isCollectionChromeSlotPlacementValue(slot.Placement, placement);
+}
+/**
+ * Checks whether a collection chrome slot has the provided semantic kind, using
+ * the same normalization rules as renderer keys.
+ */
+export function isCollectionChromeSlotKind(slot, kind) {
+    return normalizeCollectionChromeSlotKind(slot.Kind) ===
+        normalizeCollectionChromeSlotKind(kind);
+}
+/**
+ * Checks whether an optional placement value matches a concrete placement.
+ *
+ * Missing slot placement values never match, including against any-placement
+ * fallback renderer bindings.
+ */
+export function isCollectionChromeSlotPlacementValue(value, placement) {
+    if (value == null) {
+        return false;
+    }
+    return normalizeCollectionChromeSlotPlacement(value) ===
+        normalizeCollectionChromeSlotPlacement(placement);
+}
+/**
+ * Returns candidate renderer keys for a collection chrome slot in resolution
+ * order.
+ *
+ * The exact kind-and-placement key is first, followed by the kind-level
+ * any-placement fallback key.
+ */
+export function getCollectionChromeSlotRendererCandidateKeys(slot) {
+    return [
+        createCollectionChromeSlotRendererKey(slot.Kind, slot.Placement),
+        createCollectionChromeSlotRendererKey(slot.Kind),
+    ];
+}
+/** Normalizes a slot kind into the registry-key token space. */
+function normalizeCollectionChromeSlotKind(value) {
+    return normalizeGeneratedEnumToken(value, collectionChromeSlotKindLabels);
+}
+/** Normalizes a slot placement into the registry-key token space. */
+function normalizeCollectionChromeSlotPlacement(value) {
+    return normalizeGeneratedEnumToken(value, collectionChromeSlotPlacementLabels);
+}
+/**
+ * Converts generated enum numbers, enum label strings, and handwritten strings
+ * into stable registry-key tokens.
+ */
+function normalizeGeneratedEnumToken(value, labels) {
+    const label = typeof value === 'number'
+        ? labels[value] ?? String(value)
+        : String(value);
+    return label.replace(/[^a-z0-9]/gi, '').toLocaleLowerCase();
+}
+//# sourceMappingURL=collection-chrome-slot-renderer-registry.js.map

package/dist/collection-chrome-slot-renderer-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-chrome-slot-renderer-registry.js","sourceRoot":"","sources":["../src/collection-chrome-slot-renderer-registry.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,yCAAyC,CAAA;AAEhD;;;GAGG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,GAAG,CAAA;AAyCnD;;;;;;;;GAQG;AACH,MAAM,UAAU,0CAA0C,CACxD,QAA2E;IAE3E,OAAO,MAAM,CAAC,WAAW,CACvB,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC;QACxB,qCAAqC,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC;QACtE,OAAO,CAAC,MAAM;KACf,CAAC,CACH,CAAA;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qCAAqC,CACnD,IAAgD,EAChD,SAAkE;IAElE,OAAO,GAAG,iCAAiC,CAAC,IAAI,CAAC,IAAI,SAAS,IAAI,IAAI;QACpE,CAAC,CAAC,gCAAgC;QAClC,CAAC,CAAC,sCAAsC,CAAC,SAAS,CAAC,EAAE,CAAA;AACzD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,2CAA2C,CACzD,QAAoF;IAEpF,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sCAAsC,CACpD,IAAuB,EACvB,IAAoC;IAEpC,OAAO,4CAA4C,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CACrE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;AACvB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mCAAmC,CACjD,QAAoF,EACpF,IAAoC;IAEpC,MAAM,SAAS,GAAG,QAAQ,IAAI,EAAE,CAAA;IAChC,KAAK,MAAM,GAAG,IAAI,4CAA4C,CAAC,IAAI,CAAC,EAAE,CAAC;QACrE,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,CAAA;QAC/B,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,QAAQ,CAAA;QACjB,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,+BAA+B,CAC7C,IAAoC,EACpC,SAA0D;IAE1D,OAAO,oCAAoC,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;AACxE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAAoC,EACpC,IAAgD;IAEhD,OAAO,iCAAiC,CAAC,IAAI,CAAC,IAAI,CAAC;QACjD,iCAAiC,CAAC,IAAI,CAAC,CAAA;AAC3C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oCAAoC,CAClD,KAAyE,EACzE,SAA0D;IAE1D,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,sCAAsC,CAAC,KAAK,CAAC;QAClD,sCAAsC,CAAC,SAAS,CAAC,CAAA;AACrD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,4CAA4C,CAC1D,IAAoC;IAEpC,OAAO;QACL,qCAAqC,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;QAChE,qCAAqC,CAAC,IAAI,CAAC,IAAI,CAAC;KACjD,CAAA;AACH,CAAC;AAED,gEAAgE;AAChE,SAAS,iCAAiC,CAAC,KAAc;IACvD,OAAO,2BAA2B,CAAC,KAAK,EAAE,8BAA8B,CAAC,CAAA;AAC3E,CAAC;AAED,qEAAqE;AACrE,SAAS,sCAAsC,CAAC,KAAc;IAC5D,OAAO,2BAA2B,CAAC,KAAK,EAAE,mCAAmC,CAAC,CAAA;AAChF,CAAC;AAED;;;GAGG;AACH,SAAS,2BAA2B,CAClC,KAAc,EACd,MAAwC;IAExC,MAAM,KAAK,GAAG,OAAO,KAAK,KAAK,QAAQ;QACrC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC;QAChC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IACjB,OAAO,KAAK,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC,iBAAiB,EAAE,CAAA;AAC7D,CAAC"}

package/dist/collection-selection-state.d.ts

@@ -0,0 +1,18 @@
+import type { CollectionSelectionMode } from './module.js';
+export interface CollectionSelectionStateEntry {
+    readonly clearSelection: () => void;
+    readonly selectedRowId: string | null;
+    readonly selectedRowIds: readonly string[];
+    readonly selectionStateId: string;
+    readonly selectRowId: (rowId: string, mode: CollectionSelectionMode) => void;
+    readonly setSelectedRowIds: (rowIds: readonly string[]) => void;
+    readonly toggleRowId: (rowId: string, mode: CollectionSelectionMode) => void;
+}
+export interface CollectionSelectionStateContextValue {
+    readonly selectedRowIdsByStateId: Readonly<Record<string, readonly string[]>>;
+    readonly clearSelection: (selectionStateId: string) => void;
+    readonly selectRowId: (selectionStateId: string, rowId: string, mode: CollectionSelectionMode) => void;
+    readonly setSelectedRowIds: (selectionStateId: string, rowIds: readonly string[]) => void;
+    readonly toggleRowId: (selectionStateId: string, rowId: string, mode: CollectionSelectionMode) => void;
+}
+//# sourceMappingURL=collection-selection-state.d.ts.map

package/dist/collection-selection-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-selection-state.d.ts","sourceRoot":"","sources":["../src/collection-selection-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACxB,MAAM,UAAU,CAAA;AAEjB,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,cAAc,EAAE,MAAM,IAAI,CAAA;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IACrC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,uBAAuB,KAAK,IAAI,CAAA;IAC5E,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,KAAK,IAAI,CAAA;IAC/D,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,uBAAuB,KAAK,IAAI,CAAA;CAC7E;AAED,MAAM,WAAW,oCAAoC;IACnD,QAAQ,CAAC,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAA;IAC7E,QAAQ,CAAC,cAAc,EAAE,CAAC,gBAAgB,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3D,QAAQ,CAAC,WAAW,EAAE,CACpB,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,uBAAuB,KAC1B,IAAI,CAAA;IACT,QAAQ,CAAC,iBAAiB,EAAE,CAC1B,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,SAAS,MAAM,EAAE,KACtB,IAAI,CAAA;IACT,QAAQ,CAAC,WAAW,EAAE,CACpB,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,uBAAuB,KAC1B,IAAI,CAAA;CACV"}

package/dist/collection-selection-state.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=collection-selection-state.js.map

package/dist/collection-selection-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-selection-state.js","sourceRoot":"","sources":["../src/collection-selection-state.ts"],"names":[],"mappings":""}

package/dist/data-source-projection.d.ts

@@ -0,0 +1,475 @@
+import { type PresentationBindingDefinition, type DataSourceDefinition, type PresentationModuleDefinition } from './module.js';
+import { type PresentationLocalValueDataSourceBinding, type PresentationLocalValueDataSourceBindingInput, type PresentationDataSourceAuthorizationRequirement, type PresentationDataSourceBinding, type PresentationTanStackQueryDataSourceBindingInput, type PresentationTanStackQueryDataSourceBinding } from './presentation-data-source-binding-model.js';
+import { type DataSourceQueryLoweringTransform } from './data-source-query-lowering.js';
+import { type PresentationQueryFormStateMap } from './presentation-query-form-state.js';
+import type { PresentationActionResultStateValues } from './presentation-action-result-state.js';
+/**
+ * Runtime inputs available while projecting semantic data-source definitions
+ * into concrete frontend bindings.
+ */
+export interface PresentationDataSourceProjectionContext {
+    /** Current query-form states keyed by query form or data-source state id. */
+    readonly queryFormStates?: PresentationQueryFormStateMap;
+    /** Route parameters supplied by the active presentation/navigation host. */
+    readonly routeParameters?: Readonly<Record<string, string | undefined>>;
+    /** Additional cache-key fragments supplied by the app or route host. */
+    readonly queryKeyParts?: readonly unknown[];
+    /** Workspace id used to scope local state or cache identity, when available. */
+    readonly workspaceId?: string | null;
+}
+/**
+ * Context passed to a registry factory while interpreting one semantic
+ * data-source definition.
+ */
+export interface PresentationDataSourceBindingFactoryContext {
+    /** Backend target binding attached to the data source, when one is declared. */
+    readonly binding: PresentationBindingDefinition | null;
+    /** Projection context shared by all data sources in the current host. */
+    readonly context: PresentationDataSourceProjectionContext;
+    /** Data-source definition being projected. */
+    readonly dataSource: DataSourceDefinition;
+    /** Presentation module that owns the data source and related query metadata. */
+    readonly module: PresentationModuleDefinition | null;
+}
+/**
+ * Factory that projects one data source into a frontend binding.
+ *
+ * Returning `null` or `undefined` lets later registry fallbacks attempt the
+ * projection.
+ */
+export type PresentationDataSourceBindingFactory = (context: PresentationDataSourceBindingFactoryContext) => PresentationDataSourceBinding | null | undefined;
+/**
+ * Factory that produces TanStack Query binding input before target-level
+ * authorization is applied.
+ */
+export type PresentationTanStackQueryDataSourceBindingFactory = (context: PresentationDataSourceBindingFactoryContext) => PresentationTargetInterpretedTanStackQueryDataSourceBindingInput | null | undefined;
+/**
+ * Executes a backend endpoint id with the already-projected route/query
+ * request payload.
+ *
+ * @typeParam TResult - Result shape returned by the endpoint executor.
+ */
+export type PresentationDataSourceEndpointExecutor = <TResult = unknown>(endpointId: string, request: PresentationDataSourceEndpointExecutionRequest) => Promise<TResult>;
+/**
+ * Request envelope passed to endpoint executors from projected data-source
+ * bindings.
+ *
+ * @typeParam TQuery - Query payload shape produced by query lowering.
+ */
+export interface PresentationDataSourceEndpointExecutionRequest<TQuery = unknown> {
+    /** Lowered query payload for endpoint-query data sources. */
+    readonly query?: TQuery | null;
+    /** Route parameters for endpoint-fetch data sources. */
+    readonly routeParameters?: Readonly<Record<string, string | null | undefined>>;
+}
+/**
+ * Options read from backend target bindings that steer frontend endpoint and
+ * authorization interpretation.
+ */
+export interface PresentationDataSourceTargetBindingOptions {
+    /** Authorization policy id resolved by the target interpretation. */
+    readonly authorizationPolicyId?: string | null;
+    /** Endpoint executor target id resolved by the API endpoint interpretation. */
+    readonly executionTargetId?: string | null;
+}
+/**
+ * Runtime behavior defaults read from data-source annotations and applied to
+ * query bindings.
+ */
+export interface PresentationDataSourceBindingRuntimeOptions {
+    /** Message shown when a successful query returns no presentable items. */
+    readonly emptyMessage?: string;
+    /** Data used before a query resolves or when a source cannot be materialized. */
+    readonly fallbackData?: unknown;
+    /** Loading label shown while the binding is pending. */
+    readonly pendingLabel?: string;
+    /** TanStack Query refetch interval in milliseconds, or `false` to disable it. */
+    readonly refetchInterval?: number | false;
+    /** TanStack Query retry setting. */
+    readonly retry?: boolean | number;
+    /** TanStack Query stale time in milliseconds. */
+    readonly staleTime?: number;
+}
+/**
+ * Local-value binding input whose authorization can be supplied by the active
+ * target interpretation instead of every feature-owned binding factory.
+ */
+export type PresentationTargetInterpretedLocalValueDataSourceBindingInput = Omit<PresentationLocalValueDataSourceBindingInput, 'authorization'> & {
+    readonly authorization?: PresentationDataSourceAuthorizationRequirement;
+};
+/**
+ * TanStack Query binding input whose authorization can be supplied by the
+ * target interpretation. Feature registries still own request/query shaping.
+ */
+export type PresentationTargetInterpretedTanStackQueryDataSourceBindingInput = Omit<PresentationTanStackQueryDataSourceBindingInput, 'authorization'> & {
+    readonly authorization?: PresentationDataSourceAuthorizationRequirement;
+};
+/** Resolves a data-source authorization requirement for a target binding. */
+export type PresentationDataSourceAuthorizationFactory = (context: PresentationDataSourceBindingFactoryContext) => PresentationDataSourceAuthorizationRequirement;
+/** Endpoint executors keyed by backend-declared execution target id. */
+export type PresentationDataSourceEndpointExecutorMap = Readonly<Record<string, PresentationDataSourceEndpointExecutor>>;
+/** Authorization factories keyed by backend-declared authorization policy id. */
+export type PresentationDataSourceAuthorizationPolicyMap = Readonly<Record<string, PresentationDataSourceAuthorizationFactory>>;
+/** Target-specific interpretation shared by all data sources of one binding kind. */
+export interface PresentationDataSourceBindingTargetInterpretation {
+    /** Default authorization policy for this target binding kind. */
+    readonly authorization?: PresentationDataSourceAuthorizationFactory;
+}
+/**
+ * Target interpretation for API endpoint data sources. This owns endpoint
+ * execution and cross-cutting query defaults; semantic registries can still
+ * provide per-source query payloads, labels, and cache keys.
+ */
+export interface PresentationDataSourceApiEndpointTargetInterpretation extends PresentationDataSourceBindingTargetInterpretation {
+    /** Creates a query key for endpoint-backed data sources. */
+    readonly createQueryKey?: (context: PresentationDataSourceApiEndpointFactoryContext) => readonly unknown[];
+    /** Default executor for API endpoint data sources. */
+    readonly executeEndpoint?: PresentationDataSourceEndpointExecutor;
+    /** Executors keyed by target binding `executionTargetId`. */
+    readonly executeEndpointByTargetId?: PresentationDataSourceEndpointExecutorMap;
+    /** Enables or disables endpoint-backed query execution. */
+    readonly isEnabled?: (context: PresentationDataSourceApiEndpointFactoryContext) => boolean;
+    /** Default pending label for endpoint-backed query bindings. */
+    readonly pendingLabel?: string | ((context: PresentationDataSourceApiEndpointFactoryContext) => string);
+    /** Default retry behavior for endpoint-backed query bindings. */
+    readonly retry?: boolean;
+}
+/** Target interpretation for backend-declared query lowering transform ids. */
+export interface PresentationDataSourceQueryLoweringTargetInterpretation {
+    /** Query-lowering transforms keyed by backend-declared transform id. */
+    readonly transformsById?: Readonly<Record<string, DataSourceQueryLoweringTransform>>;
+}
+/**
+ * Frontend interpretation of backend data-source target bindings for one
+ * concrete presentation target.
+ */
+export interface PresentationDataSourceTargetInterpretation {
+    /** Interpretation for API endpoint data-source bindings. */
+    readonly apiEndpoint?: PresentationDataSourceApiEndpointTargetInterpretation;
+    /** Named authorization policies available to target bindings. */
+    readonly authorizationPoliciesById?: PresentationDataSourceAuthorizationPolicyMap;
+    /** Fallback authorization policy for bindings without a narrower policy. */
+    readonly defaultAuthorization?: PresentationDataSourceAuthorizationFactory;
+    /** Interpretation for frontend-owned local state data-source bindings. */
+    readonly localState?: PresentationDataSourceBindingTargetInterpretation;
+    /** Interpretation for backend-declared query-lowering transforms. */
+    readonly queryLowering?: PresentationDataSourceQueryLoweringTargetInterpretation;
+}
+/** Options used when invoking a projected endpoint through the target. */
+export interface ExecutePresentationDataSourceTargetEndpointOptions {
+    /** Binding whose target options select endpoint executor and authorization policy. */
+    readonly binding?: PresentationBindingDefinition | null;
+}
+/**
+ * Registry of data-source binding factories used to project semantic data
+ * sources onto frontend runtime bindings.
+ */
+export interface PresentationDataSourceBindingProjectionRegistry {
+    /** Generic factory for API endpoint bindings. */
+    readonly apiEndpoint?: PresentationDataSourceBindingFactory;
+    /** Exact factories keyed by data-source id. */
+    readonly byDataSourceId?: Readonly<Record<string, PresentationDataSourceBindingFactory>>;
+    /** Exact factories keyed by endpoint id. */
+    readonly byEndpointId?: Readonly<Record<string, PresentationDataSourceBindingFactory>>;
+    /** Default authorization policy used by unbound or projected bindings. */
+    readonly defaultAuthorization?: (context: PresentationDataSourceBindingFactoryContext) => PresentationDataSourceAuthorizationRequirement;
+    /** Last-resort factory when no exact or generic API factory matches. */
+    readonly fallback?: PresentationDataSourceBindingFactory;
+}
+/**
+ * Options for adapting target-interpreted TanStack Query binding factories into
+ * a full data-source projection registry.
+ */
+export interface TanStackQueryDataSourceBindingProjectionRegistryOptions {
+    /** Generic endpoint factory returning TanStack Query binding input. */
+    readonly apiEndpoint?: PresentationTanStackQueryDataSourceBindingFactory;
+    /** Exact factories keyed by data-source id. */
+    readonly byDataSourceId?: Readonly<Record<string, PresentationDataSourceBindingFactory>>;
+    /** Exact endpoint factories keyed by endpoint id. */
+    readonly byEndpointId?: Readonly<Record<string, PresentationTanStackQueryDataSourceBindingFactory>>;
+    /** Authorization policy applied when a factory does not provide one. */
+    readonly defaultAuthorization?: (context: PresentationDataSourceBindingFactoryContext) => PresentationDataSourceAuthorizationRequirement;
+    /** Active target interpretation that supplies authorization and execution defaults. */
+    readonly targetInterpretation?: PresentationDataSourceTargetInterpretation;
+}
+/**
+ * Options for the generic API endpoint TanStack Query projector.
+ */
+export interface ApiEndpointTanStackQueryDataSourceBindingProjectionRegistryOptions {
+    /** Optional target-specific cache key builder. */
+    readonly createQueryKey?: (context: PresentationDataSourceApiEndpointFactoryContext) => readonly unknown[];
+    /** Optional endpoint executor overriding the active target interpretation. */
+    readonly executeEndpoint?: PresentationDataSourceEndpointExecutor;
+    /** Optional query enablement guard. */
+    readonly isEnabled?: (context: PresentationDataSourceApiEndpointFactoryContext) => boolean;
+    /** Pending label or label factory for generated query bindings. */
+    readonly pendingLabel?: string | ((context: PresentationDataSourceApiEndpointFactoryContext) => string);
+    /** Retry behavior for generated query bindings. */
+    readonly retry?: boolean;
+    /** Default authorization policy applied to generated query bindings. */
+    readonly defaultAuthorization?: (context: PresentationDataSourceBindingFactoryContext) => PresentationDataSourceAuthorizationRequirement;
+    /** Active target interpretation that supplies defaults not provided here. */
+    readonly targetInterpretation?: PresentationDataSourceTargetInterpretation;
+}
+/**
+ * Factory context for API endpoint data-source bindings after endpoint id and
+ * route parameters have been resolved.
+ */
+export interface PresentationDataSourceApiEndpointFactoryContext extends PresentationDataSourceBindingFactoryContext {
+    /** Resolved API endpoint id. */
+    readonly endpointId: string;
+    /** Route parameters projected for this data source. */
+    readonly routeParameters: Readonly<Record<string, string | null | undefined>>;
+}
+/** Options for projecting a list of semantic data-source ids. */
+export interface ProjectPresentationDataSourceBindingsOptions {
+    /** Shared runtime projection context. */
+    readonly context?: PresentationDataSourceProjectionContext;
+    /** Fallback data-source definitions when the module does not contain an id. */
+    readonly dataSourceDefinitions?: readonly DataSourceDefinition[];
+    /** Data-source ids to project, de-duplicated before projection. */
+    readonly dataSourceIds: readonly string[];
+    /** Presentation module that owns data-source definitions and target bindings. */
+    readonly module: PresentationModuleDefinition | null;
+    /** Projection registry used to resolve concrete frontend bindings. */
+    readonly registry: PresentationDataSourceBindingProjectionRegistry;
+}
+/**
+ * Options for creating endpoint-query binding input from backend query
+ * lowering.
+ *
+ * @typeParam TRequest - Lowered endpoint query request shape.
+ */
+export interface CreateDataSourceEndpointQueryBindingInputOptions<TRequest extends object> {
+    /** Factory context for the data source being projected. */
+    readonly context: PresentationDataSourceBindingFactoryContext;
+    /** Base request values merged into the lowered query request. */
+    readonly defaultRequest?: Partial<TRequest>;
+    /** Empty-state message for the generated query binding. */
+    readonly emptyMessage?: string;
+    /** Query enablement override. */
+    readonly enabled?: boolean;
+    /** Endpoint id to execute. */
+    readonly endpointId: string;
+    /** Fallback data for the generated query binding. */
+    readonly fallbackData?: unknown;
+    /** Pagination request merged into the lowered query request. */
+    readonly paginationRequest?: object | null;
+    /** Pending label for the generated query binding. */
+    readonly pendingLabel?: string;
+    /** Additional query-key fragments. */
+    readonly queryKeyParts?: readonly unknown[];
+    /** Refetch interval in milliseconds, or `false` to disable it. */
+    readonly refetchInterval?: number | false;
+    /** Retry behavior for the generated query binding. */
+    readonly retry?: boolean | number;
+    /** Stale time in milliseconds. */
+    readonly staleTime?: number;
+    /** Target interpretation used for endpoint execution and authorization. */
+    readonly targetInterpretation: PresentationDataSourceTargetInterpretation;
+    /** Per-source query lowering transforms. */
+    readonly transforms?: Readonly<Record<string, DataSourceQueryLoweringTransform>>;
+    /** Source value used by query lowering. */
+    readonly value?: unknown;
+}
+/** Options for creating endpoint-fetch binding input from a data source. */
+export interface CreateDataSourceEndpointFetchBindingInputOptions {
+    /** Factory context for the data source being projected. */
+    readonly context: PresentationDataSourceBindingFactoryContext;
+    /** Empty-state message for the generated query binding. */
+    readonly emptyMessage?: string;
+    /** Query enablement override. */
+    readonly enabled?: boolean;
+    /** Endpoint id to execute, defaulting to the data-source binding endpoint. */
+    readonly endpointId?: string;
+    /** Fallback data for the generated query binding. */
+    readonly fallbackData?: unknown;
+    /** Pending label for the generated query binding. */
+    readonly pendingLabel?: string;
+    /** Additional query-key fragments. */
+    readonly queryKeyParts?: readonly unknown[];
+    /** Refetch interval in milliseconds, or `false` to disable it. */
+    readonly refetchInterval?: number | false;
+    /** Retry behavior for the generated query binding. */
+    readonly retry?: boolean | number;
+    /** Route parameters to pass to the endpoint executor. */
+    readonly routeParameters?: Readonly<Record<string, string | null | undefined>>;
+    /** Stale time in milliseconds. */
+    readonly staleTime?: number;
+    /** Target interpretation used for endpoint execution and authorization. */
+    readonly targetInterpretation: PresentationDataSourceTargetInterpretation;
+}
+/** Options for projecting an aggregate-query data source. */
+export interface CreateDataSourceAggregateQueryBindingOptions {
+    /** Factory context for the aggregate data source being projected. */
+    readonly context: PresentationDataSourceBindingFactoryContext;
+    /** Additional query-key fragments. */
+    readonly queryKeyParts?: readonly unknown[];
+    /** Target interpretation used to materialize source data. */
+    readonly targetInterpretation: PresentationDataSourceTargetInterpretation;
+    /** Per-source query lowering transforms used to query the source data source. */
+    readonly transforms?: Readonly<Record<string, DataSourceQueryLoweringTransform>>;
+    /** Source value used by query lowering. */
+    readonly value?: unknown;
+}
+/** Options for creating a collection-query projection registry. */
+export interface CreateCollectionQueryDataSourceBindingProjectionRegistryOptions {
+    /** Pagination requests keyed by data-source id. */
+    readonly paginationRequestsByDataSourceId?: Readonly<Record<string, object | null | undefined>>;
+    /** Static or computed query-key fragments. */
+    readonly queryKeyParts?: readonly unknown[] | ((context: PresentationDataSourceBindingFactoryContext) => readonly unknown[]);
+    /** Optional local-value override for collection data sources. */
+    readonly resolveLocalValue?: (context: PresentationDataSourceBindingFactoryContext) => PresentationTargetInterpretedLocalValueDataSourceBindingInput | null | undefined;
+    /** Optional per-source query-lowering transform resolver. */
+    readonly resolveTransforms?: (context: PresentationDataSourceBindingFactoryContext) => Readonly<Record<string, DataSourceQueryLoweringTransform>> | undefined;
+    /** Optional source value resolver for query lowering. */
+    readonly resolveValue?: (context: PresentationDataSourceBindingFactoryContext) => unknown;
+    /** Target interpretation used for generated bindings. */
+    readonly targetInterpretation: PresentationDataSourceTargetInterpretation;
+}
+/** Options for creating an aggregate-query projection registry. */
+export interface CreateAggregateQueryDataSourceBindingProjectionRegistryOptions {
+    /** Static or computed query-key fragments. */
+    readonly queryKeyParts?: readonly unknown[] | ((context: PresentationDataSourceBindingFactoryContext) => readonly unknown[]);
+    /** Optional per-source query-lowering transform resolver. */
+    readonly resolveTransforms?: (context: PresentationDataSourceBindingFactoryContext) => Readonly<Record<string, DataSourceQueryLoweringTransform>> | undefined;
+    /** Optional source value resolver for query lowering. */
+    readonly resolveValue?: (context: PresentationDataSourceBindingFactoryContext) => unknown;
+    /** Target interpretation used for generated bindings. */
+    readonly targetInterpretation: PresentationDataSourceTargetInterpretation;
+}
+/** Options for creating endpoint-fetch projection registries. */
+export interface CreateApiEndpointFetchDataSourceBindingProjectionRegistryOptions {
+    /** Static or computed query-key fragments. */
+    readonly queryKeyParts?: readonly unknown[] | ((context: PresentationDataSourceBindingFactoryContext) => readonly unknown[]);
+    /** Target interpretation used for generated bindings. */
+    readonly targetInterpretation: PresentationDataSourceTargetInterpretation;
+}
+/** Options for creating local-state projection registries. */
+export interface CreateLocalStateDataSourceBindingProjectionRegistryOptions {
+    /** Resolves a local-value binding input for a local-state data source. */
+    readonly resolveLocalValue: (context: PresentationDataSourceBindingFactoryContext) => PresentationTargetInterpretedLocalValueDataSourceBindingInput | null | undefined;
+    /** Target interpretation used for authorization defaults. */
+    readonly targetInterpretation: PresentationDataSourceTargetInterpretation;
+}
+/** Options for projecting action-result state values as data-source bindings. */
+export interface CreateActionResultStateDataSourceBindingProjectionRegistryOptions {
+    /** Route-scoped data-source values written by action result policies. */
+    readonly values?: PresentationActionResultStateValues;
+    /** Target interpretation used for authorization defaults. */
+    readonly targetInterpretation: PresentationDataSourceTargetInterpretation;
+}
+/** Static or factory-produced query-key fragments used by binding projectors. */
+export type DataSourceQueryKeyParts = readonly unknown[] | ((context: PresentationDataSourceBindingFactoryContext) => readonly unknown[]);
+/**
+ * Per-data-source interpretation hooks used by collection and aggregate query
+ * projectors.
+ */
+export interface DataSourceQueryInterpretation {
+    /** Optional local-value override for the data source. */
+    readonly localValue?: (context: PresentationDataSourceBindingFactoryContext) => PresentationTargetInterpretedLocalValueDataSourceBindingInput | null | undefined;
+    /** Normalizes a source value before query lowering. */
+    readonly normalizeValue?: (value: unknown, context: PresentationDataSourceBindingFactoryContext) => unknown;
+    /** Query-key fragments for this data source. */
+    readonly queryKeyParts?: DataSourceQueryKeyParts;
+    /** Reads the source value used by query lowering. */
+    readonly readValue?: (context: PresentationDataSourceBindingFactoryContext) => unknown;
+    /** Per-data-source query lowering transforms or transform resolver. */
+    readonly transforms?: Readonly<Record<string, DataSourceQueryLoweringTransform>> | ((context: PresentationDataSourceBindingFactoryContext) => Readonly<Record<string, DataSourceQueryLoweringTransform>> | undefined);
+}
+/** Registry of query interpretation hooks keyed by data-source id. */
+export interface DataSourceQueryInterpretationRegistry {
+    /** Per-source interpretation hooks keyed by data-source id. */
+    readonly byDataSourceId?: Readonly<Record<string, DataSourceQueryInterpretation>>;
+    /** Default query-key fragments when a source has no override. */
+    readonly defaultQueryKeyParts?: DataSourceQueryKeyParts;
+    /** Shared query lowering transforms or transform resolver. */
+    readonly transforms?: Readonly<Record<string, DataSourceQueryLoweringTransform>> | ((context: PresentationDataSourceBindingFactoryContext) => Readonly<Record<string, DataSourceQueryLoweringTransform>> | undefined);
+}
+/**
+ * Resolvers adapted from a query interpretation registry to the option shape
+ * consumed by collection and aggregate binding registry factories.
+ */
+export type DataSourceQueryInterpretationResolvers = Pick<CreateCollectionQueryDataSourceBindingProjectionRegistryOptions, 'queryKeyParts' | 'resolveLocalValue' | 'resolveTransforms' | 'resolveValue'> & Pick<CreateAggregateQueryDataSourceBindingProjectionRegistryOptions, 'queryKeyParts' | 'resolveTransforms' | 'resolveValue'>;
+/** Preserves target interpretation objects as a named projection concept. */
+export declare function createPresentationDataSourceTargetInterpretation(interpretation: PresentationDataSourceTargetInterpretation): PresentationDataSourceTargetInterpretation;
+/**
+ * Resolves authorization from the target interpretation based on the backend
+ * binding kind declared for the data source.
+ */
+export declare function resolvePresentationDataSourceTargetAuthorization(targetInterpretation: PresentationDataSourceTargetInterpretation | undefined, context: PresentationDataSourceBindingFactoryContext): PresentationDataSourceAuthorizationRequirement;
+/** Creates a local-value binding with authorization supplied by the target. */
+export declare function createTargetInterpretedLocalValueDataSourceBinding(context: PresentationDataSourceBindingFactoryContext, targetInterpretation: PresentationDataSourceTargetInterpretation | undefined, binding: PresentationTargetInterpretedLocalValueDataSourceBindingInput): PresentationLocalValueDataSourceBinding;
+/** Creates a TanStack Query binding with authorization supplied by the target. */
+export declare function createTargetInterpretedTanStackQueryDataSourceBinding(context: PresentationDataSourceBindingFactoryContext, targetInterpretation: PresentationDataSourceTargetInterpretation | undefined, binding: PresentationTargetInterpretedTanStackQueryDataSourceBindingInput, defaultAuthorization?: PresentationDataSourceAuthorizationFactory): PresentationTanStackQueryDataSourceBinding;
+/** Creates endpoint-query binding input from backend-declared query lowering. */
+export declare function createDataSourceEndpointQueryBindingInput<TRequest extends object = Record<string, unknown>, TResult = unknown>({ context, defaultRequest, emptyMessage, enabled, endpointId, fallbackData, paginationRequest, pendingLabel, queryKeyParts, refetchInterval, retry, staleTime, targetInterpretation, transforms, value, }: CreateDataSourceEndpointQueryBindingInputOptions<TRequest>): PresentationTargetInterpretedTanStackQueryDataSourceBindingInput;
+/** Creates a fully wrapped endpoint-query binding from backend query lowering. */
+export declare function createDataSourceEndpointQueryBinding<TRequest extends object = Record<string, unknown>, TResult = unknown>(options: CreateDataSourceEndpointQueryBindingInputOptions<TRequest>): PresentationTanStackQueryDataSourceBinding;
+/** Creates a default binding registry for backend-declared collection-query data sources. */
+export declare function createCollectionQueryDataSourceBindingProjectionRegistry({ paginationRequestsByDataSourceId, queryKeyParts, resolveLocalValue, resolveTransforms, resolveValue, targetInterpretation, }: CreateCollectionQueryDataSourceBindingProjectionRegistryOptions): PresentationDataSourceBindingProjectionRegistry;
+/** Creates a default binding registry for backend-declared aggregate-query data sources. */
+export declare function createAggregateQueryDataSourceBindingProjectionRegistry({ queryKeyParts, resolveTransforms, resolveValue, targetInterpretation, }: CreateAggregateQueryDataSourceBindingProjectionRegistryOptions): PresentationDataSourceBindingProjectionRegistry;
+/** Creates a default fetch binding registry for endpoint-backed data sources. */
+export declare function createApiEndpointFetchDataSourceBindingProjectionRegistry({ queryKeyParts, targetInterpretation, }: CreateApiEndpointFetchDataSourceBindingProjectionRegistryOptions): PresentationDataSourceBindingProjectionRegistry;
+/** Creates a default binding registry for frontend-owned local-state data sources. */
+export declare function createLocalStateDataSourceBindingProjectionRegistry({ resolveLocalValue, targetInterpretation, }: CreateLocalStateDataSourceBindingProjectionRegistryOptions): PresentationDataSourceBindingProjectionRegistry;
+/**
+ * Creates a binding registry that exposes action-result state writes as local
+ * values for their target data sources.
+ */
+export declare function createActionResultStateDataSourceBindingProjectionRegistry({ targetInterpretation, values, }: CreateActionResultStateDataSourceBindingProjectionRegistryOptions): PresentationDataSourceBindingProjectionRegistry;
+/** Adapts data-source query interpretation metadata to collection/aggregate projector hooks. */
+export declare function createDataSourceQueryInterpretationResolvers({ byDataSourceId, defaultQueryKeyParts, transforms, }: DataSourceQueryInterpretationRegistry): DataSourceQueryInterpretationResolvers;
+/** Creates endpoint-fetch binding input from an API endpoint data source. */
+export declare function createDataSourceEndpointFetchBindingInput<TResult = unknown>({ context, emptyMessage, enabled, endpointId, fallbackData, pendingLabel, queryKeyParts, refetchInterval, retry, routeParameters, staleTime, targetInterpretation, }: CreateDataSourceEndpointFetchBindingInputOptions): PresentationTargetInterpretedTanStackQueryDataSourceBindingInput;
+/** Creates a fully wrapped endpoint-fetch binding from an API endpoint data source. */
+export declare function createDataSourceEndpointFetchBinding<TResult = unknown>(options: CreateDataSourceEndpointFetchBindingInputOptions): PresentationTanStackQueryDataSourceBinding;
+/** Creates a binding that materializes a source data source and evaluates aggregate measures. */
+export declare function createDataSourceAggregateQueryBinding({ context, queryKeyParts, targetInterpretation, transforms, value, }: CreateDataSourceAggregateQueryBindingOptions): PresentationTanStackQueryDataSourceBinding | null;
+/** Executes an API endpoint through the active target interpretation. */
+export declare function executePresentationDataSourceTargetEndpoint<TResult = unknown>(targetInterpretation: PresentationDataSourceTargetInterpretation, endpointId: string, request?: PresentationDataSourceEndpointExecutionRequest, options?: ExecutePresentationDataSourceTargetEndpointOptions): Promise<TResult>;
+/**
+ * Composes independently owned data-source binding registries into one
+ * projection registry. Later registries override earlier factories for the same
+ * data-source or endpoint id so app-level composition can replace defaults at
+ * narrower ownership boundaries.
+ */
+export declare function mergePresentationDataSourceBindingProjectionRegistries(...registries: readonly PresentationDataSourceBindingProjectionRegistry[]): PresentationDataSourceBindingProjectionRegistry;
+/**
+ * Projects semantic data-source definitions onto concrete frontend binding
+ * plans. React hooks are deliberately not used here; hook-backed realization is
+ * handled later by PresentationDataSourceBinder.
+ */
+export declare function projectPresentationDataSourceBindings({ context, dataSourceDefinitions, dataSourceIds, module, registry, }: ProjectPresentationDataSourceBindingsOptions): readonly PresentationDataSourceBinding[];
+/**
+ * Adapts TanStack Query binding-input factories into a full projection
+ * registry by applying target-level authorization to every produced binding.
+ */
+export declare function createTanStackQueryDataSourceBindingProjectionRegistry({ apiEndpoint, byDataSourceId, byEndpointId, defaultAuthorization, targetInterpretation, }: TanStackQueryDataSourceBindingProjectionRegistryOptions): PresentationDataSourceBindingProjectionRegistry;
+/**
+ * Creates a generic TanStack Query projection registry for API endpoint data
+ * sources. The registry resolves endpoint ids from backend bindings, projects
+ * route parameters, applies runtime annotations, and executes through the
+ * active target interpretation.
+ */
+export declare function createApiEndpointTanStackQueryDataSourceBindingProjectionRegistry({ createQueryKey, defaultAuthorization, executeEndpoint, isEnabled, pendingLabel, retry, targetInterpretation, }: ApiEndpointTanStackQueryDataSourceBindingProjectionRegistryOptions): PresentationDataSourceBindingProjectionRegistry;
+/**
+ * Reads target binding options from a backend presentation binding.
+ *
+ * Option names are matched case-insensitively and may use either camelCase or
+ * PascalCase.
+ */
+export declare function readPresentationDataSourceTargetBindingOptions(binding: PresentationBindingDefinition | null | undefined): PresentationDataSourceTargetBindingOptions;
+/**
+ * Reads runtime query defaults from the standard
+ * `cohesive.presentation.data-source.runtime` data-source annotation.
+ */
+export declare function readDataSourceBindingRuntimeOptions(dataSource: Pick<DataSourceDefinition, 'Annotations'> | null | undefined): PresentationDataSourceBindingRuntimeOptions;
+/**
+ * Resolves the endpoint executor selected by a binding's `executionTargetId`,
+ * falling back to the default API endpoint executor on the target
+ * interpretation.
+ */
+export declare function resolvePresentationDataSourceTargetEndpointExecutor(targetInterpretation: PresentationDataSourceTargetInterpretation | undefined, binding: PresentationBindingDefinition | null | undefined): PresentationDataSourceEndpointExecutor | undefined;
+//# sourceMappingURL=data-source-projection.d.ts.map