@cratis/event-models 0.112.0 → 0.113.0

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

@@ -0,0 +1,28 @@
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+import type { ScreenEditorController } from './ScreenEditorController';
+import type { ScreenEditorEnvironment } from './ScreenEditorHost';
+export interface ScreenEditorWindowState {
+    size: {
+        width: number;
+        height: number;
+    };
+    setSize: (size: {
+        width: number;
+        height: number;
+    }) => void;
+    isInspectorOpen: boolean;
+    toggleInspector: () => void;
+    available: {
+        width: number;
+        height: number;
+    };
+}
+export interface ScreenEditorWindowProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    window: ScreenEditorWindowState;
+    deviceFrame?: boolean;
+    saveFailure?: string;
+}
+export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, deviceFrame, saveFailure }: ScreenEditorWindowProps) => import("react").JSX.Element;

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

@@ -0,0 +1,21 @@
+import { type ReactNode } from 'react';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+import { type PaletteIcons, type PaletteSource } from '../Palette/buildPalette';
+import type { LayoutLabels } from '../Layouts/toLayoutContainerDescriptors';
+import type { ScreenEditorEnvironment, ScreenEditorResult, ScreenEditorSubject } from './ScreenEditorHost';
+export interface ScreenEditorWorkspaceProps {
+    subject: ScreenEditorSubject;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    layoutLabels: LayoutLabels;
+    icons: PaletteIcons;
+    paletteSources: readonly PaletteSource[];
+    initialSize?: {
+        width: number;
+        height: number;
+    };
+    onChange?: (result: ScreenEditorResult) => void;
+    renderPaletteHost?: (palette: ReactNode) => ReactNode;
+    onDismiss?: () => void;
+}
+export declare const ScreenEditorWorkspace: (props: ScreenEditorWorkspaceProps) => import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+import type { SceneDocumentProblem } from '../Document/readSceneDocument';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+export interface UnreadableScreenProps {
+    problem: SceneDocumentProblem;
+    strings: ScreenEditorStrings;
+    onClose?: () => void;
+}
+export declare const UnreadableScreen: ({ problem, strings, onClose }: UnreadableScreenProps) => import("react").JSX.Element;

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

@@ -0,0 +1,5 @@
+import type { ReactNode } from 'react';
+export interface WindowTitleBarProps {
+    controls: ReactNode;
+}
+export declare const WindowTitleBar: ({ controls }: WindowTitleBarProps) => import("react").JSX.Element;

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

@@ -0,0 +1,16 @@
+import type { ConfigurationDestination } from '@cratis/components/ConfigurationEditor';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+import type { QuillLoader } from '@cratis/scene.primereact';
+import type { StateChangeSlice } from '../Actions/StateChangeSlice';
+import type { ScreenEditorFileUpload } from './ScreenEditorFileUpload';
+import { type DiscoveredQueryCandidate } from '../Binding/toSceneCandidates';
+import type { ScreenEditorEnvironment } from './ScreenEditorHost';
+export interface ScreenEditorEnvironmentSource {
+    runtime: ScreenEditorRuntime;
+    queryCandidates?: readonly DiscoveredQueryCandidate[];
+    stateChangeSlices?: readonly StateChangeSlice[];
+    destinations?: readonly ConfigurationDestination[];
+    richText?: QuillLoader | false;
+    fileUpload?: ScreenEditorFileUpload;
+}
+export declare function createScreenEditorEnvironment(source: ScreenEditorEnvironmentSource): ScreenEditorEnvironment;

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

@@ -0,0 +1 @@
+export declare const nextElementId: () => string;

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

@@ -0,0 +1,14 @@
+import type { SceneDocument } from '@cratis/scene.model';
+import { type SceneDocumentProblem } from '../Document/readSceneDocument';
+import type { ScreenEditorSubject } from './ScreenEditorHost';
+export interface OpenedSubject {
+    document: SceneDocument;
+}
+export type OpenResult = {
+    opened: true;
+    subject: OpenedSubject;
+} | {
+    opened: false;
+    problem: SceneDocumentProblem;
+};
+export declare function openSubject(subject: ScreenEditorSubject): OpenResult;

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

@@ -0,0 +1,4 @@
+import type { ScreenEditorController } from './ScreenEditorController';
+import type { OpenedSubject } from './openSubject';
+import type { ScreenEditorEnvironment } from './ScreenEditorHost';
+export declare function useScreenEditor(opened: OpenedSubject, authoringTemplate: string | undefined, environment: ScreenEditorEnvironment): ScreenEditorController;

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

