@cratis/event-models 0.0.0-stage → 0.105.6

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

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+import { type CellConnectors } from '../../Connections';
+import { InteractionMiniCard } from './InteractionMiniCard';
+export type InteractionLayout = {
+    kind: 'centered';
+    cards: ReactNode;
+    corners?: ReactNode;
+    hasItems: boolean;
+} | {
+    kind: 'sideBySide';
+    cards: ReactNode;
+    readModelOnTop: boolean;
+    commandBelow: boolean;
+    hasLeftCard: boolean;
+    hasRightCard: boolean;
+} | {
+    kind: 'split';
+    left: ReactNode;
+    leftCorner?: ReactNode;
+    right: ReactNode;
+    rightCorner?: ReactNode;
+    hasItems: boolean;
+};
+export interface InteractionCellProps {
+    collapsed?: boolean;
+    conn: CellConnectors;
+    rowHeight: number;
+    miniCards: readonly InteractionMiniCard[];
+    layout: InteractionLayout;
+}
+export declare const InteractionCell: ({ collapsed, conn, rowHeight, miniCards, layout }: InteractionCellProps) => import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+export declare enum InteractionMiniCard {
+    command = "command",
+    readModel = "readmodel"
+}

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

@@ -0,0 +1,6 @@
+export interface OptionalReadModelProps {
+    label: string;
+    defineLabel: string;
+    onDefine: (host: DOMRect) => void;
+}
+export declare const OptionalReadModel: ({ label, defineLabel, onDefine }: OptionalReadModelProps) => import("react").JSX.Element;

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

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

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

@@ -0,0 +1,5 @@
+export * from './InteractionCard';
+export * from './InteractionCell';
+export * from './InteractionMiniCard';
+export * from './OptionalReadModel';
+export * from './SliceInteraction';

package/dist/Rows/RowType.d.ts

@@ -0,0 +1,7 @@
+export declare enum RowType {
+    UI = "ui",
+    Chat = "chat",
+    System = "system",
+    Interaction = "interaction",
+    Events = "events"
+}

package/dist/Rows/System/SystemCell.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type CellConnectors } from '../../Connections';
+import { type AutomationTriggerType, SliceType } from '../../Model';
+export interface SystemCellProps {
+    sliceType: SliceType;
+    isSystemSlice: boolean;
+    collapsed?: boolean;
+    conn: CellConnectors;
+    rowHeight: number;
+    triggerType?: AutomationTriggerType;
+}
+export declare const SystemCell: ({ sliceType, isSystemSlice, collapsed, conn, rowHeight, triggerType }: SystemCellProps) => React.JSX.Element;

package/dist/Rows/System/TriggerControl.d.ts

@@ -0,0 +1,8 @@
+import { AutomationTriggerType } from '../../Model';
+import { TriggerKind } from './TriggerKind';
+export interface TriggerControlProps {
+    triggerType?: AutomationTriggerType;
+    onTriggerKindChosen: (kind: TriggerKind) => void;
+    onTriggerOpened: () => void;
+}
+export declare const TriggerControl: ({ triggerType, onTriggerKindChosen, onTriggerOpened }: TriggerControlProps) => import("react").JSX.Element;

package/dist/Rows/System/TriggerKind.d.ts

@@ -0,0 +1,5 @@
+export declare enum TriggerKind {
+    timer = "timer",
+    event = "event",
+    custom = "custom"
+}

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

@@ -0,0 +1,4 @@
+export * from './triggerBadges';
+export * from './SystemCell';
+export * from './TriggerControl';
+export * from './TriggerKind';

package/dist/Rows/System/triggerBadges.d.ts

@@ -0,0 +1,4 @@
+import { AutomationTriggerType } from '../../Model';
+import type { EventModelMessages } from '../../Messages';
+export declare const triggerIcon: (type: AutomationTriggerType) => string | undefined;
+export declare const triggerTitle: (type: AutomationTriggerType, messages: EventModelMessages) => string;

package/dist/Rows/UserExperience/AddPrototypeButton.d.ts

@@ -0,0 +1,7 @@
+import type { PrototypeTemplate } from './PrototypeTemplate';
+export interface AddPrototypeButtonProps {
+    templates: readonly PrototypeTemplate[];
+    onFromScratch: (host: DOMRect) => void;
+    onFromTemplate: (template: PrototypeTemplate, host: DOMRect) => void;
+}
+export declare const AddPrototypeButton: ({ templates, onFromScratch, onFromTemplate }: AddPrototypeButtonProps) => import("react").JSX.Element;

