import { R as SystemKey, U as PartKey, Z as TreeOfLife, a5 as NodeType, a6 as NodeId, aa as Node, G as TreeWorkspaceDescriptor, z as CorrespondenceEdge, B as TreeNote, A as TreeNoteTarget, J as CorrespondenceMatch, K as CorrespondenceMap, E as TreeOverlay } from '../correspondence-model-DWXbAjC-.mjs';
export { ab as BaseNode, Y as Bridge, v as COLORS, w as COLORS_DATA, C as ColorData, y as CorrespondenceMetadata, x as CorrespondenceSource, I as CorrespondenceStep, F as FOUR_WORLDS, a as FOUR_WORLDS_DATA, n as HEBREW_LETTERS, o as HEBREW_LETTERS_DATA, H as HebrewLetterData, _ as KaabalahTypes, l as LATIN_LETTERS, m as LATIN_LETTERS_DATA, k as LURIANIC_PATHS, L as LatinLetterData, $ as LetterTypes, V as Loader, j as MELKITZEDEKI_PATHS, e as MODALITIES, t as MUSICAL_NOTES, u as MUSICAL_NOTES_DATA, a4 as MiscTypes, M as MusicalNoteData, a9 as NodeData, a3 as NumerologyTypes, d as PLANETS, P as PathData, b as SPHERES, c as SPHERES_DATA, Q as SYSTEMS, S as SphereData, O as System, q as TAROT_ARKANNUS, s as TAROT_ARKANNUS_DATA, r as TAROT_DECKS, p as TAROT_SUITS, a2 as TantraTypes, T as TarotArkAnnuData, a1 as TarotTypes, D as TreeOverlayCorrespondence, X as Unloader, i as WESTERN_ASPECTS, g as WESTERN_ELEMENTS, h as WESTERN_HOUSES, f as WESTERN_ZODIAC_SIGNS, a0 as WesternAstrologyTypes, W as WorldData, a7 as id, N as makeCorrespondenceId, a8 as parseId } from '../correspondence-model-DWXbAjC-.mjs';
export { G as GetTreeTopologySpheresOptions, i as TREE_TOPOLOGY_LIGHTNING_SPHERE_NAMES, h as TREE_TOPOLOGY_PATH_IDS, g as TREE_TOPOLOGY_SPHERE_IDS, f as TREE_TOPOLOGY_SPHERE_NAMES, s as TreeTopology, l as TreeTopologyAdjacentSphere, r as TreeTopologyOptions, k as TreeTopologyPath, b as TreeTopologyPathId, q as TreeTopologyPathLookup, o as TreeTopologyRoute, e as TreeTopologyRouteDirection, d as TreeTopologyRouteKey, m as TreeTopologyRouteSegment, n as TreeTopologyRouteTarget, j as TreeTopologySphere, a as TreeTopologySphereId, p as TreeTopologySphereLookup, T as TreeTopologySphereName, c as TreeTopologySphereRole, t as getTreeTopology } from '../topology-CSSfYL2c.mjs';

interface TreeOptions {
    system: SystemKey;
    parts?: Exclude<PartKey, "base">[];
}
/**
 * Creates a new Tree of Life instance with optional system loaders
 * @param opts Configuration options for which systems to load
 * @returns A new TreeOfLife instance with the requested systems loaded
 */
declare function createTree(opts?: TreeOptions): TreeOfLife;

interface TreeCorrespondenceQueryOptions<T extends NodeType = NodeType> {
    type?: T | readonly T[];
    depth?: number;
    includeSelf?: boolean;
    limit?: number;
}
interface TreeFindNodesOptions<T extends NodeType = NodeType> {
    type?: T | readonly T[];
    ids?: readonly NodeId<T>[];
    search?: string;
    predicate?: (node: Node<T>) => boolean;
}
interface TreeVisualRequest {
    nodeId: NodeId<NodeType>;
    kind?: string;
    [key: string]: unknown;
}
interface TreeVisualResult {
    kind: string;
    nodeId: NodeId<NodeType>;
    [key: string]: unknown;
}
type TreeVisualResolver = (input: {
    request: TreeVisualRequest;
    workspace: TreeWorkspace;
}) => TreeVisualResult | undefined;
interface CreateTreeWorkspaceOptions {
    base?: TreeWorkspace | TreeOfLife;
    overlays?: TreeOverlay[];
    descriptor?: TreeWorkspaceDescriptor;
    visualResolvers?: TreeVisualResolver[];
}
type TreeGraphData = {
    descriptor: TreeWorkspaceDescriptor;
    nodesById: Map<NodeId<NodeType>, Node<NodeType>>;
    nodeIdsByType: Map<NodeType, NodeId<NodeType>[]>;
    edgesById: Map<string, CorrespondenceEdge>;
    edgeIdsByNodeId: Map<NodeId<NodeType>, string[]>;
    notesById: Map<string, TreeNote>;
    noteIdsByNodeId: Map<NodeId<NodeType>, string[]>;
    noteIdsByCorrespondenceId: Map<string, string[]>;
};
declare class TreeWorkspace {
    private readonly graph;
    private readonly visualResolvers;
    readonly descriptor: TreeWorkspaceDescriptor;
    constructor(graph: TreeGraphData, visualResolvers?: readonly TreeVisualResolver[]);
    getNode<T extends NodeType>(id: NodeId<T>): Node<T> | undefined;
    hasNode(id: NodeId<NodeType>): boolean;
    getNodes<T extends NodeType>(type?: T): Node<T>[];
    findNodes<T extends NodeType = NodeType>(options?: TreeFindNodesOptions<T>): Node<T>[];
    getEdge(left: NodeId<NodeType>, right: NodeId<NodeType>): CorrespondenceEdge | undefined;
    getEdges(nodeId?: NodeId<NodeType>): CorrespondenceEdge[];
    getNotes(target?: TreeNoteTarget): TreeNote[];
    getCorrespondences<T extends NodeType, U extends NodeType = NodeType>(nodeId: NodeId<T>, options?: TreeCorrespondenceQueryOptions<U>): CorrespondenceMatch<U>[];
    getCorrespondenceMap<T extends NodeType>(nodeId: NodeId<T>, options?: Omit<TreeCorrespondenceQueryOptions, "type">): CorrespondenceMap;
    resolveVisual(request: TreeVisualRequest): TreeVisualResult | undefined;
}
declare function createTreeWorkspace(options?: CreateTreeWorkspaceOptions): TreeWorkspace;
declare function getCanonicalTree(opts?: TreeOptions): TreeWorkspace;

export { CorrespondenceEdge, CorrespondenceMap, CorrespondenceMatch, type CreateTreeWorkspaceOptions, Node, NodeId, NodeType, PartKey, SystemKey, type TreeCorrespondenceQueryOptions, type TreeFindNodesOptions, TreeNote, TreeNoteTarget, TreeOfLife, type TreeOptions, TreeOverlay, type TreeVisualRequest, type TreeVisualResolver, type TreeVisualResult, TreeWorkspace, TreeWorkspaceDescriptor, createTree, createTreeWorkspace, getCanonicalTree };