import { TranslatorState, TranslatorGenerator } from '@lcap/nasl-translator';
import type TypeAnnotation from './TypeAnnotation__';
import { ElementToVueOptions } from './ViewElement__';
import { EventPayload } from '../common/types';
import * as types from './utils/types';
import LogicItem from './LogicItem__';
import type MatchCase from './MatchCase__';
/**
 * 匹配
 */
export declare class Match extends LogicItem {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'Match';
    /**
     * 逻辑项
     */
    expression: types.LogicItemNode;
    /**
     * 是否表达式形态
     */
    isExpression: boolean;
    /**
     * 匹配分支列表
     */
    cases: Array<MatchCase>;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<Match>);
    static from(source: any, parentNode?: any, parentKey?: string): Match;
    /**
     * 插入匹配分支
     * @internal
     * @param matchCaseOptions 匹配分支参数
     */
    _insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
    /**
     * 插入匹配分支
     * @internal
     * @param matchCase 已有的匹配分支实例
     */
    _insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
    /**
     * 插入匹配分支
     * @param matchCaseOptions 匹配分支参数
     */
    insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
    /**
     * 插入匹配分支
     * @param matchCase 已有的匹配分支实例
     */
    insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
    /**
     * 添加匹配分支
     * @internal
     * @param matchCaseOptions 匹配分支参数
     */
    _addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
    /**
     * 添加匹配分支
     * @internal
     * @param matchCase 已有的匹配分支实例
     */
    _addMatchCase(matchCase: MatchCase): MatchCase;
    /**
     * 添加匹配分支
     * @param matchCaseOptions 匹配分支参数
     */
    addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
    /**
     * 添加匹配分支
     * @param matchCase 已有的匹配分支实例
     */
    addMatchCase(matchCase: MatchCase): MatchCase;
    /**
     * 删除匹配分支
     * @param matchCase 已有的匹配分支实例
     */
    removeMatchCase(matchCase: MatchCase): void;
    name?: string;
    enumerableItems: Array<LogicItem | TypeAnnotation>;
    get isEnumerable(): boolean;
    cacheStatus(): Promise<void>;
    /**
     * 是否允许新建case
     */
    get canAddCase(): boolean;
    getEnumerableItems(typeAnnotation?: TypeAnnotation): Promise<TypeAnnotation[] | types.LogicItemNode[]>;
    setIsExpression(isExpression: boolean): void;
    /**
     * 设置逻辑项
     */
    setExpression(expression: types.LogicItemNode): void;
    setExpressionWitchCase(expression: types.LogicItemNode): Promise<void>;
    autoGenCases(oldExpression: types.LogicItemNode): Promise<void>;
    autoGenCasesAST({ oldAst, cacheType }: any): Promise<void>;
    changeGenCases(): Promise<void>;
    static getDefaultOptions(): {
        label: string;
    };
    isTypeMatching(): Promise<boolean>;
    onChange($event?: EventPayload): void;
    get expressionNameInView(): string;
    getViewMatchExpressionBuilder(): string;
    getArgsList(): string[];
    getInViewMethod(state?: TranslatorState): string;
    setIsExpressionCustom(isExpression: boolean): void;
    toVue(state?: ElementToVueOptions): string;
    toUI(state?: TranslatorState, hideDetails?: boolean): string;
    toJS(state?: TranslatorState): string;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): TranslatorGenerator;
    toNaturalTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): string;
    toTextualNASL(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): string;
}
export default Match;
//# sourceMappingURL=Match__.d.ts.map