package/dist/Rows/UserExperience/PrototypeTemplate.d.ts

@@ -0,0 +1,6 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface PrototypeTemplate {
+    id: Guid;
+    name: string;
+    onChosen: (sliceId: Guid, actorId: string, host: DOMRect) => void;
+}

package/dist/Rows/UserExperience/UiCell.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { type PrototypeLayout } from '@cratis/scene/Prototypes';
+import type { UIElement, IComponent } from '@cratis/scene';
+import { type CellConnectors } from '../../Connections';
+export interface UiCellProps {
+    elements: readonly (UIElement | IComponent)[];
+    windowSize?: {
+        width: number;
+        height: number;
+    };
+    layout?: PrototypeLayout;
+    collapsed?: boolean;
+    conn: CellConnectors;
+    rowHeight: number;
+    actorId: string;
+}
+export declare const UiCell: ({ elements, windowSize, layout, collapsed, conn, rowHeight, actorId }: UiCellProps) => React.JSX.Element;

package/dist/Rows/UserExperience/addPrototypeMenuItems.d.ts

@@ -0,0 +1,8 @@
+import type { EventModelMessages } from '../../Messages';
+import type { MenuDropdownItem } from '../../Menus';
+import type { PrototypeTemplate } from './PrototypeTemplate';
+export interface AddPrototypeMenuActions {
+    onFromScratch: () => void;
+    onFromTemplate: (template: PrototypeTemplate) => void;
+}
+export declare const addPrototypeMenuItems: (templates: readonly PrototypeTemplate[], messages: EventModelMessages['prototypes'], actions: AddPrototypeMenuActions) => MenuDropdownItem[];

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

@@ -0,0 +1,4 @@
+export * from './UiCell';
+export * from './AddPrototypeButton';
+export * from './addPrototypeMenuItems';
+export * from './PrototypeTemplate';

package/dist/Rows/eventRowAffordances.d.ts

@@ -0,0 +1,5 @@
+import { SliceType } from '../Model';
+export declare const usesEventReferencePicker: (sliceType: SliceType) => boolean;
+export declare const showsAddNewEventButton: (sliceType: SliceType) => boolean;
+export declare const showsEventReferencePlaceholder: (sliceType: SliceType, eventCount: number) => boolean;
+export declare const showsExternalEventPicker: (sliceType: SliceType) => boolean;

package/dist/Rows/index.d.ts

@@ -0,0 +1,12 @@
+export * from './RowType';
+export * from './CellAction';
+export * from './CellActionButton';
+export * from './CellCorner';
+export * from './CellCornerAction';
+export * from './CellCornerPlacement';
+export * from './eventRowAffordances';
+export * from './System';
+export * from './UserExperience';
+export * from './Chat';
+export * from './Events';
+export * from './Interaction';

package/dist/SliceDragging/SliceDragGestureVerdict.d.ts

@@ -0,0 +1,5 @@
+export declare enum SliceDragGestureVerdict {
+    pending = "pending",
+    commit = "commit",
+    abandon = "abandon"
+}

package/dist/SliceDragging/SliceDragGhost.d.ts

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

package/dist/SliceDragging/SliceDropIndicator.d.ts

@@ -0,0 +1,5 @@
+export interface SliceDropIndicatorProps {
+    isValid: boolean;
+    marginLeft: number;
+}
+export declare const SliceDropIndicator: ({ isValid, marginLeft }: SliceDropIndicatorProps) => import("react").JSX.Element;

