@qwanyx/stack 0.2.66 → 0.2.68

package/dist/auth/index.d.ts

@@ -1,7 +1,44 @@
 /**
- * Generic authentication manager
- * Handles token storage and retrieval
+ * Authentication Module
+ * Handles token storage, user management, and API authentication
  */
+export interface AuthUser {
+    _id: string;
+    email: string;
+    role: string;
+    [key: string]: any;
+}
+export interface LoginResult {
+    success: boolean;
+    user?: AuthUser;
+    token?: string;
+    error?: string;
+    requiresVerification?: boolean;
+}
+export interface RegisterResult {
+    success: boolean;
+    userId?: string;
+    email?: string;
+    error?: string;
+    requiresVerification?: boolean;
+}
+export interface VerifyEmailResult {
+    success: boolean;
+    user?: AuthUser;
+    token?: string;
+    error?: string;
+}
+export interface PasswordResetResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface AuthServiceConfig {
+    apiUrl: string;
+    systemId?: string;
+    onLogin?: (user: AuthUser) => void;
+    onLogout?: () => void;
+}
 export declare class AuthManager {
     /**
      * Store authentication token
@@ -31,4 +68,85 @@ export declare class AuthManager {
      * Get authorization header
      */
     static getAuthHeader(): Record<string, string>;
+    /**
+     * Store user data
+     */
+    static setUser(user: AuthUser): void;
+    /**
+     * Get stored user data
+     */
+    static getUser(): AuthUser | null;
+    /**
+     * Clear user data
+     */
+    static clearUser(): void;
+    /**
+     * Clear all auth data
+     */
+    static clearAll(): void;
+}
+export declare class AuthService {
+    private config;
+    constructor(config: AuthServiceConfig);
+    /**
+     * Register a new user with email and password
+     * Sends verification code to email
+     */
+    register(email: string, password: string, options?: {
+        firstName?: string;
+        lastName?: string;
+        phone?: string;
+    }): Promise<RegisterResult>;
+    /**
+     * Verify email with code received by email
+     * Returns token on success (auto-login)
+     */
+    verifyEmail(email: string, code: string): Promise<VerifyEmailResult>;
+    /**
+     * Request password reset code sent to email
+     */
+    requestPasswordReset(email: string): Promise<PasswordResetResult>;
+    /**
+     * Set new password using verification code
+     * Returns token on success (auto-login)
+     */
+    setPasswordWithCode(email: string, code: string, password: string): Promise<VerifyEmailResult>;
+    /**
+     * Login with email and password
+     * Uses system coprocessor for authentication
+     */
+    login(email: string, password: string): Promise<LoginResult>;
+    /**
+     * Resend verification code to email
+     * (Uses same endpoint as password reset)
+     */
+    resendVerificationCode(email: string): Promise<PasswordResetResult>;
+    /**
+     * Logout - clear all auth data
+     */
+    logout(): void;
+    /**
+     * Check if user has a specific role in a group
+     */
+    checkRole(groupId: string, userId: string): Promise<string | null>;
+    /**
+     * Check if user is admin for current system
+     */
+    isAdmin(userId: string): Promise<boolean>;
+    /**
+     * Get current user from storage
+     */
+    getCurrentUser(): AuthUser | null;
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated(): boolean;
 }
+/**
+ * Initialize the auth service
+ */
+export declare function initializeAuthService(config: AuthServiceConfig): AuthService;
+/**
+ * Get the auth service instance
+ */
+export declare function getAuthService(): AuthService;

package/dist/components/AuthFlow.d.ts

