@cratis/event-models 0.0.0-stage → 0.105.6

package/dist/Features/featureHeaderMenuItems.d.ts

@@ -0,0 +1,4 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { MenuDropdownItem } from '../Menus';
+import type { FeatureHeaderMenuAction } from './FeatureHeaderMenuAction';
+export declare const featureHeaderMenuItems: (featureId: Guid, actions: readonly FeatureHeaderMenuAction[], hostRect: () => DOMRect | undefined) => MenuDropdownItem[];

package/dist/Features/index.d.ts

@@ -0,0 +1,12 @@
+export * from './FeatureColumnFrame';
+export * from './FeatureGridSurface';
+export * from './FeaturesArea';
+export * from './featureAreaState';
+export * from './featureDropEdge';
+export * from './FeatureHeader';
+export * from './FeatureHeaderAction';
+export * from './FeatureHeaderMenuAction';
+export * from './FeatureHeaderSuggestion';
+export * from './FeatureHeaderCell';
+export * from './FeaturesReordered';
+export * from './useFeatureDrag';

package/dist/Features/useFeatureDrag.d.ts

@@ -0,0 +1,16 @@
+import type { Guid } from '@cratis/fundamentals';
+import { type HeaderDragStart, type HeaderDragState } from '../HeaderDragging';
+import type { FeaturesReordered } from './FeaturesReordered';
+export interface FeatureDragState extends HeaderDragState {
+    featureId: Guid;
+    moduleId: Guid;
+    sourceIndex: number;
+    currentY: number;
+    dropIndex: number;
+}
+export type FeatureDragStart = (featureId: Guid, label: string, start: HeaderDragStart) => void;
+export interface FeatureDrag {
+    featureDrag?: FeatureDragState;
+    handleFeatureDragStart?: FeatureDragStart;
+}
+export declare function useFeatureDrag(moduleId: Guid, featureIds: readonly Guid[], onFeaturesReordered?: FeaturesReordered): FeatureDrag;

package/dist/Features/useFeatureSlotTargets.d.ts

@@ -0,0 +1,11 @@
+import { type RefCallback } from 'react';
+type Slot = 'header' | 'column';
+type Targets = {
+    header?: HTMLDivElement;
+    column?: HTMLDivElement;
+};
+export declare function useFeatureSlotTargets(): {
+    targets: Map<string, Targets>;
+    register: (featureId: string, slot: Slot) => RefCallback<HTMLDivElement>;
+};
+export {};

package/dist/Geometry/CurveAxis.d.ts

@@ -0,0 +1,5 @@
+/** The axis a flow connection curve's end tangents follow. */
+export declare enum CurveAxis {
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}

package/dist/Geometry/connectionCurve.d.ts

@@ -0,0 +1,13 @@
+import { CurveAxis } from './CurveAxis';
+/** A point in the curve's coordinate space. */
+export interface CurvePoint {
+    x: number;
+    y: number;
+}
+/**
+ * Builds the smooth cubic-bezier path used for flow connections: both end tangents are aligned with
+ * the given axis, with the control points placed halfway along that axis. This is the single curve
+ * style shared by the connections between the cards inside a slice (vertical flow) and the links
+ * between module collections on the canvas (axis follows the dominant direction).
+ */
+export declare function smoothCurvePath(start: CurvePoint, end: CurvePoint, axis: CurveAxis): string;

package/dist/Geometry/index.d.ts

@@ -0,0 +1,5 @@
+export * from './CurveAxis';
+export * from './connectionCurve';
+export * from './linkGeometry';
+export * from './pillLabelWidth';
+export * from './rowLabelWidth';

package/dist/Geometry/linkGeometry.d.ts