package/dist/SliceDragging/SliceDropTarget.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { Guid } from '@cratis/fundamentals';
+export interface SliceDropTargetProps {
+    moduleId: Guid;
+    featureId: Guid;
+    active?: boolean;
+    busy?: boolean;
+    acceptsReorder?: boolean;
+    acceptsMove?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const SliceDropTarget: ({ moduleId, featureId, active, busy, acceptsReorder, acceptsMove, style, className, children }: SliceDropTargetProps) => React.JSX.Element;

package/dist/SliceDragging/SliceDropVerdict.d.ts

@@ -0,0 +1,4 @@
+export interface SliceDropVerdict {
+    isValid: boolean;
+    reason?: string;
+}

package/dist/SliceDragging/SliceMoved.d.ts

@@ -0,0 +1,2 @@
+import type { Guid } from '@cratis/fundamentals';
+export type SliceMoved = (sliceId: Guid, fromFeatureId: Guid, toFeatureId: Guid, index: number) => void;

package/dist/SliceDragging/ValidateSliceDrop.d.ts

@@ -0,0 +1,3 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceDropVerdict } from './SliceDropVerdict';
+export type ValidateSliceDrop = (sliceId: Guid, targetFeatureId: Guid, index: number) => SliceDropVerdict | undefined;

package/dist/SliceDragging/dropIndicatorClassName.d.ts

@@ -0,0 +1 @@
+export declare const dropIndicatorClassName: (isValid: boolean) => "event-modeling-grid-slice-drop-indicator" | "event-modeling-grid-slice-drop-indicator event-modeling-grid-slice-drop-indicator--invalid";

package/dist/SliceDragging/index.d.ts

@@ -0,0 +1,14 @@
+export * from './dropIndicatorClassName';
+export * from './readSliceDragGesture';
+export * from './readSlicePress';
+export * from './SliceDragGestureVerdict';
+export * from './SliceDragGhost';
+export * from './snapshotSlice';
+export * from './SliceDropIndicator';
+export * from './SliceDropTarget';
+export * from './SliceDropVerdict';
+export * from './sliceMove';
+export * from './SliceMoved';
+export * from './useSliceDrag';
+export * from './useSliceDragIntent';
+export * from './ValidateSliceDrop';

package/dist/SliceDragging/readSliceDragGesture.d.ts

@@ -0,0 +1,5 @@
+import { SliceDragGestureVerdict } from './SliceDragGestureVerdict';
+export declare const DRAG_THRESHOLD = 4;
+export declare const TOUCH_LONG_PRESS_MS = 450;
+export declare const TOUCH_LONG_PRESS_TOLERANCE = 10;
+export declare function readSliceDragGesture(pointerType: string, deltaX: number, deltaY: number): SliceDragGestureVerdict;

package/dist/SliceDragging/readSlicePress.d.ts

@@ -0,0 +1,20 @@
+export declare const INTERACTIVE_SELECTOR = "input, textarea, select, button, a, [role=\"button\"], [contenteditable=\"true\"], .p-dropdown, .p-checkbox";
+export interface PressedElement {
+    closest(selectors: string): unknown;
+}
+export interface SlicePressEvent {
+    target: PressedElement | null;
+    clientX: number;
+    clientY: number;
+    pointerId: number;
+    pointerType: string;
+    elementTop: number;
+}
+export interface SlicePress {
+    startX: number;
+    startY: number;
+    grabOffsetY: number;
+    pointerId: number;
+    pointerType: string;
+}
+export declare function readSlicePress(event: SlicePressEvent, disabled: boolean): SlicePress | null;

package/dist/SliceDragging/sliceMove.d.ts

@@ -0,0 +1,10 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface SliceDropPosition {
+    featureId: Guid;
+    targetFeatureId: Guid;
+    sourceIndex: number;
+    dropIndex: number;
+}
+export declare const sliceMove: (position: SliceDropPosition) => {
+    index: number;
+} | undefined;

package/dist/SliceDragging/snapshotSlice.d.ts

@@ -0,0 +1,8 @@
+export declare const HIT_TEST_ATTRIBUTES: string[];
+export interface GhostNode {
+    removeAttribute(name: string): void;
+    setAttribute(name: string, value: string): void;
+    readonly children: ArrayLike<GhostNode>;
+}
+export declare function prepareGhost(node: GhostNode): void;
+export declare function createSliceDragGhost(element: HTMLElement): HTMLElement | null;

package/dist/SliceDragging/useSliceDrag.d.ts

