@cratis/event-models 0.0.0-stage → 0.106.0

package/dist/Modules/moduleAreaState.d.ts

@@ -0,0 +1,27 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface ModuleAreaItem {
+    id: Guid;
+    name: string;
+    collapsed: boolean;
+}
+export interface ModuleAreaState<T extends ModuleAreaItem> {
+    snapshot: T[];
+    modules: T[];
+    additions: T[];
+    order?: Guid[];
+    collapses: ReadonlyMap<string, boolean>;
+    renames: ReadonlyMap<string, string>;
+    collapseBarriers: ReadonlyMap<string, boolean>;
+    renameBarriers: ReadonlyMap<string, string>;
+    orderBarrier?: Guid[];
+}
+export declare const createModuleAreaState: <T extends ModuleAreaItem>(modules: T[]) => ModuleAreaState<T>;
+export declare function reconcileModules<T extends ModuleAreaItem>(state: ModuleAreaState<T>, snapshot: T[]): ModuleAreaState<T>;
+export declare function setModuleCollapse<T extends ModuleAreaItem>(state: ModuleAreaState<T>, id: Guid, collapsed: boolean): ModuleAreaState<T>;
+export declare function setModuleRename<T extends ModuleAreaItem>(state: ModuleAreaState<T>, id: Guid, name: string): ModuleAreaState<T>;
+export declare function setModuleOrder<T extends ModuleAreaItem>(state: ModuleAreaState<T>, ids: Guid[]): ModuleAreaState<T>;
+export declare function revertModuleCollapse<T extends ModuleAreaItem>(state: ModuleAreaState<T>, id: Guid): ModuleAreaState<T>;
+export declare function revertModuleRename<T extends ModuleAreaItem>(state: ModuleAreaState<T>, id: Guid): ModuleAreaState<T>;
+export declare function revertModuleOrder<T extends ModuleAreaItem>(state: ModuleAreaState<T>, priorOrder?: Guid[]): ModuleAreaState<T>;
+export declare function orderModules<T extends ModuleAreaItem>(modules: T[], ids: readonly Guid[]): T[];
+export declare function updateModule<T extends ModuleAreaItem>(state: ModuleAreaState<T>, id: Guid, change: (module: T) => T): ModuleAreaState<T>;

package/dist/Modules/moduleWidth.d.ts

@@ -0,0 +1,2 @@
+import { type MeasureLabelWidth } from '../Geometry';
+export declare function moduleWidth(featureWidths: readonly number[], name: string, measure?: MeasureLabelWidth): number;

package/dist/Modules/persistModuleChange.d.ts

@@ -0,0 +1 @@
+export declare function persistModuleChange(execute: () => Promise<boolean>, revert: () => void, onPersistenceError: (error: unknown) => void): Promise<void>;

package/dist/Modules/useModuleDrag.d.ts

@@ -0,0 +1,15 @@
+import type { Guid } from '@cratis/fundamentals';
+import { type HeaderDragStart, type HeaderDragState } from '../HeaderDragging';
+import type { ModulesReordered } from './ModulesReordered';
+export interface ModuleDragState extends HeaderDragState {
+    moduleId: Guid;
+    sourceIndex: number;
+    currentY: number;
+    dropIndex: number;
+}
+export type ModuleDragStart = (moduleId: Guid, label: string, start: HeaderDragStart) => void;
+export interface ModuleDrag {
+    moduleDrag?: ModuleDragState;
+    handleModuleDragStart?: ModuleDragStart;
+}
+export declare function useModuleDrag(collectionId: Guid, moduleIds: readonly Guid[], onModulesReordered?: ModulesReordered): ModuleDrag;

package/dist/Pickers/EventReferencePicker.d.ts

@@ -0,0 +1,10 @@
+export interface EventReferencePickerProps<TOption> {
+    options: readonly TOption[];
+    nameOf: (option: TOption) => string;
+    onSelect: (option: TOption) => void;
+    label: string;
+    searchPlaceholder: string;
+    emptyLabel: string;
+    placeholder?: string;
+}
+export declare const EventReferencePicker: <TOption>({ options, nameOf, onSelect, label, searchPlaceholder, emptyLabel, placeholder }: EventReferencePickerProps<TOption>) => import("react").JSX.Element;