@@ -0,0 +1,62 @@
+import { CurveAxis } from './CurveAxis';
+/** A rectangle expressed in canvas (world) coordinates. */
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A point expressed in canvas (world) coordinates. */
+export interface Point {
+    x: number;
+    y: number;
+}
+/** The endpoints of a directed link plus the tangent axis its spline should follow. */
+export interface SplineEndpoints {
+    /** The point on the source rectangle's border the curve leaves from. */
+    start: Point;
+    /** The point on the target rectangle's border the curve arrives at. */
+    end: Point;
+    /** The axis the curve's end tangents follow — the dominant direction between the two rectangles. */
+    axis: CurveAxis;
+}
+/** The center point of a rectangle. */
+export declare function centerOf(rect: Rect): Point;
+/** A zero-size rectangle at a point, so point targets (the drag pointer) reuse the rect-based spline math. */
+export declare function rectAt(point: Point): Rect;
+/**
+ * The part of a collection's measured rectangle that holds the slice content — the specifications
+ * rendered below the slice columns are excluded, so anchors and curve endpoints center on the
+ * content rather than the full (specification-inclusive) footprint.
+ */
+export declare function contentRectOf(rect: Rect, contentHeight: number): Rect;
+/** The point a link drag starts from: the right edge of a rectangle, vertically centered. */
+export declare function linkAnchor(rect: Rect): Point;
+/**
+ * Computes the spline endpoints between two rectangles: the curve leaves and arrives on the facing
+ * edges along the dominant axis between the two centers, at each edge's midpoint, with the tangents
+ * following that axis — the same curve style as the connections between the cards inside a slice.
+ */
+export declare function computeSplineEndpoints(source: Rect, target: Rect): SplineEndpoints;
+/** The midpoint between two points. */
+export declare function midpoint(a: Point, b: Point): Point;
+/** Whether a point lies within a rectangle (borders inclusive). */
+export declare function pointInRect(point: Point, rect: Rect): boolean;
+/** Something a link can connect to — anything carrying a stringifiable id. */
+export interface Identified {
+    id: {
+        toString(): string;
+    };
+}
+/**
+ * Resolves the collection a link drop connects to. Prefers the target directly under the release
+ * point, but falls back to the target the affordance last committed to (looked up by id) — so a quick
+ * release that lands a hair outside the target, or whose final pointermove the browser coalesced away,
+ * still links to what the user was shown "will connect" to. Never returns the drag's own source.
+ */
+export declare function resolveDropTarget<T extends Identified>(releaseTarget: T | null, lastTargetId: string | null, lookup: (id: string) => T | undefined, sourceId: string): T | null;
+/**
+ * The smallest rectangle containing every supplied rectangle and point, expanded by padding on all
+ * sides. Returns a zero rectangle when nothing is supplied.
+ */
+export declare function boundingBox(rects: Rect[], points: Point[], padding: number): Rect;

package/dist/Geometry/pillLabelWidth.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Measures the rendered pixel width of `text` at the given font. Implemented with real canvas font
+ * metrics by {@link defaultMeasureLabelWidth}; injected as a parameter everywhere it is consumed so
+ * {@link computePillLabelMinWidth} — and the pure layout functions built on it — stay spec-able without
+ * jsdom's lack of real canvas font metrics in Vitest. Mirrors the `MeasureTextWidth` pattern in
+ * `@cratis/event-models` (Cards/autoFitTitle.ts).
+ */
+export type MeasureLabelWidth = (text: string, fontSizePx: number, fontWeight: string | number, fontFamily: string) => number;
+/** Matches `.event-modeling-grid-pill`'s own font rules (PillHeader.css) — the label measures against it. */
+export declare const PILL_LABEL_FONT_SIZE_PX = 12;
+/** Matches `.event-modeling-grid-pill`'s `font-weight` (PillHeader.css). */
+export declare const PILL_LABEL_FONT_WEIGHT = 600;
+/** The pill sets no `font-family` of its own, so it inherits the app root's (see `:root` in index.css). */
+export declare const PILL_LABEL_FONT_FAMILY = "Inter, Avenir, Helvetica, Arial, sans-serif";
+/**
+ * The fixed-size chrome a pill needs around its label, regardless of label content: the icon clusters
+ * either side of the label plus the pill's own horizontal padding.
+ *
+ * `.event-modeling-grid-pill-left` / `-right` (PillHeader.css) are flex rows of ~20x20 icon buttons with
+ * a 4px gap — never content-dependent, so a fixed overhead is a stable, defensible approximation rather
+ * than enumerating every conditional button. It is sized for the busiest header as it was drawn when
+ * explanation, Mermaid export and enabling were still buttons of their own: 2 icons on the left (the
+ * collapse button, the chat button) and 7 on the right: 9 × 20px + 8 × 4px gaps = 212px, plus the pill's
+ * own `padding: 0 8px` (16px) = 228px, rounded up a little for sub-pixel layout rounding. Those actions now
+ * sit in the header's options menu; the overhead is left as it was so moving them changed no board's
+ * layout, and a header now has room to spare rather than none.
+ */
+export declare const PILL_ICON_CLUSTER_OVERHEAD_PX = 230;
+/** Real canvas-based measurement. jsdom (used by the Vitest specs) has no canvas font metrics and
+ *  returns 0 width for every measurement — specs that need a real label-width contribution inject a
+ *  stub {@link MeasureLabelWidth} instead. */
+export declare const defaultMeasureLabelWidth: MeasureLabelWidth;
+/**
+ * The minimum pixel width a pill (module or feature header) needs to fit `label` without its
+ * `white-space: nowrap; min-width: min-content` content bleeding outside its computed column width —
+ * the measured label plus the fixed icon-cluster/padding overhead.
+ */
+export declare function computePillLabelMinWidth(label: string, measure?: MeasureLabelWidth): number;

