import type { Store, StoreEntry, StoreRecordError, StoreLink } from './interfaces/Store';
import type { NormalizedKeyMetadata } from './main';
export declare function isGraphNode<N, D = N>(node: ProxyGraphNode<N, D>): node is GraphNode<N, D>;
declare enum GraphNodeType {
    Link = "Link",
    Node = "Node",
    Error = "Error",
    Locked = "Locked"
}
export declare class GraphNodeError {
    store: Store;
    data: StoreRecordError;
    type: GraphNodeType.Error;
    constructor(store: Store, data: StoreRecordError);
    retrieve(): StoreRecordError;
}
export declare class GraphLink<NC, DC, S = unknown> {
    store: Store;
    data: StoreLink<S>;
    type: GraphNodeType.Link;
    constructor(store: Store, data: StoreLink<S>);
    isPending(): boolean;
    isMissing(): boolean;
    follow(): GraphNode<NC, DC> | GraphNodeError | null;
    linkData(): S | undefined;
    writeLinkData(data: S): void;
}
export declare class GraphNode<N, D = N> {
    store: Store;
    data: N;
    storeKey: string | NormalizedKeyMetadata;
    type: GraphNodeType.Node;
    constructor(store: Store, data: Extract<StoreEntry<N>, N>, storeKey: string | NormalizedKeyMetadata);
    object<K extends keyof N>(propertyName: K): GraphNode<N[K], Record<K, D>[K]>;
    link<NC, DC, S = unknown>(propertyName: keyof N): GraphLink<NC, DC, S>;
    scalar<K extends keyof N>(propertyName: K): N[K];
    keys<K extends keyof N>(): K[];
    isScalar<K extends keyof N>(propertyName: K): boolean;
    isMissing<K extends keyof N>(propertyName: K): boolean;
    isPending<K extends keyof N>(propertyName: K): boolean;
    write<K extends keyof N>(propertyName: K, value: N[K]): void;
    isUndefined<K extends keyof N>(propertyName: K): boolean;
    retrieve(): N;
}
export type ProxyGraphNode<N, D = N> = GraphNode<N, D> | GraphNodeError | null;
export {};