package/dist/Pickers/PickerPanel.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export interface PickerTriggerProps {
+    open: boolean;
+    toggle: () => void;
+}
+export interface PickerPanelProps<TOption> {
+    options: readonly TOption[];
+    nameOf: (option: TOption) => string;
+    color: string;
+    searchPlaceholder: string;
+    emptyLabel: string;
+    onSelect: (option: TOption) => void;
+    footer?: (close: () => void) => React.ReactNode;
+    trigger: (props: PickerTriggerProps) => React.ReactNode;
+}
+export declare const PickerPanel: <TOption>({ options, nameOf, color, searchPlaceholder, emptyLabel, onSelect, footer, trigger }: PickerPanelProps<TOption>) => React.JSX.Element;

package/dist/Pickers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EventReferencePicker';
+export * from './PickerPanel';

package/dist/Pickers/useDismissOnOutsidePointer.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from 'react';
+export declare const useDismissOnOutsidePointer: (elements: RefObject<Element | null>[], onDismiss: () => void, enabled: boolean) => void;

package/dist/Presentation/DetailLevel.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The board-level detail level for the event modeling editor.
+ * - `full` is the default, fully interactive view.
+ * - `overview` is a compact, read-only, high-level view that hides specifications and property/detail
+ *   cells and disables every building/editing affordance.
+ */
+export type DetailLevel = 'full' | 'overview';
+export declare const defaultDetailLevel: DetailLevel;
+/**
+ * Whether a slice is read-only for the given detail level. The `overview` level forces every slice
+ * read-only regardless of its workflow status; the `full` level defers to the slice's own status.
+ */
+export declare function isSliceReadOnlyForDetailLevel(detailLevel: DetailLevel, statusReadOnly: boolean): boolean;
+/**
+ * Whether property/detail cells are shown for the given detail level. The `overview` level hides them
+ * entirely; the `full` level defers to the per-scope details-visibility toggle.
+ */
+export declare function areSliceDetailsVisibleForDetailLevel(detailLevel: DetailLevel, detailsVisible: boolean): boolean;
+/** Whether specifications are shown for the given detail level. The `overview` level hides them entirely. */
+export declare function areSpecificationsVisibleForDetailLevel(detailLevel: DetailLevel): boolean;

package/dist/Presentation/EventModelPresentation.d.ts

@@ -0,0 +1,8 @@
+import type { DetailLevel } from './DetailLevel';
+import type { DetailsVisibilityState } from './detailsVisibility';
+import type { VisualizationMode } from './VisualizationMode';
+export interface EventModelPresentation {
+    detailLevel: DetailLevel;
+    visualizationMode: VisualizationMode;
+    detailsVisibility: DetailsVisibilityState;
+}

package/dist/Presentation/EventModelPresentationContext.d.ts

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

package/dist/Presentation/EventModelPresentationProvider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { EventModelPresentation } from './EventModelPresentation';
+export interface EventModelPresentationProviderProps {
+    presentation: EventModelPresentation;
+    children?: React.ReactNode;
+}
+export declare const EventModelPresentationProvider: ({ presentation, children }: EventModelPresentationProviderProps) => React.JSX.Element;

package/dist/Presentation/VisualizationMode.d.ts

@@ -0,0 +1 @@
+export type VisualizationMode = 'simplified' | 'fillLines';

package/dist/Presentation/defaultEventModelPresentation.d.ts

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

package/dist/Presentation/detailsVisibility.d.ts