@@ -0,0 +1,30 @@
+import { Guid } from '@cratis/fundamentals';
+import type { SliceMoved } from './SliceMoved';
+import type { ValidateSliceDrop } from './ValidateSliceDrop';
+export interface DraggableFeature {
+    id: Guid;
+    slices: ReadonlyArray<{
+        id: Guid;
+    }>;
+}
+export interface SliceDragState {
+    sliceId: Guid;
+    moduleId: Guid;
+    featureId: Guid;
+    targetFeatureId: Guid;
+    sourceIndex: number;
+    ghostLabel: string;
+    ghostWidth: number;
+    ghost: HTMLElement | null;
+    currentX: number;
+    currentY: number;
+    dropIndex: number;
+    headerY: number;
+    zoom: number;
+    isValid: boolean;
+    invalidReason?: string;
+}
+export declare function useSliceDrag(feature: DraggableFeature, moduleId: Guid, onSliceMoved?: SliceMoved, validateSliceDrop?: ValidateSliceDrop): {
+    sliceDrag: SliceDragState | undefined;
+    handleSliceDragStart: ((sliceId: Guid, sliceName: string, clientX: number, clientY: number, columnWidth: number, headerY: number, zoom: number, ghost?: HTMLElement | null) => void) | undefined;
+};

package/dist/SliceDragging/useSliceDragIntent.d.ts

@@ -0,0 +1,10 @@
+import type React from 'react';
+import { Guid } from '@cratis/fundamentals';
+export type SliceDragStartHandler = (sliceId: Guid, sliceName: string, clientX: number, clientY: number, columnWidth: number, headerY: number, zoom: number, ghost: HTMLElement | null) => void;
+export interface SliceDragIntentHandlers {
+    onPointerDown: (event: React.PointerEvent<HTMLDivElement>) => void;
+    onPointerMove: (event: React.PointerEvent<HTMLDivElement>) => void;
+    onPointerUp: () => void;
+    onContextMenu: (event: React.MouseEvent<HTMLDivElement>) => void;
+}
+export declare function useSliceDragIntent(sliceId: Guid | undefined, sliceName: string, columnWidth: number, disabled: boolean, onSliceDragStart?: SliceDragStartHandler): SliceDragIntentHandlers;

package/dist/SliceTypes/SliceTypeIcon.d.ts

@@ -0,0 +1,5 @@
+import { SliceType } from '../Model';
+export interface SliceTypeIconProps {
+    type: SliceType;
+}
+export declare const SliceTypeIcon: ({ type }: SliceTypeIconProps) => import("react").JSX.Element;

package/dist/SliceTypes/SliceTypeMenu.d.ts

@@ -0,0 +1,6 @@
+import type { SliceType } from '../Model';
+export interface SliceTypeMenuProps {
+    onSelect: (type: SliceType) => void;
+    disabled?: boolean;
+}
+export declare const SliceTypeMenu: ({ onSelect, disabled }: SliceTypeMenuProps) => import("react").JSX.Element;

package/dist/SliceTypes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './SliceTypeIcon';
+export * from './SliceTypeMenu';
+export * from './sliceTypeMenuItems';

package/dist/SliceTypes/sliceTypeMenuItems.d.ts

@@ -0,0 +1,7 @@
+import { SliceType } from '../Model';
+import type { EventModelMessages } from '../Messages';
+import type { MenuDropdownItem } from '../Menus';
+export declare const sliceTypes: readonly SliceType[];
+export declare const sliceTypeLabel: (type: SliceType, messages: EventModelMessages) => string;
+export declare const sliceTypeDescription: (type: SliceType, messages: EventModelMessages) => string;
+export declare const sliceTypeMenuItems: (messages: EventModelMessages, onSelect: (type: SliceType) => void) => MenuDropdownItem[];

package/dist/Slices/SliceColumn.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceHeaderSlice } from './SliceHeaderSlice';
+import type { SliceDragStartHandler } from '../SliceDragging';
+export interface SliceColumnProps {
+    featureId: Guid;
+    slice: SliceHeaderSlice;
+    eventCount: number;
+    collapsed: boolean;
+    isDragging?: boolean;
+    onSliceDragStart?: SliceDragStartHandler;
+    header?: ReactNode;
+    headerHeight?: number;
+    body: ReactNode | ((inView: boolean) => ReactNode);
+    specifications?: ReactNode | ((inView: boolean, width: number) => ReactNode);
+    collapsedWidth: number;
+}
+export declare const SliceColumn: ({ featureId, slice, eventCount, collapsed, isDragging, onSliceDragStart, header, headerHeight, body, specifications, collapsedWidth }: SliceColumnProps) => import("react").JSX.Element;