@@ -0,0 +1,13 @@
+import type { ActionModel } from '../Actions/ActionModel';
+import type { StateChangeSlice } from '../Actions/StateChangeSlice';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ActionEditorProps {
+    action?: ActionModel;
+    slices: readonly StateChangeSlice[];
+    sources: readonly string[];
+    strings: ScreenEditorStrings;
+    disabled: boolean;
+    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;

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

@@ -0,0 +1,6 @@
+import type { SceneDiagnostic } from '@cratis/scene.model';
+export interface DiagnosticListProps {
+    diagnostics: readonly SceneDiagnostic[];
+    label: string;
+}
+export declare const DiagnosticList: ({ diagnostics, label }: DiagnosticListProps) => import("react").JSX.Element | null;

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

@@ -0,0 +1,11 @@
+import type { NodeInspection } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ExposureSectionProps {
+    inspection: NodeInspection;
+    componentId: string;
+    controller: ScreenEditorController;
+    strings: ScreenEditorStrings;
+    authoringTemplate?: string;
+}
+export declare const ExposureSection: ({ inspection, componentId, controller, strings, authoringTemplate }: ExposureSectionProps) => import("react").JSX.Element | null;

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

@@ -0,0 +1,14 @@
+import type { InspectedProperty, SceneDiagnostic } from '@cratis/scene.model';
+import type { EffectiveIconCatalog } from '@cratis/scene.engine';
+import type { IconAdapterRegistry } from '@cratis/scene.react';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface IconPropertiesProps {
+    properties: readonly InspectedProperty[];
+    controller: ScreenEditorController;
+    catalog: EffectiveIconCatalog;
+    adapters: IconAdapterRegistry;
+    diagnostics: readonly SceneDiagnostic[];
+    strings: ScreenEditorStrings;
+}
+export declare const IconProperties: ({ properties, controller, catalog, adapters, diagnostics, strings }: IconPropertiesProps) => import("react").JSX.Element | null;

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

@@ -0,0 +1,4 @@
+export declare enum InspectorTab {
+    Properties = "properties",
+    Structure = "structure"
+}

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

@@ -0,0 +1,10 @@
+import type { NodeInspection } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface LayoutTypeSectionProps {
+    inspection: NodeInspection;
+    controller: ScreenEditorController;
+    strings: ScreenEditorStrings;
+    disabled: boolean;
+}
+export declare const LayoutTypeSection: ({ inspection, controller, strings, disabled }: LayoutTypeSectionProps) => import("react").JSX.Element | null;

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

@@ -0,0 +1,6 @@
+import { Ownership } from '../Structure/Ownership';
+export interface OwnershipBadgeProps {
+    ownership: Ownership;
+    label: string;
+}
+export declare const OwnershipBadge: ({ ownership, label }: OwnershipBadgeProps) => import("react").JSX.Element | null;

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

@@ -0,0 +1,17 @@
+import { type ChangeLayoutTypeEdit, type NodeInspection } from '@cratis/scene.model';
+import { type SceneOrderedItem } from '../Collections/orderedItems';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import { isSimpleProperty } from '../Properties/toPropertyGroups';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+import type { Ownership } from '../Structure/Ownership';
+export interface PropertiesPanelProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    ownership: Ownership | undefined;
+    authoringTemplate?: string;
+}
+export declare const PropertiesPanel: ({ controller, environment, strings, ownership, authoringTemplate }: PropertiesPanelProps) => import("react").JSX.Element;
+export type { NodeInspection, ChangeLayoutTypeEdit, SceneOrderedItem };
+export { isSimpleProperty };

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

@@ -0,0 +1,12 @@
+import type { InspectedProperty, QueryBinding, QueryCandidate } from '@cratis/scene.model';
+import type { BindingTypeScope } from '@cratis/scene.engine';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface QueryBindingEditorProps {
+    property: InspectedProperty;
+    candidates: readonly QueryCandidate[];
+    scope: BindingTypeScope;
+    strings: ScreenEditorStrings;
+    disabled: boolean;
+    onChange: (binding: QueryBinding | undefined) => void;
+}
+export declare const QueryBindingEditor: ({ property, candidates, scope, strings, disabled, onChange }: QueryBindingEditorProps) => import("react").JSX.Element;

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