@@ -0,0 +1,12 @@
+export interface DetailsVisibilityState {
+    global: boolean;
+    modules: Record<string, boolean>;
+    features: Record<string, boolean>;
+    slices: Record<string, boolean>;
+}
+export declare const defaultDetailsVisibilityState: DetailsVisibilityState;
+export declare function toggleGlobalDetails(state: DetailsVisibilityState): DetailsVisibilityState;
+export declare function toggleModuleDetails(state: DetailsVisibilityState, moduleId: string): DetailsVisibilityState;
+export declare function toggleFeatureDetails(state: DetailsVisibilityState, featureId: string): DetailsVisibilityState;
+export declare function toggleSliceDetails(state: DetailsVisibilityState, sliceId: string): DetailsVisibilityState;
+export declare function areDetailsVisible(state: DetailsVisibilityState, moduleId: string, featureId: string, sliceId: string): boolean;

package/dist/Presentation/index.d.ts

@@ -0,0 +1,7 @@
+export * from './VisualizationMode';
+export * from './DetailLevel';
+export * from './detailsVisibility';
+export * from './EventModelPresentation';
+export * from './defaultEventModelPresentation';
+export * from './EventModelPresentationContext';
+export * from './EventModelPresentationProvider';

package/dist/Properties/SchemaTooltipProperties.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { JsonSchema } from '@cratis/components/SchemaEditor';
+export interface SchemaTooltipPropertiesProps {
+    title: React.ReactNode;
+    schema?: string | JsonSchema;
+    showTitle?: boolean;
+    compact?: boolean;
+}
+export declare const SchemaTooltipProperties: React.FC<SchemaTooltipPropertiesProps>;

package/dist/Properties/TypeBadge.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface TypeBadgeProps {
+    type: string;
+    /**
+     * The concept the property is typed as. When set, the badge names the concept instead of the primitive
+     * it wraps — the primitive stays in the tooltip, since that is what the value still behaves as.
+     */
+    concept?: string;
+}
+export declare const TypeBadge: React.FC<TypeBadgeProps>;

package/dist/Properties/index.d.ts

@@ -0,0 +1,3 @@
+export * from './TypeBadge';
+export * from './schemaProperties';
+export * from './SchemaTooltipProperties';

package/dist/Properties/schemaProperties.d.ts

@@ -0,0 +1,6 @@
+import type { JsonSchema } from '@cratis/components/SchemaEditor';
+export interface SchemaProperty {
+    name: string;
+    type: string;
+}
+export declare const topLevelSchemaProperties: (schema?: string | JsonSchema) => SchemaProperty[];

package/dist/Reading/DocumentNode.d.ts

@@ -0,0 +1,22 @@
+import { Guid } from '@cratis/fundamentals';
+export declare class DocumentNode {
+    private readonly _value;
+    readonly path: string;
+    private constructor();
+    static root(value: unknown): DocumentNode;
+    has(key: string): boolean;
+    string(key: string): string;
+    optionalString(key: string): string | undefined;
+    number(key: string): number;
+    enumValue(key: string): number;
+    optionalEnumValue(key: string): number | undefined;
+    boolean(key: string): boolean;
+    guid(key: string): Guid;
+    optionalGuid(key: string): Guid | undefined;
+    strings(key: string): string[];
+    record(key: string): Record<string, unknown>;
+    raw(key: string): unknown;
+    object(key: string): DocumentNode | undefined;
+    array<T>(key: string, read: (node: DocumentNode) => T): T[];
+    private invalid;
+}

package/dist/Reading/InvalidEventModelDocument.d.ts

@@ -0,0 +1,4 @@
+export declare class InvalidEventModelDocument extends Error {
+    readonly path: string;
+    constructor(path: string, reason: string);
+}

package/dist/Reading/index.d.ts

@@ -0,0 +1,4 @@
+export * from './InvalidEventModelDocument';
+export * from './isKnownValue';
+export * from './readEventModelDocument';
+export * from './readJsonSchema';

package/dist/Reading/isKnownValue.d.ts

@@ -0,0 +1 @@
+export declare const isKnownValue: (enumeration: Record<string, string | number>, value: string | number) => boolean;

package/dist/Reading/readActors.d.ts

