import { BaseNodeClass, BaseNodeType } from '../../../nodes/_Base';
import { BaseOperation } from '../../../operations/_Base';
import { NodeContext } from '../../NodeContext';
import { PolyEngine } from '../../../Poly';
import { PolyDictionary } from '../../../../types/GlobalTypes';
export interface OperationRegisterOptions {
    printWarnings?: boolean;
}
export interface NodeRegisterOptions {
    only?: string[];
    except?: string[];
    userAllowed?: boolean;
    polyNode?: boolean;
    printWarnings?: boolean;
}
export type BaseNodeConstructor = typeof BaseNodeClass;
type NodeConstructorByType = Map<string, BaseNodeConstructor>;
type NodeConstructorByTypeByContext = Map<NodeContext, NodeConstructorByType>;
export type BaseOperationConstructor = typeof BaseOperation;
export type OnNodeRegisterCallback = (poly: PolyEngine) => void;
export type OnOperationRegisterCallback = (poly: PolyEngine) => void;
export declare class NodesRegister {
    private poly;
    private _nodesRegister;
    private _nodesRegisterCategories;
    private _nodesRegisterOptions;
    constructor(poly: PolyEngine);
    private static type;
    private static filterType;
    register(node: BaseNodeConstructor, tabMenuCategory?: string | string[], options?: NodeRegisterOptions): void;
    deregister(context: NodeContext, nodeType: string): void;
    isRegistered(context: NodeContext, nodeType: string): boolean;
    nodeOptions(context: NodeContext, nodeType: string): NodeRegisterOptions | undefined;
    registeredNodesForParentNode(parentNode: BaseNodeType): (typeof BaseNodeClass)[];
    registeredNodes(parentNode: BaseNodeType): PolyDictionary<BaseNodeConstructor>;
    registeredCategory(context: NodeContext, nodeType: string): string[] | undefined;
    map(): NodeConstructorByTypeByContext;
}
export declare class OperationsRegister {
    private poly;
    private _operation_register;
    constructor(poly: PolyEngine);
    private static type;
    private static filterType;
    register(operation: BaseOperationConstructor, options?: OperationRegisterOptions): void;
    registeredOperationsForContextAndParentType(context: NodeContext, parentNodeType: string): (typeof BaseOperation)[];
    registeredOperation(context: NodeContext, operationType: string): BaseOperationConstructor | undefined;
}
export {};