@@ -0,0 +1,57 @@
+import { ReactNode } from 'react';
+import { LoginFormTheme } from './LoginForm';
+export type AuthFlowState = 'login' | 'register' | 'verify-email' | 'forgot-password' | 'verify-reset-code' | 'reset-password';
+export interface AuthFlowTheme extends LoginFormTheme {
+}
+export interface AuthFlowProps {
+    onLogin: (email: string, password: string) => Promise<{
+        success: boolean;
+        error?: string;
+        requiresVerification?: boolean;
+    }>;
+    onRegister: (email: string, password: string, options?: {
+        firstName?: string;
+        lastName?: string;
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+        requiresVerification?: boolean;
+    }>;
+    onVerifyEmail: (email: string, code: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    onRequestPasswordReset: (email: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    onResetPassword: (email: string, code: string, password: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    onResendCode?: (email: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    onSuccess?: () => void;
+    initialState?: AuthFlowState;
+    logo?: ReactNode;
+    theme?: AuthFlowTheme;
+    showNameFields?: boolean;
+    className?: string;
+    isModal?: boolean;
+    labels?: {
+        loginTitle?: string;
+        registerTitle?: string;
+        verifyTitle?: string;
+        forgotPasswordTitle?: string;
+        resetPasswordTitle?: string;
+    };
+}
+export declare function AuthFlow({ onLogin, onRegister, onVerifyEmail, onRequestPasswordReset, onResetPassword, onResendCode, onSuccess, initialState, logo, theme, showNameFields, className, isModal, labels, }: AuthFlowProps): import("react/jsx-runtime").JSX.Element;
+export interface AuthFlowModalProps extends AuthFlowProps {
+    isOpen: boolean;
+    onClose: () => void;
+    backdropBlur?: boolean;
+}
+export declare function AuthFlowModal({ isOpen, onClose, backdropBlur, ...flowProps }: AuthFlowModalProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/AuthProvider.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { AuthUser, LoginResult, RegisterResult, VerifyEmailResult, PasswordResetResult } from '../auth';
+export interface AuthContextType {
+    user: AuthUser | null;
+    token: string | null;
+    isAdmin: boolean;
+    loading: boolean;
+    login: (email: string, password: string) => Promise<LoginResult>;
+    register: (email: string, password: string, options?: {
+        firstName?: string;
+        lastName?: string;
+    }) => Promise<RegisterResult>;
+    verifyEmail: (email: string, code: string) => Promise<VerifyEmailResult>;
+    requestPasswordReset: (email: string) => Promise<PasswordResetResult>;
+    setPasswordWithCode: (email: string, code: string, password: string) => Promise<VerifyEmailResult>;
+    resendVerificationCode: (email: string) => Promise<PasswordResetResult>;
+    logout: () => void;
+    refreshUser: () => void;
+}
+export interface AuthProviderConfig {
+    apiUrl: string;
+    systemId: string;
+    children: ReactNode;
+}
+export declare function AuthProvider({ apiUrl, systemId, children }: AuthProviderConfig): import("react/jsx-runtime").JSX.Element;
+export declare function useAuth(): AuthContextType;

package/dist/components/ComboStack.d.ts

@@ -12,12 +12,16 @@ export interface ComboStackOption {
 export interface ComboStackProps {
     /** Available options */
     options: ComboStackOption[];
+    /** Currently selected value (id) */
+    value?: string;
     /** Type of items (for create modal) */
     type?: 'project' | 'contact' | 'folder' | 'context' | 'focus' | string;
     /** Placeholder text for search */
     placeholder?: string;
     /** Called when an item is clicked */
     onItemClick?: (option: ComboStackOption) => void;
+    /** Called when selection is cleared */
+    onClear?: () => void;
     /** Called when + is clicked to create new item */
     onCreate?: () => void;
     /** Max height before scrolling (default: 300px) */
@@ -36,4 +40,4 @@ export interface ComboStackTheme {
     border?: string;
     primary?: string;
 }
-export declare function ComboStack({ options, type, placeholder, onItemClick, onCreate, maxHeight, className, theme: themeProp, }: ComboStackProps): import("react/jsx-runtime").JSX.Element;
+export declare function ComboStack({ options, value, type, placeholder, onItemClick, onClear, onCreate, maxHeight, className, theme: themeProp, }: ComboStackProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ForgotPasswordForm.d.ts

@@ -0,0 +1,32 @@
+export interface ForgotPasswordFormTheme {
+    primaryColor?: string;
+    primaryHoverColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    textMutedColor?: string;
+    borderColor?: string;
+    errorColor?: string;
+    errorBackgroundColor?: string;
+    successColor?: string;
+    successBackgroundColor?: string;
+    inputBackground?: string;
+    borderRadius?: string;
+}
+export interface ForgotPasswordFormProps {
+    onRequestReset: (email: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    onSuccess?: (email: string) => void;
+    onBackClick?: () => void;
+    title?: string;
+    subtitle?: string;
+    submitText?: string;
+    loadingText?: string;
+    emailLabel?: string;
+    backText?: string;
+    theme?: ForgotPasswordFormTheme;
+    className?: string;
+    isModal?: boolean;
+}
+export declare function ForgotPasswordForm({ onRequestReset, onSuccess, onBackClick, title, subtitle, submitText, loadingText, emailLabel, backText, theme: customTheme, className, isModal, }: ForgotPasswordFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/LoginForm.d.ts

@@ -0,0 +1,50 @@
+import { ReactNode } from 'react';
+export interface LoginFormTheme {
+    primaryColor?: string;
+    primaryHoverColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    textMutedColor?: string;
+    borderColor?: string;
+    errorColor?: string;
+    errorBackgroundColor?: string;
+    inputBackground?: string;
+    borderRadius?: string;
+}
+export interface LoginFormProps {
+    /** Function to handle login - should return { success, error? } */
+    onLogin: (email: string, password: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Callback after successful login */
+    onSuccess?: () => void;
+    /** Logo element to display at top */
+    logo?: ReactNode;
+    /** Title text (default: "Connexion") */
+    title?: string;
+    /** Submit button text (default: "Se connecter") */
+    submitText?: string;
+    /** Loading text (default: "Connexion...") */
+    loadingText?: string;
+    /** Email label (default: "Email") */
+    emailLabel?: string;
+    /** Password label (default: "Mot de passe") */
+    passwordLabel?: string;
+    /** Theme customization */
+    theme?: LoginFormTheme;
+    /** Additional class name for the form container */
+    className?: string;
+    /** Whether this is displayed in a modal (adds shadow/rounding) */
+    isModal?: boolean;
+}
+export declare function LoginForm({ onLogin, onSuccess, logo, title, submitText, loadingText, emailLabel, passwordLabel, theme: customTheme, className, isModal, }: LoginFormProps): import("react/jsx-runtime").JSX.Element;
+export interface LoginModalProps extends LoginFormProps {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Callback to close the modal */
+    onClose: () => void;
+    /** Backdrop blur (default: true) */
+    backdropBlur?: boolean;
+}
+export declare function LoginModal({ isOpen, onClose, backdropBlur, ...formProps }: LoginModalProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/QMap/QMap.d.ts

@@ -0,0 +1,14 @@
+/**
+ * QMap - 2D Graph Visualization Component
+ *
+ * A powerful graph/mindmap component for visualizing and editing
+ * node-edge graphs with:
+ * - React component rendering for nodes
+ * - SVG edges (bezier, orthogonal, straight)
+ * - Zoom and pan (d3-zoom)
+ * - Multi-selection with rubber-band
+ * - Node dragging
+ */
+import { GraphNode } from '../../types';
+import type { QMapProps } from './types';
+export declare function QMap<T extends GraphNode = GraphNode>({ viewNode, nodes, edges, renderNode, defaultNodeWidth, defaultNodeHeight, onNodeMove, onNodeClick, onNodeDoubleClick, onNodeContextMenu, onSelectionChange, onEdgeClick, onViewChange, onTransformChange, minZoom, maxZoom, initialTransform, defaultEdgeStyle, defaultEdgeColor, defaultEdgeWidth, draggable, selectable, zoomable, pannable, className, style, background, showGrid, gridSize }: QMapProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/QMap/QMapEdge.d.ts

@@ -0,0 +1,21 @@
+/**
+ * QMapEdge - Individual edge SVG path component
+ *
+ * Renders a single edge between two nodes with:
+ * - Configurable style (bezier, orthogonal, straight)
+ * - Configurable color and width
+ * - Click handling
+ * - Hover feedback
+ */
+import React from 'react';
+import type { QMapEdge as QMapEdgeType, QMapNodePosition, EdgeStyle } from './types';
+export interface QMapEdgeProps {
+    edge: QMapEdgeType;
+    sourcePosition: QMapNodePosition;
+    targetPosition: QMapNodePosition;
+    style: EdgeStyle;
+    color: string;
+    width: number;
+    onClick?: (edge: QMapEdgeType, event: React.MouseEvent) => void;
+}
+export declare const QMapEdge: React.NamedExoticComponent<QMapEdgeProps>;

package/dist/components/QMap/QMapEdgeLayer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * QMapEdgeLayer - SVG container for all edges
+ *
+ * Renders all edges in a single SVG element for performance.
+ * Positioned absolutely to overlay the node layer.
+ */
+import React from 'react';
+import type { QMapEdge as QMapEdgeType, QMapNodePosition, EdgeStyle } from './types';
+export interface QMapEdgeLayerProps {
+    edges: QMapEdgeType[];
+    nodePositions: Map<string, QMapNodePosition>;
+    defaultStyle: EdgeStyle;
+    defaultColor: string;
+    defaultWidth: number;
+    onEdgeClick?: (edge: QMapEdgeType, event: React.MouseEvent) => void;
+}
+export declare const QMapEdgeLayer: React.NamedExoticComponent<QMapEdgeLayerProps>;

package/dist/components/QMap/QMapNode.d.ts

@@ -0,0 +1,24 @@
+/**
+ * QMapNode - Individual node wrapper for QMap
+ *
+ * Handles:
+ * - Absolute positioning based on position data
+ * - Rotation via CSS transform
+ * - Drag initiation
+ * - Selection visual state
+ */
+import React from 'react';
+import type { QMapNodePosition } from './types';
+export interface QMapNodeProps {
+    nodeId: string;
+    position: QMapNodePosition;
+    isSelected: boolean;
+    isDragging: boolean;
+    draggable: boolean;
+    onDragStart: (nodeId: string, event: React.MouseEvent) => void;
+    onClick?: (event: React.MouseEvent) => void;
+    onDoubleClick?: (event: React.MouseEvent) => void;
+    onContextMenu?: (event: React.MouseEvent) => void;
+    children: React.ReactNode;
+}
+export declare const QMapNode: React.NamedExoticComponent<QMapNodeProps>;

package/dist/components/QMap/QMapSelectionBox.d.ts

@@ -0,0 +1,19 @@
+/**
+ * QMapSelectionBox - Rubber-band selection rectangle
+ *
+ * Renders a semi-transparent selection box during marquee selection.
+ * Positioned in canvas coordinates but rendered in screen space.
+ */
+import type { QMapTransform } from './types';
+export interface QMapSelectionBoxProps {
+    /** Selection box in canvas coordinates */
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Current transform for converting to screen space */
+    transform: QMapTransform;
+}
+export declare const QMapSelectionBox: import("react").NamedExoticComponent<QMapSelectionBoxProps>;

package/dist/components/QMap/hooks/useNodeDrag.d.ts

@@ -0,0 +1,17 @@
+/**
+ * useNodeDrag - Node dragging hook for QMap
+ *
+ * Handles individual node dragging with:
+ * - Mouse down/move/up events
+ * - Transform-aware coordinate conversion
+ * - Drag state tracking
+ */
+import type { QMapTransform, UseNodeDragReturn } from '../types';
+export interface UseNodeDragOptions {
+    transform: QMapTransform;
+    onDragStart?: (nodeId: string) => void;
+    onDragMove?: (nodeId: string, x: number, y: number, deltaX: number, deltaY: number) => void;
+    onDragEnd?: (nodeId: string, x: number, y: number) => void;
+    disabled?: boolean;
+}
+export declare function useNodeDrag(options: UseNodeDragOptions): UseNodeDragReturn;

package/dist/components/QMap/hooks/useSelection.d.ts

@@ -0,0 +1,17 @@
+/**
+ * useSelection - Multi-selection hook for QMap
+ *
+ * Handles:
+ * - Rubber-band (marquee) selection by dragging on background
+ * - Click to select single node
+ * - Shift+click for additive selection
+ * - Select all / clear selection
+ */
+import type { QMapTransform, QMapNodePosition, UseSelectionReturn } from '../types';
+export interface UseSelectionOptions {
+    transform: QMapTransform;
+    nodePositions: Map<string, QMapNodePosition>;
+    disabled?: boolean;
+    onSelectionChange?: (selectedIds: string[]) => void;
+}
+export declare function useSelection(options: UseSelectionOptions): UseSelectionReturn;

package/dist/components/QMap/hooks/useZoomPan.d.ts

@@ -0,0 +1,19 @@
+/**
+ * useZoomPan - d3-zoom integration hook for QMap
+ *
+ * Handles zoom/pan with:
+ * - Mouse wheel zoom
+ * - Touch pinch zoom
+ * - Pan by dragging background
+ * - Smooth transitions
+ */
+import type { QMapTransform, UseZoomPanReturn } from '../types';
+export interface UseZoomPanOptions {
+    minZoom?: number;
+    maxZoom?: number;
+    initialTransform?: QMapTransform;
+    zoomable?: boolean;
+    pannable?: boolean;
+    onTransformChange?: (transform: QMapTransform) => void;
+}
+export declare function useZoomPan(options?: UseZoomPanOptions): UseZoomPanReturn;

package/dist/components/QMap/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * QMap - 2D Graph Visualization Component
+ *
+ * @qwanyx/stack component for visualizing and editing node-edge graphs.
+ */
+export { QMap } from './QMap';
+export { QMapNode } from './QMapNode';
+export { QMapEdge as QMapEdgeComponent } from './QMapEdge';
+export { QMapEdgeLayer } from './QMapEdgeLayer';
+export { QMapSelectionBox } from './QMapSelectionBox';
+export { useZoomPan } from './hooks/useZoomPan';
+export { useNodeDrag } from './hooks/useNodeDrag';
+export { useSelection } from './hooks/useSelection';
+export * from './utils/geometry';
+export type { QMapProps, QMapNodePosition, QMapTransform, QMapViewData, QMapEdge, EdgeStyle, QMapNodeProps, QMapEdgeLayerProps, QMapEdgeProps, QMapSelectionBoxProps, UseZoomPanReturn, UseSelectionReturn, UseNodeDragReturn } from './types';

package/dist/components/QMap/types.d.ts

@@ -0,0 +1,158 @@
+/**
+ * QMap - 2D Graph Visualization Component Types
+ */
+import { ReactNode } from 'react';
+import { GraphNode } from '../../types';
+export interface QMapNodePosition {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    rotation?: number;
+}
+export interface QMapTransform {
+    x: number;
+    y: number;
+    k: number;
+}
+export interface QMapViewData {
+    /** Node positions keyed by node._id */
+    positions: Record<string, QMapNodePosition>;
+    /** Current viewport transform */
+    transform?: QMapTransform;
+    /** Per-edge style overrides keyed by edge id */
+    edgeStyles?: Record<string, EdgeStyle>;
+}
+export type EdgeStyle = 'bezier' | 'orthogonal' | 'straight';
+export interface QMapEdge {
+    id: string;
+    source: string;
+    target: string;
+    style?: EdgeStyle;
+    label?: string;
+    color?: string;
+    width?: number;
+    data?: Record<string, any>;
+}
+export interface QMapProps<T extends GraphNode = GraphNode> {
+    /** Parent view node containing positions in data.positions */
+    viewNode: GraphNode;
+    /** Nodes to display on the map */
+    nodes: T[];
+    /** Edges connecting nodes */
+    edges: QMapEdge[];
+    /** Custom node renderer */
+    renderNode: (node: T, isSelected: boolean, position: QMapNodePosition) => ReactNode;
+    /** Default node dimensions when not specified in position */
+    defaultNodeWidth?: number;
+    defaultNodeHeight?: number;
+    onNodeMove?: (nodeId: string, x: number, y: number) => void;
+    onNodeClick?: (node: T, event: React.MouseEvent) => void;
+    onNodeDoubleClick?: (node: T, event: React.MouseEvent) => void;
+    onNodeContextMenu?: (node: T, event: React.MouseEvent) => void;
+    onSelectionChange?: (selectedIds: string[]) => void;
+    onEdgeClick?: (edge: QMapEdge, event: React.MouseEvent) => void;
+    onViewChange?: (viewData: QMapViewData) => void;
+    onTransformChange?: (transform: QMapTransform) => void;
+    minZoom?: number;
+    maxZoom?: number;
+    initialTransform?: QMapTransform;
+    defaultEdgeStyle?: EdgeStyle;
+    defaultEdgeColor?: string;
+    defaultEdgeWidth?: number;
+    /** Allow nodes to be dragged */
+    draggable?: boolean;
+    /** Allow multi-select with rubber-band */
+    selectable?: boolean;
+    /** Allow zoom with wheel */
+    zoomable?: boolean;
+    /** Allow pan by dragging background */
+    pannable?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    /** Background color or pattern */
+    background?: string;
+    /** Show grid pattern */
+    showGrid?: boolean;
+    gridSize?: number;
+}
+export interface QMapNodeProps<T extends GraphNode = GraphNode> {
+    node: T;
+    position: QMapNodePosition;
+    isSelected: boolean;
+    isDragging: boolean;
+    transform: QMapTransform;
+    draggable: boolean;
+    onDragStart: (nodeId: string, event: React.MouseEvent) => void;
+    onDragMove: (nodeId: string, deltaX: number, deltaY: number) => void;
+    onDragEnd: (nodeId: string) => void;
+    onClick?: (node: T, event: React.MouseEvent) => void;
+    onDoubleClick?: (node: T, event: React.MouseEvent) => void;
+    onContextMenu?: (node: T, event: React.MouseEvent) => void;
+    children: ReactNode;
+}
+export interface QMapEdgeLayerProps {
+    edges: QMapEdge[];
+    nodePositions: Map<string, QMapNodePosition>;
+    defaultStyle: EdgeStyle;
+    defaultColor: string;
+    defaultWidth: number;
+    onEdgeClick?: (edge: QMapEdge, event: React.MouseEvent) => void;
+}
+export interface QMapEdgeProps {
+    edge: QMapEdge;
+    sourcePosition: QMapNodePosition;
+    targetPosition: QMapNodePosition;
+    style: EdgeStyle;
+    color: string;
+    width: number;
+    onClick?: (edge: QMapEdge, event: React.MouseEvent) => void;
+}
+export interface QMapSelectionBoxProps {
+    /** Selection box in canvas coordinates */
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Current transform for converting to screen space */
+    transform: QMapTransform;
+}
+export interface UseZoomPanReturn {
+    transform: QMapTransform;
+    containerRef: React.RefObject<HTMLDivElement>;
+    zoomTo: (x: number, y: number, scale: number, animate?: boolean) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    resetZoom: () => void;
+    fitToContent: (nodes: QMapNodePosition[], padding?: number) => void;
+}
+export interface UseSelectionReturn {
+    selectedIds: Set<string>;
+    setSelectedIds: React.Dispatch<React.SetStateAction<Set<string>>>;
+    selectionBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    isSelecting: boolean;
+    startSelection: (event: React.MouseEvent) => void;
+    updateSelection: (event: React.MouseEvent) => void;
+    endSelection: () => void;
+    toggleSelect: (nodeId: string, additive?: boolean) => void;
+    selectAll: () => void;
+    clearSelection: () => void;
+}
+export interface UseNodeDragReturn {
+    draggedNodeId: string | null;
+    isDragging: boolean;
+    dragOffset: {
+        x: number;
+        y: number;
+    };
+    startDrag: (nodeId: string, event: React.MouseEvent) => void;
+    updateDrag: (event: React.MouseEvent) => void;
+    endDrag: () => void;
+}