@cratis/event-models 0.338.0 → 0.339.0

package/dist/screen-editor/ScreenEditor/DesignMode/Outlets/OutletStrings.d.ts

@@ -0,0 +1,74 @@
+export interface OutletStrings {
+    kinds: Record<string, string>;
+    newItem: Record<string, string>;
+    frameName: (name: string, kind: string) => string;
+    tagLong: (name: string, summary: string) => string;
+    title: (name: string, kind: string) => string;
+    declaredBy: (owner: string) => string;
+    editingAs: string;
+    levels: Record<string, string>;
+    levelName: (kind: string, name: string) => string;
+    everyScreenBelow: (level: string) => string;
+    modeTitle: string;
+    modes: Record<'inherit' | 'extend' | 'override', {
+        title: string;
+        description: (owner: string) => string;
+    }>;
+    copyPrompt: string;
+    copyYes: string;
+    copyNo: string;
+    extendsNotice: string;
+    items: string;
+    add: (item: string) => string;
+    own: string;
+    fromLevel: (owner: string) => string;
+    contributedBy: (owner: string) => string;
+    hiddenHere: string;
+    overriddenHere: string;
+    hide: string;
+    bringBack: string;
+    contributionNote: string;
+    nothingYet: string;
+    bindings: {
+        title: string;
+        sets: string;
+        control: string;
+        controls: Record<string, string>;
+        shows: string;
+        valueFrom: string;
+        trend: string;
+        target: string;
+        slot: string;
+        icon: string;
+        opens: string;
+        opensChoices: Record<string, string>;
+        chooseParameter: string;
+        chooseScreen: string;
+        chooseField: string;
+        automatic: string;
+        noQuery: string;
+    };
+    otherOutlets: string;
+    modeOf: Record<'inherit' | 'extend' | 'override' | 'declares', string>;
+    added: (count: number) => string;
+    template: {
+        slots: string;
+        outlets: string;
+        name: string;
+        kind: string;
+        subject: string;
+        subjects: Record<string, string>;
+        slot: string;
+        noSlot: string;
+        defaults: string;
+        defaultsCount: (count: number) => string;
+        addOutlet: string;
+        removeOutlet: string;
+        removeDefault: string;
+        newOutletName: string;
+        routed: string;
+        primary: string;
+        optional: string;
+    };
+}
+export declare const defaultOutletStrings: OutletStrings;

package/dist/screen-editor/ScreenEditor/DesignMode/Outlets/createOutletDesign.d.ts

@@ -0,0 +1,34 @@
+import { OutletKind, type ComponentDesignModeDescriptor, type OutletItem, type OutletSubject, type SceneDocument } from '@cratis/scene.model';
+import { type EffectiveOutlet, type OutletChain } from '@cratis/scene.engine';
+import { type DesignModeItem, type DesignModeItemSource, type DesignModePlan, type DesignModeRejection } from '../designModeTypes';
+import { type OutletBindingContext } from './outletBindings';
+import { type OutletEditingLevel } from './outletDocument';
+import type { OutletStrings } from './OutletStrings';
+export type OutletLevelMode = 'inherit' | 'extend' | 'override';
+export interface OutletDesignInputs {
+    document: SceneDocument;
+    outlets: OutletChain;
+    outlet: string;
+    level: OutletEditingLevel;
+    newId: () => string;
+    binding: OutletBindingContext;
+    strings: OutletStrings;
+}
+export interface OutletDesign extends DesignModeItemSource {
+    name: string;
+    outletKind: OutletKind;
+    subject?: OutletSubject;
+    slot?: string;
+    declaredBy?: string;
+    level: OutletEditingLevel;
+    mode: OutletLevelMode;
+    effective: EffectiveOutlet;
+    removed: readonly DesignModeItem[];
+    designMode: ComponentDesignModeDescriptor;
+    setMode: (mode: OutletLevelMode, copy?: boolean) => DesignModePlan | DesignModeRejection;
+    addItem: (item: OutletItem) => DesignModePlan;
+    hide: (item: DesignModeItem) => DesignModePlan | DesignModeRejection;
+    bringBack: (item: DesignModeItem) => DesignModePlan | DesignModeRejection;
+}
+export declare function declaresOutlet(outlets: OutletChain, outlet: string): boolean;
+export declare function createOutletDesign(inputs: OutletDesignInputs): OutletDesign | undefined;