package/dist/Geometry/rowLabelWidth.d.ts

@@ -0,0 +1 @@
+export declare const rowLabelWidth = 56;

package/dist/HeaderDragging/HeaderDragGhost.d.ts

@@ -0,0 +1,6 @@
+import type { HeaderDragState } from './HeaderDragState';
+export interface HeaderDragGhostProps {
+    drag?: HeaderDragState;
+    headerHeight: number;
+}
+export declare const HeaderDragGhost: ({ drag, headerHeight }: HeaderDragGhostProps) => import("react").ReactPortal | undefined;

package/dist/HeaderDragging/HeaderDragStart.d.ts

@@ -0,0 +1,8 @@
+export interface HeaderDragStart {
+    clientX: number;
+    clientY: number;
+    width: number;
+    headerY: number;
+    zoom: number;
+    ghost: HTMLElement | null;
+}

package/dist/HeaderDragging/HeaderDragState.d.ts

@@ -0,0 +1,8 @@
+export interface HeaderDragState {
+    ghost: HTMLElement | null;
+    ghostLabel: string;
+    ghostWidth: number;
+    currentX: number;
+    headerY: number;
+    zoom: number;
+}

package/dist/HeaderDragging/createHeaderDragGhost.d.ts

@@ -0,0 +1 @@
+export declare function createHeaderDragGhost(element: HTMLElement): HTMLElement | null;

package/dist/HeaderDragging/headerDropIndex.d.ts

@@ -0,0 +1,5 @@
+export interface HeaderExtent {
+    left: number;
+    width: number;
+}
+export declare const headerDropIndex: (extents: readonly HeaderExtent[], clientX: number) => number;

package/dist/HeaderDragging/index.d.ts

@@ -0,0 +1,8 @@
+export * from './createHeaderDragGhost';
+export * from './HeaderDragGhost';
+export * from './headerDropIndex';
+export * from './HeaderDragStart';
+export * from './HeaderDragState';
+export * from './reorderedIds';
+export * from './useHeaderDragIntent';
+export * from './zoomOfAncestor';

package/dist/HeaderDragging/reorderedIds.d.ts

@@ -0,0 +1,2 @@
+import type { Guid } from '@cratis/fundamentals';
+export declare function reorderedIds(ids: readonly Guid[], sourceIndex: number, dropIndex: number): Guid[] | undefined;

package/dist/HeaderDragging/useHeaderDragIntent.d.ts

@@ -0,0 +1,8 @@
+import { type PointerEventHandler } from 'react';
+import type { HeaderDragStart } from './HeaderDragStart';
+export interface HeaderDragHandlers {
+    onPointerDown: PointerEventHandler<HTMLDivElement>;
+    onPointerMove: PointerEventHandler<HTMLDivElement>;
+    onPointerUp: PointerEventHandler<HTMLDivElement>;
+}
+export declare function useHeaderDragIntent(onDragStart?: (start: HeaderDragStart) => void): HeaderDragHandlers | undefined;

package/dist/HeaderDragging/zoomOfAncestor.d.ts

@@ -0,0 +1 @@
+export declare function zoomOfAncestor(element: HTMLElement | null): number;

package/dist/Headers/CollapseButton.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface CollapseButtonProps {
+    collapsed: boolean;
+    onToggle?: () => void;
+}
+export declare const CollapseButton: React.FC<CollapseButtonProps>;

package/dist/Headers/DetailsToggle.d.ts

@@ -0,0 +1,5 @@
+export interface DetailsToggleProps {
+    visible: boolean;
+    onToggle: () => void;
+}
+export declare const DetailsToggle: ({ visible, onToggle }: DetailsToggleProps) => import("react").JSX.Element;

package/dist/Headers/EditableLabel.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface EditableLabelProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    style?: React.CSSProperties;
+    validate?: (value: string) => string | undefined;
+    readOnly?: boolean;
+}
+export declare const EditableLabel: React.FC<EditableLabelProps>;