@@ -0,0 +1,106 @@
+import type { IconPickerLabels } from '@cratis/components/IconPicker';
+import type { IconPropertyFieldStrings } from '../../Icons/IconPropertyFieldStrings';
+import type { JsonPropertyFieldStrings } from '../PropertyEditors/Json/JsonPropertyFieldStrings';
+import type { Ownership } from '../Structure/Ownership';
+import type { SceneDocumentProblem } from '../Document/readSceneDocument';
+import type { StructureEditRejection } from '../Structure/StructureEditRejection';
+export interface ScreenEditorStrings {
+    inspectorTitle: string;
+    windowLabel: string;
+    propertiesTab: string;
+    structureTab: string;
+    openInspector: string;
+    closeInspector: string;
+    desktopPreview: string;
+    mobilePreview: string;
+    sizeClass: (width: string, height: string) => string;
+    viewportSize: (width: number, height: number) => string;
+    noSelection: string;
+    nameLabel: string;
+    typeLabel: string;
+    ownershipLabel: string;
+    ownership: Record<Ownership, string>;
+    ownershipHint: Record<Ownership, string>;
+    unreadable: {
+        title: string;
+        warning: string;
+        close: string;
+        reasons: Record<SceneDocumentProblem, string>;
+    };
+    stopped: {
+        title: string;
+        message: string;
+        close: string;
+    };
+    undo: string;
+    redo: string;
+    palette: string;
+    layoutDrawer: string;
+    closeDrawer: string;
+    deleteElement: string;
+    saveRefused: string;
+    properties: {
+        diagnostics: string;
+        noProperties: string;
+        layoutType: string;
+        changeLayout: string;
+        confirmLayoutTitle: string;
+        confirmLayoutAccept: string;
+        confirmLayoutCancel: string;
+        exposure: string;
+        exposeProperty: string;
+        unexposeProperty: string;
+        exposedToScopes: string;
+        itemsLabel: string;
+        addItem: string;
+        icon: IconPropertyFieldStrings;
+        iconPickerLabels?: IconPickerLabels;
+        json?: JsonPropertyFieldStrings;
+        query: {
+            label: string;
+            choose: string;
+            none: string;
+            missing: string;
+            parameters: string;
+            columns: string;
+            sourceFor: (parameter: string) => string;
+            noSource: string;
+            showColumn: (field: string) => string;
+            preview: {
+                noQuery: string;
+                missingQuery: string;
+                loading: string;
+                empty: string;
+                error: string;
+            };
+        };
+        action: {
+            label: string;
+            none: string;
+            slice: string;
+            chooseSlice: string;
+            inputs: string;
+            presentation: string;
+            presentations: {
+                none: string;
+                modal: string;
+                drawer: string;
+            };
+            sourceFor: (input: string) => string;
+            problems: {
+                missingSlice: string;
+                unmappedInput: (input: string) => string;
+                unknownInput: (input: string) => string;
+                unknownSource: (input: string) => string;
+            };
+        };
+    };
+    structureLabel: string;
+    structureEmpty: string;
+    moveUp: string;
+    moveDown: string;
+    outdent: string;
+    indent: string;
+    moved: string;
+    rejection: Record<StructureEditRejection, string>;
+}

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

@@ -0,0 +1,13 @@
+import { type ReactNode } from 'react';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ScreenInspectorProps {
+    strings: ScreenEditorStrings;
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    authoringTemplate?: string;
+    structure: ReactNode;
+    onClose: () => void;
+}
+export declare const ScreenInspector: ({ strings, controller, environment, authoringTemplate, structure, onClose }: ScreenInspectorProps) => import("react").JSX.Element;

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

@@ -0,0 +1,13 @@
+import type { StructureEdit } from '../Structure/StructureEdit';
+import type { StructureEditRejection } from '../Structure/StructureEditRejection';
+import type { StructureTreeAdapter } from '../Structure/StructureTreeAdapter';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface StructureTreeProps<T> {
+    roots: T[];
+    adapter: StructureTreeAdapter<T>;
+    strings: ScreenEditorStrings;
+    selectedId?: string;
+    onSelect: (id: string) => void;
+    onEdit: (edit: StructureEdit) => StructureEditRejection | undefined;
+}
+export declare function StructureTree<T>({ roots, adapter, strings, selectedId, onSelect, onEdit }: StructureTreeProps<T>): import("react").JSX.Element;

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