package/dist/screen-editor/ScreenEditor/DesignMode/Outlets/outletBindings.d.ts

@@ -0,0 +1,23 @@
+import { OutletItemKind, OutletSubject, type ApplicationStructure, type InspectedProperty, type OutletItem, type PropertyDescriptor, type QueryCandidate } from '@cratis/scene.model';
+import type { OutletStrings } from './OutletStrings';
+import type { HookPlacementInput, PlacementEnvironment } from '../../Placement/hookPlacement';
+import type { PlacementStrings } from '../../Placement/PlacementStrings';
+export interface OutletBindingContext {
+    queries: readonly QueryCandidate[];
+    screens: readonly {
+        id: string;
+        label: string;
+    }[];
+    actionProperties: readonly PropertyDescriptor[];
+    structure?: ApplicationStructure;
+    strings: OutletStrings['bindings'];
+    placement?: PlacementEnvironment;
+    placementStrings?: PlacementStrings;
+    outletSubject?: OutletSubject;
+}
+export declare function hookOf(item: OutletItem, context: Pick<OutletBindingContext, 'outletSubject'>): HookPlacementInput;
+export declare const bindingActionsOf: (kind: OutletItemKind | string) => readonly string[];
+export declare function bindingProperty(actionId: string, item: OutletItem, context: OutletBindingContext): InspectedProperty | undefined;
+export declare function bindingChange(actionId: string, value: unknown): Record<string, unknown> | undefined;
+export declare function bindingChips(item: OutletItem, context: OutletBindingContext): Record<string, string>;
+export declare function isUnbound(item: OutletItem): boolean;

package/dist/screen-editor/ScreenEditor/DesignMode/Outlets/outletDesignModes.d.ts

@@ -0,0 +1,6 @@
+import { OutletItemKind, OutletKind, type ComponentDesignModeDescriptor } from '@cratis/scene.model';
+export declare const addActionOf: Record<OutletKind, {
+    id: string;
+    item: OutletItemKind;
+}>;
+export declare function outletDesignModeOf(kind: OutletKind): ComponentDesignModeDescriptor;

package/dist/screen-editor/ScreenEditor/DesignMode/Outlets/outletDocument.d.ts

@@ -0,0 +1,15 @@
+import type { Outlet, OutletRefinement, SceneDocument } from '@cratis/scene.model';
+import { OutletLevelKind, type OutletLevel } from '@cratis/scene.engine';
+export type OutletDocument = SceneDocument & {
+    outletLevels?: OutletLevel[];
+};
+export interface OutletEditingLevel {
+    kind: OutletLevelKind;
+    name: string;
+}
+export declare const sameLevel: (one: OutletEditingLevel | undefined, other: OutletEditingLevel | undefined) => boolean;
+export declare const outletLevelsOf: (document: SceneDocument) => OutletLevel[];
+export declare function withOutletLevels(document: SceneDocument, levels: readonly OutletLevel[]): SceneDocument;
+export declare function refinementAt(document: SceneDocument, level: OutletEditingLevel, outlet: string): OutletRefinement | undefined;
+export declare function withRefinement(document: SceneDocument, level: OutletEditingLevel, outlet: string, refinement: OutletRefinement | undefined): SceneDocument;
+export declare function withTemplateOutlets(document: SceneDocument, template: string, outlets: readonly Outlet[]): SceneDocument;

package/dist/screen-editor/ScreenEditor/DesignMode/Outlets/outletItemOps.d.ts

