/**
 * Copyright (c) 2018-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
 *
 * @author Adam Midlik <midlik@gmail.com>
 * @author Aliaksei Chareshneu <chareshneu.tech@gmail.com>
 */
import { BehaviorSubject } from 'rxjs';
import { PluginStateObject } from 'molstar/lib/mol-plugin-state/objects';
import { PluginBehavior } from 'molstar/lib/mol-plugin/behavior';
import { PluginContext } from 'molstar/lib/mol-plugin/context';
import { StateObjectCell, StateSelection, StateTransform } from 'molstar/lib/mol-state';
import { ParamDefinition } from 'molstar/lib/mol-util/param-definition';
import { VolsegMeshSegmentation } from '../meshes/mesh-extension';
import { VolumeApiV2 } from './volseg-api/api';
import { DescriptionData, SegmentAnnotationData, ShapePrimitiveData } from './volseg-api/data';
import { MetadataWrapper } from './volseg-api/utils';
import { VolsegMeshSegmentationData } from './entry-meshes';
import { VolsegLatticeSegmentationData } from './entry-segmentation';
import { VolsegStateData } from './entry-state';
import { VolsegVolumeData, SimpleVolumeParamValues } from './entry-volume';
import { StateTransforms } from 'molstar/lib/mol-plugin-state/transforms';
import { PluginComponent } from 'molstar/lib/mol-plugin-state/component';
import { VolsegGeometricSegmentationData } from './entry-geometric-segmentation';
import { VolsegGeometricSegmentation } from './shape_primitives';
import { RuntimeContext } from 'molstar/lib//mol-task';
import { CVSXFilesData } from '../cvsx-extension/data';
import { Source } from '../../common';
export declare const GEOMETRIC_SEGMENTATION_NODE_TAG = "geometric-segmentation-node";
export declare const MESH_SEGMENTATION_NODE_TAG = "mesh-segmentation-node";
export declare const MAX_VOXELS: number;
export declare const BOX: [[number, number, number], [number, number, number]] | null;
export declare const VOLUME_NODE_TAG = "volume-node-tag";
export declare const LATTICE_SEGMENTATION_NODE_TAG = "segmenation-node-tag";
export declare function createLoadVolsegParams(plugin?: PluginContext, entrylists?: {
    [source: string]: string[];
}): {
    serverUrl: ParamDefinition.Text<string>;
    source: ParamDefinition.Mapped<ParamDefinition.NamedParams<unknown, string>>;
};
export type LoadVolsegParamValues = ParamDefinition.Values<ReturnType<typeof createLoadVolsegParams>>;
type RawDataKind = 'volume' | 'segmentation' | 'mesh' | 'primitive';
export declare function createVolsegEntryParams(plugin?: PluginContext): {
    serverUrl: ParamDefinition.Text<string>;
    source: ParamDefinition.Select<"custom" | "emdb" | "pdbe" | "empiar" | "idr">;
    entryId: ParamDefinition.Text<string>;
};
type VolsegEntryParamValues = ParamDefinition.Values<ReturnType<typeof createVolsegEntryParams>>;
export declare namespace VolsegEntryParamValues {
    function fromLoadVolsegParamValues(params: LoadVolsegParamValues): VolsegEntryParamValues;
}
declare const VolsegEntry_base: {
    new (data: VolsegEntryData, props?: {
        label: string;
        description?: string | undefined;
    } | undefined): {
        id: import("molstar/lib/mol-util").UUID;
        type: PluginStateObject.TypeInfo;
        label: string;
        description?: string | undefined;
        data: VolsegEntryData;
    };
    type: PluginStateObject.TypeInfo;
    is(obj?: import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>> | undefined): obj is import("molstar/lib/mol-state").StateObject<VolsegEntryData, PluginStateObject.TypeInfo>;
};
export declare class VolsegEntry extends VolsegEntry_base {
}
export type VolRepr3DT = typeof StateTransforms.Representation.VolumeRepresentation3D;
export declare class RawMeshSegmentData {
    segmentId: number;
    data: Uint8Array | string;
    constructor(segmentId: number, data: Uint8Array | string);
}
declare class RawChannelData extends PluginComponent {
    timeframeIndex: number;
    channelId: string;
    data: Uint8Array | string | RawMeshSegmentData[];
    constructor(timeframeIndex: number, channelId: string, data: Uint8Array | string | RawMeshSegmentData[]);
}
declare class RawSegmentationData extends PluginComponent {
    timeframeIndex: number;
    segmentationId: string;
    data: Uint8Array | string | RawMeshSegmentData[] | ShapePrimitiveData;
    constructor(timeframeIndex: number, segmentationId: string, data: Uint8Array | string | RawMeshSegmentData[] | ShapePrimitiveData);
}
export interface StateHierarchyMirror {
    volumes: StateObjectCell<PluginStateObject.Volume.Data>[];
    segmentations: StateObjectCell<PluginStateObject.Volume.Data>[];
    geometricSegmentations: StateObjectCell<VolsegGeometricSegmentation>[];
    meshSegmentations: StateObjectCell<VolsegMeshSegmentation>[];
}
declare class RawTimeframesDataCache {
    entryData: VolsegEntryData;
    kind: RawDataKind;
    private cache;
    private maxEntries;
    private totalSizeLimitInBytes;
    constructor(entryData: VolsegEntryData, kind: RawDataKind);
    private setCacheSizeInItems;
    private _createKey;
    private _getEntrySize;
    private _setCacheSizeInItems;
    add(data: RawChannelData | RawSegmentationData): null | undefined;
    get(timeframeIndex: number, channelIdOrSegmentationId: string, kind: RawDataKind): Promise<RawChannelData | RawSegmentationData>;
}
export declare class VolsegEntryData extends PluginBehavior.WithSubscribers<VolsegEntryParamValues> {
    plugin: PluginContext;
    ref: string;
    api: VolumeApiV2;
    source: Source;
    /** Number part of entry ID; e.g. '1832' */
    entryNumber: string;
    /** Full entry ID; e.g. 'emd-1832' */
    entryId: string;
    pdbs: string[];
    kind: 'api' | 'file';
    filesData: CVSXFilesData | undefined;
    metadata: BehaviorSubject<MetadataWrapper | undefined>;
    cachedVolumeTimeframesData: RawTimeframesDataCache;
    cachedSegmentationTimeframesData: RawTimeframesDataCache;
    cachedMeshesTimeframesData: RawTimeframesDataCache;
    cachedShapePrimitiveData: RawTimeframesDataCache;
    state: {
        hierarchy: BehaviorSubject<StateHierarchyMirror | undefined>;
    };
    readonly volumeData: VolsegVolumeData;
    readonly geometricSegmentationData: VolsegGeometricSegmentationData;
    readonly latticeSegmentationData: VolsegLatticeSegmentationData;
    readonly meshSegmentationData: VolsegMeshSegmentationData;
    private readonly modelData;
    private highlightRequest;
    private getStateNode;
    currentState: BehaviorSubject<ParamDefinition.Values<{
        selectedSegment: ParamDefinition.Text<string>;
        visibleSegments: ParamDefinition.ObjectList<ParamDefinition.Normalize<{
            segmentKey: string;
        }>>;
        visibleModels: ParamDefinition.ObjectList<ParamDefinition.Normalize<{
            pdbId: string;
        }>>;
        channelsData: ParamDefinition.ObjectList<ParamDefinition.Normalize<{
            channelId: string;
            volumeIsovalueKind: string;
            volumeIsovalueValue: number;
            volumeType: "slice" | "off" | "direct-volume" | "isosurface";
            volumeOpacity: number;
            label: string;
            color: import("molstar/lib/mol-util/color").Color;
        }>>;
    }>>;
    currentVolume: BehaviorSubject<StateTransform<import("molstar/lib/mol-state").StateTransformer<PluginStateObject.Volume.Data, PluginStateObject.Volume.Representation3D, ParamDefinition.Normalize<{
        type: ParamDefinition.NamedParams<any, string>;
        colorTheme: ParamDefinition.NamedParams<any, string>;
        sizeTheme: ParamDefinition.NamedParams<any, string>;
    }>>>[]>;
    currentTimeframe: BehaviorSubject<number>;
    private constructor();
    private initialize;
    private initializeFromFile;
    static create(plugin: PluginContext, params: VolsegEntryParamValues): Promise<VolsegEntryData>;
    private static getRawLatticeSegmentationsFromCSVX;
    private static getRawGeometricSegmentationsFromCVSX;
    private static getRawMeshSegmentationsFromCSVX;
    static createFromFile(plugin: PluginContext, file: Uint8Array, runtimeCtx: RuntimeContext): Promise<VolsegEntryData>;
    getData(timeframeIndex: number, channelIdOrSegmentationId: string, kind: RawDataKind): Promise<string | Uint8Array | ShapePrimitiveData | RawMeshSegmentData[] | undefined>;
    sync(): void;
    private init;
    private initFromFile;
    updateMetadata(): Promise<void>;
    register(ref: string): Promise<void>;
    unregister(): Promise<void>;
    removeSegmentAnnotation(segmentId: number, segmentationId: string, kind: 'lattice' | 'mesh' | 'primitive'): Promise<void>;
    removeDescription(descriptionId: string): Promise<void>;
    editDescriptions(descriptionData: DescriptionData[]): Promise<void>;
    editSegmentAnnotations(segmentAnnotationData: SegmentAnnotationData[]): Promise<void>;
    private _resolveBinaryUrl;
    _resolveStringUrl(urlString: string): Promise<string>;
    _loadRawMeshSegmentationData(timeframe: number, segmentationId: string): Promise<RawSegmentationData>;
    _loadGeometricSegmentationData(timeframe: number, segmentationId: string): Promise<RawSegmentationData>;
    _loadRawChannelData(timeframe: number, channelId: string): Promise<RawChannelData>;
    _loadRawLatticeSegmentationData(timeframe: number, segmentationId: string): Promise<RawSegmentationData>;
    private loadRawChannelsData;
    private loadRawLatticeSegmentationData;
    private loadRawMeshSegmentationData;
    private loadRawShapePrimitiveData;
    preloadVolumeTimeframesData(): Promise<void>;
    preloadSegmentationTimeframesDataFromFile(): void;
    preloadShapePrimitivesTimeframesDataFromFile(): void;
    preloadMeshTimeframesDataFromFile(): void;
    preloadVolumeTimeframesDataFromFile(): void;
    preloadSegmentationTimeframesData(): Promise<void>;
    preloadMeshesTimeframesData(): Promise<void>;
    preloadShapePrimitivesTimeframesData(): Promise<void>;
    updateProjectData(timeframeIndex: number): Promise<void>;
    changeCurrentTimeframe(index: number): void;
    addCurrentVolume(t: StateTransform<VolRepr3DT>): void;
    removeCurrentVolume(ref: string): void;
    actionHighlightSegment(segmentKey?: string): void;
    actionSetOpacity(opacity: number, segmentationId: string, kind: 'lattice' | 'mesh' | 'primitive'): Promise<void>;
    actionShowFittedModel(pdbIds: string[]): Promise<void>;
    actionSetVolumeVisual(type: 'isosurface' | 'direct-volume' | 'off', channelId: string, transform: StateTransform): Promise<void>;
    actionUpdateVolumeVisual(params: SimpleVolumeParamValues, channelId: string, transform: StateTransform): Promise<void>;
    private highlightSegment;
    private selectSegment;
    updateStateNode(params: Partial<VolsegStateData>): Promise<void>;
    findNodesByRef(ref: string): StateObjectCell<import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, StateTransform<import("molstar/lib/mol-state").StateTransformer<import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, any>>>;
    /** Find the nodes under this entry root which have all of the given tags. */
    findNodesByTags(...tags: string[]): StateSelection.CellSeq<StateObjectCell<import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, StateTransform<import("molstar/lib/mol-state").StateTransformer<import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, any>>>>;
    newUpdate(): import("molstar/lib/mol-state").StateBuilder.To<import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, import("molstar/lib/mol-state").StateTransformer<import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, import("molstar/lib/mol-state").StateObject<any, import("molstar/lib/mol-state").StateObject.Type<any>>, any>>;
    private readonly labelProvider;
    private getSegmentationIdFromLoci;
    private getSegmentationKindFromLoci;
    private getSegmentIdFromLoci;
    setTryUseGpu(tryUseGpu: boolean): Promise<void>;
    setSelectionMode(selectSegments: boolean): Promise<void>;
}
export {};