@@ -0,0 +1,21 @@
+import type { DragEvent, KeyboardEvent } from 'react';
+import { DropZone } from '../Structure/DropZone';
+import type { StructureRow } from '../Structure/StructureRow';
+import type { StructureTreeAdapter } from '../Structure/StructureTreeAdapter';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface StructureTreeRowProps<T> {
+    row: StructureRow<T>;
+    adapter: StructureTreeAdapter<T>;
+    strings: ScreenEditorStrings;
+    isSelected: boolean;
+    isFocusable: boolean;
+    dropZone?: DropZone;
+    onSelect: (id: string) => void;
+    onToggle: (id: string) => void;
+    onKeyDown: (event: KeyboardEvent<HTMLLIElement>, id: string) => void;
+    onDragStart: (id: string) => void;
+    onDragOver: (event: DragEvent<HTMLLIElement>, id: string) => void;
+    onDrop: (event: DragEvent<HTMLLIElement>, id: string) => void;
+    onDragEnd: () => void;
+}
+export declare function StructureTreeRow<T>({ row, adapter, strings, isSelected, isFocusable, dropZone, onSelect, onToggle, onKeyDown, onDragStart, onDragOver, onDrop, onDragEnd }: StructureTreeRowProps<T>): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+import type { ViewportSize } from '../Viewport/ViewportSize';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ViewportControlsProps {
+    windowSize: ViewportSize;
+    available: ViewportSize;
+    strings: ScreenEditorStrings;
+    onResize: (size: ViewportSize) => void;
+}
+export declare const ViewportControls: ({ windowSize, available, strings, onResize }: ViewportControlsProps) => import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import { DropZone } from '../Structure/DropZone';
+export declare function pointerDropZone(offsetY: number, rowHeight: number, acceptsChildren: boolean): DropZone;

package/dist/screen-editor/ScreenEditor/Layouts/LayoutCatalogEntry.d.ts

@@ -0,0 +1,11 @@
+import type { FlowContainerKind } from '@cratis/scene.model';
+import type { LayoutArrangement } from '@cratis/scene/ScreenEditor';
+import type { LayoutItem } from './LayoutItem';
+import type { PanelConstruct } from './PanelConstruct';
+export interface LayoutCatalogEntry {
+    item: LayoutItem;
+    type: string;
+    panel: PanelConstruct;
+    flowKind?: FlowContainerKind;
+    arrangement: LayoutArrangement;
+}

package/dist/screen-editor/ScreenEditor/Layouts/LayoutItem.d.ts

@@ -0,0 +1,8 @@
+export declare enum LayoutItem {
+    Stack = "stack",
+    Row = "row",
+    Grid = "grid",
+    Container = "container",
+    Wrap = "wrap",
+    Canvas = "canvas"
+}

package/dist/screen-editor/ScreenEditor/Layouts/PanelConstruct.d.ts

@@ -0,0 +1,7 @@
+export declare enum PanelConstruct {
+    Panel = "Panel",
+    StackPanel = "StackPanel",
+    WrapPanel = "WrapPanel",
+    Grid = "Grid",
+    Canvas = "Canvas"
+}

package/dist/screen-editor/ScreenEditor/Layouts/layoutCatalog.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutCatalogEntry } from './LayoutCatalogEntry';
+export declare const layoutCatalog: readonly LayoutCatalogEntry[];

package/dist/screen-editor/ScreenEditor/Layouts/layoutChange.d.ts

@@ -0,0 +1,13 @@
+import { type ChangeLayoutTypeEdit, type LayoutType, type SceneDiagnostic } from '@cratis/scene.model';
+export type LayoutChangeStep = {
+    kind: 'applied';
+} | {
+    kind: 'confirm';
+    lost: string;
+    edit: ChangeLayoutTypeEdit;
+} | {
+    kind: 'refused';
+    diagnostics: SceneDiagnostic[];
+};
+export declare const changeLayoutType: (elementNodeId: string, to: `${LayoutType}`, acceptLoss?: boolean) => ChangeLayoutTypeEdit;
+export declare function readLayoutChange(edit: ChangeLayoutTypeEdit, applied: boolean, diagnostics: readonly SceneDiagnostic[]): LayoutChangeStep;