package/dist/Headers/EntityErrorIndicator.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface EntityErrorIndicatorProps {
+    /** The error message to display in the tooltip. */
+    error: string;
+}
+/**
+ * Small error icon that shows a tooltip with the error details.
+ * Rendered alongside entity headers (modules, features, slices) when a command fails.
+ */
+export declare const EntityErrorIndicator: React.FC<EntityErrorIndicatorProps>;

package/dist/Headers/EntityErrorKind.d.ts

@@ -0,0 +1,6 @@
+/** The level of the board hierarchy an errored placeholder stands in for. */
+export declare enum EntityErrorKind {
+    Module = "module",
+    Feature = "feature",
+    Slice = "slice"
+}

package/dist/Headers/ErroredEntity.d.ts

@@ -0,0 +1,17 @@
+import { EntityErrorKind } from './EntityErrorKind';
+export interface ErroredEntityProps {
+    /** Which level of the board failed. */
+    kind: EntityErrorKind;
+    /** The name of the module, feature, or slice that failed. */
+    label: string;
+    /** The message describing why it failed; shown on hover. */
+    error: string;
+    /** Rebuilds the entity from its source data. */
+    onRetry: () => void;
+}
+/**
+ * Stands in for a module, feature, or slice whose render failed: it keeps the board's shape, crosses the
+ * entity out, and reveals the error on hover — so one broken entity costs the user that entity instead
+ * of the whole board.
+ */
+export declare const ErroredEntity: ({ kind, label, error, onRetry }: ErroredEntityProps) => import("react").JSX.Element;

package/dist/Headers/PillHeader.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export type PillHeaderVariant = 'module' | 'feature';
+export interface PillHeaderProps {
+    variant: PillHeaderVariant;
+    collapsed: boolean;
+    onToggle?: () => void;
+    label: string;
+    onRenameLabel: (name: string) => void;
+    labelReadOnly?: boolean;
+    validateLabel?: (name: string) => string | undefined;
+    labelStyle?: React.CSSProperties;
+    background: string;
+    border: string;
+    height: number;
+    /** Extra affordances rendered right after the collapse button, before the label — such as the conversation button. */
+    leadingContent?: React.ReactNode;
+    children?: React.ReactNode;
+    draggable?: boolean;
+    onPointerDown?: React.PointerEventHandler<HTMLDivElement>;
+    onPointerMove?: React.PointerEventHandler<HTMLDivElement>;
+    onPointerUp?: React.PointerEventHandler<HTMLDivElement>;
+    /** When set, the pill shows a red border and an error indicator icon with the message as tooltip. */
+    error?: string;
+}
+export declare const PillHeader: React.FC<PillHeaderProps>;

package/dist/Headers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './CollapseButton';
+export * from './DetailsToggle';
+export * from './EditableLabel';
+export * from './EntityErrorIndicator';
+export * from './EntityErrorKind';
+export * from './ErroredEntity';
+export * from './PillHeader';

package/dist/Icons/CogWheel.d.ts

@@ -0,0 +1 @@
+export declare const CogWheel: () => import("react").JSX.Element;

package/dist/Icons/index.d.ts

@@ -0,0 +1 @@
+export * from './CogWheel';

package/dist/Layout/boardMetrics.d.ts

@@ -0,0 +1,20 @@
+import { RowType } from '../Rows/RowType';
+export declare const boardMetrics: {
+    readonly minSliceWidth: 220;
+    readonly minPillWidth: 150;
+    readonly sliceWidth: 220;
+    readonly sliceWidthDouble: 350;
+    readonly translatorSliceWidth: 360;
+    readonly sliceGap: 8;
+    readonly collapsedFeatureWidth: 80;
+    readonly collapsedModuleWidth: 100;
+    readonly collapsedSliceWidth: 36;
+    readonly headerHeight: 44;
+    readonly roleRowHeight: 80;
+    readonly specificationSectionHeight: 80;
+    readonly itemsPerRow: 2;
+    readonly uiCardHeight: 84;
+    readonly cardHeight: 56;
+    readonly cellVerticalPadding: 24;
+};
+export declare const rowHeights: Readonly<Record<RowType, number>>;

package/dist/Layout/index.d.ts

@@ -0,0 +1,3 @@
+export * from './boardMetrics';
+export * from './sliceLayout';
+export * from './sliceRows';

package/dist/Layout/sliceLayout.d.ts