package/dist/Slices/SliceColumnFrame.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceStatus } from '../Model';
+import { type SliceDragStartHandler } from '../SliceDragging';
+export interface SliceColumnFrameProps {
+    featureId: Guid;
+    name: string;
+    status: SliceStatus;
+    width: number;
+    collapsed: boolean;
+    isDragging?: boolean;
+    onDragStart?: SliceDragStartHandler;
+    ref?: React.Ref<HTMLDivElement>;
+    onMouseEnter?: () => void;
+    onMouseLeave?: () => void;
+    onFocusCapture?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlurCapture?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    children?: React.ReactNode;
+}
+export declare const SliceColumnFrame: ({ featureId, name, status, width, collapsed, isDragging, onDragStart, ref, onMouseEnter, onMouseLeave, onFocusCapture, onBlurCapture, children, }: SliceColumnFrameProps) => React.JSX.Element;

package/dist/Slices/SliceContext.d.ts

@@ -0,0 +1,2 @@
+import type { SliceContextValue } from './SliceContextValue';
+export declare const SliceContext: import("react").Context<SliceContextValue | undefined>;

package/dist/Slices/SliceContextValue.d.ts

@@ -0,0 +1,7 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceType } from '../Model';
+export interface SliceContextValue {
+    readOnly: boolean;
+    sliceId?: Guid;
+    sliceType?: SliceType;
+}

package/dist/Slices/SliceHeader.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { SliceStatus } from '../Model';
+import type { SliceHeaderSlice } from './SliceHeaderSlice';
+export interface SliceHeaderProps {
+    slice: SliceHeaderSlice;
+    height: number;
+    collapsed: boolean;
+    selectableStatuses?: readonly SliceStatus[];
+    unselectableStatusReason?: string;
+    error?: string;
+    leading?: React.ReactNode;
+    trailing?: React.ReactNode;
+}
+export declare const SliceHeader: ({ slice, height, collapsed, selectableStatuses, unselectableStatusReason, error, leading, trailing, }: SliceHeaderProps) => React.JSX.Element;

package/dist/Slices/SliceHeaderAction.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceHeaderSlice } from './SliceHeaderSlice';
+export interface SliceHeaderAction {
+    icon: ReactNode;
+    tooltip: string;
+    when?: (slice: SliceHeaderSlice) => boolean;
+    disabled?: boolean;
+    onActivate: (sliceId: Guid, host: DOMRect) => void;
+}

package/dist/Slices/SliceHeaderSlice.d.ts

@@ -0,0 +1,2 @@
+import type { Slice } from '../Model';
+export type SliceHeaderSlice = Pick<Slice, 'id' | 'name' | 'sliceType' | 'status'>;

package/dist/Slices/SliceNames.d.ts

@@ -0,0 +1,6 @@
+export interface SliceNames {
+    name?: string;
+    commandName?: string;
+    eventName?: string;
+    readModelName?: string;
+}

package/dist/Slices/SlicePlaceholder.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { SliceType } from '../Model';
+import { RowType } from '../Rows/RowType';
+export interface SlicePlaceholderSlice {
+    sliceType: SliceType;
+    hasCommand: boolean;
+    hasReadModel: boolean;
+    eventCount: number;
+}
+export interface SlicePlaceholderProps {
+    slice: SlicePlaceholderSlice;
+    contentRows: readonly RowType[];
+    rowHeights: Readonly<Record<RowType, number>>;
+}
+export declare const SlicePlaceholder: React.FC<SlicePlaceholderProps>;

package/dist/Slices/SliceProvider.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceStatus, SliceType } from '../Model';
+export interface SliceProviderProps {
+    sliceId: Guid;
+    sliceType: SliceType;
+    status: SliceStatus;
+    children?: React.ReactNode;
+}
+export declare const SliceProvider: ({ sliceId, sliceType, status, children }: SliceProviderProps) => React.JSX.Element;

