@tumaet/apollon 4.3.0 → 4.5.0

package/dist/internals.d.ts

@@ -0,0 +1,868 @@
+import { Edge } from '@xyflow/react';
+import { EdgeProps } from '@xyflow/react';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { Node as Node_2 } from '@xyflow/react';
+import { NodeProps } from '@xyflow/react';
+import { OnEdgesChange } from '@xyflow/react';
+import { OnNodesChange } from '@xyflow/react';
+import { StoreApi } from 'zustand';
+import * as Y from 'yjs';
+
+declare function Activity({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function ActivityActionNode({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function ActivityFinalNode({ id, width, height, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function ActivityForkNode({ id, width, height, parentId, data, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function ActivityForkNodeHorizontal({ id, width, height, parentId, data, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function ActivityInitialNode({ id, width, height, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function ActivityMergeNode({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function ActivityObjectNode({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare type ApollonEdge = {
+    id: string;
+    source: string;
+    target: string;
+    type: DiagramEdgeType;
+    sourceHandle: string;
+    targetHandle: string;
+    data: OrthogonalEdgeData;
+};
+
+declare enum ApollonMode {
+    Modelling = "Modelling",
+    Exporting = "Exporting",
+    Assessment = "Assessment"
+}
+
+declare type ApollonNode = {
+    id: string;
+    width: number;
+    height: number;
+    type: DiagramNodeType;
+    position: {
+        x: number;
+        y: number;
+    };
+    data: {
+        [key: string]: unknown;
+    };
+    parentId?: string;
+    measured: {
+        width: number;
+        height: number;
+    };
+};
+
+declare enum ApollonView {
+    Modelling = "Modelling",
+    Exporting = "Exporting",
+    Highlight = "Highlight"
+}
+
+declare type Assessment = {
+    modelElementId: string;
+    elementType: string;
+    score: number;
+    feedback?: string;
+    dropInfo?: unknown;
+    label?: string;
+    labelColor?: string;
+    correctionStatus?: FeedbackCorrectionStatus;
+};
+
+declare type BaseEdgeProps = ExtendedEdgeProps;
+
+declare function BPMNAnnotation({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNAnnotationProps>>): JSX_2.Element | null;
+
+declare type BPMNAnnotationProps = DefaultNodeProps;
+
+declare function BPMNCallActivity({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNCallActivityProps>>): JSX_2.Element | null;
+
+declare type BPMNCallActivityProps = DefaultNodeProps;
+
+declare function BPMNDataObject({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNDataObjectProps>>): JSX_2.Element | null;
+
+declare type BPMNDataObjectProps = DefaultNodeProps;
+
+declare function BPMNDataStore({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNDataStoreProps>>): JSX_2.Element | null;
+
+declare type BPMNDataStoreProps = DefaultNodeProps;
+
+declare function BPMNEndEvent({ id, width, height, data, }: NodeProps<Node_2<BPMNEventProps>>): JSX_2.Element;
+
+declare type BPMNEventProps = DefaultNodeProps & {
+    eventType: BPMNStartEventType;
+};
+
+declare function BPMNGateway({ id, width, height, data, }: NodeProps<Node_2<BPMNGatewayProps>>): JSX_2.Element;
+
+declare type BPMNGatewayProps = DefaultNodeProps & {
+    gatewayType: BPMNGatewayType;
+};
+
+declare type BPMNGatewayType = "complex" | "event-based" | "exclusive" | "inclusive" | "parallel";
+
+declare function BPMNGroup({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNGroupProps>>): JSX_2.Element | null;
+
+declare type BPMNGroupProps = DefaultNodeProps;
+
+declare function BPMNIntermediateEvent({ id, width, height, data, }: NodeProps<Node_2<BPMNEventProps>>): JSX_2.Element;
+
+declare type BPMNMarkerType = "none" | "parallel multi instance" | "sequential multi instance" | "loop";
+
+declare function BPMNPool({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNPoolProps>>): JSX_2.Element | null;
+
+declare type BPMNPoolProps = DefaultNodeProps;
+
+declare function BPMNStartEvent({ id, width, height, data, }: NodeProps<Node_2<BPMNEventProps>>): JSX_2.Element;
+
+declare type BPMNStartEventType = "default" | "message" | "timer" | "conditional" | "signal";
+
+declare function BPMNSubprocess({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNSubprocessProps>>): JSX_2.Element | null;
+
+declare type BPMNSubprocessProps = DefaultNodeProps;
+
+declare function BPMNTask({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNTaskProps>>): JSX_2.Element | null;
+
+declare type BPMNTaskProps = DefaultNodeProps & {
+    taskType: BPMNTaskType;
+    marker: BPMNMarkerType;
+};
+
+declare type BPMNTaskType = "default" | "user" | "send" | "receive" | "manual" | "business-rule" | "script";
+
+declare function BPMNTransaction({ id, width, height, data, parentId, }: NodeProps<Node_2<BPMNTransactionProps>>): JSX_2.Element | null;
+
+declare type BPMNTransactionProps = DefaultNodeProps;
+
+declare function Class({ id, width, height, data, }: NodeProps<Node_2<ClassNodeProps>>): JSX_2.Element;
+
+declare type ClassNodeElement = {
+    id: string;
+} & DefaultNodeProps;
+
+declare type ClassNodeProps = {
+    methods: ClassNodeElement[];
+    attributes: ClassNodeElement[];
+    stereotype?: ClassType;
+} & DefaultNodeProps;
+
+declare enum ClassType {
+    Abstract = "Abstract",
+    Interface = "Interface",
+    Enumeration = "Enumeration"
+}
+
+declare type CollaborationCursor = {
+    x: number;
+    y: number;
+};
+
+declare type CollaborationState = {
+    user?: CollaborationUser;
+    cursor?: CollaborationCursor | null;
+    viewport?: CollaborationViewport | null;
+    followingClientId?: number | null;
+    selectedElementId?: string | null;
+};
+
+declare type CollaborationUser = {
+    name: string;
+    color: string;
+    id?: string;
+    imageUrl?: string;
+};
+
+declare type CollaborationViewport = {
+    x: number;
+    y: number;
+    zoom: number;
+};
+
+declare type CollaboratorInfo = {
+    id: string;
+    name: string;
+    color: string;
+    imageUrl?: string;
+    clientIds: number[];
+    isLocal: boolean;
+};
+
+declare function ColorDescription({ width, height, data, id, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function CommunicationObjectName({ id, width, height, data, }: NodeProps<Node_2<CommunicationObjectNodeProps>>): JSX_2.Element;
+
+declare type CommunicationObjectNodeProps = {
+    methods: ClassNodeElement[];
+    attributes: ClassNodeElement[];
+} & DefaultNodeProps;
+
+declare function Component({ id, width, height, data, parentId, }: NodeProps<Node_2<ComponentNodeProps>>): JSX_2.Element | null;
+
+declare function ComponentInterface({ id, width, height, data, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare type ComponentNodeProps = {
+    isComponentHeaderShown: boolean;
+} & DefaultNodeProps;
+
+declare function ComponentSubsystem({ id, width, height, data, parentId, }: NodeProps<Node_2<ComponentSubsystemNodeProps>>): JSX_2.Element | null;
+
+declare type ComponentSubsystemNodeProps = {
+    isComponentSubsystemHeaderShown: boolean;
+} & DefaultNodeProps;
+
+/**
+ * Convert v2 format to v4 format
+ */
+export declare function convertV2ToV4(v2Data: V2DiagramFormat): UMLModel;
+
+/**
+ * Convert v3 edge types to v4 edge types
+ */
+export declare function convertV3EdgeTypeToV4(v3Type: string, flowType?: string): string;
+
+/**
+ * Convert v3 handle directions to v4 handle IDs
+ * V3 uses Direction enum, V4 uses HandleId enum
+ */
+export declare function convertV3HandleToV4(v3Handle: string): string;
+
+/**
+ * Convert V3 messages format to V4 MessageData array
+ */
+export declare function convertV3MessagesToV4(messages: V3Messages | MessageData[] | undefined): MessageData[];
+
+/**
+ * Convert v3 node types to v4 node types
+ */
+export declare function convertV3NodeTypeToV4(v3Type: string): string;
+
+/**
+ * Main conversion function from v3 to v4 format
+ */
+export declare function convertV3ToV4(v3Data: V3DiagramFormat | V3UMLModel): UMLModel;
+
+/**
+ * Construct a `YjsSync` against minimal stub stores. Intended for
+ * tests that exercise the wire protocol (sync/awareness handshake,
+ * incremental updates, reconnect behaviour) without dragging the React
+ * editor / React-Flow / zustand-with-middleware setup into the harness.
+ *
+ * Stores expose only the methods the sync class actually invokes. The
+ * Yjs observers will call them, but their bodies are no-ops because the
+ * test asserts directly against the `Y.Doc` that's returned.
+ */
+export declare function createHeadlessSync(ydoc?: Y.Doc): {
+    ydoc: Y.Doc;
+    sync: YjsSync;
+};
+
+declare type CustomEdgeProps = {
+    sourceRole: string | null;
+    sourceMultiplicity: string | null;
+    targetRole: string | null;
+    targetMultiplicity: string | null;
+    points: IPoint[];
+    label?: string | null;
+    messages?: MessageData[];
+    strokeColor?: string;
+    textColor?: string;
+};
+
+declare type DefaultNodeProps = {
+    name: string;
+    fillColor?: string;
+    strokeColor?: string;
+    textColor?: string;
+};
+
+declare function DeploymentArtifact({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function DeploymentComponent({ id, width, height, data, parentId, }: NodeProps<Node_2<DeploymentComponentProps>>): JSX_2.Element | null;
+
+declare type DeploymentComponentProps = {
+    isComponentHeaderShown: boolean;
+} & DefaultNodeProps;
+
+declare function DeploymentInterface({ id, width, height, data, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function DeploymentNode({ id, width, height, data, parentId, }: NodeProps<Node_2<DeploymentNodeProps>>): JSX_2.Element | null;
+
+declare type DeploymentNodeProps = {
+    isComponentHeaderShown: boolean;
+    stereotype: string;
+} & DefaultNodeProps;
+
+declare type DiagramEdgeType = keyof typeof diagramEdgeTypes;
+
+declare const diagramEdgeTypes: {
+    ClassAggregation: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ClassInheritance: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ClassRealization: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ClassComposition: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ClassBidirectional: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ClassUnidirectional: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ClassDependency: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ActivityControlFlow: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ObjectLink: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    FlowChartFlowline: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    SyntaxTreeLink: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    CommunicationLink: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    PetriNetArc: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    UseCaseAssociation: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    UseCaseInclude: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    UseCaseExtend: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    UseCaseGeneralization: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ComponentDependency: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ComponentProvidedInterface: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ComponentRequiredInterface: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ComponentRequiredThreeQuarterInterface: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ComponentRequiredQuarterInterface: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    DeploymentAssociation: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    DeploymentDependency: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    DeploymentProvidedInterface: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    DeploymentRequiredInterface: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    DeploymentRequiredThreeQuarterInterface: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    DeploymentRequiredQuarterInterface: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    SfcDiagramEdge: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    ReachabilityGraphArc: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    BPMNSequenceFlow: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    BPMNMessageFlow: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    BPMNAssociationFlow: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+    BPMNDataAssociationFlow: ({ id, type, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, sourceHandleId, targetHandleId, data, }: BaseEdgeProps) => JSX_2.Element;
+};
+
+declare type DiagramNodeType = keyof typeof diagramNodeTypes;
+
+declare const diagramNodeTypes: {
+    package: typeof Package;
+    class: typeof Class;
+    objectName: typeof ObjectName;
+    communicationObjectName: typeof CommunicationObjectName;
+    colorDescription: typeof ColorDescription;
+    titleAndDesctiption: typeof TitleAndDesctiption;
+    activity: typeof Activity;
+    activityInitialNode: typeof ActivityInitialNode;
+    activityFinalNode: typeof ActivityFinalNode;
+    activityActionNode: typeof ActivityActionNode;
+    activityObjectNode: typeof ActivityObjectNode;
+    activityMergeNode: typeof ActivityMergeNode;
+    activityForkNode: typeof ActivityForkNode;
+    activityForkNodeHorizontal: typeof ActivityForkNodeHorizontal;
+    useCase: typeof UseCase;
+    useCaseActor: typeof UseCaseActor;
+    useCaseSystem: typeof UseCaseSystem;
+    component: typeof Component;
+    componentInterface: typeof ComponentInterface;
+    componentSubsystem: typeof ComponentSubsystem;
+    deploymentNode: typeof DeploymentNode;
+    deploymentComponent: typeof DeploymentComponent;
+    deploymentArtifact: typeof DeploymentArtifact;
+    deploymentInterface: typeof DeploymentInterface;
+    flowchartTerminal: typeof FlowchartTerminal;
+    flowchartProcess: typeof FlowchartProcess;
+    flowchartDecision: typeof FlowchartDecision;
+    flowchartInputOutput: typeof FlowchartInputOutput;
+    flowchartFunctionCall: typeof FlowchartFunctionCall;
+    syntaxTreeTerminal: typeof SyntaxTreeTerminal;
+    syntaxTreeNonterminal: typeof SyntaxTreeNonterminal;
+    petriNetTransition: typeof PetriNetTransition;
+    petriNetPlace: typeof PetriNetPlace;
+    bpmnTask: typeof BPMNTask;
+    bpmnStartEvent: typeof BPMNStartEvent;
+    bpmnIntermediateEvent: typeof BPMNIntermediateEvent;
+    bpmnEndEvent: typeof BPMNEndEvent;
+    bpmnGateway: typeof BPMNGateway;
+    bpmnSubprocess: typeof BPMNSubprocess;
+    bpmnTransaction: typeof BPMNTransaction;
+    bpmnCallActivity: typeof BPMNCallActivity;
+    bpmnAnnotation: typeof BPMNAnnotation;
+    bpmnDataObject: typeof BPMNDataObject;
+    bpmnDataStore: typeof BPMNDataStore;
+    bpmnPool: typeof BPMNPool;
+    bpmnGroup: typeof BPMNGroup;
+    reachabilityGraphMarking: typeof ReachabilityGraphMarking;
+    sfcStart: typeof SfcStart;
+    sfcStep: typeof SfcStep;
+    sfcActionTable: typeof SfcActionTable;
+    sfcTransitionBranch: typeof SfcTransitionBranch;
+    sfcJump: typeof SfcJump;
+};
+
+declare type DiagramStore = {
+    nodes: Node_2[];
+    edges: Edge[];
+    selectedElementIds: string[];
+    diagramId: string;
+    assessments: Record<string, Assessment>;
+    interactiveElements: Record<string, boolean>;
+    interactiveRelationships: Record<string, boolean>;
+    interactiveSelectionInitialized: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    undoManager: Y.UndoManager | null;
+    previewMode: boolean;
+    setDiagramId: (diagramId: string) => void;
+    setNodes: (payload: Node_2[] | ((nodes: Node_2[]) => Node_2[])) => void;
+    setEdges: (payload: Edge[] | ((edges: Edge[]) => Edge[])) => void;
+    setNodesAndEdges: (nodes: Node_2[], edges: Edge[]) => void;
+    addEdge: (edge: Edge) => void;
+    addNode: (node: Node_2) => void;
+    onNodesChange: OnNodesChange;
+    onEdgesChange: OnEdgesChange;
+    reset: () => void;
+    setSelectedElementsId: (payload: string[] | ((edges: string[]) => string[])) => void;
+    getAssessment: (id: string) => Assessment | undefined;
+    setAssessments: (assessments: Record<string, Assessment> | ((prev: Record<string, Assessment>) => Record<string, Assessment>)) => void;
+    updateNodesFromYjs: () => void;
+    updateEdgesFromYjs: () => void;
+    updateAssessmentFromYjs: () => void;
+    addOrUpdateAssessment: (assessment: Assessment) => void;
+    undo: () => void;
+    redo: () => void;
+    initializeUndoManager: () => void;
+    updateUndoRedoState: () => void;
+    toggleInteractiveElement: (elementId: string) => void;
+    getInteractiveForSerialization: () => InteractiveElements | undefined;
+    setInteractive: (interactive: InteractiveElements | undefined) => void;
+    isElementInteractive: (elementId: string) => boolean;
+    /**
+     * Toggle the preview overlay. When entering, the Yjs doc is left
+     * untouched by store mutators and observers. When exiting, the local
+     * Zustand state is rebuilt from the (peer-augmented) Yjs maps so the
+     * canvas catches up to everything that arrived during preview.
+     */
+    setPreviewMode: (active: boolean) => void;
+};
+
+declare type ExtendedEdgeProps = EdgeProps<Edge<CustomEdgeProps>> & {
+    markerEnd?: string;
+    markerPadding?: number;
+    strokeDashArray?: string;
+    type: string;
+};
+
+declare type FeedbackCorrectionStatus = {
+    description?: string;
+    status: "CORRECT" | "INCORRECT" | "NOT_VALIDATED";
+};
+
+declare function FlowchartDecision({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function FlowchartFunctionCall({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function FlowchartInputOutput({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function FlowchartProcess({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function FlowchartTerminal({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare type InteractiveElements = {
+    elements: Record<string, boolean>;
+    relationships: Record<string, boolean>;
+};
+
+declare interface IPoint {
+    x: number;
+    y: number;
+}
+
+declare interface IPoint_2 {
+    x: number;
+    y: number;
+}
+
+/**
+ * Check if data is in v2 format
+ */
+export declare function isV2Format(data: any): data is V2DiagramFormat;
+
+/**
+ * Check if data is in v3 format
+ */
+export declare function isV3Format(data: any): data is V3DiagramFormat;
+
+/**
+ * Check if data is in v4 format
+ */
+export declare function isV4Format(data: any): data is UMLModel;
+
+declare interface MessageData {
+    id: string;
+    text: string;
+    direction: "target" | "source";
+}
+
+export declare enum MessageType {
+    YjsSYNC = 0,
+    YjsUpdate = 1,
+    AwarenessSync = 2,
+    AwarenessUpdate = 3
+}
+
+declare type MetadataStore = {
+    diagramTitle: string;
+    diagramType: UMLDiagramType;
+    mode: ApollonMode;
+    view: ApollonView;
+    availableViews: ApollonView[];
+    readonly: boolean;
+    debug: boolean;
+    scrollLock: boolean;
+    scrollEnabled: boolean;
+    connectionGuidanceActive: boolean;
+    connectionGuidanceSourceNodeId: string | null;
+    connectionGuidanceSourceHandleId: string | null;
+    reconnectPreviewEdgeId: string | null;
+    reconnectPreviewHandleType: "source" | "target" | null;
+    reconnectPreviewBasePoints: IPoint[];
+    setMode: (mode: ApollonMode) => void;
+    setView: (view: ApollonView) => void;
+    setAvailableViews: (availableViews: ApollonView[]) => void;
+    setReadonly: (readonly: boolean) => void;
+    setScrollLock: (scrollLock: boolean) => void;
+    setScrollEnabled: (scrollEnabled: boolean) => void;
+    startConnectionGuidance: (sourceNodeId: string | null, sourceHandleId: string | null) => void;
+    stopConnectionGuidance: () => void;
+    startReconnectPreview: (edgeId: string, handleType: "source" | "target", basePoints: IPoint[]) => void;
+    stopReconnectPreview: () => void;
+    updateDiagramTitle: (diagramTitle: string) => void;
+    updateDiagramType: (diagramType: UMLDiagramType) => void;
+    updateMetaData: (diagramTitle: string, diagramType: UMLDiagramType) => void;
+    updateMetaDataFromYjs: () => void;
+    reset: () => void;
+    setDebug: (debug: boolean) => void;
+};
+
+declare function ObjectName({ id, width, height, data, }: NodeProps<Node_2<ObjectNodeProps>>): JSX_2.Element;
+
+declare type ObjectNodeProps = {
+    methods: ClassNodeElement[];
+    attributes: ClassNodeElement[];
+} & DefaultNodeProps;
+
+declare interface OrthogonalEdgeData {
+    [key: string]: unknown;
+    points: IPoint_2[];
+}
+
+declare function Package({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function PetriNetPlace({ id, width, height, data, }: NodeProps<Node_2<PetriNetPlaceProps>>): JSX_2.Element | null;
+
+declare type PetriNetPlaceProps = {
+    tokens: number;
+    capacity: number | "Infinity";
+} & DefaultNodeProps;
+
+declare function PetriNetTransition({ id, width, height, data, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare type Props = Node_2<{
+    description?: string;
+    title: string;
+}>;
+
+declare function ReachabilityGraphMarking({ id, width, height, data, parentId, }: NodeProps<Node_2<ReachabilityGraphMarkingProps>>): JSX_2.Element | null;
+
+declare type ReachabilityGraphMarkingProps = DefaultNodeProps & {
+    isInitialMarking: boolean;
+};
+
+export declare type SendBroadcastMessage = (base64data: string) => void;
+
+declare type SfcActionRow = DefaultNodeProps & {
+    id: string;
+    identifier: string;
+};
+
+declare function SfcActionTable({ id, width, height, data, }: NodeProps<Node_2<SfcActionTableProps>>): JSX_2.Element | null;
+
+declare type SfcActionTableProps = DefaultNodeProps & {
+    actionRows: SfcActionRow[];
+};
+
+declare function SfcJump({ id, width, height, data, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function SfcStart({ id, width, height, data, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function SfcStep({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function SfcTransitionBranch({ id, width, height, data, }: NodeProps<Node_2<SfcTransitionBranchNodeProps>>): JSX_2.Element | null;
+
+declare type SfcTransitionBranchNodeProps = DefaultNodeProps & {
+    showHint: boolean;
+};
+
+declare function SyntaxTreeNonterminal({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function SyntaxTreeTerminal({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function TitleAndDesctiption({ width, height, id, data: { description, title }, }: NodeProps<Props>): JSX_2.Element | null;
+
+declare type UMLDiagramType = keyof typeof UMLDiagramType;
+
+declare const UMLDiagramType: {
+    readonly ClassDiagram: "ClassDiagram";
+    readonly ObjectDiagram: "ObjectDiagram";
+    readonly ActivityDiagram: "ActivityDiagram";
+    readonly UseCaseDiagram: "UseCaseDiagram";
+    readonly CommunicationDiagram: "CommunicationDiagram";
+    readonly ComponentDiagram: "ComponentDiagram";
+    readonly DeploymentDiagram: "DeploymentDiagram";
+    readonly PetriNet: "PetriNet";
+    readonly ReachabilityGraph: "ReachabilityGraph";
+    readonly SyntaxTree: "SyntaxTree";
+    readonly Flowchart: "Flowchart";
+    readonly BPMN: "BPMN";
+    readonly Sfc: "Sfc";
+};
+
+declare type UMLModel = {
+    version: `4.${number}.${number}`;
+    id: string;
+    title: string;
+    type: UMLDiagramType;
+    nodes: ApollonNode[];
+    edges: ApollonEdge[];
+    assessments: {
+        [id: string]: Assessment;
+    };
+    interactive?: InteractiveElements;
+};
+
+declare function UseCase({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function UseCaseActor({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare function UseCaseSystem({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX_2.Element | null;
+
+declare interface V2DiagramFormat {
+    version: string;
+    size: {
+        width: number;
+        height: number;
+    };
+    type: string;
+    interactive: {
+        elements: string[];
+        relationships: string[];
+    };
+    elements: V3UMLElement[];
+    relationships: V3UMLRelationship[];
+    assessments: V3Assessment[];
+}
+
+export declare type V3Assessment = {
+    modelElementId: string;
+    elementType: string;
+    score: number;
+    feedback?: string;
+    dropInfo?: any;
+    label?: string;
+    labelColor?: string;
+    correctionStatus?: {
+        description?: string;
+        status: "CORRECT" | "INCORRECT" | "NOT_VALIDATED";
+    };
+};
+
+export declare type V3BPMNEndEvent = {
+    eventType: "default" | "message" | "escalation" | "error" | "compensation" | "signal" | "terminate";
+};
+
+export declare type V3BPMNGateway = {
+    gatewayType: "complex" | "event-based" | "exclusive" | "inclusive" | "parallel";
+};
+
+export declare type V3BPMNIntermediateEvent = {
+    eventType: "default" | "message-catch" | "message-throw" | "timer-catch" | "escalation-throw" | "conditional-catch" | "link-catch" | "link-throw" | "compensation-throw" | "signal-catch" | "signal-throw";
+};
+
+export declare type V3BPMNStartEvent = {
+    eventType: "default" | "message" | "timer" | "conditional" | "signal";
+};
+
+export declare type V3BPMNTask = {
+    taskType: "default" | "user" | "send" | "receive" | "manual" | "business-rule" | "script";
+    marker: "none" | "parallel multi instance" | "sequential multi instance" | "loop";
+};
+
+export declare type V3DiagramFormat = {
+    id: string;
+    title: string;
+    model: V3UMLModel;
+    lastUpdate?: string;
+};
+
+export declare type V3Message = {
+    id: string;
+    name: string;
+    direction: "source" | "target";
+};
+
+export declare type V3Messages = {
+    [id: string]: V3Message;
+};
+
+export declare type V3Selection = {
+    elements: {
+        [id: string]: boolean;
+    };
+    relationships: {
+        [id: string]: boolean;
+    };
+};
+
+export declare type V3UMLClassifier = {
+    attributes: string[];
+    methods: string[];
+};
+
+export declare type V3UMLComponentComponent = {
+    displayStereotype: boolean;
+};
+
+export declare type V3UMLComponentSubsystem = {
+    stereotype: string;
+    displayStereotype: boolean;
+};
+
+export declare type V3UMLDeploymentComponent = {
+    displayStereotype: boolean;
+};
+
+export declare type V3UMLDeploymentNode = {
+    stereotype: string;
+    displayStereotype: boolean;
+};
+
+export declare type V3UMLElement = V3UMLModelElement & Partial<V3UMLClassifier> & Partial<V3UMLDeploymentNode> & Partial<V3UMLDeploymentComponent> & Partial<V3UMLComponentSubsystem> & Partial<V3UMLComponentComponent> & Partial<V3UMLPetriNetPlace> & Partial<V3BPMNTask> & Partial<V3BPMNGateway> & Partial<V3BPMNStartEvent> & Partial<V3BPMNIntermediateEvent> & Partial<V3BPMNEndEvent> & Partial<V3UMLReachabilityGraphMarking>;
+
+export declare interface V3UMLModel {
+    version: string;
+    type: string;
+    size: {
+        width: number;
+        height: number;
+    };
+    interactive: {
+        elements: Record<string, boolean>;
+        relationships: Record<string, boolean>;
+    };
+    elements: Record<string, V3UMLElement>;
+    relationships: Record<string, V3UMLRelationship>;
+    assessments: Record<string, V3Assessment>;
+}
+
+export declare type V3UMLModelElement = {
+    id: string;
+    name: string;
+    type: V3UMLModelElementType;
+    owner: string | null;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    highlight?: string;
+    fillColor?: string;
+    strokeColor?: string;
+    textColor?: string;
+    assessmentNote?: string;
+};
+
+export declare type V3UMLModelElementType = string;
+
+export declare type V3UMLPetriNetPlace = {
+    amountOfTokens: number;
+    capacity: number | string;
+};
+
+export declare type V3UMLReachabilityGraphMarking = {
+    isInitialMarking: boolean;
+};
+
+export declare type V3UMLRelationship = V3UMLModelElement & {
+    path: IPoint[];
+    source: {
+        element: string;
+        direction: string;
+        multiplicity?: string;
+        role?: string;
+    };
+    target: {
+        element: string;
+        direction: string;
+        multiplicity?: string;
+        role?: string;
+    };
+    isManuallyLayouted?: boolean;
+    messages?: {
+        [id: string]: {
+            id: string;
+            name: string;
+            direction: "source" | "target";
+        };
+    };
+    flowType?: string;
+};
+
+export declare class YjsSync {
+    private readonly stopYjsObserver;
+    private sendBroadcastMessage;
+    private readonly ydoc;
+    private readonly diagramStore;
+    private readonly metadataStore;
+    private readonly awareness;
+    constructor(ydoc: Y.Doc, diagramStore: StoreApi<DiagramStore>, metadataStore: StoreApi<MetadataStore>);
+    stopSync(): void;
+    /**
+     * Push the entire local Yjs document as a single `YjsUpdate`. Callers should
+     * invoke this after a (re)connect so peers absorb any edits made while we
+     * were disconnected — those updates fire while `readyState !== OPEN`, are
+     * silently dropped by the send callback, and never replayed otherwise.
+     * Yjs CRDTs converge on merge, so peers that already have these ops just
+     * no-op.
+     */
+    broadcastFullState: () => void;
+    setSendBroadcastMessage: (sendFn: SendBroadcastMessage) => void;
+    setLocalAwarenessUser: (user: CollaborationUser) => void;
+    setLocalAwarenessCursor: (cursor: {
+        x: number;
+        y: number;
+    } | null) => void;
+    setLocalAwarenessViewport: (viewport: CollaborationViewport | null) => void;
+    setLocalAwarenessFollowing: (followingClientId: number | null) => void;
+    setLocalAwarenessSelectedElement: (selectedElementId: string | null) => void;
+    setLocalAwarenessState: (state: Partial<CollaborationState>) => void;
+    subscribeToAwarenessChanges: (callback: (states: Map<number, CollaborationState>) => void) => () => void;
+    getAwarenessStates: () => Map<number, CollaborationState>;
+    getCollaborators: () => CollaboratorInfo[];
+    subscribeToCollaboratorChanges: (callback: (collaborators: CollaboratorInfo[]) => void) => () => void;
+    getLocalAwarenessClientId: () => number;
+    private static narrowState;
+    private getTypedStates;
+    private computeParticipantSignature;
+    private sendFramedMessage;
+    private applyUpdate;
+    handleReceivedData: (base64Data: string) => void;
+    private startYjsObserver;
+    private isUndoRedoTransaction;
+    /**
+     *  Convert Uint8Array to Base64 string
+     */
+    static uint8ToBase64(uint8: Uint8Array): string;
+    /**
+     * Convert Base64 string to Uint8Array
+     */
+    private base64ToUint8;
+}
+
+export { }