@nice2dev/ui-science 1.0.10

package/dist/index.d.ts

@@ -0,0 +1,1461 @@
+import { default as default_2 } from 'react';
+
+export declare type AnalysisId = string;
+
+/** Analysis result */
+export declare interface AnalysisResult {
+    id: AnalysisId;
+    datasetId: DatasetId;
+    type: AnalysisType;
+    parameters: Record<string, any>;
+    result: any;
+    createdAt: string;
+    executionTimeMs: number;
+}
+
+export declare type AnalysisType = 'descriptive' | 'correlation' | 'regression' | 'ttest' | 'anova' | 'chi-square' | 'pca' | 'clustering' | 'distribution' | 'time-series';
+
+export declare interface Animation3D {
+    enabled: boolean;
+    duration?: number;
+    loop?: boolean;
+    frames?: Array<{
+        data: Plot3DData[];
+        name?: string;
+        duration?: number;
+    }>;
+    autoPlay?: boolean;
+}
+
+export declare interface AnnotationConfig {
+    id: string;
+    type: 'line' | 'band' | 'point' | 'text' | 'arrow' | 'box' | 'ellipse';
+    position: {
+        x?: number | string | Date;
+        y?: number;
+        x2?: number | string | Date;
+        y2?: number;
+        xRef?: 'data' | 'paper';
+        yRef?: 'data' | 'paper';
+    };
+    text?: string;
+    style?: {
+        color?: string;
+        fillColor?: string;
+        opacity?: number;
+        lineWidth?: number;
+        lineStyle?: 'solid' | 'dashed' | 'dotted';
+        fontSize?: number;
+        fontWeight?: 'normal' | 'bold';
+    };
+    draggable?: boolean;
+    visible?: boolean;
+}
+
+export declare interface Atom {
+    id: number;
+    element: string;
+    x: number;
+    y: number;
+    z: number;
+    serial?: number;
+    name?: string;
+    residueName?: string;
+    residueSeq?: number;
+    chainId?: string;
+    occupancy?: number;
+    bFactor?: number;
+    charge?: number;
+    mass?: number;
+    radius?: number;
+    color?: string;
+    selected?: boolean;
+    visible?: boolean;
+}
+
+/** Attachment */
+export declare interface Attachment {
+    id: AttachmentId;
+    name: string;
+    type: string;
+    size: number;
+    url: string;
+    uploadedAt: string;
+    uploadedBy: UserId;
+    checksum?: string;
+}
+
+export declare type AttachmentId = string;
+
+/** Author information */
+export declare interface Author {
+    given: string;
+    family: string;
+    orcid?: string;
+    affiliation?: string;
+}
+
+export declare interface Axis3DConfig {
+    title?: string;
+    range?: [number, number];
+    tickFormat?: string;
+    gridColor?: string;
+    gridWidth?: number;
+    showGrid?: boolean;
+    showLine?: boolean;
+    showTickLabels?: boolean;
+    nticks?: number;
+    autoRange?: boolean | 'reversed';
+}
+
+export declare interface AxisConfig {
+    id: string;
+    type: ScaleType;
+    position: 'left' | 'right' | 'top' | 'bottom';
+    label?: string;
+    unit?: string;
+    min?: number | 'auto';
+    max?: number | 'auto';
+    gridLines?: boolean;
+    tickFormat?: string | ((v: any) => string);
+    tickCount?: number;
+    tickValues?: number[];
+    reversed?: boolean;
+}
+
+export declare interface Bond {
+    id: number;
+    atom1: number;
+    atom2: number;
+    order: 1 | 2 | 3 | 4;
+    type?: 'covalent' | 'hydrogen' | 'ionic' | 'metallic' | 'disulfide';
+    length?: number;
+    color?: string;
+    visible?: boolean;
+}
+
+export declare type BranchStyle = 'rectangular' | 'diagonal' | 'curved' | 'straight';
+
+export declare interface Camera3D {
+    eye: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    center: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    up: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    projection?: 'perspective' | 'orthographic';
+    fov?: number;
+}
+
+export declare interface Chain {
+    id: string;
+    residues: number[];
+    type?: 'protein' | 'dna' | 'rna' | 'ligand' | 'water' | 'ion';
+    color?: string;
+}
+
+export declare type ChartType = 'scatter' | 'line' | 'bar' | 'histogram' | 'box-plot' | 'violin' | 'area' | 'bubble' | 'contour' | 'heatmap' | 'polar' | 'radar';
+
+/** Citation/Reference entry */
+export declare interface Citation {
+    id: CitationId;
+    type: ReferenceType;
+    title: string;
+    authors: Author[];
+    year?: number;
+    month?: number;
+    day?: number;
+    journal?: string;
+    volume?: string;
+    issue?: string;
+    pages?: string;
+    publisher?: string;
+    edition?: string;
+    doi?: string;
+    isbn?: string;
+    issn?: string;
+    pmid?: string;
+    arxiv?: string;
+    url?: string;
+    abstract?: string;
+    keywords?: string[];
+    language?: string;
+    accessed?: string;
+    booktitle?: string;
+    conference?: string;
+    location?: string;
+    school?: string;
+    degree?: string;
+    notes?: string;
+    tags?: string[];
+    collections?: CollectionId[];
+    createdAt: string;
+    updatedAt: string;
+    sourceDatabase?: string;
+}
+
+/** Citation collection/folder */
+export declare interface CitationCollection {
+    id: CollectionId;
+    name: string;
+    description?: string;
+    parentId?: CollectionId;
+    color?: string;
+    citationCount: number;
+    createdAt: string;
+}
+
+declare interface CitationContextValue {
+    service: CitationService;
+    citations: Citation[];
+    collections: CitationCollection[];
+    selectedCollection: CollectionId;
+    setSelectedCollection: (id: CollectionId) => void;
+    selectedCitation: CitationId | null;
+    setSelectedCitation: (id: CitationId | null) => void;
+    searchQuery: string;
+    setSearchQuery: (query: string) => void;
+    citationStyle: CitationStyle;
+    setCitationStyle: (style: CitationStyle) => void;
+    refresh: () => void;
+}
+
+export declare type CitationId = string;
+
+export declare class CitationService {
+    private config;
+    private citations;
+    private collections;
+    constructor(config?: CitationServiceConfig);
+    /** Add citation */
+    addCitation(data: Partial<Citation>): Citation;
+    /** Update citation */
+    updateCitation(id: CitationId, data: Partial<Citation>): Citation;
+    /** Delete citation */
+    deleteCitation(id: CitationId): void;
+    /** Get citation */
+    getCitation(id: CitationId): Citation | undefined;
+    /** Search citations */
+    searchCitations(query: string, options?: {
+        collection?: CollectionId;
+        type?: ReferenceType;
+        year?: number;
+        tags?: string[];
+    }): Citation[];
+    /** List all citations */
+    listCitations(collectionId?: CollectionId): Citation[];
+    /** Create collection */
+    createCollection(data: Partial<CitationCollection>): CitationCollection;
+    /** List collections */
+    listCollections(): CitationCollection[];
+    /** Format citation */
+    formatCitation(id: CitationId, style: CitationStyle): string;
+    /** Format multiple citations as bibliography */
+    formatBibliography(ids: CitationId[], style: CitationStyle): string;
+    /** Import from BibTeX */
+    importBibtex(content: string): Citation[];
+    private parseBibtexFields;
+    private parseBibtexAuthors;
+    /** Export as BibTeX */
+    exportBibtex(ids?: CitationId[]): string;
+    /** Search external databases */
+    searchDatabase(database: 'crossref' | 'pubmed', query: string, limit?: number): Promise<DatabaseSearchResult>;
+    private searchCrossref;
+    private searchPubMed;
+    /** Fetch citation by DOI */
+    fetchByDOI(doi: string): Promise<Citation | null>;
+    private updateCollectionCounts;
+    private generateId;
+}
+
+export declare interface CitationServiceConfig {
+    crossrefEmail?: string;
+    pubmedApiKey?: string;
+    semanticScholarApiKey?: string;
+    onError?: (error: Error) => void;
+}
+
+/** Citation style */
+export declare type CitationStyle = 'apa' | 'mla' | 'chicago' | 'harvard' | 'ieee' | 'vancouver' | 'nature' | 'science' | 'bibtex';
+
+export declare interface Clade {
+    id: string;
+    name: string;
+    nodeIds: string[];
+    color?: string;
+    background?: string;
+    showLabel?: boolean;
+}
+
+export declare type CollectionId = string;
+
+export declare type ColorScale = 'viridis' | 'plasma' | 'inferno' | 'magma' | 'cividis' | 'jet' | 'rainbow' | 'coolwarm' | 'RdBu' | 'spectral' | 'turbo' | 'grayscale';
+
+export declare type ColorScheme = 'element' | 'chain' | 'residue' | 'secondary' | 'bfactor' | 'hydrophobicity' | 'custom';
+
+/** Column definition */
+export declare interface ColumnDef {
+    name: ColumnName;
+    type: ColumnType;
+    nullable: boolean;
+    unique: number;
+    missing: number;
+    stats?: ColumnStats;
+}
+
+export declare type ColumnName = string;
+
+/** Statistics for numeric columns */
+export declare interface ColumnStats {
+    count: number;
+    mean?: number;
+    median?: number;
+    std?: number;
+    min?: number;
+    max?: number;
+    q1?: number;
+    q3?: number;
+    skewness?: number;
+    kurtosis?: number;
+    mode?: any;
+    variance?: number;
+}
+
+/** Column data types */
+export declare type ColumnType = 'number' | 'string' | 'boolean' | 'date' | 'category' | 'mixed';
+
+export declare interface ContourConfig {
+    data: Array<{
+        lat: number;
+        lng: number;
+        value: number;
+    }>;
+    levels: number[];
+    colors?: string[];
+    showLabels?: boolean;
+    smoothing?: number;
+}
+
+export declare function createCitationService(config?: CitationServiceConfig): CitationService;
+
+export declare function createDataAnalysisService(config?: DataAnalysisServiceConfig): DataAnalysisService;
+
+export declare function createLabNotebookService(config: LabNotebookServiceConfig): LabNotebookService;
+
+/** Custom field definition */
+export declare interface CustomField {
+    id: string;
+    name: string;
+    type: 'text' | 'number' | 'date' | 'select' | 'multiselect' | 'checkbox';
+    required: boolean;
+    options?: string[];
+    defaultValue?: any;
+}
+
+export declare class DataAnalysisService {
+    private config;
+    private datasets;
+    private analyses;
+    constructor(config?: DataAnalysisServiceConfig);
+    /** Import data from CSV */
+    importCSV(content: string, options?: {
+        delimiter?: string;
+        header?: boolean;
+        name?: string;
+    }): Promise<Dataset>;
+    /** Import data from JSON */
+    importJSON(content: string | object[], options?: {
+        name?: string;
+    }): Promise<Dataset>;
+    /** Create dataset */
+    createDataset(params: {
+        name: string;
+        data: Record<string, any>[];
+        description?: string;
+        source?: DataSource;
+    }): Dataset;
+    private inferColumns;
+    /** Run analysis */
+    runAnalysis(datasetId: DatasetId, type: AnalysisType, parameters?: Record<string, any>): AnalysisResult;
+    private descriptiveAnalysis;
+    private correlationAnalysis;
+    private regressionAnalysis;
+    private tTestAnalysis;
+    private distributionAnalysis;
+    /** Apply transformation */
+    transform(datasetId: DatasetId, transformation: Transformation): Dataset;
+    private applyFilter;
+    private applySort;
+    private applyFillNA;
+    private applyDropNA;
+    private applyNormalize;
+    private applyStandardize;
+    /** Export dataset */
+    exportCSV(datasetId: DatasetId): string;
+    /** Get dataset */
+    getDataset(id: DatasetId): Dataset | undefined;
+    /** List datasets */
+    listDatasets(): Dataset[];
+    private generateId;
+}
+
+export declare interface DataAnalysisServiceConfig {
+    maxRowsInMemory?: number;
+    onProgress?: (progress: number) => void;
+}
+
+/** Search result from external database */
+export declare interface DatabaseSearchResult {
+    source: 'crossref' | 'pubmed' | 'semanticscholar' | 'openalex';
+    total: number;
+    results: Partial<Citation>[];
+}
+
+export declare interface DataPoint {
+    x: number | string | Date;
+    y: number;
+    z?: number;
+    error?: number | [number, number];
+    label?: string;
+    color?: string;
+    size?: number;
+    meta?: Record<string, any>;
+}
+
+/** Entry data section */
+export declare interface DataSection {
+    id: string;
+    title: string;
+    type: 'text' | 'table' | 'image' | 'chart' | 'code' | 'formula' | 'file';
+    content: any;
+    order: number;
+}
+
+export declare interface DataSeries {
+    id: string;
+    name: string;
+    data: DataPoint[];
+    type?: ChartType;
+    color?: string;
+    marker?: MarkerConfig;
+    line?: LineConfig;
+    errorBars?: ErrorBar;
+    fill?: FillConfig;
+    visible?: boolean;
+    yAxisId?: string;
+    xAxisId?: string;
+    group?: string;
+}
+
+/** Dataset */
+export declare interface Dataset {
+    id: DatasetId;
+    name: string;
+    description?: string;
+    columns: ColumnDef[];
+    data: Record<string, any>[];
+    rowCount: number;
+    createdAt: string;
+    updatedAt: string;
+    source?: DataSource;
+}
+
+export declare type DatasetId = string;
+
+/** Data source info */
+export declare interface DataSource {
+    type: 'csv' | 'json' | 'excel' | 'api' | 'database' | 'manual';
+    path?: string;
+    url?: string;
+    query?: string;
+}
+
+/** Entry comment */
+export declare interface EntryComment {
+    id: string;
+    userId: UserId;
+    userName: string;
+    content: string;
+    createdAt: string;
+    replyTo?: string;
+}
+
+export declare type EntryId = string;
+
+/** Entry signature */
+export declare interface EntrySignature {
+    userId: UserId;
+    userName: string;
+    role: 'author' | 'witness' | 'reviewer' | 'approver';
+    signedAt: string;
+    reason?: string;
+    signatureHash: string;
+}
+
+/** Entry status */
+export declare type EntryStatus = 'draft' | 'in-progress' | 'completed' | 'reviewed' | 'signed' | 'locked';
+
+/** Entry template */
+export declare interface EntryTemplate {
+    id: string;
+    name: string;
+    type: EntryType;
+    sections: Omit<DataSection, 'id'>[];
+    customFields: Record<string, any>;
+}
+
+/** Entry types */
+export declare type EntryType = 'experiment' | 'protocol' | 'observation' | 'calculation' | 'meeting' | 'report' | 'note';
+
+export declare interface ErrorBar {
+    type: 'std' | 'sem' | 'ci95' | 'ci99' | 'custom';
+    direction: 'both' | 'positive' | 'negative';
+    value?: number;
+    valueLow?: number;
+    valueHigh?: number;
+}
+
+export declare interface ExportConfig {
+    formats: Array<'png' | 'svg' | 'pdf' | 'csv' | 'json'>;
+    dpi?: number;
+    width?: number;
+    height?: number;
+}
+
+export declare type FileFormat = 'pdb' | 'mol' | 'mol2' | 'sdf' | 'xyz' | 'cif' | 'mmcif';
+
+export declare interface FillConfig {
+    enabled: boolean;
+    color?: string;
+    opacity?: number;
+    target?: 'origin' | 'start' | 'end' | string;
+}
+
+export declare interface GeoCoordinate {
+    lat: number;
+    lng: number;
+}
+
+export declare interface GeoJSONFeature {
+    type: 'Feature';
+    geometry: {
+        type: 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon';
+        coordinates: any;
+    };
+    properties?: Record<string, any>;
+}
+
+export declare interface HeatmapConfig {
+    points: HeatmapPoint[];
+    radius?: number;
+    maxIntensity?: number;
+    gradient?: Record<number, string>;
+    opacity?: number;
+}
+
+export declare interface HeatmapPoint {
+    position: GeoCoordinate;
+    intensity: number;
+}
+
+export declare interface Label {
+    id: string;
+    text: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    atomId?: number;
+    residueId?: number;
+    fontSize?: number;
+    color?: string;
+    background?: string;
+}
+
+/** Lab notebook entry */
+export declare interface LabEntry {
+    id: EntryId;
+    notebookId: NotebookId;
+    type: EntryType;
+    status: EntryStatus;
+    title: string;
+    objective?: string;
+    hypothesis?: string;
+    methods?: string;
+    results?: string;
+    conclusions?: string;
+    sections: DataSection[];
+    attachments: Attachment[];
+    tags: string[];
+    linkedEntries: EntryId[];
+    createdAt: string;
+    updatedAt: string;
+    createdBy: UserId;
+    lastModifiedBy: UserId;
+    version: number;
+    signatures: EntrySignature[];
+    comments: EntryComment[];
+}
+
+/** Lab notebook */
+export declare interface LabNotebook {
+    id: NotebookId;
+    name: string;
+    description?: string;
+    project?: string;
+    owner: UserId;
+    collaborators: NotebookCollaborator[];
+    entries: LabEntry[];
+    createdAt: string;
+    updatedAt: string;
+    isArchived: boolean;
+    settings: NotebookSettings;
+}
+
+declare interface LabNotebookContextValue {
+    service: LabNotebookService;
+    notebooks: LabNotebook[];
+    currentNotebook: LabNotebook | null;
+    currentEntry: LabEntry | null;
+    setCurrentNotebook: (id: NotebookId | null) => void;
+    setCurrentEntry: (id: EntryId | null) => void;
+    refresh: () => Promise<void>;
+}
+
+export declare function LabNotebookProvider({ service, children, }: LabNotebookProviderProps): default_2.ReactElement;
+
+export declare interface LabNotebookProviderProps {
+    service: LabNotebookService;
+    children: default_2.ReactNode;
+}
+
+export declare class LabNotebookService {
+    private config;
+    private notebooks;
+    constructor(config: LabNotebookServiceConfig);
+    /** Create new notebook */
+    createNotebook(data: Partial<LabNotebook>): Promise<LabNotebook>;
+    /** Get notebook by ID */
+    getNotebook(id: NotebookId): Promise<LabNotebook | null>;
+    /** List all notebooks */
+    listNotebooks(): Promise<LabNotebook[]>;
+    /** Create new entry */
+    createEntry(notebookId: NotebookId, data: Partial<LabEntry>): Promise<LabEntry>;
+    /** Update entry */
+    updateEntry(notebookId: NotebookId, entryId: EntryId, data: Partial<LabEntry>): Promise<LabEntry>;
+    /** Sign entry */
+    signEntry(notebookId: NotebookId, entryId: EntryId, signature: Omit<EntrySignature, 'signedAt' | 'signatureHash'>): Promise<LabEntry>;
+    /** Add attachment to entry */
+    addAttachment(notebookId: NotebookId, entryId: EntryId, file: File): Promise<Attachment>;
+    /** Search entries */
+    searchEntries(query: string, filters?: {
+        notebookId?: NotebookId;
+        type?: EntryType;
+        status?: EntryStatus;
+        tags?: string[];
+        dateFrom?: string;
+        dateTo?: string;
+    }): Promise<LabEntry[]>;
+    /** Export entry to PDF/HTML */
+    exportEntry(notebookId: NotebookId, entryId: EntryId, format: 'pdf' | 'html' | 'docx'): Promise<Blob>;
+    private generateEntryHTML;
+    private generateId;
+    private generateSignatureHash;
+}
+
+export declare interface LabNotebookServiceConfig {
+    apiUrl: string;
+    authToken?: string;
+    onError?: (error: Error) => void;
+}
+
+export declare interface LegendConfig {
+    show: boolean;
+    position: 'top' | 'bottom' | 'left' | 'right' | 'inside';
+    orientation: 'horizontal' | 'vertical';
+    interactive?: boolean;
+}
+
+export declare interface LineConfig {
+    style: 'solid' | 'dashed' | 'dotted' | 'dash-dot';
+    width: number;
+    color?: string;
+    interpolation?: 'linear' | 'step' | 'stepBefore' | 'stepAfter' | 'basis' | 'cardinal' | 'monotone';
+    tension?: number;
+}
+
+export declare interface MapBounds {
+    north: number;
+    south: number;
+    east: number;
+    west: number;
+}
+
+export declare interface MapLayer {
+    id: string;
+    name: string;
+    visible: boolean;
+    opacity?: number;
+    zIndex?: number;
+    markers?: MapMarker[];
+    polylines?: MapPolyline[];
+    polygons?: MapPolygon[];
+    geojson?: GeoJSONFeature[];
+    heatmap?: HeatmapConfig;
+    contour?: ContourConfig;
+}
+
+export declare interface MapLegend {
+    title?: string;
+    items: Array<{
+        color: string;
+        label: string;
+        shape?: 'circle' | 'square' | 'line';
+    }>;
+    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+}
+
+export declare interface MapMarker {
+    id: string;
+    position: GeoCoordinate;
+    label?: string;
+    color?: string;
+    size?: number;
+    shape?: 'circle' | 'square' | 'triangle' | 'diamond' | 'pin';
+    data?: Record<string, any>;
+    tooltip?: string;
+    icon?: string;
+    cluster?: string;
+}
+
+export declare interface MapPolygon {
+    id: string;
+    path: GeoCoordinate[];
+    fillColor?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    fillOpacity?: number;
+    label?: string;
+    data?: Record<string, any>;
+}
+
+export declare interface MapPolyline {
+    id: string;
+    path: GeoCoordinate[];
+    color?: string;
+    width?: number;
+    style?: 'solid' | 'dashed' | 'dotted';
+    label?: string;
+    arrows?: boolean;
+}
+
+export declare type MapProjection = 'mercator' | 'equirectangular' | 'orthographic' | 'robinson' | 'mollweide' | 'sinusoidal' | 'albers';
+
+export declare interface MarkerConfig {
+    shape: 'circle' | 'square' | 'triangle' | 'diamond' | 'cross' | 'plus' | 'star' | 'none';
+    size: number;
+    fillColor?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    opacity?: number;
+}
+
+export declare interface Measurement {
+    id: string;
+    type: 'distance' | 'angle' | 'dihedral';
+    atoms: number[];
+    value: number;
+    unit: string;
+    label?: string;
+    color?: string;
+}
+
+export declare interface Mesh3D {
+    id: string;
+    name: string;
+    type: 'mesh3d';
+    vertices: Point3D[];
+    faces: [number, number, number][];
+    faceColor?: string[];
+    vertexColor?: number[];
+    colorScale?: ColorScale;
+    flatShading?: boolean;
+    lighting?: SurfaceLighting;
+}
+
+export declare interface Molecule {
+    id: string;
+    name: string;
+    atoms: Atom[];
+    bonds: Bond[];
+    residues?: Residue[];
+    chains?: Chain[];
+    formula?: string;
+    molecularWeight?: number;
+    metadata?: Record<string, any>;
+}
+
+export declare function Nice3DPlot({ data, title, width, height, scene, showColorBar, animation, showLegend, legendPosition, enableRotation, enableZoom, enablePan, showAxes, showAxisLabels, focalLength, theme, onCameraChange, onPointClick, onPointHover, className, style, }: Nice3DPlotProps): default_2.ReactElement;
+
+export declare interface Nice3DPlotProps {
+    /** Plot data (surfaces, scatter, volumes, meshes) */
+    data: Plot3DData[];
+    /** Plot title */
+    title?: string;
+    /** Width */
+    width?: number | string;
+    /** Height */
+    height?: number | string;
+    /** Scene configuration */
+    scene?: Scene3DConfig;
+    /** Show colorbar */
+    showColorBar?: boolean;
+    /** Animation configuration */
+    animation?: Animation3D;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Legend position */
+    legendPosition?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    /** Enable mouse rotation */
+    enableRotation?: boolean;
+    /** Enable zoom */
+    enableZoom?: boolean;
+    /** Enable pan */
+    enablePan?: boolean;
+    /** Show axes */
+    showAxes?: boolean;
+    /** Show axis labels */
+    showAxisLabels?: boolean;
+    /** Focal length for perspective */
+    focalLength?: number;
+    /** Theme */
+    theme?: 'light' | 'dark' | 'scientific';
+    /** On camera change */
+    onCameraChange?: (camera: Camera3D) => void;
+    /** On point click */
+    onPointClick?: (point: Point3D, dataIndex: number) => void;
+    /** On point hover */
+    onPointHover?: (point: Point3D | null, dataIndex: number) => void;
+    /** Class name */
+    className?: string;
+    /** Style */
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceCitation({ service, className, style }: NiceCitationProps): default_2.ReactElement;
+
+export declare interface NiceCitationProps {
+    service: CitationService;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceDataAnalysis({ service, className, style, }: NiceDataAnalysisProps): default_2.ReactElement;
+
+export declare interface NiceDataAnalysisProps {
+    service: DataAnalysisService;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceGeographicMap({ projection, layers, markers, polylines, polygons, heatmap, bounds, center, zoom, showGraticule, graticuleInterval, showCoastlines, showBorders, landColor, oceanColor, borderColor, graticuleColor, width, height, enablePan, enableZoom, showControls, scaleBar, legend, showLayerControl, onMarkerClick, onMarkerHover, onMapClick, onPolygonClick, onBoundsChange, className, style, }: NiceGeographicMapProps): default_2.ReactElement;
+
+export declare interface NiceGeographicMapProps {
+    /** Map projection */
+    projection?: MapProjection;
+    /** Map layers */
+    layers?: MapLayer[];
+    /** Map markers (convenience prop) */
+    markers?: MapMarker[];
+    /** Map polylines (convenience prop) */
+    polylines?: MapPolyline[];
+    /** Map polygons (convenience prop) */
+    polygons?: MapPolygon[];
+    /** Heatmap config (convenience prop) */
+    heatmap?: HeatmapConfig;
+    /** Map bounds */
+    bounds?: MapBounds;
+    /** Center coordinate */
+    center?: GeoCoordinate;
+    /** Zoom level (1-20) */
+    zoom?: number;
+    /** Show graticule (lat/lng grid) */
+    showGraticule?: boolean;
+    /** Graticule interval in degrees */
+    graticuleInterval?: number;
+    /** Show coastlines */
+    showCoastlines?: boolean;
+    /** Show country borders */
+    showBorders?: boolean;
+    /** Land color */
+    landColor?: string;
+    /** Ocean color */
+    oceanColor?: string;
+    /** Border color */
+    borderColor?: string;
+    /** Graticule color */
+    graticuleColor?: string;
+    /** Width */
+    width?: number | string;
+    /** Height */
+    height?: number | string;
+    /** Enable pan */
+    enablePan?: boolean;
+    /** Enable zoom */
+    enableZoom?: boolean;
+    /** Show controls */
+    showControls?: boolean;
+    /** Scale bar config */
+    scaleBar?: ScaleBar;
+    /** Legend */
+    legend?: MapLegend;
+    /** Show layer control */
+    showLayerControl?: boolean;
+    /** On marker click */
+    onMarkerClick?: (marker: MapMarker) => void;
+    /** On marker hover */
+    onMarkerHover?: (marker: MapMarker | null) => void;
+    /** On map click */
+    onMapClick?: (coord: GeoCoordinate) => void;
+    /** On polygon click */
+    onPolygonClick?: (polygon: MapPolygon) => void;
+    /** On bounds change */
+    onBoundsChange?: (bounds: MapBounds) => void;
+    /** Class name */
+    className?: string;
+    /** Style */
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceLabNotebook({ service, className, style, }: NiceLabNotebookProps): default_2.ReactElement;
+
+export declare interface NiceLabNotebookProps {
+    service: LabNotebookService;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceMolecularViewer({ molecule, format, style, colorScheme, showHydrogens, showWaters, showLabels, labelType, width, height, backgroundColor, enableRotation, enableZoom, showControls, measurements, surfaces, labels, selection, highlightColor, spin, spinSpeed, onAtomClick, onAtomHover, onSelectionChange, className, styleOverride, }: NiceMolecularViewerProps): default_2.ReactElement;
+
+export declare interface NiceMolecularViewerProps {
+    /** Molecule data or PDB/MOL string */
+    molecule?: Molecule | string;
+    /** File format if molecule is string */
+    format?: FileFormat;
+    /** Rendering style */
+    style?: RenderStyle;
+    /** Color scheme */
+    colorScheme?: ColorScheme;
+    /** Show hydrogens */
+    showHydrogens?: boolean;
+    /** Show waters */
+    showWaters?: boolean;
+    /** Show labels */
+    showLabels?: boolean;
+    /** Label type */
+    labelType?: 'element' | 'name' | 'residue' | 'chain' | 'serial';
+    /** Width */
+    width?: number | string;
+    /** Height */
+    height?: number | string;
+    /** Background color */
+    backgroundColor?: string;
+    /** Enable rotation */
+    enableRotation?: boolean;
+    /** Enable zoom */
+    enableZoom?: boolean;
+    /** Show controls */
+    showControls?: boolean;
+    /** Measurements to display */
+    measurements?: Measurement[];
+    /** Surfaces to render */
+    surfaces?: Surface[];
+    /** Custom labels */
+    labels?: Label[];
+    /** Selection */
+    selection?: Selection_2;
+    /** Highlight color */
+    highlightColor?: string;
+    /** Spin animation */
+    spin?: boolean;
+    /** Spin speed (degrees per frame) */
+    spinSpeed?: number;
+    /** On atom click */
+    onAtomClick?: (atom: Atom) => void;
+    /** On atom hover */
+    onAtomHover?: (atom: Atom | null) => void;
+    /** On selection change */
+    onSelectionChange?: (selection: Selection_2) => void;
+    /** Class name */
+    className?: string;
+    /** Style */
+    styleOverride?: default_2.CSSProperties;
+}
+
+export declare function NicePhylogeneticTree({ tree, layout, branchStyle, nodeShape, nodeSize, showBranchLengths, showBootstrap, bootstrapThreshold, showLeafLabels, showInternalLabels, labelFontSize, branchWidth, branchColor, nodeColor, highlightColor, clades, annotations, colorScale, width, height, padding, enableZoom, enablePan, showControls, onNodeClick, onNodeHover, onBranchClick, className, style, }: NicePhylogeneticTreeProps): default_2.ReactElement;
+
+export declare interface NicePhylogeneticTreeProps {
+    /** Tree data or Newick string */
+    tree?: TreeNode | string;
+    /** Tree layout */
+    layout?: TreeLayout;
+    /** Branch style */
+    branchStyle?: BranchStyle;
+    /** Node shape */
+    nodeShape?: NodeShape;
+    /** Node size */
+    nodeSize?: number;
+    /** Show branch lengths */
+    showBranchLengths?: boolean;
+    /** Show bootstrap values */
+    showBootstrap?: boolean;
+    /** Bootstrap threshold */
+    bootstrapThreshold?: number;
+    /** Show leaf labels */
+    showLeafLabels?: boolean;
+    /** Show internal labels */
+    showInternalLabels?: boolean;
+    /** Label font size */
+    labelFontSize?: number;
+    /** Branch width */
+    branchWidth?: number;
+    /** Branch color */
+    branchColor?: string;
+    /** Node color */
+    nodeColor?: string;
+    /** Highlight color */
+    highlightColor?: string;
+    /** Clades to visualize */
+    clades?: Clade[];
+    /** Annotations */
+    annotations?: TreeAnnotation[];
+    /** Color scale for metadata */
+    colorScale?: TreeColorScale;
+    /** Width */
+    width?: number | string;
+    /** Height */
+    height?: number | string;
+    /** Padding */
+    padding?: number;
+    /** Enable zoom */
+    enableZoom?: boolean;
+    /** Enable pan */
+    enablePan?: boolean;
+    /** Show controls */
+    showControls?: boolean;
+    /** On node click */
+    onNodeClick?: (node: TreeNode) => void;
+    /** On node hover */
+    onNodeHover?: (node: TreeNode | null) => void;
+    /** On branch click */
+    onBranchClick?: (source: TreeNode, target: TreeNode) => void;
+    /** Class name */
+    className?: string;
+    /** Style */
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceScientificChart({ series, title, subtitle, width, height, type, xAxis, yAxis, statOverlays, annotations, legend, tooltip, zoom, export: exportConfig, statisticalTests, gridLines, aspectRatio, animation, theme, onPointClick, onPointHover, onZoomChange, onAnnotationChange, className, style, }: NiceScientificChartProps): default_2.ReactElement;
+
+export declare interface NiceScientificChartProps {
+    /** Data series to display */
+    series: DataSeries[];
+    /** Chart title */
+    title?: string;
+    /** Subtitle */
+    subtitle?: string;
+    /** Chart width */
+    width?: number | string;
+    /** Chart height */
+    height?: number | string;
+    /** Chart type (default for all series) */
+    type?: ChartType;
+    /** X axis configuration */
+    xAxis?: AxisConfig | AxisConfig[];
+    /** Y axis configuration */
+    yAxis?: AxisConfig | AxisConfig[];
+    /** Statistical overlays to show */
+    statOverlays?: StatOverlay[];
+    /** Annotations to display */
+    annotations?: AnnotationConfig[];
+    /** Legend configuration */
+    legend?: LegendConfig;
+    /** Tooltip configuration */
+    tooltip?: TooltipConfig;
+    /** Zoom/pan configuration */
+    zoom?: ZoomConfig;
+    /** Export configuration */
+    export?: ExportConfig;
+    /** Statistical tests to perform */
+    statisticalTests?: StatisticalTest[];
+    /** Grid lines */
+    gridLines?: boolean;
+    /** Aspect ratio */
+    aspectRatio?: number;
+    /** Animation */
+    animation?: boolean | {
+        duration: number;
+        easing: string;
+    };
+    /** Theme */
+    theme?: 'light' | 'dark' | 'publication' | 'presentation';
+    /** On data point click */
+    onPointClick?: (point: DataPoint, series: DataSeries, event: default_2.MouseEvent) => void;
+    /** On point hover */
+    onPointHover?: (point: DataPoint | null, series: DataSeries | null) => void;
+    /** On zoom change */
+    onZoomChange?: (xRange: [number, number] | null, yRange: [number, number] | null) => void;
+    /** On annotation change */
+    onAnnotationChange?: (annotation: AnnotationConfig) => void;
+    /** Class name */
+    className?: string;
+    /** Style */
+    style?: default_2.CSSProperties;
+}
+
+export declare type NodeShape = 'circle' | 'square' | 'triangle' | 'diamond' | 'none';
+
+/** Notebook collaborator */
+export declare interface NotebookCollaborator {
+    userId: UserId;
+    name: string;
+    email: string;
+    role: 'viewer' | 'editor' | 'admin';
+    addedAt: string;
+}
+
+export declare type NotebookId = string;
+
+/** Notebook settings */
+export declare interface NotebookSettings {
+    requireSignatures: boolean;
+    requireWitness: boolean;
+    autoLockAfterSign: boolean;
+    defaultEntryType: EntryType;
+    customFields: CustomField[];
+    templates: EntryTemplate[];
+}
+
+export declare type Plot3DData = Surface3D | Scatter3D | Volume3D | Mesh3D | VectorField3D;
+
+export declare type Plot3DType = 'scatter3d' | 'surface' | 'wireframe' | 'mesh3d' | 'isosurface' | 'volume' | 'streamtube' | 'cone' | 'contour3d';
+
+export declare interface Point3D {
+    x: number;
+    y: number;
+    z: number;
+    color?: number | string;
+    size?: number;
+    label?: string;
+    meta?: Record<string, any>;
+}
+
+/** Citation/reference type */
+export declare type ReferenceType = 'article' | 'book' | 'chapter' | 'conference' | 'thesis' | 'report' | 'patent' | 'website' | 'software' | 'dataset' | 'video' | 'misc';
+
+export declare type RenderStyle = 'ball-stick' | 'space-filling' | 'stick' | 'wireframe' | 'cartoon' | 'ribbon' | 'surface';
+
+export declare interface Residue {
+    id: number;
+    name: string;
+    seq: number;
+    chainId: string;
+    atoms: number[];
+    secondaryStructure?: 'helix' | 'sheet' | 'loop' | 'turn' | 'coil';
+    color?: string;
+}
+
+export declare interface ScaleBar {
+    show: boolean;
+    position?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+    units?: 'metric' | 'imperial';
+}
+
+export declare type ScaleType = 'linear' | 'log' | 'log2' | 'sqrt' | 'symlog' | 'time' | 'band' | 'ordinal';
+
+export declare interface Scatter3D {
+    id: string;
+    name: string;
+    type: 'scatter3d';
+    points: Point3D[];
+    mode?: 'markers' | 'lines' | 'markers+lines';
+    marker?: {
+        size?: number | number[];
+        color?: string | number[];
+        colorScale?: ColorScale;
+        symbol?: 'circle' | 'square' | 'diamond' | 'cross';
+        opacity?: number;
+    };
+    line?: {
+        width?: number;
+        color?: string;
+        dash?: 'solid' | 'dash' | 'dot';
+    };
+}
+
+export declare interface Scene3DConfig {
+    aspectRatio?: 'auto' | 'cube' | 'data' | {
+        x: number;
+        y: number;
+        z: number;
+    };
+    camera?: Camera3D;
+    xAxis?: Axis3DConfig;
+    yAxis?: Axis3DConfig;
+    zAxis?: Axis3DConfig;
+    bgcolor?: string;
+    dragMode?: 'orbit' | 'turntable' | 'zoom' | 'pan' | false;
+    hoverMode?: 'closest' | 'x' | 'y' | 'z' | false;
+}
+
+declare interface Selection_2 {
+    atoms?: number[];
+    residues?: number[];
+    chains?: string[];
+    expression?: string;
+}
+export { Selection_2 as Selection }
+
+export declare interface StatisticalTest {
+    type: 't-test' | 'anova' | 'chi-square' | 'correlation' | 'mann-whitney';
+    series: string[];
+    result?: {
+        statistic: number;
+        pValue: number;
+        significant: boolean;
+        interpretation: string;
+    };
+}
+
+export declare type StatOverlay = 'mean' | 'median' | 'regression' | 'trendline' | 'confidence-interval' | 'prediction-band' | 'std-dev' | 'quartiles';
+
+declare const Stats_2: {
+    /** Calculate mean */
+    mean(values: number[]): number;
+    /** Calculate median */
+    median(values: number[]): number;
+    /** Calculate variance */
+    variance(values: number[], population?: boolean): number;
+    /** Calculate standard deviation */
+    std(values: number[], population?: boolean): number;
+    /** Calculate mode */
+    mode(values: any[]): any;
+    /** Calculate percentile */
+    percentile(values: number[], p: number): number;
+    /** Calculate quartiles */
+    quartiles(values: number[]): {
+        q1: number;
+        q2: number;
+        q3: number;
+    };
+    /** Calculate skewness */
+    skewness(values: number[]): number;
+    /** Calculate kurtosis */
+    kurtosis(values: number[]): number;
+    /** Correlation coefficient (Pearson) */
+    correlation(x: number[], y: number[]): number;
+    /** Correlation matrix */
+    correlationMatrix(data: Record<string, number[]>): Record<string, Record<string, number>>;
+    /** Covariance */
+    covariance(x: number[], y: number[], population?: boolean): number;
+    /** Simple linear regression */
+    linearRegression(x: number[], y: number[]): {
+        slope: number;
+        intercept: number;
+        r2: number;
+        equation: string;
+    };
+    /** T-test (two-sample) */
+    tTest(sample1: number[], sample2: number[]): {
+        tStatistic: number;
+        pValue: number;
+        degreesOfFreedom: number;
+        meanDiff: number;
+    };
+    /** Normal CDF approximation */
+    normalCDF(x: number): number;
+    /** Chi-square test */
+    chiSquare(observed: number[], expected: number[]): {
+        chiSquare: number;
+        pValue: number;
+        degreesOfFreedom: number;
+    };
+    /** Z-score normalization */
+    zScore(values: number[]): number[];
+    /** Min-max normalization */
+    minMaxNormalize(values: number[], min?: number, max?: number): number[];
+    /** Describe dataset */
+    describe(values: number[]): ColumnStats;
+};
+export { Stats_2 as Stats }
+
+export declare interface Surface {
+    id: string;
+    type: 'vdw' | 'sas' | 'ses' | 'ms';
+    opacity: number;
+    colorScheme: ColorScheme;
+    selection?: Selection_2;
+    wireframe?: boolean;
+}
+
+export declare interface Surface3D {
+    id: string;
+    name: string;
+    type: 'surface' | 'wireframe';
+    xData: number[];
+    yData: number[];
+    zData: number[][];
+    colorData?: number[][];
+    colorScale?: ColorScale;
+    opacity?: number;
+    showScale?: boolean;
+    lighting?: SurfaceLighting;
+}
+
+export declare interface SurfaceLighting {
+    ambient: number;
+    diffuse: number;
+    specular: number;
+    roughness: number;
+    fresnel: number;
+}
+
+export declare interface TooltipConfig {
+    enabled: boolean;
+    mode: 'point' | 'index' | 'nearest' | 'crosshair';
+    format?: (point: DataPoint, series: DataSeries) => string;
+    shared?: boolean;
+}
+
+/** Transformation operation */
+export declare interface Transformation {
+    type: TransformationType;
+    column?: ColumnName;
+    columns?: ColumnName[];
+    parameters: Record<string, any>;
+    newColumnName?: string;
+}
+
+export declare type TransformationType = 'filter' | 'sort' | 'group' | 'aggregate' | 'pivot' | 'melt' | 'rename' | 'drop' | 'fillna' | 'dropna' | 'map' | 'bin' | 'normalize' | 'standardize' | 'log' | 'diff' | 'lag' | 'rolling';
+
+export declare interface TreeAnnotation {
+    nodeId: string;
+    text: string;
+    position?: 'left' | 'right' | 'above' | 'below';
+    color?: string;
+    fontSize?: number;
+}
+
+export declare interface TreeColorScale {
+    name: string;
+    property: string;
+    colors: string[];
+    min?: number;
+    max?: number;
+}
+
+export declare interface TreeEdge {
+    source: string;
+    target: string;
+    length?: number;
+    support?: number;
+    color?: string;
+    style?: 'solid' | 'dashed' | 'dotted';
+    width?: number;
+}
+
+export declare type TreeLayout = 'rectangular' | 'radial' | 'circular' | 'unrooted' | 'diagonal';
+
+export declare interface TreeNode {
+    id: string;
+    name?: string;
+    parent?: string;
+    children?: TreeNode[];
+    branchLength?: number;
+    bootstrap?: number;
+    support?: number;
+    metadata?: Record<string, any>;
+    color?: string;
+    collapsed?: boolean;
+    highlighted?: boolean;
+    annotation?: string;
+}
+
+export declare function useCitation(): CitationContextValue;
+
+export declare function useLabNotebook(): LabNotebookContextValue;
+
+export declare type UserId = string;
+
+export declare interface VectorField3D {
+    id: string;
+    name: string;
+    type: 'cone' | 'streamtube';
+    x: number[];
+    y: number[];
+    z: number[];
+    u: number[];
+    v: number[];
+    w: number[];
+    sizeRef?: number;
+    colorScale?: ColorScale;
+    showScale?: boolean;
+}
+
+export declare interface Volume3D {
+    id: string;
+    name: string;
+    type: 'volume' | 'isosurface';
+    xData: number[];
+    yData: number[];
+    zData: number[];
+    values: number[][][];
+    isoMin?: number;
+    isoMax?: number;
+    opacity?: number | number[];
+    colorScale?: ColorScale;
+    caps?: {
+        x: boolean;
+        y: boolean;
+        z: boolean;
+    };
+    surface?: {
+        show: boolean;
+        count: number;
+    };
+    slices?: {
+        x: {
+            show: boolean;
+            locations: number[];
+        };
+        y: {
+            show: boolean;
+            locations: number[];
+        };
+        z: {
+            show: boolean;
+            locations: number[];
+        };
+    };
+}
+
+export declare interface ZoomConfig {
+    enabled: boolean;
+    mode: 'x' | 'y' | 'xy';
+    wheel?: boolean;
+    drag?: boolean;
+    pinch?: boolean;
+    resetButton?: boolean;
+}
+
+export { }