package/dist/Slices/SliceRows.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from 'react';
+import type { ActorType, SliceType } from '../Model';
+import { type CellConnectors } from '../Connections';
+import { RowType } from '../Rows/RowType';
+export interface SliceRowCell<TActor> {
+    rowType: RowType;
+    conn: CellConnectors;
+    rowHeight: number;
+    actor?: TActor;
+}
+export interface SliceRowsProps<TActor extends {
+    id: {
+        toString(): string;
+    };
+    actorType: ActorType;
+}> {
+    sliceType: SliceType;
+    contentRows: readonly RowType[];
+    rowHeights: Readonly<Record<RowType, number>>;
+    actors: readonly TActor[];
+    renderCell: (cell: SliceRowCell<TActor>) => ReactNode;
+}
+export declare const SliceRows: <TActor extends {
+    id: {
+        toString(): string;
+    };
+    actorType: ActorType;
+}>({ sliceType, contentRows, rowHeights, actors, renderCell }: SliceRowsProps<TActor>) => import("react").JSX.Element;

package/dist/Slices/SlicesArea.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode, type Ref } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import { useSliceDrag, type ValidateSliceDrop } from '../SliceDragging';
+import type { Slice, SliceType } from '../Model';
+import type { SliceNames } from './SliceNames';
+import { type SliceAreaItem } from './sliceAreaState';
+export interface SlicesAreaHandle<T extends SliceAreaItem> {
+    addSlice: (sliceType: SliceType, afterSliceId?: Guid, names?: SliceNames) => void;
+    updateSlices: (update: (previous: T[]) => T[]) => void;
+    addProjectedSlice: (slice: T, afterSliceId?: Guid) => void;
+    moveIn: (slice: T, index: number) => void;
+    completeMoveIn: (id: Guid, succeeded: boolean) => void;
+    moveOut: (id: Guid) => boolean;
+    completeMoveOut: (id: Guid, succeeded: boolean) => void;
+}
+export interface SlicesAreaProps<T extends SliceAreaItem> {
+    initialSlices: T[];
+    ref?: Ref<SlicesAreaHandle<T>>;
+    moduleId: Guid;
+    featureId: Guid;
+    featureCollapsed: boolean;
+    hideEmptyPlaceholder?: boolean;
+    onSlicesChanged?: (slices: T[]) => void;
+    createSlice: (slice: Slice) => T;
+    onAddSlice?: (slice: T, afterSliceId?: Guid) => Promise<Guid | undefined>;
+    onReorderSlices?: (sliceIds: Guid[]) => Promise<boolean>;
+    onMoveSlice?: (slice: T, targetFeatureId: Guid, targetIndex: number) => Promise<boolean>;
+    validateSliceDrop?: ValidateSliceDrop;
+    renderSlice: (slice: T, options: {
+        collapsed: boolean;
+        sliceCollapsed: boolean;
+        isDragging: boolean;
+        onSliceDragStart: ReturnType<typeof useSliceDrag>['handleSliceDragStart'];
+        addSlice: SlicesAreaHandle<T>['addSlice'];
+        updateSlices: SlicesAreaHandle<T>['updateSlices'];
+    }) => ReactNode;
+}
+export declare function SlicesArea<T extends SliceAreaItem>({ ref, initialSlices, moduleId, featureId, featureCollapsed, hideEmptyPlaceholder, onSlicesChanged, createSlice, onAddSlice, onReorderSlices, onMoveSlice, validateSliceDrop, renderSlice, }: SlicesAreaProps<T>): import("react").JSX.Element | null;

package/dist/Slices/createOptimisticSlice.d.ts

@@ -0,0 +1,3 @@
+import { SliceType, type Slice } from '../Model';
+import type { SliceNames } from './SliceNames';
+export declare const createOptimisticSlice: (sliceType: SliceType, names?: SliceNames) => Slice;

package/dist/Slices/index.d.ts

@@ -0,0 +1,15 @@
+export * from './resolveSliceReadOnly';
+export * from './SliceContextValue';
+export * from './SliceProvider';
+export * from './useSlice';
+export * from './SliceHeader';
+export * from './SliceHeaderAction';
+export * from './SliceHeaderSlice';
+export * from './SliceColumn';
+export * from './SlicesArea';
+export * from './SliceNames';
+export * from './createOptimisticSlice';
+export * from './sliceAreaState';
+export * from './SliceColumnFrame';
+export * from './SliceRows';
+export * from './SlicePlaceholder';

package/dist/Slices/resolveSliceReadOnly.d.ts

@@ -0,0 +1,3 @@
+import { SliceStatus } from '../Model';
+import { type DetailLevel } from '../Presentation';
+export declare const resolveSliceReadOnly: (boardReadOnly: boolean, detailLevel: DetailLevel, status: SliceStatus) => boolean;