package/dist/screen-editor/ScreenEditor/Layouts/toLayoutContainerDescriptors.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentType } from 'react';
+import type { LayoutContainerDescriptor } from '@cratis/scene/ScreenEditor';
+import type { LayoutCatalogEntry } from './LayoutCatalogEntry';
+import type { LayoutItem } from './LayoutItem';
+export type LayoutLabels = Record<LayoutItem, string>;
+export type LayoutIcons = Record<LayoutItem, ComponentType<{
+    className?: string;
+}>>;
+export declare function toLayoutContainerDescriptors(catalog: readonly LayoutCatalogEntry[], labels: LayoutLabels, icons?: LayoutIcons): LayoutContainerDescriptor[];

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

@@ -0,0 +1,10 @@
+import type { LayoutItem } from '../Layouts/LayoutItem';
+export type PalettePayload = {
+    kind: 'layout';
+    item: LayoutItem;
+} | {
+    kind: 'component';
+    componentName: string;
+    package: string;
+};
+export declare const isPalettePayload: (value: unknown) => value is PalettePayload;

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

@@ -0,0 +1,22 @@
+import type { ToolbarDrawerItem } from '@cratis/components/Toolbar';
+import type { ReactNode } from 'react';
+import type { LayoutLabels } from '../Layouts/toLayoutContainerDescriptors';
+import type { LayoutItem } from '../Layouts/LayoutItem';
+export interface PaletteDrawer {
+    id: string;
+    title: string;
+    items: ToolbarDrawerItem[];
+}
+export interface PaletteSource {
+    package: string;
+    components: readonly string[];
+}
+export interface PaletteIcons {
+    layout: (item: LayoutItem) => ReactNode;
+    component: (componentName: string) => ReactNode;
+    drawer: {
+        layout: ReactNode;
+        package: ReactNode;
+    };
+}
+export declare function buildPalette(layoutTitle: string, labels: LayoutLabels, icons: PaletteIcons, sources: readonly PaletteSource[]): PaletteDrawer[];

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

@@ -0,0 +1,2 @@
+export declare const corePackageName = "core";
+export declare function insertedComponentName(componentName: string, packageName: string): string;

package/dist/screen-editor/ScreenEditor/Properties/allowedIconChoices.d.ts

@@ -0,0 +1,3 @@
+import type { IconPickerAllowed } from '@cratis/components/IconPicker';
+import { type PropertyChoice } from '@cratis/scene.model';
+export declare function allowedIconChoices(choices: PropertyChoice[] | undefined): IconPickerAllowed | undefined;

package/dist/screen-editor/ScreenEditor/Properties/choiceKeys.d.ts

@@ -0,0 +1,6 @@
+import type { InspectedProperty } from '@cratis/scene.model';
+export declare const choiceKey: (value: unknown) => string;
+export declare const selectedChoiceKey: (value: unknown) => string;
+export declare function choiceValueOf(property: InspectedProperty, key: unknown): {
+    value: unknown;
+} | undefined;

package/dist/screen-editor/ScreenEditor/Properties/iconDiagnostics.d.ts

@@ -0,0 +1,7 @@
+import { type SceneDiagnostic } from '@cratis/scene.model';
+export declare const isIconDiagnostic: (diagnostic: SceneDiagnostic) => boolean;
+export declare function iconMessageOf(diagnostics: readonly SceneDiagnostic[], path: string, itemId?: string): string | undefined;
+export declare const withoutIconDiagnostics: (diagnostics: readonly SceneDiagnostic[]) => SceneDiagnostic[];
+export declare function iconMessagesOfItems(diagnostics: readonly SceneDiagnostic[], path: string): Record<string, {
+    icon: string;
+}>;

package/dist/screen-editor/ScreenEditor/Properties/propertyEdits.d.ts

@@ -0,0 +1,3 @@
+import { type InspectedProperty, type SceneEdit } from '@cratis/scene.model';
+export declare function editForValue(elementId: string, property: InspectedProperty, value: unknown): SceneEdit;
+export declare function editForCollectionField(elementId: string, property: InspectedProperty, itemId: string, field: string, value: unknown): SceneEdit;

package/dist/screen-editor/ScreenEditor/Properties/toPropertyGroups.d.ts