@@ -0,0 +1,4 @@
+import type { Actor, UserExperienceActor } from '../Model';
+import type { DocumentNode } from './DocumentNode';
+export declare const readActor: (node: DocumentNode) => Actor;
+export declare const readUserExperienceActor: (node: DocumentNode) => UserExperienceActor;

package/dist/Reading/readBoardItems.d.ts

@@ -0,0 +1,5 @@
+import type { ModuleCollectionLink, Position, StickyNote } from '../Model';
+import type { DocumentNode } from './DocumentNode';
+export declare const readPosition: (node: DocumentNode | undefined) => Position;
+export declare const readStickyNote: (node: DocumentNode) => StickyNote;
+export declare const readModuleCollectionLink: (node: DocumentNode) => ModuleCollectionLink;

package/dist/Reading/readEventModelDocument.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../Model';
+export declare const readEventModelDocument: (json: unknown) => EventModel;

package/dist/Reading/readJsonSchema.d.ts

@@ -0,0 +1,2 @@
+import type { JsonSchema } from '@cratis/components/types';
+export declare const readJsonSchema: (value: unknown) => JsonSchema;

package/dist/Reading/readModules.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleCollection } from '../Model';
+import type { DocumentNode } from './DocumentNode';
+export declare const readModuleCollection: (node: DocumentNode) => ModuleCollection;

package/dist/Reading/readSlice.d.ts

@@ -0,0 +1,3 @@
+import type { Slice } from '../Model';
+import type { DocumentNode } from './DocumentNode';
+export declare const readSlice: (node: DocumentNode) => Slice;

package/dist/Reading/readSliceItems.d.ts

@@ -0,0 +1,7 @@
+import type { CommandItem, EventItem, ExternalEventItem, QueryItem, ReadModelItem } from '../Model';
+import type { DocumentNode } from './DocumentNode';
+export declare const readCommandItem: (node: DocumentNode) => CommandItem;
+export declare const readEventItem: (node: DocumentNode) => EventItem;
+export declare const readExternalEventItem: (node: DocumentNode) => ExternalEventItem;
+export declare const readReadModelItem: (node: DocumentNode) => ReadModelItem;
+export declare const readQueryItem: (node: DocumentNode) => QueryItem;

package/dist/Reading/readSpecification.d.ts

@@ -0,0 +1,3 @@
+import type { SliceSpecification } from '../Model';
+import type { DocumentNode } from './DocumentNode';
+export declare const readSliceSpecification: (node: DocumentNode) => SliceSpecification;

package/dist/References/EventNavigateButton.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface EventNavigateButtonProps {
+    onClick: (clickEvent: React.MouseEvent) => void;
+}
+export declare const EventNavigateButton: React.FC<EventNavigateButtonProps>;

package/dist/References/ExternalEventCard.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Guid } from '@cratis/fundamentals';
+export interface ExternalEventCardProps {
+    id: Guid;
+    name: string;
+    sourceEventId?: Guid;
+    isSelected?: boolean;
+    onSelected?: () => void;
+    onNavigate?: (sourceEventId: Guid) => void;
+    ariaLabel?: string;
+    'data-card-id'?: string;
+    'data-slice-id'?: string;
+}
+export declare const ExternalEventCard: React.FC<ExternalEventCardProps>;

package/dist/References/index.d.ts

@@ -0,0 +1,3 @@
+export * from './EventNavigateButton';
+export * from './ExternalEventCard';
+export * from './useReferenceHover';

package/dist/References/useReferenceHover.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Guid } from '@cratis/fundamentals';
+export declare const REFERENCE_DIM_BOARD_SELECTOR = "[data-event-model-board]";
+export declare const REFERENCE_DIM_CLASS = "event-modeling-board--dim-others";
+export declare const REFERENCE_UNDIMMED_CLASS = "event-modeling-event--undimmed";
+export interface ReferenceHover {
+    ref: React.RefObject<HTMLDivElement | null>;
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+    handleNavigate: (clickEvent: React.MouseEvent) => void;
+}
+export declare function useReferenceHover(sourceEventId: Guid, onNavigate?: (sourceEventId: Guid) => void): ReferenceHover;

