import { EventEmitter } from '../utils/emitter';
import { HashFunction } from '../utils/hash';
import { SerializedStore } from '../utils/inspect';
import { Matcher, MatcherFactory } from './matchers';
import { Stream } from './stream';
export declare const CONTEXT: unique symbol;
export declare const GRAPH_NODE: unique symbol;
export declare const GRAPH_OPERATION: unique symbol;
export declare const GRAPH_ACTION: unique symbol;
export declare const NODE_DEFINITION: unique symbol;
export declare const NODE_TYPE: unique symbol;
export declare const OPERATION_TYPE: unique symbol;
export declare const SCOPE: unique symbol;
export declare const MATCHER: unique symbol;
export declare const PROXIED_NODE: unique symbol;
export declare const PROXIED_NODE_DEFINITION: unique symbol;
export declare type NodeLike = any;
export declare type NodeType<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>> = StaticNodeType<T, P, V> | DynamicNodeType<T, P, S, D, V, M, O>;
export declare type NodeName = string;
export declare type NodeProperties = {};
export declare type SerializableObject = NodeDefinition | GraphOperation | Matcher<any, any>;
export declare type SerializedNodeProperties = any;
export declare type SerializedOperationProperties = any;
export interface StaticNodeType<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P> {
    [NODE_TYPE]: true;
    name: T;
    hash: HashFunction<P>;
    shape: Matcher<P>;
    serialize: false | undefined | (<T>(value: P, serialize: (value: SerializableObject) => T) => V);
    deserialize: false | undefined | (<T>(properties: V, deserialize: (node: T) => SerializableObject) => P);
    is: (value: GraphNode) => value is GraphNode<T, P, never, V>;
    getType?: (properties: P, getType: (value: any) => string) => string;
}
export interface StaticNodeDefinition<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P, N extends StaticNodeType<T, P, V> = StaticNodeType<T, P, V>> extends NodeDefinition<T, P, never, never, V, N> {
}
export interface StaticGraphNode<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P, N extends StaticNodeType<T, P, V> = StaticNodeType<T, P, V>> extends GraphNode<T, P, never, never, V, N> {
}
export declare type DynamicNodeType<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>> = StatelessNodeType<T, P, V, M, O> | StatefulNodeType<T, P, S, D, V, M, O>;
export interface DynamicNodeDefinition<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>, N extends DynamicNodeType<T, P, S, D, V, M, O> = DynamicNodeType<T, P, S, D, V, M, O>> extends NodeDefinition<T, P, S, D, V, N> {
}
export interface DynamicGraphNode<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>, N extends DynamicNodeType<T, P, S, D, V> = DynamicNodeType<T, P, S, D, V, M, O>> extends GraphNode<T, P, S, D, V, N> {
}
export interface StatelessNodeType<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>> extends StaticNodeType<T, P, V> {
    operations: {
        [K in M]: StatelessOperationHandler<T, P, V, M, GraphOperation<K> & O>;
    };
}
export interface StatelessNodeDefinition<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P, N extends StatelessNodeType<T, P, V> = StatelessNodeType<T, P, V>> extends NodeDefinition<T, P, never, never, V, N> {
}
export interface StatelessGraphNode<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P, N extends StatelessNodeType<T, P, V> = StatelessNodeType<T, P, V>> extends GraphNode<T, P, never, never, V, N> {
}
export interface StatefulNodeType<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>> extends StaticNodeType<T, P, V> {
    state: Matcher<S>;
    hashState: HashFunction<S>;
    getInitialState(properties: P): S;
    operations: {
        [K in M]: StatefulOperationHandler<T, P, S, D, V, M, GraphOperation<K> & O>;
    };
    onSubscribe?(node: StatefulGraphNode<T, P, S, D, V, M, O, this>): void;
    onUnsubscribe?(node: StatefulGraphNode<T, P, S, D, V, M, O, this>): void;
}
export interface StatefulNodeDefinition<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>, N extends StatefulNodeType<T, P, S, D, V, M, O> = StatefulNodeType<T, P, S, D, V, M, O>> extends NodeDefinition<T, P, S, D, V, N> {
}
export interface StatefulGraphNode<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>, N extends StatefulNodeType<T, P, S, D, V, M, O> = StatefulNodeType<T, P, S, D, V, M, O>> extends GraphNode<T, P, S, D, V, N> {
}
export declare type OperationHandler<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>> = StatelessOperationHandler<T, P, V, M, O> | StatefulOperationHandler<T, P, S, D, V, M, O>;
export interface StatelessOperationHandler<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>> {
    cacheable: boolean;
    getDependencies: (definition: NodeDefinition<T, P, never, never, V>, operation: O) => Array<Dependency>;
    getContextDependencies: (node: NodeDefinition<T, P, never, never, V>, operation: O) => Array<ContextDependency>;
    run(node: GraphNode<T, P, never, never, V>, operation: O, dependencies: Array<GraphNode>, context: Array<GraphNode>, state: undefined): GraphNode | GraphAction;
}
export interface StatefulOperationHandler<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>> {
    cacheable: boolean;
    getDependencies(node: NodeDefinition<T, P, S, D, V>, operation: O): Array<Dependency>;
    getContextDependencies(node: NodeDefinition<T, P, S, D, V>, operation: O): Array<ContextDependency>;
    run(node: GraphNode<T, P, S, D, V>, operation: O, dependencies: Array<GraphNode>, context: Array<GraphNode>, state: S): GraphNode | GraphAction;
    onInvalidate?(node: StatefulGraphNode<T, P, S, D, V, M, O, StatefulNodeType<T, P, S, D, V, M, O>>, operation: O): void;
    onSubscribe?(node: StatefulGraphNode<T, P, S, D, V, M, O, StatefulNodeType<T, P, S, D, V, M, O>>, operation: O): void;
    onUpdate?(node: StatefulGraphNode<T, P, S, D, V, M, O, StatefulNodeType<T, P, S, D, V, M, O>>, operation: O, dependencies: Array<GraphNode>, context: Array<GraphNode>, previousDependencies: Array<GraphNode> | undefined): void;
    onUnsubscribe?(node: StatefulGraphNode<T, P, S, D, V, M, O, StatefulNodeType<T, P, S, D, V, M, O>>, operation: O): void;
}
export declare type NodeState = any;
export declare type NodeData = {
    [key: string]: any;
};
export interface NodeExecutionContext<S extends NodeState, D extends NodeData> {
    getData(): Partial<D>;
    setData(update: ValueUpdater<D>): Partial<D>;
    getState(): S;
    setState(update: ValueUpdater<S>, callback?: (state: S) => void): void;
    retain(): number;
    release(): number;
}
export declare type ValueUpdater<T> = Partial<{
    [key in keyof T]: T[key];
}> | ((previous: T) => T);
export interface NodeDependencyUntilCondition {
    predicate: (node: GraphNode) => boolean;
    errorMessage?: (node: GraphNode) => string;
}
export interface ResolveOptions {
    until?: NodeDependencyUntilCondition;
    acceptNil?: boolean;
}
export interface DependencyOptions {
    allowErrors?: boolean;
    allowPending?: boolean;
    acceptNil?: boolean;
    until?: NodeDependencyUntilCondition;
    once?: boolean;
    invalidate?: boolean;
}
export interface NodeDependency extends DependencyOptions {
    target: NodeDefinition | GraphNode;
}
export interface Dependency {
    target: NodeDefinition | GraphNode;
    operation: GraphOperation;
    allowErrors: boolean;
    allowPending: boolean;
    invalidate: boolean;
}
export interface RequiredContextDependency extends DependencyOptions {
    name: string | symbol;
    required: true | string | ((node: GraphNode, name: string | symbol) => string);
}
export interface OptionalContextDependency extends DependencyOptions {
    name: string | symbol;
    required: false;
    defaultValue: NodeDefinition;
}
export declare type ContextDependency = RequiredContextDependency | OptionalContextDependency;
export interface NodeDefinition<T extends NodeName = any, P extends NodeProperties = any, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, N extends NodeType<T, P, S, D, V> = NodeType<T, P, S, D, V>> {
    [NODE_DEFINITION]: true;
    id: string;
    type: N;
    properties: P;
}
export declare type SerializedNodeDefinition<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P, N extends NodeType<T, P, any, V> = NodeType<T, P, any, V>> = {
    $type: N['name'];
    data: V;
};
export interface GraphNode<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, N extends NodeType<T, P, S, D, V> = NodeType<T, P, S, D, V>> {
    [GRAPH_NODE]: true;
    id: string;
    definition: NodeDefinition<T, P, S, D, V, N>;
    scope: Scope;
    context: Context;
}
export declare type NodeStream<T extends GraphNode = GraphNode> = Stream<T>;
export interface Scope {
    [SCOPE]: true;
    id: string;
    globalEvents: MusterEventSource;
    store: Store;
    events: MusterEventSource;
    parent: Scope | undefined;
    onSubscribe: (() => void) | undefined;
    onUnsubscribe: (() => void) | undefined;
}
export interface Context {
    [CONTEXT]: true;
    id: string;
    root: Context;
    parent: Context | undefined;
    values: ContextValues;
}
export declare type ContextName = string;
export declare type ContextValues = {
    [key in ContextName]: GraphNode;
};
export interface OperationType<N extends OperationName = OperationName, P extends OperationProperties = OperationProperties, S extends SerializedOperationProperties = P> {
    [OPERATION_TYPE]: true;
    name: N;
    shape: Matcher<P>;
    hash: HashFunction<P>;
    serialize: false | undefined | (<T>(value: P, serialize: (value: SerializableObject) => T) => S);
    deserialize: false | undefined | (<T>(value: S, deserialize: (value: T) => SerializableObject) => P);
}
export declare type OperationName = string;
export declare type OperationProperties = {};
export interface GraphOperation<T extends OperationName = OperationName, P extends OperationProperties = OperationProperties, S extends SerializedOperationProperties = P, O extends OperationType<T, P, S> = OperationType<T, P, S>> {
    [GRAPH_OPERATION]: true;
    id: string;
    type: O;
    properties: P;
}
export declare type SerializedGraphOperation<T extends OperationName = OperationName, P extends OperationProperties = OperationProperties, S extends SerializedOperationProperties = P, O extends OperationType<T, P, S> = OperationType<T, P, S>> = {
    $operation: O['name'];
    id: string;
    data: P;
};
export interface GraphAction<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>, N1 extends StaticNodeType<T, P, V> = StaticNodeType<T, P, V>, N2 extends DynamicNodeType<T, P, S, D, V> = DynamicNodeType<T, P, S, D, V, M, O>> {
    [GRAPH_ACTION]: true;
    id: string;
    node: StaticGraphNode<T, P, V, N1> | DynamicGraphNode<T, P, S, D, V, M, O, N2>;
    operation: GraphOperation;
}
export interface StaticGraphAction<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, V extends SerializedNodeProperties = P, N extends StaticNodeType<T, P, V> = StaticNodeType<T, P, V>> {
    [GRAPH_ACTION]: true;
    id: string;
    node: StaticGraphNode<T, P, V, N>;
    operation: GraphOperation;
}
export interface DynamicGraphAction<T extends NodeName = NodeName, P extends NodeProperties = NodeProperties, S extends NodeState = NodeState, D extends NodeData = NodeData, V extends SerializedNodeProperties = P, M extends OperationName = OperationName, O extends GraphOperation<M> = GraphOperation<M>, N extends DynamicNodeType<T, P, S, D, V> = DynamicNodeType<T, P, S, D, V, M, O>> {
    [GRAPH_ACTION]: true;
    id: string;
    node: DynamicGraphNode<T, P, S, D, V, M, O, N>;
    operation: GraphOperation;
}
export declare type ChildKey = any;
export interface Params {
    [id: string]: ChildKey;
}
export interface CreateChildScopeOptions {
    retain: () => number;
    release: () => number;
    redispatch?: ((event: MusterEvent) => MusterEvent | undefined) | true;
}
export interface Store {
    subscribe(node: GraphNode, operation: GraphOperation, callback: UpdateCallback, options?: {
        debug?: boolean;
    }): DisposeCallback;
    retain(node: GraphNode, operation?: GraphOperation): number;
    release(node: GraphNode, operation?: GraphOperation): number;
    invalidate(node: GraphNode, operation?: GraphOperation): boolean;
    getNodeData<D extends NodeData>(node: StatefulGraphNode<NodeName, NodeProperties, NodeState, D>): D | undefined;
    setNodeData<D extends NodeData>(node: StatefulGraphNode<NodeName, NodeProperties, NodeState, D>, data: D): void;
    getNodeState<S extends NodeState>(node: StatefulGraphNode<NodeName, NodeProperties, S>): S | undefined;
    setNodeState<S extends NodeState>(node: StatefulGraphNode<NodeName, NodeProperties, S>, state: S): void;
    disposeScope(scope: Scope): void;
    inspect(): SerializedStore;
}
export declare type UpdateCallback = (value: GraphNode) => void;
export declare type DisposeCallback = () => void;
export interface MusterEvent<T extends MusterEventName = MusterEventName, V extends MusterEventPayload = MusterEventPayload> {
    type: T;
    payload: V;
}
export declare type MusterEventName = string;
export declare type MusterEventPayload = any;
export declare type MusterEventSource<T extends MusterEventName = MusterEventName, V extends MusterEventPayload = MusterEventPayload> = EventEmitter<MusterEvent<T, V>>;
export declare type MusterTypeName = string;
export interface MusterType<N extends MusterTypeName> {
    name: N;
    deserialize: (value: SerializedMusterTypeData | undefined, deserialize: (value: any) => any) => Matcher<any, any>;
    serialize?: (value: Matcher<any, any>, serialize: (value: any) => any) => SerializedMusterTypeData;
}
export interface SerializedMusterType<N extends MusterTypeName = string> {
    $musterType: string;
    data: SerializedMusterTypeData | undefined;
}
export declare type SerializedMusterTypeData = any;
export declare type MusterTypeMap = {
    [name in MusterTypeName]: MusterType<any>;
};
export declare type NodeTypeMap = {
    [name in NodeName]: NodeType;
};
export declare type OperationTypeMap = {
    [name in OperationName]: OperationType;
};
export interface ProxiedNode {
    [PROXIED_NODE]: NodeDefinition | GraphNode;
    [PROXIED_NODE_DEFINITION]: NodeDefinition;
}
export declare function getProxiedNodeValue(value: ProxiedNode): NodeDefinition | GraphNode;
export declare function getProxiedNodeDefinition(value: ProxiedNode): NodeDefinition;
export declare function isProxiedNode(value: any): value is ProxiedNode;
export declare function isScope(value: any): value is Scope;
export declare function isNodeDefinition(value: any): value is NodeDefinition;
export declare function isNodeType(value: any): value is NodeType;
export declare function isGraphNode(value: any): value is GraphNode;
export declare function isContext(value: any): value is Context;
export declare function isOperationType(value: any): value is OperationType;
export declare function isGraphOperation(value: any): value is GraphOperation;
export declare function isGraphAction(value: any): value is GraphAction;
export declare function isEvent(value: any): value is MusterEvent;
export declare function isMatcher(value: any): value is Matcher<any, any>;
export declare function getMatcherType<T, P>(matcher: Matcher<T, P>): Matcher<T, never> | MatcherFactory<T, P>;
export declare function getMatcherOptions<T, P>(matcher: Matcher<T, P>): P;
export declare function createMatcher<T, P = never>(name: string, match: ((value: any) => boolean), options?: P | undefined): Matcher<T, P>;
export declare function setUnitTestMatcher(matcher: (value: any) => boolean): void;