@@ -0,0 +1,9 @@
+import { type InspectedProperty } from '@cratis/scene.model';
+import type { PropertyDescriptor as ControlDescriptor, PropertyGroup } from '@cratis/components/ConfigurationEditor';
+export declare const isSimpleProperty: (property: InspectedProperty) => boolean;
+export declare const isDrawnByItsOwnEditor: (typeId: string, path: string) => boolean;
+export declare function toControlDescriptor(property: InspectedProperty): ControlDescriptor;
+export declare function toPropertyGroups(properties: readonly InspectedProperty[], typeId?: string): {
+    groups: PropertyGroup[];
+    values: Record<string, unknown>;
+};

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonDraftKind.d.ts

@@ -0,0 +1,6 @@
+export declare enum JsonDraftKind {
+    Unchanged = "unchanged",
+    Unset = "unset",
+    Set = "set",
+    Invalid = "invalid"
+}

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonDraftOutcome.d.ts

@@ -0,0 +1,13 @@
+import type { JsonDraftKind } from './JsonDraftKind';
+import type { JsonProblem } from './JsonProblem';
+export type JsonDraftOutcome = {
+    kind: JsonDraftKind.Unchanged;
+} | {
+    kind: JsonDraftKind.Unset;
+} | {
+    kind: JsonDraftKind.Set;
+    value: unknown;
+} | {
+    kind: JsonDraftKind.Invalid;
+    problem: JsonProblem;
+};

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonDraftState.d.ts

@@ -0,0 +1,4 @@
+export interface JsonDraftState {
+    text: string;
+    base: unknown;
+}

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonProblem.d.ts

@@ -0,0 +1,5 @@
+import type { JsonProblemKind } from './JsonProblemKind';
+export interface JsonProblem {
+    kind: JsonProblemKind;
+    detail: string;
+}

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonProblemKind.d.ts

@@ -0,0 +1,6 @@
+export declare enum JsonProblemKind {
+    Required = "required",
+    Syntax = "syntax",
+    UnsafeInteger = "unsafeInteger",
+    OutOfRange = "outOfRange"
+}

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonProperties.d.ts

@@ -0,0 +1,9 @@
+import type { InspectedProperty } from '@cratis/scene.model';
+import type { JsonPropertyFieldStrings } from './JsonPropertyFieldStrings';
+export interface JsonPropertiesProps {
+    properties: readonly InspectedProperty[];
+    componentId: string;
+    setProperty: (property: InspectedProperty, value: unknown) => void;
+    strings?: JsonPropertyFieldStrings;
+}
+export declare const JsonProperties: ({ properties, componentId, setProperty, strings }: JsonPropertiesProps) => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonPropertyField.d.ts

@@ -0,0 +1,13 @@
+import type { JsonPropertyFieldStrings } from './JsonPropertyFieldStrings';
+export interface JsonPropertyFieldProps {
+    label: string;
+    description?: string;
+    value: unknown;
+    onApply: (value: unknown) => void;
+    readOnly?: boolean;
+    reason?: string;
+    required?: boolean;
+    strings: JsonPropertyFieldStrings;
+    rows?: number;
+}
+export declare const JsonPropertyField: ({ label, description, value, onApply, readOnly, reason, required, strings, rows }: JsonPropertyFieldProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonPropertyFieldStrings.d.ts

@@ -0,0 +1,9 @@
+export interface JsonPropertyFieldStrings {
+    placeholder: string;
+    problems: {
+        required: string;
+        syntax: (detail: string) => string;
+        unsafeInteger: (literal: string) => string;
+        outOfRange: (literal: string) => string;
+    };
+}

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonReading.d.ts

@@ -0,0 +1,8 @@
+import type { JsonProblem } from './JsonProblem';
+export type JsonReading = {
+    value: unknown;
+    problem?: undefined;
+} | {
+    problem: JsonProblem;
+    value?: undefined;
+};

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/defaultJsonPropertyFieldStrings.d.ts

@@ -0,0 +1,2 @@
+import type { JsonPropertyFieldStrings } from './JsonPropertyFieldStrings';
+export declare const defaultJsonPropertyFieldStrings: JsonPropertyFieldStrings;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/describeJsonProblem.d.ts

@@ -0,0 +1,3 @@
+import type { JsonProblem } from './JsonProblem';
+import type { JsonPropertyFieldStrings } from './JsonPropertyFieldStrings';
+export declare function describeJsonProblem(problem: JsonProblem, strings: JsonPropertyFieldStrings): string;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/formatJson.d.ts

@@ -0,0 +1 @@
+export declare const formatJson: (value: unknown) => string;