package/dist/RowLabels/ActorRowDragGhost.d.ts

@@ -0,0 +1,5 @@
+import type { ActorRowDragState } from './useActorRowDrag';
+export interface ActorRowDragGhostProps {
+    drag?: ActorRowDragState;
+}
+export declare const ActorRowDragGhost: ({ drag }: ActorRowDragGhostProps) => import("react").ReactPortal | undefined;

package/dist/RowLabels/ActorRowDropIndicator.d.ts

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

package/dist/RowLabels/ActorsReordered.d.ts

@@ -0,0 +1,3 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { ActorType } from '../Model';
+export type ActorsReordered = (collectionId: Guid, actorType: ActorType, orderedIds: string[]) => void;

package/dist/RowLabels/RowLabel.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+import type { ActorType } from '../Model';
+import { RowType } from '../Rows/RowType';
+import type { RowLabelBadge } from './RowLabelBadge';
+export interface RowLabelProps {
+    rowType: RowType;
+    height?: number;
+    name?: string;
+    actorId?: string;
+    onRenamed?: (name: string) => void;
+    validateName?: (name: string) => string | undefined;
+    onActorAdded?: (actorType: ActorType) => void;
+    onDragStart?: (clientX: number, clientY: number) => void;
+    dragging?: boolean;
+    badge?: RowLabelBadge;
+    personaAvatar?: ReactNode;
+    children?: ReactNode;
+}
+export declare const RowLabel: ({ rowType, height, name, actorId, onRenamed, validateName, onActorAdded, onDragStart, dragging, badge, personaAvatar, children, }: RowLabelProps) => import("react").JSX.Element;

package/dist/RowLabels/RowLabelAction.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export interface RowLabelAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    danger?: boolean;
+    onActivate: (actorId: string, host: DOMRect) => void;
+}

package/dist/RowLabels/RowLabelBadge.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { RowLabelAction } from './RowLabelAction';
+export interface RowLabelBadge {
+    title: string;
+    avatar?: ReactNode;
+    actions?: readonly RowLabelAction[];
+    onActivate?: () => void;
+}

package/dist/RowLabels/RowLabelsColumn.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { Actor, ActorType } from '../Model';
+import { RowType } from '../Rows/RowType';
+import { type RowLabelProps } from './RowLabel';
+import type { ActorsReordered } from './ActorsReordered';
+export interface RowLabelsColumnProps {
+    collectionId: Guid;
+    topOffset: number;
+    contentRows: readonly RowType[];
+    rowHeights: Record<RowType, number>;
+    actors: readonly Actor[];
+    onActorAdded?: (rowType: RowType, actorType: ActorType) => void;
+    onActorRenamed?: (actorId: string, name: string) => void;
+    onRowRenamed?: (rowType: RowType, name: string) => void;
+    onActorsReordered?: ActorsReordered;
+    renderActorLabel?: (actor: Actor, label: RowLabelProps) => ReactNode;
+    renderEmptyActorLabel?: (rowType: RowType, label: RowLabelProps) => ReactNode;
+}
+export declare const RowLabelsColumn: ({ collectionId, topOffset, contentRows, rowHeights, actors, onActorAdded, onActorRenamed, onRowRenamed, onActorsReordered, renderActorLabel, renderEmptyActorLabel, }: RowLabelsColumnProps) => import("react").JSX.Element;

package/dist/RowLabels/RowLabelsColumnFrame.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export interface RowLabelsColumnFrameProps {
+    topOffset: number;
+    collectionId?: string;
+    children?: ReactNode;
+}
+export declare const RowLabelsColumnFrame: ({ topOffset, collectionId, children }: RowLabelsColumnFrameProps) => import("react").JSX.Element;

package/dist/RowLabels/actorKinds.d.ts