@@ -0,0 +1,14 @@
+import { SliceType } from '../Model';
+import { RowType } from '../Rows/RowType';
+export interface SliceLayoutInput {
+    sliceType: SliceType;
+    events: readonly unknown[];
+}
+export declare function sliceColumnWidth(slice: SliceLayoutInput | {
+    sliceType: SliceType;
+    eventCount: number;
+}): number;
+export declare function rowHeightForSlice(rowType: RowType, slice: SliceLayoutInput): number;
+export declare function computeGlobalRowHeights(slices: readonly {
+    slice: SliceLayoutInput;
+}[], contentRows: readonly RowType[]): Record<RowType, number>;

package/dist/Layout/sliceRows.d.ts

@@ -0,0 +1,7 @@
+import { ActorType, SliceType } from '../Model';
+import { RowType } from '../Rows/RowType';
+export declare const sliceTypeSupportsActor: (sliceType: SliceType, actorType: ActorType) => boolean;
+export declare const sliceTypeSupportsRow: (sliceType: SliceType, rowType: RowType) => boolean;
+export declare const actorsForRow: <TActor extends {
+    actorType: ActorType;
+}>(actors: readonly TActor[], rowType: RowType) => TActor[];

package/dist/Links/ModuleCollectionLinks.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { Guid } from '@cratis/fundamentals';
+import type { ModuleCollectionLink, Position } from '../Model';
+export interface LinkedCollectionPlacement {
+    id: Guid;
+    position: Position;
+    width: number;
+    height: number;
+    contentHeight: number;
+}
+export interface ModuleCollectionLinksProps {
+    links: ModuleCollectionLink[];
+    collections: LinkedCollectionPlacement[];
+    getZoom: () => number;
+    onCollectionsLinked?: (sourceCollectionId: Guid, targetCollectionId: Guid) => Promise<Guid | undefined>;
+    onCollectionsUnlinked?: (linkId: Guid) => Promise<boolean>;
+    onPersistenceError?: (error: unknown) => void;
+}
+export declare const ModuleCollectionLinks: ({ links, collections, getZoom, onCollectionsLinked, onCollectionsUnlinked, onPersistenceError }: ModuleCollectionLinksProps) => React.JSX.Element | null;

package/dist/Links/drawableLinks.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleCollectionLink } from '../Model';
+import { type Point, type Rect } from '../Geometry';
+export interface DrawableLink {
+    link: ModuleCollectionLink;
+    path: string;
+    center: Point;
+}
+export declare const drawableLinks: (links: ModuleCollectionLink[], contentOf: (collectionId: string) => Rect | undefined) => DrawableLink[];

package/dist/Links/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ModuleCollectionLinks';
+export * from './drawableLinks';

package/dist/Links/linkState.d.ts

@@ -0,0 +1,17 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { ModuleCollectionLink } from '../Model';
+export interface LinkState {
+    snapshot: ModuleCollectionLink[];
+    additions: ModuleCollectionLink[];
+    removals: ReadonlySet<string>;
+    pending: ReadonlySet<string>;
+    observedRemovals: ReadonlySet<string>;
+}
+export declare const linkPair: (sourceCollectionId: Guid, targetCollectionId: Guid) => string;
+export declare const visibleLinks: (state: LinkState) => ModuleCollectionLink[];
+export declare const createLinkState: (snapshot: ModuleCollectionLink[]) => LinkState;
+export declare const reconcileLinks: (state: LinkState, snapshot: ModuleCollectionLink[]) => LinkState;
+export declare const beginLink: (state: LinkState, link: ModuleCollectionLink) => LinkState;
+export declare const finishLink: (state: LinkState, link: ModuleCollectionLink, persistedId?: Guid) => LinkState;
+export declare const beginUnlink: (state: LinkState, id: Guid) => LinkState;
+export declare const finishUnlink: (state: LinkState, id: Guid, succeeded: boolean) => LinkState;

package/dist/Menus/MenuDropdown.d.ts

@@ -0,0 +1,29 @@
+import React, { ReactNode } from 'react';
+import { Guid } from '@cratis/fundamentals';
+export interface MenuDropdownItem {
+    id: string | Guid;
+    label?: string;
+    description?: string;
+    icon?: React.ReactNode;
+    onClick?: () => void;
+    keepOpen?: boolean;
+    items?: MenuDropdownItem[];
+    isSeparator?: boolean;
+    isHeader?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    tooltip?: string;
+}
+export interface MenuDropdownProps {
+    trigger: React.ReactNode;
+    items: MenuDropdownItem[];
+    align?: 'left' | 'right';
+    onClose?: () => void;
+}
+export interface MenuDropdownOpenProviderProps {
+    children: ReactNode;
+}
+export declare const toggleOpenMenuId: (currentOpenMenuId: string | undefined, menuId: string) => string | undefined;
+export declare const closeOpenMenuId: (currentOpenMenuId: string | undefined, menuId: string) => string | undefined;
+export declare const MenuDropdownOpenProvider: React.FC<MenuDropdownOpenProviderProps>;
+export declare const MenuDropdown: React.FC<MenuDropdownProps>;