@@ -0,0 +1,11 @@
+import type { OutletItem } from '@cratis/scene.model';
+export declare function findOutletItem(items: readonly OutletItem[], id: string): OutletItem | undefined;
+export declare function siblingsOfOutletItem(items: readonly OutletItem[], id: string): readonly OutletItem[] | undefined;
+export declare const changeOutletItem: (items: readonly OutletItem[], id: string, change: Record<string, unknown>) => OutletItem[];
+export declare const removeOutletItem: (items: readonly OutletItem[], id: string) => OutletItem[];
+export declare function moveOutletItem(items: readonly OutletItem[], id: string, to: number): OutletItem[];
+export declare function duplicateOutletItem(items: readonly OutletItem[], id: string, newId: () => string): {
+    items: OutletItem[];
+    copy?: OutletItem;
+};
+export declare const addOutletSubItem: (items: readonly OutletItem[], parentId: string, child: OutletItem) => OutletItem[];

package/dist/screen-editor/ScreenEditor/DesignMode/Outlets/screenOutletChain.d.ts

@@ -0,0 +1,18 @@
+import type { DialogTemplate, Layout, SceneDocument, ScreenTemplate } from '@cratis/scene.model';
+import { type OutletChain, type OutletLevel } from '@cratis/scene.engine';
+import { type OutletEditingLevel } from './outletDocument';
+export interface ScreenOutletChainInputs {
+    document: SceneDocument;
+    screen: string;
+    path?: readonly string[];
+    templates?: readonly ScreenTemplate[];
+    layouts?: readonly Layout[];
+    dialogTemplate?: DialogTemplate;
+}
+export declare function screenOutletChain({ document, screen, path, templates, layouts, dialogTemplate }: ScreenOutletChainInputs): OutletChain;
+export declare const editingLevelsOf: (chain: readonly OutletLevel[]) => OutletEditingLevel[];
+export declare function chainAt(outlets: OutletChain, level: OutletEditingLevel | undefined): OutletChain;
+export declare const declaredOutletsOf: (chain: readonly OutletLevel[]) => {
+    outlet: import("@cratis/scene.model").Outlet;
+    level: OutletLevel;
+}[];

package/dist/screen-editor/ScreenEditor/DesignMode/Outlets/screenOutlets.d.ts

@@ -0,0 +1,44 @@
+import { type DialogTemplate, type Layout, type OutletKind, PropertyDescriptor, QueryCandidate, SceneDocument, ScreenTemplate } from '@cratis/scene.model';
+import { type DescriptorCatalog, type OutletChain } from '@cratis/scene.engine';
+import type { ScreenEditorController } from '../../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../../Host/ScreenEditorHost';
+import type { StateChangeSlice } from '../../Actions/StateChangeSlice';
+import { type OutletDesign } from './createOutletDesign';
+import type { OutletBindingContext } from './outletBindings';
+import { type OutletEditingLevel } from './outletDocument';
+import type { OutletStrings } from './OutletStrings';
+export interface ScreenOutlets {
+    outlets: OutletChain;
+    levels: readonly OutletEditingLevel[];
+    level: OutletEditingLevel | undefined;
+    declared: readonly {
+        name: string;
+        kind: OutletKind;
+        owner: string;
+        shell: boolean;
+    }[];
+    binding: OutletBindingContext;
+    design: (outlet: string) => OutletDesign | undefined;
+}
+export interface ScreenOutletsInputs {
+    document: SceneDocument;
+    catalog: DescriptorCatalog;
+    path?: readonly string[];
+    templates?: readonly ScreenTemplate[];
+    layouts?: readonly Layout[];
+    dialogTemplate?: DialogTemplate;
+    requestedLevel?: OutletEditingLevel;
+    queries: readonly QueryCandidate[];
+    slices?: readonly StateChangeSlice[];
+    screens: readonly {
+        id: string;
+        label: string;
+    }[];
+    structure?: OutletBindingContext['structure'];
+    strings: OutletStrings;
+    newId?: () => string;
+}
+export declare function queriesOfScreen(document: SceneDocument, candidates: readonly QueryCandidate[]): QueryCandidate[];
+export declare function actionPropertiesOf(catalog: DescriptorCatalog): PropertyDescriptor[];
+export declare function screenOutletsOf(inputs: ScreenOutletsInputs): ScreenOutlets;
+export declare function useScreenOutlets(controller: ScreenEditorController, environment: ScreenEditorEnvironment, strings: OutletStrings): ScreenOutlets;

