@tumaet/apollon 4.4.0 → 4.6.0

package/dist/index.d.ts

@@ -1,10 +1,897 @@
-export * from './typings';
-export * from './apollon-editor';
-export * from './utils/helpers';
-export * from './utils/versionConverter';
-export * from './utils';
-export { log, setLogLevel, setLogger } from './logger';
-export type { LogLevel } from './logger';
-export { YjsSyncClass, MessageType } from './sync/yjsSyncClass';
-export type { SendBroadcastMessage } from './sync/yjsSyncClass';
-export { createHeadlessSync } from './sync/headless';
+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 { XYPosition } from '@xyflow/react';
+
+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 namespace Apollon {
+    export {
+        UMLDiagramType,
+        DiagramNodeType,
+        DiagramEdgeType,
+        Styles,
+        Unsubscriber,
+        Subscribers,
+        UMLModelElementType,
+        CollaborationUser,
+        CollaborationCursor,
+        CollaborationViewport,
+        CollaborationState,
+        CollaboratorInfo,
+        ApollonCollaborationOptions,
+        Locale,
+        ApollonMode,
+        ApollonNode,
+        OrthogonalEdgeData,
+        ApollonEdge,
+        InteractiveElements,
+        UMLModel,
+        ApollonView,
+        SvgExportMode,
+        ApollonOptions,
+        FeedbackCorrectionStatus,
+        Assessment,
+        ExportOptions,
+        SVG
+    }
+}
+
+export declare type ApollonCollaborationOptions = {
+    enabled?: boolean;
+    user?: CollaborationUser;
+    showPresence?: boolean;
+    showCursors?: boolean;
+    showSelectionHighlights?: boolean;
+    showFollow?: boolean;
+};
+
+export declare type ApollonEdge = {
+    id: string;
+    source: string;
+    target: string;
+    type: DiagramEdgeType;
+    sourceHandle: string;
+    targetHandle: string;
+    data: OrthogonalEdgeData;
+};
+
+export declare class ApollonEditor {
+    private root;
+    private reactFlowInstance;
+    private readonly syncManager;
+    private readonly ydoc;
+    private readonly diagramStore;
+    private readonly metadataStore;
+    private readonly popoverStore;
+    private readonly assessmentSelectionStore;
+    private readonly alignmentGuidesStore;
+    private readonly edgeGeometryStore;
+    private subscribers;
+    constructor(element: HTMLElement, options?: Apollon.ApollonOptions);
+    private setReactFlowInstance;
+    getNodes(): Node_2[];
+    getEdges(): Edge[];
+    getViewport(): {
+        x: number;
+        y: number;
+        zoom: number;
+    } | null;
+    screenToFlowPosition(position: {
+        x: number;
+        y: number;
+    }): XYPosition | null;
+    flowToScreenPosition(position: {
+        x: number;
+        y: number;
+    }): XYPosition | null;
+    fitView(options?: {
+        padding?: number;
+        duration?: number;
+    }): void;
+    set diagramType(type: UMLDiagramType);
+    destroy(): void;
+    /** Renders a model to SVG via a hidden, off-screen mount. */
+    static exportModelAsSvg(model: Apollon.UMLModel, options?: Apollon.ExportOptions): Promise<Apollon.SVG>;
+    /**
+     * exports current model as svg
+     * @param options options to change the export behavior (add margin, exclude element ...)
+     */
+    exportAsSVG(options?: Apollon.ExportOptions): Promise<Apollon.SVG>;
+    private getNewSubscriptionId;
+    subscribeToModelChange(callback: (state: Apollon.UMLModel) => void): number;
+    subscribeToDiagramNameChange(callback: (diagramTitle: string) => void): number;
+    subscribeToAssessmentSelection(callback: (selectedElementIds: string[]) => void): number;
+    subscribeToSelectionChange(callback: (selectedElementIds: string[]) => void): number;
+    subscribeToAwarenessChanges(callback: (states: Map<number, Apollon.CollaborationState>) => void): number;
+    subscribeToCollaboratorChanges(callback: (collaborators: Apollon.CollaboratorInfo[]) => void): number;
+    unsubscribe(subscriberId: number): void;
+    sendBroadcastMessage(sendFn: SendBroadcastMessage): void;
+    receiveBroadcastedMessage(base64Data: string): void;
+    /**
+     * Push the entire local Yjs document to peers. Hosts should call this on
+     * every (re)connect so any edits made while the transport was closed are
+     * absorbed by the room. See `YjsSync.broadcastFullState`.
+     */
+    broadcastFullState(): void;
+    setLocalAwarenessUser(user: Apollon.CollaborationUser): void;
+    setLocalAwarenessCursor(cursor: Apollon.CollaborationCursor | null): void;
+    setLocalAwarenessSelectedElement(selectedElementId: string | null): void;
+    setLocalAwarenessState(state: Partial<Apollon.CollaborationState>): void;
+    getLocalAwarenessClientId(): number;
+    getCollaborators(): Apollon.CollaboratorInfo[];
+    updateDiagramTitle(name: string): void;
+    /**
+     * Toggles the editor's read-only state at runtime. Used by hosting apps
+     * to lock the canvas while previewing an immutable snapshot (e.g. the
+     * version-history preview), without tearing down and re-mounting the
+     * editor instance.
+     */
+    setReadonly(readonly: boolean): void;
+    /** Live-toggle modeling vs assessment vs exporting mode. */
+    setMode(mode: Apollon.ApollonMode): void;
+    /** Live-toggle whether the canvas captures page scroll. */
+    setScrollLock(scrollLock: boolean): void;
+    /**
+     * Toggle preview-overlay mode. When `true`, subsequent `model = …`
+     * assignments and other store mutators update the local Zustand caches
+     * (so the canvas displays the overlay) WITHOUT writing to the Yjs
+     * doc — leaving the collaborative document untouched. Yjs observers
+     * also stop propagating peer-driven updates to Zustand, so the overlay
+     * doesn't flicker as collaborators edit the live diagram.
+     *
+     * On flip-off the local Zustand state is rebuilt from the (now
+     * peer-augmented) Yjs maps so the canvas catches up to everything
+     * collaborators committed during the preview.
+     *
+     * Hosts should call `setPreviewMode(true)` before applying a preview
+     * model and `setPreviewMode(false)` on exit. The Yjs doc never needs
+     * to be "restored" from a snapshot because it was never disturbed.
+     */
+    setPreviewMode(active: boolean): void;
+    toggleInteractiveElementsMode(forceEnabled?: boolean): void;
+    getInteractiveForSerialization(): Apollon.InteractiveElements | undefined;
+    getDiagramMetadata(): {
+        diagramTitle: string;
+        diagramType: "ClassDiagram" | "ObjectDiagram" | "ActivityDiagram" | "UseCaseDiagram" | "CommunicationDiagram" | "ComponentDiagram" | "DeploymentDiagram" | "PetriNet" | "ReachabilityGraph" | "SyntaxTree" | "Flowchart" | "BPMN" | "Sfc";
+    };
+    get model(): Apollon.UMLModel;
+    set model(model: Apollon.UMLModel);
+    getSelectedElements(): string[];
+    get view(): Apollon.ApollonView;
+    set view(view: Apollon.ApollonView);
+    addOrUpdateAssessment(assessment: Apollon.Assessment): void;
+    static generateInitialSyncMessage(): string;
+    static generateInitialAwarenessSyncMessage(): string;
+}
+
+export declare enum ApollonMode {
+    Modelling = "Modelling",
+    Exporting = "Exporting",
+    Assessment = "Assessment"
+}
+
+export 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;
+    };
+};
+
+export declare type ApollonOptions = {
+    type?: UMLDiagramType;
+    mode?: ApollonMode;
+    view?: ApollonView;
+    availableViews?: ApollonView[];
+    readonly?: boolean;
+    enablePopups?: boolean;
+    model?: UMLModel;
+    locale?: Locale;
+    debug?: boolean;
+    collaborationEnabled?: boolean;
+    collaboration?: ApollonCollaborationOptions;
+    scrollLock?: boolean;
+};
+
+declare const apollonTheme: {
+    color: {
+        primary: string;
+        secondary: string;
+        warningYellow: string;
+        background: string;
+        backgroundVariant: string;
+        grid: string;
+        primaryContrast: string;
+        gray: string;
+        grayAccent: string;
+    };
+    font: {
+        color: string;
+        family: string;
+        size: number;
+    };
+    interactive: {
+        normal: string;
+        hovered: string;
+    };
+};
+
+export declare enum ApollonView {
+    Modelling = "Modelling",
+    Exporting = "Exporting",
+    Highlight = "Highlight"
+}
+
+export declare type Assessment = {
+    modelElementId: string;
+    elementType: string;
+    score: number;
+    feedback?: string;
+    dropInfo?: unknown;
+    label?: string;
+    labelColor?: string;
+    correctionStatus?: FeedbackCorrectionStatus;
+};
+
+export declare type AssessmentViewData = {
+    elementId: string;
+    elementType: string;
+    name: string;
+    feedback: string;
+    score: number;
+};
+
+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"
+}
+
+export declare const collabColorFromName: (name: string) => string;
+
+export declare type CollaborationCursor = {
+    x: number;
+    y: number;
+};
+
+export declare type CollaborationState = {
+    user?: CollaborationUser;
+    cursor?: CollaborationCursor | null;
+    viewport?: CollaborationViewport | null;
+    followingClientId?: number | null;
+    selectedElementId?: string | null;
+};
+
+export declare type CollaborationUser = {
+    name: string;
+    color: string;
+    id?: string;
+    imageUrl?: string;
+};
+
+export declare type CollaborationViewport = {
+    x: number;
+    y: number;
+    zoom: number;
+};
+
+export 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;
+
+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;
+
+export 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;
+};
+
+export 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;
+};
+
+export declare type ExportOptions = {
+    margin?: number | {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    keepOriginalSize?: boolean;
+    include?: string[];
+    exclude?: string[];
+    /**
+     * Controls how SVG output is post-processed.
+     * - "web": keep CSS variables for theme-adaptive rendering in browsers
+     * - "compat": resolve CSS variables + inline attributes for PowerPoint/Inkscape
+     */
+    svgMode?: SvgExportMode;
+};
+
+declare type ExtendedEdgeProps = EdgeProps<Edge<CustomEdgeProps>> & {
+    markerEnd?: string;
+    markerPadding?: number;
+    strokeDashArray?: string;
+    type: string;
+};
+
+export 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;
+
+export declare const getAssessmentNameForArtemis: (elementId: string, model: UMLModel) => {
+    name: string;
+    type: string;
+} | undefined;
+
+export declare const getEdgeAssessmentDataById: (edgeId: string, model: UMLModel) => AssessmentViewData | undefined;
+
+export declare const getNodeAssessmentDataByNodeElementId: (nodeElementId: string, model: UMLModel) => AssessmentViewData | undefined;
+
+/**
+ * Universal import function that handles v2, v3 and v4 formats
+ */
+export declare function importDiagram(data: any | V3UMLModel): UMLModel;
+
+export 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;
+}
+
+export declare enum Locale {
+    en = "en",
+    de = "de"
+}
+
+export declare const log: {
+    debug: (...a: unknown[]) => void;
+    warn: (...a: unknown[]) => void;
+    error: (...a: unknown[]) => void;
+};
+
+export declare type LogLevel = "silent" | "error" | "warn" | "debug";
+
+declare interface MessageData {
+    id: string;
+    text: string;
+    direction: "target" | "source";
+}
+
+declare function ObjectName({ id, width, height, data, }: NodeProps<Node_2<ObjectNodeProps>>): JSX_2.Element;
+
+declare type ObjectNodeProps = {
+    methods: ClassNodeElement[];
+    attributes: ClassNodeElement[];
+} & DefaultNodeProps;
+
+export 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;
+}>;
+
+export declare const randomCollabName: () => string;
+
+declare function ReachabilityGraphMarking({ id, width, height, data, parentId, }: NodeProps<Node_2<ReachabilityGraphMarkingProps>>): JSX_2.Element | null;
+
+declare type ReachabilityGraphMarkingProps = DefaultNodeProps & {
+    isInitialMarking: boolean;
+};
+
+declare type SendBroadcastMessage = (base64data: string) => void;
+
+export declare function setLogger(next: Partial<Sink>): void;
+
+export declare function setLogLevel(next: LogLevel): 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 type Sink = Pick<Console, "error" | "warn" | "debug">;
+
+export declare type Styles = typeof apollonTheme;
+
+export declare type Subscribers = {
+    [key: number]: Unsubscriber;
+};
+
+export declare type SVG = {
+    svg: string;
+    clip: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+
+export declare type SvgExportMode = "web" | "compat";
+
+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;
+
+export declare type UMLDiagramType = keyof typeof UMLDiagramType;
+
+export 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";
+};
+
+export declare type UMLModel = {
+    version: `4.${number}.${number}`;
+    id: string;
+    title: string;
+    type: UMLDiagramType;
+    nodes: ApollonNode[];
+    edges: ApollonEdge[];
+    assessments: {
+        [id: string]: Assessment;
+    };
+    interactive?: InteractiveElements;
+};
+
+export declare type UMLModelElementType = DiagramNodeType | DiagramEdgeType;
+
+export declare type Unsubscriber = () => void;
+
+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 type V3Assessment = {
+    modelElementId: string;
+    elementType: string;
+    score: number;
+    feedback?: string;
+    dropInfo?: any;
+    label?: string;
+    labelColor?: string;
+    correctionStatus?: {
+        description?: string;
+        status: "CORRECT" | "INCORRECT" | "NOT_VALIDATED";
+    };
+};
+
+declare type V3BPMNEndEvent = {
+    eventType: "default" | "message" | "escalation" | "error" | "compensation" | "signal" | "terminate";
+};
+
+declare type V3BPMNGateway = {
+    gatewayType: "complex" | "event-based" | "exclusive" | "inclusive" | "parallel";
+};
+
+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";
+};
+
+declare type V3BPMNStartEvent = {
+    eventType: "default" | "message" | "timer" | "conditional" | "signal";
+};
+
+declare type V3BPMNTask = {
+    taskType: "default" | "user" | "send" | "receive" | "manual" | "business-rule" | "script";
+    marker: "none" | "parallel multi instance" | "sequential multi instance" | "loop";
+};
+
+declare type V3UMLClassifier = {
+    attributes: string[];
+    methods: string[];
+};
+
+declare type V3UMLComponentComponent = {
+    displayStereotype: boolean;
+};
+
+declare type V3UMLComponentSubsystem = {
+    stereotype: string;
+    displayStereotype: boolean;
+};
+
+declare type V3UMLDeploymentComponent = {
+    displayStereotype: boolean;
+};
+
+declare type V3UMLDeploymentNode = {
+    stereotype: string;
+    displayStereotype: boolean;
+};
+
+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>;
+
+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>;
+}
+
+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;
+};
+
+declare type V3UMLModelElementType = string;
+
+declare type V3UMLPetriNetPlace = {
+    amountOfTokens: number;
+    capacity: number | string;
+};
+
+declare type V3UMLReachabilityGraphMarking = {
+    isInitialMarking: boolean;
+};
+
+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 { }