@@ -0,0 +1,8 @@
+import type { EventModelMessages } from '../Messages';
+import { ActorType } from '../Model';
+export interface ActorKind {
+    actorType: ActorType;
+    label: string;
+    color: string;
+}
+export declare const actorKinds: (messages: EventModelMessages) => ActorKind[];

package/dist/RowLabels/actorRows.d.ts

@@ -0,0 +1,4 @@
+import { ActorType } from '../Model';
+import { RowType } from '../Rows/RowType';
+export declare const actorTypeOfRow: (rowType: RowType) => ActorType | undefined;
+export declare const rowOfActorType: (actorType: ActorType) => RowType;

package/dist/RowLabels/index.d.ts

@@ -0,0 +1,12 @@
+export * from './ActorRowDragGhost';
+export * from './ActorRowDropIndicator';
+export * from './actorKinds';
+export * from './actorRows';
+export * from './ActorsReordered';
+export * from './RowLabel';
+export * from './RowLabelAction';
+export * from './RowLabelBadge';
+export * from './RowLabelsColumnFrame';
+export * from './RowLabelsColumn';
+export * from './rowTypeName';
+export * from './useActorRowDrag';

package/dist/RowLabels/rowTypeName.d.ts

@@ -0,0 +1,3 @@
+import type { EventModelMessages } from '../Messages';
+import { RowType } from '../Rows/RowType';
+export declare const rowTypeName: (rowType: RowType, messages: EventModelMessages) => string;

package/dist/RowLabels/useActorRowDrag.d.ts

@@ -0,0 +1,30 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { ActorType } from '../Model';
+import { RowType } from '../Rows/RowType';
+import type { ActorsReordered } from './ActorsReordered';
+export interface DraggableActor {
+    id: string;
+    name: string;
+    actorType: ActorType;
+}
+export interface ActorRowDragState {
+    actorId: string;
+    rowType: RowType;
+    sourceIndex: number;
+    ghostLabel: string;
+    currentX: number;
+    currentY: number;
+    dropIndex: number;
+}
+export type ActorRowDragStart = (actorId: string, clientX: number, clientY: number) => void;
+export interface ActorRowDrag {
+    actorDrag?: ActorRowDragState;
+    handleActorDragStart?: ActorRowDragStart;
+}
+export declare function reorderedActorIds(ids: readonly string[], sourceIndex: number, dropIndex: number): string[] | undefined;
+export interface ActorDrop {
+    actorType: ActorType;
+    orderedIds: string[];
+}
+export declare function actorDrop(actors: readonly DraggableActor[], actorId: string, dropIndex: number): ActorDrop | undefined;
+export declare function useActorRowDrag(collectionId: Guid, actors: readonly DraggableActor[], onActorsReordered?: ActorsReordered): ActorRowDrag;

package/dist/Rows/CellAction.d.ts

@@ -0,0 +1,8 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Slice } from '../Model';
+export interface CellAction {
+    icon?: string;
+    tooltip: string;
+    when?: (slice: Slice) => boolean;
+    onActivate: (sliceId: Guid, host: DOMRect) => void;
+}

package/dist/Rows/CellActionButton.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { CellAction } from './CellAction';
+export interface CellActionButtonProps {
+    action: CellAction;
+}
+export declare const CellActionButton: ({ action }: CellActionButtonProps) => React.JSX.Element | undefined;

package/dist/Rows/CellCorner.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { CellCornerPlacement } from './CellCornerPlacement';
+export interface CellCornerProps {
+    placement: CellCornerPlacement;
+    children?: React.ReactNode;
+}
+export declare const CellCorner: ({ placement, children }: CellCornerProps) => React.JSX.Element;

package/dist/Rows/CellCornerAction.d.ts

@@ -0,0 +1,7 @@
+import type { CellAction } from './CellAction';
+import type { CellCornerPlacement } from './CellCornerPlacement';
+export interface CellCornerActionProps {
+    placement: CellCornerPlacement;
+    action: CellAction;
+}
+export declare const CellCornerAction: ({ placement, action }: CellCornerActionProps) => import("react").JSX.Element | undefined;