package/dist/Menus/index.d.ts

@@ -0,0 +1 @@
+export * from './MenuDropdown';

package/dist/Messages/EventModelMessages.d.ts

@@ -0,0 +1,153 @@
+export interface EventModelMessages {
+    collapse: {
+        expand: string;
+        collapse: string;
+    };
+    editableLabel: {
+        doubleClickToRename: string;
+    };
+    erroredEntity: {
+        module: string;
+        feature: string;
+        slice: string;
+        couldNotBeRendered: (kind: string, error: string) => string;
+        failedToRender: string;
+        retry: string;
+    };
+    stickyNotes: {
+        newNote: string;
+    };
+    links: {
+        dragToLink: string;
+        removeLink: string;
+    };
+    specificationStatus: {
+        idle: string;
+        running: string;
+        passed: string;
+        failed: string;
+        inconclusive: string;
+    };
+    properties: {
+        none: string;
+    };
+    references: {
+        navigateToOriginal: string;
+    };
+    interaction: {
+        command: string;
+        readModel: string;
+        externalEvent: string;
+        open: string;
+        doubleClickToRenamePrefix: string;
+        defineReadModel: string;
+        addExternalEvent: string;
+        searchExternalEvents: string;
+        noExternalEventsAvailable: string;
+    };
+    events: {
+        addEvent: string;
+        openEvent: string;
+        doubleClickToRenamePrefix: string;
+        addExistingEvent: string;
+        searchEvents: string;
+        noEventsAvailable: string;
+        noEventsYet: string;
+    };
+    triggers: {
+        timer: string;
+        event: string;
+        custom: string;
+    };
+    prototypes: {
+        add: string;
+        fromScratch: string;
+        fromScratchDescription: string;
+        fromTemplate: string;
+        fromTemplateDescription: string;
+        noTemplates: string;
+    };
+    triggerControl: {
+        add: string;
+        edit: string;
+        kinds: Record<'timer' | 'event' | 'custom', {
+            title: string;
+            description: string;
+        }>;
+    };
+    statuses: {
+        notStarted: string;
+        draft: string;
+        analysis: string;
+        readyForImplementation: string;
+        inProgress: string;
+        readyForReview: string;
+        done: string;
+        titlePrefix: string;
+        change: string;
+    };
+    sliceTypes: {
+        add: string;
+        stateChange: string;
+        stateChangeDescription: string;
+        stateView: string;
+        stateViewDescription: string;
+        automation: string;
+        automationDescription: string;
+        translator: string;
+        translatorDescription: string;
+    };
+    slices: {
+        namePlaceholder: string;
+        empty: string;
+    };
+    modules: {
+        add: string;
+        options: string;
+        addModule: string;
+        addModuleDescription: string;
+        addFeature: string;
+        addFeatureDescription: string;
+    };
+    features: {
+        empty: string;
+        add: string;
+        options: string;
+        addSubFeature: string;
+        addSubFeatureDescription: string;
+        addSliceDescription: string;
+        back: string;
+    };
+    details: {
+        show: string;
+        hide: string;
+    };
+    specifications: {
+        add: string;
+        namePlaceholder: string;
+        delete: string;
+        given: string;
+        when: string;
+        then: string;
+        addItem: string;
+        search: string;
+        noItems: string;
+        addError: string;
+        error: string;
+        missingRule: string;
+        defineReadModel: string;
+    };
+    rows: {
+        ui: string;
+        chat: string;
+        system: string;
+        interaction: string;
+        events: string;
+    };
+    actors: {
+        add: string;
+        ui: string;
+        system: string;
+        chat: string;
+    };
+}

package/dist/Messages/EventModelMessagesContext.d.ts

@@ -0,0 +1,3 @@
+import type { EventModelMessages } from './EventModelMessages';
+export declare const EventModelMessagesContext: import("react").Context<EventModelMessages>;
+export declare const useEventModelMessages: () => EventModelMessages;