import { PluginContext } from 'molstar/lib/mol-plugin/context';
import { StateObject } from 'molstar/lib/mol-state';
import { PluginStateObject } from 'molstar/lib/mol-plugin-state/objects';
import { StateBuilder } from 'molstar/lib/mol-state';
import { Loci } from 'molstar/lib/mol-model/loci';
import { QueryParam } from './helpers';
import { Structure } from "molstar/lib/mol-model/structure";
import { StructureElement } from 'molstar/lib/mol-model/structure';
import { Representation } from 'molstar/lib/mol-repr/representation';
import { StructureRepresentationProvider } from 'molstar/lib/mol-repr/structure/representation';
import { ParamDefinition as PD } from 'molstar/lib/mol-util/param-definition';
declare class DrugflowMolstarPlugin {
    private _ev;
    readonly events: {
        loadComplete: import("rxjs").Subject<boolean>;
    };
    plugin: PluginContext;
    assemblyRef: string;
    granularity: string;
    selected_info: any;
    selectedParams: any;
    isHighlightColorUpdated: boolean;
    private hiddenState;
    init(targetElement: HTMLElement, params?: any): Promise<void>;
    get state(): import("Molstar/mol-state/state").State;
    private applyState;
    private create_ligand_view;
    create_tmp_label_comp(): Promise<void>;
    create_surf_comp(name?: string): Promise<void>;
    create_tmp_ligand_comp(chain_id: string, ligand_res_id: number): Promise<void>;
    remove_tmp_comp(comp_ref: string, _structure_id?: string): Promise<void>;
    /**
     * 创建配体查询（排除水分子）
     */
    private createLigandQuery;
    /**
     * 创建多肽链查询（auth_asym_id包含'p'）
     */
    private createPeptideQuery;
    /**
     * 创建非多肽聚合物查询（排除多肽链）
     */
    private createNonPeptidePolymerQuery;
    /**
     * 创建基础结构（从model）
     */
    createBaseStructure(model: any, structureId: string): StateBuilder.To<PluginStateObject.Molecule.Structure, import("Molstar/mol-state/transformer").StateTransformer<PluginStateObject.Molecule.Model, PluginStateObject.Molecule.Structure, PD.Normalize<{
        type: PD.NamedParams<PD.Normalize<{
            dynamicBonds: any;
        }>, "auto"> | PD.NamedParams<PD.Normalize<{
            dynamicBonds: any;
            id: any;
        }>, "assembly"> | PD.NamedParams<PD.Normalize<{
            dynamicBonds: any;
            ijkMin: any;
            ijkMax: any;
        }>, "symmetry"> | PD.NamedParams<PD.Normalize<{
            dynamicBonds: any;
        }>, "model"> | PD.NamedParams<PD.Normalize<{
            dynamicBonds: any;
            radius: any;
        }>, "symmetry-mates"> | PD.NamedParams<PD.Normalize<{
            dynamicBonds: any;
            generators: any;
        }>, "symmetry-assembly">;
    }>>>;
    /**
     * 异步构建完整蛋白结构（推荐使用）
     * 使用 createComponent API，结构更清晰
     */
    buildFullProteinStructureAsync(structureId?: string, options?: {
        polymer?: boolean;
        ligand?: boolean;
        water?: boolean;
    }): Promise<string[]>;
    /**
     * 异步构建配体口袋组件
     * 创建配体和周围环境两个组件
     */
    private buildLigandPocketComponentsAsync;
    /**
     * 异步构建多肽链组件
     * 创建多肽链组件和可选的背景组件
     */
    private buildPeptideComponentsAsync;
    /**
     * 加载数据（从URL或字符串）
     */
    loadData(params: {
        url?: string;
        pdbString?: string;
        isBinary?: boolean;
    }): Promise<import("Molstar/mol-state/object").StateObjectSelector<PluginStateObject.Data.String | PluginStateObject.Data.Binary, import("Molstar/mol-state/transformer").StateTransformer<StateObject<any, StateObject.Type<any>>, StateObject<any, StateObject.Type<any>>, any>>>;
    /**
     * 解析轨迹并创建模型
     */
    parseAndCreateModel(data: any, format: 'mmcif' | 'pdb' | 'sdf' | 'mol' | 'mol2' | 'xyz' | 'gro' | 'pdbqt' | 'cifCore', modelIndex?: number): Promise<import("Molstar/mol-state/object").StateObjectSelector<PluginStateObject.Molecule.Model, import("Molstar/mol-state/transformer").StateTransformer<StateObject<any, StateObject.Type<any>>, StateObject<any, StateObject.Type<any>>, any>>>;
    /**
     * 更新assemblyRef
     */
    private updateAssemblyRef;
    /**
     * 获取所有已加载的结构列表
     * @returns 结构信息数组
     */
    getLoadedStructures(): {
        index: number;
        ref: string;
        label: string;
        components: {
            key: string | undefined;
            ref: string;
            label: string | undefined;
        }[];
    }[];
    /**
     * 获取指定组件的所有表示
     * @param componentRef - 组件引用
     * @returns 表示信息数组
     */
    getRepresentations(componentRef: string): any[];
    /**
     * 获取指定 Structure 的所有 contact
     * @param structureRef - Structure 引用（如 'Structure_0'）
     * @returns Contact 信息数组
     */
    getContacts(structureRef: string): any[];
    /**
     * 获取所有组件及其表示的完整树形结构
     * @returns 完整的结构树
     */
    getStructureTree(): {
        components: {
            representations: any[];
            key: string | undefined;
            ref: string;
            label: string | undefined;
        }[];
        contacts: any[];
        index: number;
        ref: string;
        label: string;
    }[];
    /**
     * 更新表示参数
     * @param reprRef - 表示引用
     * @param params - 新的参数
     */
    updateRepresentation(reprRef: string, params: any): Promise<void>;
    /**
     * 删除指定的表示
     * @param reprRef - 表示引用
     */
    deleteRepresentation(reprRef: string): Promise<void>;
    /**
     * 切换表示的可见性
     * @param reprRef - 表示引用
     */
    toggleRepresentationVisibility(reprRef: string): void;
    /**
     * 切换 contact 的可见性
     * @param contactRef - contact 引用
     */
    toggleContactVisibility(contactRef: string): void;
    /**
     * 删除组件及其所有表示
     * @param componentRef - 组件引用
     */
    deleteComponent(componentRef: string): Promise<void>;
    /**
     * 删除整个结构（Structure）及其所有组件和表示
     * @param structureId - 结构ID（如 '0', '1', 'ref-1' 等）
     * @returns 是否成功删除
     */
    deleteStructure(structureId: string): Promise<boolean>;
    /**
     * 创建新组件
     * @param options - 组件配置选项
     * @returns 组件引用
     */
    createComponent(options: {
        /** 组件类型: 'polymer', 'ligand', 'water', 'ion', 'all', 'custom' */
        type: 'polymer' | 'ligand' | 'water' | 'ion' | 'all' | 'custom';
        /** 组件引用（可选，自动生成） */
        componentRef?: string;
        /** 结构ID（可选，默认'0'） */
        structureId?: string;
        /** 自定义查询表达式（type='custom'时使用） */
        expression?: any;
        /** 组件标签（可选） */
        label?: string;
    }): Promise<string | null>;
    /**
     * 获取当前用户选择的 Expression
     * @returns 选择的 MolScript Expression，如果没有选择则返回 null
     */
    getSelectionExpression(): Promise<any | null>;
    /**
     * 修改表示的显示类型
     * @param reprRef - 表示引用
     * @param type - 新的类型 (cartoon, ball-and-stick, surface等)
     * @param params - 额外参数
     */
    changeRepresentationType(reprRef: string, type: string, params?: any): Promise<void>;
    /**
     * 修改表示的颜色主题
     * @param reprRef - 表示引用
     * @param colorTheme - 颜色主题名称
     */
    changeRepresentationColor(reprRef: string, colorTheme: string): Promise<void>;
    /**
     * 修改表示的透明度
     * @param reprRef - 表示引用
     * @param alpha - 透明度 (0-1)
     */
    changeRepresentationAlpha(reprRef: string, alpha: number): Promise<void>;
    /**
     * 加载并渲染完整蛋白结构
     * @param url - PDB文件URL
     * @param format - 文件格式 (mmcif, pdb, sdf等)
     * @param options - 可选参数
     */
    /**
     * 加载完整蛋白结构
     * 流程：Load Data → Parse Model → Add Structure → Create Components
     *
     * @param url - 蛋白文件URL
     * @param format - 文件格式
     * @param options - 加载选项
     * @returns 创建的组件引用列表
     */
    loadFullProtein(url: string, format?: 'mmcif' | 'pdb' | 'sdf' | 'mol' | 'mol2' | 'xyz' | 'gro' | 'pdbqt' | 'cifCore', options?: {
        isBinary?: boolean;
        modelIndex?: number;
        showPolymer?: boolean;
        showLigand?: boolean;
        showWater?: boolean;
        pdbString?: string;
    }): Promise<{
        componentRefs: string[];
        structureId: string;
    }>;
    /**
     * 加载并渲染配体口袋
     * 流程：Load Data → Parse Model → Add Structure → Create Ligand Pocket Components
     *
     * 支持多次调用创建多个配体口袋叠加视图进行比较
     *
     * @param url - PDB文件URL
     * @param ligandInfo - 配体信息
     * @param format - 文件格式
     * @param options - 可选参数
     * @returns 创建的组件引用列表 [ligandRef, surroundingsRef]
     *
     */
    loadLigandPocket(url: string, ligandInfo: {
        name?: string;
        site?: string;
        ligandId?: string;
    }, format?: 'mmcif' | 'pdb' | 'sdf' | 'mol' | 'mol2' | 'xyz' | 'gro' | 'pdbqt' | 'cifCore', options?: {
        isBinary?: boolean;
        modelIndex?: number;
        pdbString?: string;
        clearPrevious?: boolean;
        radius?: number;
    }): Promise<{
        componentRefs: string[];
        structureId: string;
    }>;
    /**
     * 加载并渲染多肽链
     * 流程：Load Data → Parse Model → Add Structure → Create Peptide Components
     *
     * @param url - PDB文件URL
     * @param format - 文件格式
     * @param options - 可选参数
     * @returns 创建的组件引用列表
     *
     * @example
     * ```javascript
     * // 只显示多肽链
     * const components = await viewer.loadPeptide('protein.pdb', 'pdb', {
     *     showBackground: false,
     *     showLigand: true
     * });
     *
     * // 显示多肽链和背景
     * const components = await viewer.loadPeptide('protein.pdb', 'pdb', {
     *     showBackground: true,
     *     showLigand: true,
     *     showWater: false
     * });
     * ```
     */
    loadPeptide(url: string, format?: 'mmcif' | 'pdb' | 'sdf' | 'mol' | 'mol2' | 'xyz' | 'gro' | 'pdbqt' | 'cifCore', options?: {
        isBinary?: boolean;
        modelIndex?: number;
        showBackground?: boolean;
        showLigand?: boolean;
        showWater?: boolean;
        pdbString?: string;
        clearPrevious?: boolean;
        peptideId?: string;
    }): Promise<{
        componentRefs: string[];
        structureId: string;
    }>;
    private getObj;
    /**
     * 为组件添加3D表示
     *
     * @example
     * ```javascript
     * // 添加cartoon表示
     * await viewer.add_repr({
     *     componentRef: 'Polymer',
     *     type: 'cartoon',
     *     colorTheme: 'secondary-structure'
     * });
     *
     * // 添加半透明surface
     * await viewer.add_repr({
     *     componentRef: 'Polymer',
     *     type: 'molecular-surface',
     *     colorTheme: 'hydrophobicity',
     *     alpha: 0.5
     * });
     * ```
     *
     * @param options - 表示配置选项
     * @returns 表示引用
     */
    add_repr(options: {
        /** 组件引用，如 'Polymer', 'Ligand' */
        componentRef: string;
        /** 表示引用（可选，自动生成） */
        reprRef?: string;
        /**
         * 表示类型
         * 常用值: 'cartoon', 'ball-and-stick', 'spacefill', 'molecular-surface', 'line', 'point'
         */
        type: string;
        /**
         * 颜色主题（可选）
         * 常用值: 'secondary-structure', 'element-symbol', 'chain-id', 'residue-name',
         *         'uniform', 'hydrophobicity', 'atom-id', 'residue-index'
         */
        colorTheme?: string;
        /** 透明度 0-1（可选，默认1） */
        alpha?: number;
        /** 是否初始可见（默认true） */
        visible?: boolean;
        /** 结构ID（可选，默认'0'） */
        structureId?: string;
        /** 额外的类型参数（可选） */
        params?: any;
    }): Promise<string | null>;
    private visual_tree;
    private parse_selection_info;
    private update_selected_info;
    set_visibility(ref: string): void;
    clear(): Promise<void>;
    add_click_listener(): void;
    add_mouse_event(func: any): void;
    private add_selection_info;
    /**
     * 根据参数获取 Loci
     * @param params - 查询参数
     * @param structureNumber - 结构编号（1-based，可选）
     * @param _expand - 扩展范围（可选，保留用于兼容性）
     * @param structureRef - 结构引用（如 'Structure_0'，可选）
     * @returns Loci 对象
     */
    getLociForParams(params: QueryParam[], structureNumber?: number, _expand?: number, structureRef?: string): {
        kind: "empty-loci";
    } | StructureElement.Loci;
    get_basic_info(): any;
    canvas: {
        toggleControls: (isVisible?: boolean) => void;
        toggleExpanded: (isExpanded?: boolean) => void;
        setBgColor: (color?: {
            r: number;
            g: number;
            b: number;
        }) => void;
        applySettings: (settings?: {
            color?: {
                r: number;
                g: number;
                b: number;
            };
            lighting?: string;
        }) => void;
        toggleSelect: (isSelect?: boolean) => void;
    };
    measure: {
        add_distance: () => Promise<void>;
        add_angle: () => Promise<void>;
        add_dihedral: () => Promise<void>;
        add_orientation: () => Promise<void>;
        add_plane: () => Promise<void>;
        clean_all_measure: () => Promise<void>;
    };
    visual: {
        select_all: () => Promise<void>;
        select_none: () => void;
        expand_select: (expand: number, type?: string) => Promise<void>;
        deselect_current: () => Promise<void>;
        inverse_select: () => Promise<void>;
        hideSelect: () => Promise<void>;
        _showSelect: (type?: string) => Promise<0 | -1>;
        changeProps: (val: any) => Promise<void>;
        toggleSpin: (isSpinning?: boolean, resetCamera?: boolean) => void;
        focus: (params: QueryParam[], structureNumber?: number, expand_num?: number) => void;
        get_current_loci: () => Promise<{
            kind: "empty-loci";
        }>;
        focus_loci: (loci: Loci | Loci[]) => void;
        focus_now: () => Promise<void>;
        select: (params: QueryParam[], deselect?: boolean) => void;
        camera_reset: () => Promise<void>;
        /**
         * 应用所有隐藏状态（内部方法）
         */
        _applyHiddenState: () => Promise<void>;
        /**
         * 使用透明度隐藏指定的链
         * @param chainId 链ID，例如 'A', 'B'
         */
        hideChain: (chainId: string) => Promise<void>;
        /**
         * 清除指定链的透明度来显示
         * @param chainId 链ID，例如 'A', 'B'
         */
        showChain: (chainId: string) => Promise<void>;
        /**
         * 使用透明度隐藏指定链中的残基
         * @param chainId 链ID，例如 'A', 'B'
         * @param residueIds 残基序号数组，例如 [10, 15, 20] 或范围 { start: 10, end: 20 }
         */
        hideResidues: (chainId: string, residueIds: number[] | {
            start: number;
            end: number;
        }) => Promise<void>;
        /**
         * 清除指定链中残基的透明度来显示
         * @param chainId 链ID，例如 'A', 'B'
         * @param residueIds 残基序号数组，例如 [10, 15, 20] 或范围 { start: 10, end: 20 }
         */
        showResidues: (chainId: string, residueIds: number[] | {
            start: number;
            end: number;
        }) => Promise<void>;
        /**
         * 切换残基的显示/隐藏状态
         * @param chainId 链ID
         * @param residueIds 残基序号数组或范围
         * @param visible true显示，false隐藏
         */
        toggleResidues: (chainId: string, residueIds: number[] | {
            start: number;
            end: number;
        }, visible: boolean) => Promise<void>;
        /**
         * 使用透明度隐藏指定的配体
         * @param chainId 链ID
         * @param resId 残基序号（可选）
         * @param resName 残基名称（可选）
         */
        hideLigand: (chainId: string, resId?: number, resName?: string) => Promise<void>;
        /**
         * 清除指定配体的透明度来显示
         * @param chainId 链ID
         * @param resId 残基序号（可选）
         * @param resName 残基名称（可选）
         */
        showLigand: (chainId: string, resId?: number, resName?: string) => Promise<void>;
        /**
         * 批量隐藏多个链
         * @param chainIds 链ID数组，例如 ['A', 'B', 'C']
         */
        hideChains: (chainIds: string[]) => Promise<void>;
        /**
         * 批量显示多个链
         * @param chainIds 链ID数组，例如 ['A', 'B', 'C']
         */
        showChains: (chainIds: string[]) => Promise<void>;
        /**
         * 切换链的显示/隐藏状态
         * @param chainId 链ID
         * @param visible true显示，false隐藏
         */
        toggleChain: (chainId: string, visible: boolean) => Promise<void>;
        /**
         * 切换配体的显示/隐藏状态
         * @param chainId 链ID
         * @param visible true显示，false隐藏
         * @param resId 残基序号（可选）
         * @param resName 残基名称（可选）
         */
        toggleLigand: (chainId: string, visible: boolean, resId?: number, resName?: string) => Promise<void>;
        /**
         * 清除所有透明度，恢复所有被隐藏的元素
         */
        clearAllTransparency: () => Promise<void>;
        /**
         * 获取当前隐藏状态
         */
        getHiddenState: () => {
            chains: string[];
            ligands: string[];
            residues: {
                [chainId: string]: number[];
            };
        };
    };
    add_shape(structure: any, params: any): Promise<import("Molstar/mol-state/object").StateObjectSelector<PluginStateObject.Molecule.Structure.Representation3D, import("Molstar/mol-state/transformer").StateTransformer<StateObject<any, StateObject.Type<any>>, StateObject<any, StateObject.Type<any>>, any>>>;
    remove_shape(selector: any): void;
    add_contact(contactPair: {
        structure_ref: string;
        start_query: QueryParam[];
        end_query: QueryParam[];
        interactionType: string;
        color: number;
        id: string;
    }): Promise<void>;
    /**
     * 添加自动计算的相互作用表示（使用 molstar 内置的 Interactions）
     * 此方法会自动计算和显示选定区域的所有相互作用（氢键、疏水作用、π-π堆积等）
     *
     * @param componentRef - 组件引用（如 'Ligand_0'）
     * @param options - 可选参数
     * @returns 表示引用
     *
     * @example
     * ```javascript
     * // 为配体添加相互作用表示
     * await viewer.add_interactions_repr({
     *     componentRef: 'Ligand_0',
     *     structureId: '0'
     * });
     *
     * // 自定义相互作用参数
     * await viewer.add_interactions_repr({
     *     componentRef: 'Ligand_plus_0',
     *     structureId: '0',
     *     interactionTypes: ['hydrogen-bond', 'hydrophobic', 'pi-stacking']
     * });
     *
     * // 只显示跨链相互作用（多肽场景）
     * await viewer.add_interactions_repr({
     *     componentRef: 'Polymer_p_plus_1',
     *     structureId: '1',
     *     interChainOnly: true  // 只显示不同链之间的相互作用
     * });
     * ```
     */
    add_interactions_repr(options: {
        /** 组件引用 */
        componentRef: string;
        /** 表示引用（可选，自动生成） */
        reprRef?: string;
        /** 结构ID（可选，默认'0'） */
        structureId?: string;
        /**
         * 相互作用类型（可选）
         * 可用值: 'hydrogen-bond', 'halogen-bond', 'ionic', 'metal-coordination',
         *         'cation-pi', 'pi-stacking', 'hydrophobic', 'weak-hydrogen-bond'
         */
        interactionTypes?: string[];
        /** 是否只显示跨链相互作用（默认false） */
        interChainOnly?: boolean;
        /** 是否初始可见（默认true） */
        visible?: boolean;
        /** 额外参数（可选） */
        params?: any;
    }): Promise<string | null>;
    /**
     * 为指定组件自动计算并显示相互作用
     * 这是一个通用方法，可用于任意组件（配体、多肽、聚合物等）
     *
     * @param componentRef - 组件引用（如 'Polymer_p1', 'Ligand_plus_0' 等）
     * @param structureId - 结构ID（可选，默认'0'）
     * @param interactionTypes - 相互作用类型（可选）
     * @param interChainOnly - 是否只显示跨链相互作用（可选，默认自动判断）
     * @returns 创建的 interactions 表示引用
     *
     * @example
     * ```javascript
     * // 为多肽显示相互作用（自动启用跨链过滤）
     * await viewer.show_component_interactions('Polymer_p_plus_1', '1');
     *
     * // 为配体显示相互作用
     * await viewer.show_component_interactions('Ligand_plus_0', '0');
     *
     * // 自定义相互作用类型
     * await viewer.show_component_interactions('Polymer_p2', '2', ['hydrogen-bond', 'ionic']);
     * ```
     */
    show_component_interactions(componentRef: string, structureId?: string, interactionTypes?: string[], interChainOnly?: boolean): Promise<string | null>;
    /**
     * 创建多肽周围环境组件（包含多肽本身+周围残基）
     * 用于计算多肽与周围残基之间的相互作用
     *
     * @param options - 配置选项
     * @returns 周围环境组件引用
     *
     * @example
     * ```javascript
     * await viewer.create_peptide_surroundings_component({
     *     peptideId: '1',
     *     peptideChainName: 'p',
     *     structureId: '1',
     *     radius: 5
     * });
     * ```
     */
    create_peptide_surroundings_component(options: {
        peptideId: string;
        peptideChainName: string;
        structureId: string;
        radius?: number;
    }): Promise<string | null>;
    /**
     * 创建背景肽链周围环境组件（包含背景肽链+背景蛋白）
     * 用于计算背景肽链与背景蛋白之间的相互作用
     *
     * @param options - 配置选项
     * @returns 周围环境组件引用
     *
     * @example
     * ```javascript
     * await viewer.create_peptide_background_surroundings_component({
     *     structureId: 'Original',
     *     radius: 5
     * });
     * ```
    */
    create_peptide_background_surroundings_component(options: {
        structureId: string;
        radius?: number;
    }): Promise<string | null>;
    /**
     * 导出 Molstar 内置计算的 Interaction 数据
     * 可用于绘制 2D interaction 图
     *
     * @param componentRef - 组件引用（如 'Ligand_plus_0'）
     * @param structureId - 结构ID（可选，默认'0'）
     * @param filterResId - 可选的残基ID，如果提供则只返回与该残基相关的相互作用
     * @returns Interaction 数据数组
     *
     * @example
     * ```javascript
     * // 导出配体周围的所有相互作用数据
     * const interactions = await viewer.exportInteractionsData('Ligand_plus_0');
     *
     * // 只导出与残基 1102 相关的相互作用
     * const ligandInteractions = await viewer.exportInteractionsData('Ligand_plus_0', '0', 1102);
     * console.log(ligandInteractions);
     * // [
     * //   {
     * //     type: 'hydrogen-bond',
     * //     atomA: { chainId: 'A', resId: 1102, resName: 'KY9', atomName: 'O38', atomId: 38 },
     * //     atomB: { chainId: 'A', resId: 745, resName: 'LYS', atomName: 'NZ', atomId: null },
     * //     distance: 2.87
     * //   },
     * //   ...
     * // ]
     * ```
     */
    exportInteractionsData(componentRef: string, structureId?: string, filterResId?: number): Promise<any[]>;
    /**
     * 辅助方法：从 structure、unit、features 和 feature index 获取原子信息
     * @private
     */
    private getAtomInfoFromFeature;
    /**
     * 导出配体为 SDF 格式（用于 RDKit.js 等）
     *
     * @param ligandComponentRef - 配体组件引用（如 'Ligand_MK1'）
     * @param structureId - 结构ID（可选，默认'0'）
     * @returns SDF 格式字符串
     *
     * @example
     * ```javascript
     * // 导出配体为 SDF
     * const sdf = await viewer.exportLigandAsSDF('Ligand_MK1', '0');
     *
     * // 然后用 RDKit.js 生成 2D 坐标
     * const mol = RDKit.get_mol(sdf);
     * mol.generate_2d_coords();
     * ```
     */
    exportLigandAsSDF(ligandComponentRef: string, structureId?: string): Promise<string>;
    /**
     * 导出配体为 MOL 格式（备用方案）
     *
     * @param ligandComponentRef - 配体组件引用
     * @param structureId - 结构ID
     * @returns MOL 格式字符串
     */
    exportLigandAsMOL(ligandComponentRef: string, structureId?: string): Promise<string>;
    /**
     * 导出配体的完整信息（包括原子、键、坐标）
     * 返回更结构化的数据，方便后续处理
     *
     * @param ligandComponentRef - 配体组件引用
     * @param structureId - 结构ID
     * @returns 配体信息对象
     */
    exportLigandStructure(ligandComponentRef: string, structureId?: string): Promise<any>;
    /**
     * 删除指定的 contact/interaction 表示
     * @param contactId - contact 的 ID（通常是 prolif_id）
     */
    remove_contact(contactId: string): Promise<void>;
    addInteractionRepr(a: any, b: any, s_ref: string, options?: any): Promise<void>;
    ArbitrarySphereVisuals: {
        'arbitrary-sphere': (ctx: any, getParams: any) => import("molstar/lib/mol-repr/structure/representation").StructureRepresentation<{
            x: PD.Numeric;
            y: PD.Numeric;
            z: PD.Numeric;
            l1: PD.Numeric;
            l2: PD.Numeric;
            l3: PD.Numeric;
            unitKinds: PD.MultiSelect<"spheres" | "gaussians" | "atomic">;
            includeParent: PD.BooleanParam;
            doubleSided: PD.BooleanParam;
            flipSided: PD.BooleanParam;
            flatShaded: PD.BooleanParam;
            ignoreLight: PD.BooleanParam;
            xrayShaded: PD.Select<boolean | "inverted">;
            transparentBackfaces: PD.Select<"on" | "off" | "opaque">;
            bumpFrequency: PD.Numeric;
            bumpAmplitude: PD.Numeric;
            alpha: PD.Numeric;
            quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
            material: PD.Group<PD.Normalize<{
                metalness: number;
                roughness: number;
                bumpiness: number;
            }>>;
            clip: PD.Group<PD.Normalize<{
                variant: import("Molstar/mol-util/clip").Clip.Variant;
                objects: PD.Normalize<{
                    type: any;
                    invert: any;
                    position: any;
                    rotation: any;
                    scale: any;
                }>[];
            }>>;
            instanceGranularity: PD.BooleanParam;
        }>;
    };
    ArbitrarySphereParams: {
        x: PD.Numeric;
        y: PD.Numeric;
        z: PD.Numeric;
        l1: PD.Numeric;
        l2: PD.Numeric;
        l3: PD.Numeric;
        unitKinds: PD.MultiSelect<"spheres" | "gaussians" | "atomic">;
        includeParent: PD.BooleanParam;
        doubleSided: PD.BooleanParam;
        flipSided: PD.BooleanParam;
        flatShaded: PD.BooleanParam;
        ignoreLight: PD.BooleanParam;
        xrayShaded: PD.Select<boolean | "inverted">;
        transparentBackfaces: PD.Select<"on" | "off" | "opaque">;
        bumpFrequency: PD.Numeric;
        bumpAmplitude: PD.Numeric;
        alpha: PD.Numeric;
        quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
        material: PD.Group<PD.Normalize<{
            metalness: number;
            roughness: number;
            bumpiness: number;
        }>>;
        clip: PD.Group<PD.Normalize<{
            variant: import("Molstar/mol-util/clip").Clip.Variant;
            objects: PD.Normalize<{
                type: any;
                invert: any;
                position: any;
                rotation: any;
                scale: any;
            }>[];
        }>>;
        instanceGranularity: PD.BooleanParam;
    };
    ArbitrarySphereVisual: (materialId: any) => import("molstar/lib/mol-repr/structure/units-visual").UnitsVisual<{
        x: PD.Numeric;
        y: PD.Numeric;
        z: PD.Numeric;
        l1: PD.Numeric;
        l2: PD.Numeric;
        l3: PD.Numeric;
        unitKinds: PD.MultiSelect<"spheres" | "gaussians" | "atomic">;
        includeParent: PD.BooleanParam;
        doubleSided: PD.BooleanParam;
        flipSided: PD.BooleanParam;
        flatShaded: PD.BooleanParam;
        ignoreLight: PD.BooleanParam;
        xrayShaded: PD.Select<boolean | "inverted">;
        transparentBackfaces: PD.Select<"on" | "off" | "opaque">;
        bumpFrequency: PD.Numeric;
        bumpAmplitude: PD.Numeric;
        alpha: PD.Numeric;
        quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
        material: PD.Group<PD.Normalize<{
            metalness: number;
            roughness: number;
            bumpiness: number;
        }>>;
        clip: PD.Group<PD.Normalize<{
            variant: import("Molstar/mol-util/clip").Clip.Variant;
            objects: PD.Normalize<{
                type: any;
                invert: any;
                position: any;
                rotation: any;
                scale: any;
            }>[];
        }>>;
        instanceGranularity: PD.BooleanParam;
    }>;
    ConfalPyramidsRepresentation: (ctx: any, getParams: any) => Representation<Structure, {
        x: PD.Numeric;
        y: PD.Numeric;
        z: PD.Numeric;
        l1: PD.Numeric;
        l2: PD.Numeric;
        l3: PD.Numeric;
        unitKinds: PD.MultiSelect<"spheres" | "gaussians" | "atomic">;
        includeParent: PD.BooleanParam;
        doubleSided: PD.BooleanParam;
        flipSided: PD.BooleanParam;
        flatShaded: PD.BooleanParam;
        ignoreLight: PD.BooleanParam;
        xrayShaded: PD.Select<boolean | "inverted">;
        transparentBackfaces: PD.Select<"on" | "off" | "opaque">;
        bumpFrequency: PD.Numeric;
        bumpAmplitude: PD.Numeric;
        alpha: PD.Numeric;
        quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
        material: PD.Group<PD.Normalize<{
            metalness: number;
            roughness: number;
            bumpiness: number;
        }>>;
        clip: PD.Group<PD.Normalize<{
            variant: import("Molstar/mol-util/clip").Clip.Variant;
            objects: PD.Normalize<{
                type: any;
                invert: any;
                position: any;
                rotation: any;
                scale: any;
            }>[];
        }>>;
        instanceGranularity: PD.BooleanParam;
    }, import("molstar/lib/mol-repr/structure/representation").StructureRepresentationState>;
    ArbitrarySphereRepresentationProvider: StructureRepresentationProvider<{
        x: PD.Numeric;
        y: PD.Numeric;
        z: PD.Numeric;
        l1: PD.Numeric;
        l2: PD.Numeric;
        l3: PD.Numeric;
        unitKinds: PD.MultiSelect<"spheres" | "gaussians" | "atomic">;
        includeParent: PD.BooleanParam;
        doubleSided: PD.BooleanParam;
        flipSided: PD.BooleanParam;
        flatShaded: PD.BooleanParam;
        ignoreLight: PD.BooleanParam;
        xrayShaded: PD.Select<boolean | "inverted">;
        transparentBackfaces: PD.Select<"on" | "off" | "opaque">;
        bumpFrequency: PD.Numeric;
        bumpAmplitude: PD.Numeric;
        alpha: PD.Numeric;
        quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
        material: PD.Group<PD.Normalize<{
            metalness: number;
            roughness: number;
            bumpiness: number;
        }>>;
        clip: PD.Group<PD.Normalize<{
            variant: import("Molstar/mol-util/clip").Clip.Variant;
            objects: PD.Normalize<{
                type: any;
                invert: any;
                position: any;
                rotation: any;
                scale: any;
            }>[];
        }>>;
        instanceGranularity: PD.BooleanParam;
    }, "arbitrary-sphere">;
    createArbitrarySphereMesh: (ctx: any, unit: any, structure: any, theme: any, props: any, mesh: any) => import("Molstar/mol-geo/geometry/mesh/mesh").Mesh;
}
export default DrugflowMolstarPlugin;