package/dist/Rows/CellCornerPlacement.d.ts

@@ -0,0 +1,4 @@
+export declare enum CellCornerPlacement {
+    add = "add",
+    top = "top"
+}

package/dist/Rows/Chat/ChatCell.d.ts

@@ -0,0 +1,9 @@
+import type { Guid } from '@cratis/fundamentals';
+import { type CellConnectors } from '../../Connections';
+export interface ChatCellProps {
+    sliceId: Guid;
+    collapsed?: boolean;
+    conn: CellConnectors;
+    rowHeight: number;
+}
+export declare const ChatCell: ({ sliceId, collapsed, conn, rowHeight }: ChatCellProps) => import("react").JSX.Element;

package/dist/Rows/Chat/index.d.ts

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

package/dist/Rows/Events/EventCard.d.ts

@@ -0,0 +1,9 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { EventItem } from '../../Model';
+export interface EventCardProps {
+    sliceId: Guid;
+    event: EventItem;
+    renameable: boolean;
+    showDetails?: boolean;
+}
+export declare const EventCard: ({ sliceId, event, renameable, showDetails }: EventCardProps) => import("react").JSX.Element;

package/dist/Rows/Events/EventReferenceCard.d.ts

@@ -0,0 +1,7 @@
+import type { EventItem } from '../../Model';
+export interface EventReferenceCardProps {
+    event: EventItem;
+    selectable: boolean;
+    showDetails?: boolean;
+}
+export declare const EventReferenceCard: ({ event, selectable, showDetails }: EventReferenceCardProps) => import("react").JSX.Element;

package/dist/Rows/Events/EventsCell.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import { type CellConnectors } from '../../Connections';
+export interface EventsCellProps {
+    collapsed?: boolean;
+    conn: CellConnectors;
+    rowHeight: number;
+    eventCount: number;
+    children?: ReactNode;
+    after?: ReactNode;
+    corners?: ReactNode;
+}
+export declare const EventsCell: ({ collapsed, conn, rowHeight, eventCount, children, after, corners }: EventsCellProps) => import("react").JSX.Element;

package/dist/Rows/Events/SliceEvents.d.ts

@@ -0,0 +1,11 @@
+import type { CellConnectors } from '../../Connections';
+import { type EventItem, type Slice } from '../../Model';
+export interface SliceEventsProps {
+    slice: Slice;
+    collapsed?: boolean;
+    conn: CellConnectors;
+    rowHeight: number;
+    priorEvents: readonly EventItem[];
+    showDetails?: boolean;
+}
+export declare const SliceEvents: ({ slice, collapsed, conn, rowHeight, priorEvents, showDetails }: SliceEventsProps) => import("react").JSX.Element;

package/dist/Rows/Events/index.d.ts

@@ -0,0 +1,5 @@
+export * from './EventsCell';
+export * from './EventCard';
+export * from './EventReferenceCard';
+export * from './SliceEvents';
+export * from './referenceableEvents';

package/dist/Rows/Events/referenceableEvents.d.ts

@@ -0,0 +1,2 @@
+import type { EventItem, Slice } from '../../Model';
+export declare const referenceableEvents: (slice: Slice, priorEvents: readonly EventItem[]) => EventItem[];

package/dist/Rows/Interaction/InteractionCard.d.ts

@@ -0,0 +1,14 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { JsonSchema } from '@cratis/components/types';
+import { ArtifactCardKind } from '../../Cards';
+export type InteractionCardKind = ArtifactCardKind.command | ArtifactCardKind.readModel;
+export interface InteractionCardProps {
+    sliceId: Guid;
+    kind: InteractionCardKind;
+    artifactId: Guid;
+    name: string;
+    schema: JsonSchema;
+    showDetails?: boolean;
+    onRenamed?: (name: string) => void;
+}
+export declare const InteractionCard: ({ sliceId, kind, artifactId, name, schema, showDetails, onRenamed }: InteractionCardProps) => import("react").JSX.Element;