package/dist/screen-editor/ScreenEditor/DesignMode/designModeTypes.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentDesignModeDescriptor, InspectedProperty, SceneEdit } from '@cratis/scene.model';
+import type { ComponentDesignModeDescriptor, InspectedProperty, SceneDocument, SceneEdit } from '@cratis/scene.model';
 import type { NavigationEdit } from '@cratis/scene.engine';
 export declare const designModeActions: {
     readonly addItem: 'addItem';
@@ -9,6 +9,15 @@ export declare const designModeActions: {
     readonly slice: 'slice';
     readonly emphasis: 'emphasis';
     readonly display: 'display';
+    readonly addFilter: 'addFilter';
+    readonly addTab: 'addTab';
+    readonly addStat: 'addStat';
+    readonly sets: 'sets';
+    readonly control: 'control';
+    readonly shows: 'shows';
+    readonly valueFrom: 'valueFrom';
+    readonly opens: 'opens';
+    readonly enabled: 'enabled';
     readonly moveEarlier: 'moveEarlier';
     readonly moveLater: 'moveLater';
     readonly duplicate: 'duplicate';
@@ -18,7 +27,8 @@ export declare const designModeActions: {
 export declare enum DesignModeItemSourceKind {
     Elements = "elements",
     Collection = "collection",
-    Region = "region"
+    Region = "region",
+    Outlet = "outlet"
 }
 export interface DesignModeItem {
     id: string;
@@ -36,6 +46,12 @@ export interface DesignModeItem {
         message: string;
     }[];
     unlinked: boolean;
+    provenance?: {
+        owner: string;
+        level: string;
+        source: string;
+    };
+    removal?: 'hidden' | 'overridden';
 }
 export interface DesignModeChoice {
     property: InspectedProperty;
@@ -50,6 +66,7 @@ export interface DesignModePlan {
     };
     renameNext?: boolean;
     navigationEdits?: NavigationEdit[];
+    documentChange?: (document: SceneDocument) => SceneDocument;
     notice?: string;
     editAtApplication?: boolean;
 }

package/dist/screen-editor/ScreenEditor/DesignMode/resolveDesignMode.d.ts

@@ -2,6 +2,7 @@ import type { ApplicationStructure, DestinationReference, ExternalComponent, Nod
 import { type DescriptorCatalog } from '@cratis/scene.engine';
 import type { Ownership } from '../Structure/Ownership';
 import { type DesignModeItemSource, type DesignModeSubject } from './designModeTypes';
+import type { OutletDesign } from './Outlets/createOutletDesign';
 export interface DesignModeInputs {
     roots: readonly SceneElement[];
     catalog: DescriptorCatalog;
@@ -17,5 +18,6 @@ export interface DesignModeInputs {
     structure?: ApplicationStructure;
     startingDestination?: DestinationReference;
     otherSource?: (component: ExternalComponent, selectedItemId: string | undefined) => DesignModeItemSource | undefined;
+    outletDesign?: (component: ExternalComponent) => OutletDesign | undefined;
 }
 export declare function resolveDesignMode(inputs: DesignModeInputs): DesignModeSubject | undefined;

package/dist/screen-editor/ScreenEditor/DesignMode/useDesignMode.d.ts

@@ -4,6 +4,7 @@ import { type DesignModeItem, type DesignModePlan, type DesignModeRejection, typ
 import type { DesignModeStrings } from './DesignModeStrings';
 import { type DesignModeInputs } from './resolveDesignMode';
 import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import { type ScreenOutlets } from './Outlets/screenOutlets';
 export interface DesignModeOptions {
     controller: ScreenEditorController;
     environment: ScreenEditorEnvironment;
@@ -26,6 +27,7 @@ export interface DesignModeState {
     act: (actionId: string, item: DesignModeItem) => boolean;
     rename: (item: DesignModeItem, label: string) => boolean;
     deselect: () => void;
+    outlets?: ScreenOutlets;
 }
 export declare function useDesignMode({ controller, environment, strings, startingLabels, startingDestination, otherSource }: DesignModeOptions): DesignModeState;
 export declare function regionOf(componentName: string): NavigationRegionKind | undefined;

package/dist/screen-editor/ScreenEditor/Forms/fieldChoices.d.ts

@@ -0,0 +1,14 @@
+import { type FormField, type QueryCandidate, type QueryResultField } from '@cratis/scene.model';
+export interface FieldChoices {
+    query: string;
+    show: string;
+}
+export type ChoiceField = FormField & {
+    choices?: FieldChoices;
+};
+export declare const choicesOf: (field: FormField) => FieldChoices | undefined;
+export declare function withChoices(field: FormField, choices: FieldChoices | undefined): FormField;
+export declare const listQueriesOf: (candidates: readonly QueryCandidate[]) => QueryCandidate[];
+export declare function defaultDisplayField(candidate: QueryCandidate): QueryResultField | undefined;
+export declare function inferChoices(type: string, candidates: readonly QueryCandidate[]): FieldChoices | undefined;
+export declare const choicesFor: (field: FormField, type: string | undefined, candidates: readonly QueryCandidate[]) => FieldChoices | undefined;

package/dist/screen-editor/ScreenEditor/Forms/fieldMarkers.d.ts

@@ -0,0 +1,8 @@
+import type { FormField } from '@cratis/scene.model';
+import type { StateChangeSlice } from '../Actions/StateChangeSlice';
+export declare enum FieldMarkerKind {
+    BoundToCommand = "boundToCommand",
+    InheritedFromRules = "inheritedFromRules",
+    Local = "local"
+}
+export declare function fieldMarkersOf(field: FormField, slice: StateChangeSlice | undefined): FieldMarkerKind[];

package/dist/screen-editor/ScreenEditor/Host/ScreenEditorController.d.ts

@@ -1,4 +1,7 @@
 import type { CanvasPlacement } from '../Document/placeOnCanvas';
+import type { DataField } from '../Data/DataField';
+import type { DataFieldRefusal } from '../Data/insertDataField';
+import type { TableDrop } from '../Surface/columnAt';
 import type { PreparedSceneScreenDraft, SceneScreenDraftPreparation } from '../Drafting/SceneScreenDraft';
 import type { ApplicationStructure, Behavior, DestinationReference, DialogTemplate, NavigationModel, Form, NodeInspection, SceneDiagnostic, SceneDocument, SceneEdit, SceneElement, ScreenTemplate, Slot, TemplateMetadata } from '@cratis/scene.model';
 import type { EditingContext, NavigationEdit } from '@cratis/scene.engine';
@@ -9,6 +12,8 @@ import type { StructureTreeAdapter } from '../Structure/StructureTreeAdapter';
 import type { EditorComposition } from '../Templates/composeEditorScreen';
 import type { DropRegion } from '../DropRegions/DropRegion';
 import type { LayoutItem } from '../Layouts/LayoutItem';
+import type { OutletEditingLevel } from '../DesignMode/Outlets/outletDocument';
+import type { ScreenEditorButtonToAdd } from './ScreenEditorHost';
 export type ElementMeasurer = (elementId: string) => {
     left: number;
     top: number;
@@ -24,8 +29,19 @@ export interface ScreenEditorController {
         rejected?: string;
     };
     setNavigationModule: (module: string | undefined) => void;
+    outletLevel: OutletEditingLevel | undefined;
+    setOutletLevel: (level: OutletEditingLevel | undefined) => void;
+    changeDocument: (change: (document: SceneDocument) => SceneDocument, label: string) => {
+        applied: boolean;
+        rejected?: string;
+    };
     selectedItemId: string | undefined;
     selectItem: (componentId: string | undefined, itemId: string | undefined) => void;
+    buttonToAdd: {
+        componentId: string;
+        button: ScreenEditorButtonToAdd;
+    } | undefined;
+    settleButtonToAdd: () => void;
     document: SceneDocument;
     prepareSceneScreenDraft?: (answer: string, parameterlessQueryIds: readonly string[]) => SceneScreenDraftPreparation;
     applySceneScreenDraft?: (draft: PreparedSceneScreenDraft) => {
@@ -57,6 +73,12 @@ export interface ScreenEditorController {
     validateMove: (edit: StructureEdit) => StructureEditRejection | undefined;
     insertComponent: (componentName: string, parentId: string | undefined, index: number | undefined, at?: CanvasPlacement) => void;
     insertLayout: (item: LayoutItem, parentId: string | undefined, index: number | undefined, at?: CanvasPlacement) => void;
+    insertElement: (element: SceneElement, parentId: string | undefined, index: number | undefined, label: string, at?: CanvasPlacement) => void;
+    insertDataField: (field: DataField, parentId: string | undefined, index: number | undefined, at?: CanvasPlacement, over?: TableDrop) => DataFieldRefusal | undefined;
+    generateForm: (sliceId: string, parentId: string | undefined, index: number | undefined) => DataFieldRefusal | undefined;
+    removeDataField: (field: Extract<DataField, {
+        source: 'query';
+    }>) => void;
     remove: (elementId: string) => void;
     canRemove: (elementId: string) => boolean;
     setProperty: (property: NodeInspection['properties'][number], value: unknown) => void;

package/dist/screen-editor/ScreenEditor/Host/ScreenEditorHost.d.ts

@@ -18,6 +18,17 @@ export interface ScreenEditorSubject {
     authoringTemplate?: string;
     screenTemplate?: string;
     screen?: string;
+    select?: ScreenEditorSelection;
+}
+export interface ScreenEditorSelection {
+    componentId: string;
+    itemId?: string;
+    add?: ScreenEditorButtonToAdd;
+}
+export interface ScreenEditorButtonToAdd {
+    outlet: string;
+    slice: string;
+    title: string;
 }
 export interface ScreenEditorEnvironment {
     runtime: ScreenEditorRuntime;

package/dist/screen-editor/ScreenEditor/Host/ScreenEditorWindow.d.ts

@@ -33,5 +33,6 @@ export interface ScreenEditorWindowProps {
     onPreview?: (document: SceneDocument) => void;
     readOnly?: boolean;
     toolbarActions?: ReactNode;
+    renderControls?: (controls: ReactNode) => ReactNode;
 }
-export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, authoringTemplate, title, deviceFrame, saveFailure, onKeepEditing, onDiscard, onPreview, readOnly, toolbarActions }: ScreenEditorWindowProps) => import("react").JSX.Element;
+export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, authoringTemplate, title, deviceFrame, saveFailure, onKeepEditing, onDiscard, onPreview, readOnly, toolbarActions, renderControls }: ScreenEditorWindowProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Host/openSubject.d.ts

@@ -1,9 +1,10 @@
 import type { SceneDocument, ScreenTemplate } from '@cratis/scene.model';
 import { type SceneDocumentProblem } from '../Document/readSceneDocument';
 import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
-import type { ScreenEditorSubject } from './ScreenEditorHost';
+import type { ScreenEditorSelection, ScreenEditorSubject } from './ScreenEditorHost';
 export interface OpenedSubject {
     document: SceneDocument;
+    select?: ScreenEditorSelection;
 }
 export type OpenResult = {
     opened: true;

package/dist/screen-editor/ScreenEditor/Inspector/ActionEditor.d.ts

@@ -1,6 +1,7 @@
 import type { CommandInputSource } from '../Actions/commandInputSources';
 import type { ActionModel } from '../Actions/ActionModel';
 import { type StateChangeSlice } from '../Actions/StateChangeSlice';
+import type { PlacementEnvironment } from '../Placement/hookPlacement';
 import type { ScreenEditorStrings } from './ScreenEditorStrings';
 export interface ActionEditorProps {
     action?: ActionModel;
@@ -8,7 +9,8 @@ export interface ActionEditorProps {
     sources: readonly CommandInputSource[];
     strings: ScreenEditorStrings;
     disabled: boolean;
+    placement?: PlacementEnvironment;
     suggestSource: (inputName: string) => string | undefined;
     onChange: (action: ActionModel | undefined) => void;
 }
-export declare const ActionEditor: ({ action, slices, sources, strings, disabled, suggestSource, onChange }: ActionEditorProps) => import("react").JSX.Element;
+export declare const ActionEditor: ({ action, slices, sources, strings, disabled, placement, suggestSource, onChange }: ActionEditorProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Inspector/CommandFormEditor.d.ts

@@ -1,10 +1,11 @@
-import type { Form } from '@cratis/scene.model';
+import type { Form, QueryCandidate } from '@cratis/scene.model';
 import type { StateChangeSlice } from '../Actions/StateChangeSlice';
 import type { ScreenEditorStrings } from './ScreenEditorStrings';
 export interface CommandFormEditorProps {
     elementId: string;
     command: string | undefined;
     slices: readonly StateChangeSlice[];
+    queries?: readonly QueryCandidate[];
     forms: readonly Form[];
     strings: ScreenEditorStrings;
     disabled: boolean;
@@ -12,4 +13,4 @@ export interface CommandFormEditorProps {
     onFormChange: (form: Form) => void;
     onFormCreate: (slice: StateChangeSlice) => void;
 }
-export declare const CommandFormEditor: ({ elementId, command, slices, forms, strings, disabled, onCommandChange, onFormChange, onFormCreate }: CommandFormEditorProps) => import("react").JSX.Element;
+export declare const CommandFormEditor: ({ elementId, command, slices, queries, forms, strings, disabled, onCommandChange, onFormChange, onFormCreate }: CommandFormEditorProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Inspector/DataBindingSections.d.ts

@@ -0,0 +1,23 @@
+import { type QueryBinding, type QueryCandidate, type QueryParameter } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+interface FeedsProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    binding: QueryBinding;
+    candidate: QueryCandidate;
+    disabled?: boolean;
+    onChange?: (binding: QueryBinding, parameter: QueryParameter, path: string) => void;
+}
+export declare const ParameterFeedsSection: ({ controller, environment, strings, binding, candidate, disabled, onChange }: FeedsProps) => import("react").JSX.Element | null;
+interface SelectionProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    elementId: string;
+    disabled: boolean;
+}
+export declare const SelectionDetailSection: ({ controller, environment, strings, elementId, disabled }: SelectionProps) => import("react").JSX.Element | null;
+export {};

package/dist/screen-editor/ScreenEditor/Inspector/FormEditor.d.ts

@@ -1,12 +1,13 @@
-import { type Form } from '@cratis/scene.model';
+import { type Form, type QueryCandidate } from '@cratis/scene.model';
 import type { StateChangeSlice } from '../Actions/StateChangeSlice';
 import type { ScreenEditorStrings } from './ScreenEditorStrings';
 export interface FormEditorProps {
     form: Form;
     slice: StateChangeSlice | undefined;
     idPrefix: string;
+    queries?: readonly QueryCandidate[];
     strings: ScreenEditorStrings['properties']['forms'];
     disabled: boolean;
     onChange: (form: Form) => void;
 }
-export declare const FormEditor: ({ form, slice, idPrefix, strings: text, disabled, onChange }: FormEditorProps) => import("react").JSX.Element;
+export declare const FormEditor: ({ form, slice, idPrefix, queries, strings: text, disabled, onChange }: FormEditorProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Inspector/OutletListEditor.d.ts

@@ -0,0 +1,11 @@
+import { type Outlet, type Slot } from '@cratis/scene.model';
+import type { OutletStrings } from '../DesignMode/Outlets/OutletStrings';
+export interface OutletListEditorProps {
+    outlets: readonly Outlet[];
+    slots: readonly Slot[];
+    disabled: boolean;
+    strings: OutletStrings;
+    newId: () => string;
+    onChange: (outlets: Outlet[]) => void;
+}
+export declare const OutletListEditor: ({ outlets, slots, disabled, strings, newId, onChange }: OutletListEditorProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Inspector/OutletSection.d.ts

@@ -0,0 +1,12 @@
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface OutletSectionProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    outlet: string;
+    componentId?: string;
+    onChooseOutlet?: (outlet: string) => void;
+}
+export declare const OutletSection: ({ controller, environment, strings, outlet, componentId, onChooseOutlet }: OutletSectionProps) => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/Inspector/ScreenEditorStrings.d.ts

@@ -212,6 +212,14 @@ export interface ScreenEditorStrings {
             manual: string;
             fieldLabel: string;
             sourceProperty: string;
+            mapping: Record<'autoMapped' | 'renamed' | 'composed' | 'broken', string>;
+            markers: Record<'boundToCommand' | 'inheritedFromRules' | 'local', string>;
+            control: string;
+            controlText: string;
+            controlPicker: string;
+            choicesQuery: string;
+            choicesShow: string;
+            choicesInferred: string;
             fieldComposition: string;
             columns: string;
             column: (index: number) => string;
@@ -262,6 +270,28 @@ export interface ScreenEditorStrings {
             missingQuery: (query: string) => string;
             missingComponent: (componentId: string) => string;
         };
+        dataBinding: {
+            feedsTitle: string;
+            fedByFilter: (title: string) => string;
+            fedByRoute: (parameter: string, slot: string) => string;
+            fedByMapping: (source: string) => string;
+            fedByNothing: string;
+            routeSource: (parameter: string) => string;
+            routeSourceNone: string;
+            routeSourceOption: (parameter: string, slot: string) => string;
+            addFilter: string;
+            filtersInAddress: string;
+            selectionTitle: string;
+            selectionHint: string;
+            selectionNone: string;
+            selectionSlot: string;
+            selectionScreen: string;
+            selectionBy: string;
+            selectionNoSlot: string;
+            selectionSummary: (screen: string, slot: string, by: string) => string;
+            statFollowsFilters: (filters: string) => string;
+            statFollowsNothing: string;
+        };
         query: {
             label: string;
             choose: string;
@@ -278,6 +308,7 @@ export interface ScreenEditorStrings {
                 loading: string;
                 empty: string;
                 error: string;
+                ready: string;
             };
         };
         action: {

package/dist/screen-editor/ScreenEditor/Inspector/ScreenOutletsSection.d.ts

@@ -0,0 +1,9 @@
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ScreenOutletsSectionProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+}
+export declare const ScreenOutletsSection: ({ controller, environment, strings }: ScreenOutletsSectionProps) => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/Palette/PaletteEntry.d.ts

@@ -1,4 +1,5 @@
 import type { LayoutItem } from '../Layouts/LayoutItem';
+import { type DataField } from '../Data/DataField';
 export type PalettePayload = {
     kind: 'layout';
     item: LayoutItem;
@@ -6,5 +7,8 @@ export type PalettePayload = {
     kind: 'component';
     componentName: string;
     package: string;
+} | {
+    kind: 'field';
+    field: DataField;
 };
 export declare const isPalettePayload: (value: unknown) => value is PalettePayload;

package/dist/screen-editor/ScreenEditor/Placement/HookEnabledField.d.ts

@@ -0,0 +1,14 @@
+import { OutletSubject } from '@cratis/scene.model';
+import { type HookPlacementInput, type PlacementEnvironment } from './hookPlacement';
+import type { EnabledValue } from './hookBinding';
+import type { PlacementStrings } from './PlacementStrings';
+export interface HookEnabledFieldProps {
+    hook: HookPlacementInput;
+    environment: PlacementEnvironment | undefined;
+    strings: PlacementStrings;
+    disabled?: boolean;
+    outletSubject?: OutletSubject;
+    value: EnabledValue;
+    onChange: (value: EnabledValue) => void;
+}
+export declare const HookEnabledField: ({ hook, environment, strings, disabled, outletSubject, value, onChange }: HookEnabledFieldProps) => import("react").JSX.Element;