declare enum KaabalahTypes {
    SPHERE = "sphere",
    PATH = "path",
    WORLD = "world"
}
declare enum LetterTypes {
    HEBREW_LETTER = "hebrewLetter",
    LATIN_LETTER = "latinLetter",
    SANSKRIT_LETTER = "sanskritLetter",
    VATTAN_LETTER = "vattanLetter"
}
declare enum WesternAstrologyTypes {
    PLANET = "planet",
    WESTERN_ZODIAC_SIGN = "westernZodiacSign",
    WESTERN_ELEMENT = "westernElement",
    HOUSE = "house",
    ASPECT = "aspect",
    MODALITIES = "modalities"
}
declare enum TarotTypes {
    TAROT_ARK_ANNU = "tarotArkAnnu",
    TAROT_SUIT = "tarotSuit"
}
declare enum TantraTypes {
    CHAKRA = "chakra",
    SUBTLE_BODY = "subtleBody"
}
declare enum NumerologyTypes {
    NUMBER = "number"
}
declare enum MiscTypes {
    COLOR = "color",
    MUSICAL_NOTE = "musicalNote",
    UNCATEGORIZED = "uncategorized"
}
type NodeType = (typeof KaabalahTypes)[keyof typeof KaabalahTypes] | (typeof LetterTypes)[keyof typeof LetterTypes] | (typeof NumerologyTypes)[keyof typeof NumerologyTypes] | (typeof MiscTypes)[keyof typeof MiscTypes] | (typeof TarotTypes)[keyof typeof TarotTypes] | (typeof TantraTypes)[keyof typeof TantraTypes] | (typeof WesternAstrologyTypes)[keyof typeof WesternAstrologyTypes];
type Branded<T, B> = T & {
    readonly __brand: B;
};
type NodeId<T extends NodeType> = Branded<`${T}:${string}`, T>;
declare const id: <T extends NodeType>(type: T, value: string | number) => NodeId<T>;
declare const parseId: <T extends NodeType>(nodeId: NodeId<T>) => string;
interface DataMap {
    sphere: SphereData;
    path: PathData;
    world: WorldData;
    hebrewLetter: HebrewLetterData;
    latinLetter: LatinLetterData;
    color: ColorData;
    musicalNote: MusicalNoteData;
    tarotArkAnnu: TarotArkAnnuData;
}
type NodeData<T extends NodeType> = T extends keyof DataMap ? DataMap[T] : never;
interface Node<T extends NodeType> {
    id: NodeId<T>;
    type: T;
    data?: NodeData<T>;
    name?: string;
}
declare class BaseNode<T extends NodeType> implements Node<T> {
    id: NodeId<T>;
    type: T;
    data?: NodeData<T>;
    _name?: string;
    constructor({ id: idValue, type, data, name, }: Omit<Node<T>, "id"> & {
        id: string | number;
    });
    get name(): string;
}

interface HermeticQabalahSphereData {
    /**
     * In Atziluth
     */
    divineName: string;
    /**
     * In Briah
     */
    archangelicName: string;
    /**
     * In Yetzirah
     */
    angelicName: string;
    /**
     * In Assiah
     */
    mundaneName: string;
}
type SphereData = {
    hebrewSpelling: string;
    englishName: string;
    magicalImage?: string;
} & Partial<HermeticQabalahSphereData>;
type PathData = {
    meaning?: string;
    from: NodeId<KaabalahTypes.SPHERE>;
    to: NodeId<KaabalahTypes.SPHERE>;
};
type WorldData = {
    englishName: string;
};
type HebrewLetterData = {
    type: "mother" | "double" | "simple";
    gematriaValue: number;
    gematriaValueWhenEnding?: number;
    symbol: string;
    hieroglyph: string;
    yvritMeaning: string;
    character: string;
    characterWhenEnding?: string;
};
type LatinLetterData = {
    isVowel: boolean;
};
type ColorData = {
    colorDescription: string;
    colorNames: string[];
    colorHexCodes: string[];
};
type MusicalNoteData = {
    note: string;
    noteDescription: string;
    frequencies?: [string, string, string, string, string, string, string, string, string];
};
type TarotArkAnnuData = {
    type: "major" | "minor" | "court";
    suit?: (typeof TAROT_SUITS)[keyof typeof TAROT_SUITS];
    aliases?: readonly string[];
    keywords?: readonly string[];
    descriptiveData?: Partial<Record<keyof typeof TAROT_DECKS, {
        name?: string;
        meaning?: string;
        reversedMeaning?: string;
        keywords?: string[];
    }>>;
};
declare const FOUR_WORLDS: {
    readonly ATZILUTH: "Atziluth";
    readonly BRIAH: "Briah";
    readonly YETZIRAH: "Yetzirah";
    readonly ASSIAH: "Assiah";
};
declare const FOUR_WORLDS_DATA: Record<keyof typeof FOUR_WORLDS, NodeData<KaabalahTypes.WORLD>>;
declare const SPHERES: {
    readonly KETHER: "Kether";
    readonly CHOKHMAH: "Chokhmah";
    readonly BINAH: "Binah";
    readonly DAATH: "Daath";
    readonly CHESED: "Chesed";
    readonly GEBURAH: "Geburah";
    readonly TIPHARETH: "Tiphareth";
    readonly NETZACH: "Netzach";
    readonly HOD: "Hod";
    readonly YESOD: "Yesod";
    readonly MALKUTH: "Malkuth";
};
declare const SPHERES_DATA: Record<keyof typeof SPHERES, NodeData<KaabalahTypes.SPHERE>>;
declare const PLANETS: {
    readonly EARTH: "Earth";
    readonly MOON: "Moon";
    readonly SUN: "Sun";
    readonly MERCURY: "Mercury";
    readonly VENUS: "Venus";
    readonly MARS: "Mars";
    readonly JUPITER: "Jupiter";
    readonly SATURN: "Saturn";
    readonly URANUS: "Uranus";
    readonly NEPTUNE: "Neptune";
    readonly PLUTO: "Pluto";
};
declare const MODALITIES: {
    readonly CARDINAL: "Cardinal";
    readonly FIXED: "Fixed";
    readonly MUTABLE: "Mutable";
};
declare const WESTERN_ZODIAC_SIGNS: {
    readonly ARIES: "Aries";
    readonly TAURUS: "Taurus";
    readonly GEMINI: "Gemini";
    readonly CANCER: "Cancer";
    readonly LEO: "Leo";
    readonly VIRGO: "Virgo";
    readonly LIBRA: "Libra";
    readonly SCORPIO: "Scorpio";
    readonly SAGITTARIUS: "Sagittarius";
    readonly CAPRICORN: "Capricorn";
    readonly AQUARIUS: "Aquarius";
    readonly PISCES: "Pisces";
};
declare const WESTERN_ELEMENTS: {
    readonly FIRE: "Fire";
    readonly AIR: "Air";
    readonly WATER: "Water";
    readonly EARTH: "Earth";
    readonly ETHER: "Ether";
};
declare const WESTERN_HOUSES: {
    readonly ASCENDANT: "ascendant";
    readonly SECOND_HOUSE: "second house";
    readonly THIRD_HOUSE: "third house";
    readonly IMUM_COELI: "imum coeli";
    readonly FIFTH_HOUSE: "fifth house";
    readonly SIXTH_HOUSE: "sixth house";
    readonly DESCENDANT: "descendant";
    readonly EIGHTH_HOUSE: "eighth house";
    readonly NINTH_HOUSE: "ninth house";
    readonly MEDIUM_COELI: "medium coeli";
    readonly ELEVENTH_HOUSE: "eleventh house";
    readonly TWELFTH_HOUSE: "twelfth house";
};
declare const WESTERN_ASPECTS: {
    readonly CONJUNCTION: "conjunction";
    readonly DUODECILE: "duodecile";
    readonly OCTILE: "octile";
    readonly SEXTILE: "sextile";
    readonly SQUARE: "square";
    readonly TRINE: "trine";
    readonly TRIOCTILE: "trioctile";
    readonly QUINCUNX: "quincunx";
    readonly OPPOSITION: "opposition";
};
declare const MELKITZEDEKI_PATHS: {
    readonly KETHER_CHOKHMAH: 1;
    readonly KETHER_BINAH: 2;
    readonly KETHER_TIPHARETH: 3;
    readonly CHOKHMAH_BINAH: 4;
    readonly CHOKHMAH_TIPHARETH: 5;
    readonly CHOKHMAH_CHESED: 6;
    readonly BINAH_TIPHARETH: 7;
    readonly BINAH_GEBURAH: 8;
    readonly CHESED_GEBURAH: 9;
    readonly CHESED_TIPHARETH: 10;
    readonly CHESED_NETZACH: 11;
    readonly GEBURAH_TIPHARETH: 12;
    readonly GEBURAH_HOD: 13;
    readonly TIPHARETH_NETZACH: 14;
    readonly TIPHARETH_YESOD: 15;
    readonly TIPHARETH_HOD: 16;
    readonly NETZACH_HOD: 17;
    readonly NETZACH_YESOD: 18;
    readonly NETZACH_MALKUTH: 19;
    readonly HOD_YESOD: 20;
    readonly HOD_MALKUTH: 21;
    readonly YESOD_MALKUTH: 22;
};
declare const LURIANIC_PATHS: {
    readonly KETHER_CHOKHMAH: 1;
    readonly KETHER_BINAH: 2;
    readonly KETHER_TIPHARETH: 3;
    readonly CHOKHMAH_BINAH: 4;
    readonly CHOKHMAH_GEBURAH: 5;
    readonly CHOKHMAH_TIPHARETH: 6;
    readonly CHOKHMAH_CHESED: 7;
    readonly BINAH_CHESED: 8;
    readonly BINAH_TIPHARETH: 9;
    readonly BINAH_GEBURAH: 10;
    readonly CHESED_GEBURAH: 11;
    readonly CHESED_TIPHARETH: 12;
    readonly CHESED_NETZACH: 13;
    readonly GEBURAH_TIPHARETH: 14;
    readonly GEBURAH_HOD: 15;
    readonly TIPHARETH_NETZACH: 16;
    readonly TIPHARETH_YESOD: 17;
    readonly TIPHARETH_HOD: 18;
    readonly NETZACH_HOD: 19;
    readonly NETZACH_YESOD: 20;
    readonly HOD_YESOD: 21;
    readonly YESOD_MALKUTH: 22;
};
declare const LATIN_LETTERS: {
    readonly A: "A";
    readonly B: "B";
    readonly C: "C";
    readonly D: "D";
    readonly E: "E";
    readonly F: "F";
    readonly G: "G";
    readonly H: "H";
    readonly I: "I";
    readonly J: "J";
    readonly K: "K";
    readonly L: "L";
    readonly M: "M";
    readonly N: "N";
    readonly O: "O";
    readonly P: "P";
    readonly Q: "Q";
    readonly R: "R";
    readonly S: "S";
    readonly T: "T";
    readonly U: "U";
    readonly V: "V";
    readonly W: "W";
    readonly X: "X";
    readonly Y: "Y";
    readonly Z: "Z";
    readonly PH: "Ph";
    readonly TS: "Ts";
    readonly TZ: "Tz";
    readonly TH: "Th";
    readonly CH: "Ch";
    readonly SH: "Sh";
    readonly KH: "Kh";
    readonly Ç: "Ç";
    readonly Ã: "Ã";
};
declare const LATIN_LETTERS_DATA: Record<keyof typeof LATIN_LETTERS, NodeData<LetterTypes.LATIN_LETTER>>;
declare const HEBREW_LETTERS: {
    readonly ALEPH: "Aleph";
    readonly BETH: "Beth";
    readonly GIMEL: "Gimel";
    readonly DALET: "Dalet";
    readonly HE: "He";
    readonly VAV: "Vav";
    readonly ZAYIN: "Zayin";
    readonly HET: "Het";
    readonly TET: "Tet";
    readonly YOD: "Yod";
    readonly KAPH: "Kaph";
    readonly LAMED: "Lamed";
    readonly MEM: "Mem";
    readonly NUN: "Nun";
    readonly SAMEKH: "Samekh";
    readonly AYIN: "Ayin";
    readonly PE: "Pe";
    readonly TSADI: "Tsadi";
    readonly QOPH: "Qoph";
    readonly RESH: "Resh";
    readonly SHIN: "Shin";
    readonly TAV: "Tav";
};
declare const HEBREW_LETTERS_DATA: Record<keyof typeof HEBREW_LETTERS, NodeData<LetterTypes.HEBREW_LETTER>>;
declare const TAROT_SUITS: {
    readonly WANDS: "Wands";
    readonly CUPS: "Cups";
    readonly SWORDS: "Swords";
    readonly PENTACLES: "Pentacles";
};
declare const TAROT_ARKANNUS: {
    readonly THE_MAGICIAN: "The Magician";
    readonly THE_HIGH_PRIESTESS: "The High Priestess";
    readonly THE_EMPRESS: "The Empress";
    readonly THE_EMPEROR: "The Emperor";
    readonly THE_HIEROPHANT: "The Hierophant";
    readonly THE_LOVER: "The Lover";
    readonly THE_CHARIOT: "The Chariot";
    readonly JUSTICE: "Justice";
    readonly THE_HERMIT: "The Hermit";
    readonly THE_WHEEL_OF_FORTUNE: "The Wheel of Fortune";
    readonly STRENGTH: "Strength";
    readonly THE_HANGED_MAN: "The Hanged Man";
    readonly DEATH: "Death";
    readonly TEMPERANCE: "Temperance";
    readonly THE_DEVIL: "The Devil";
    readonly THE_TOWER: "The Tower";
    readonly THE_STAR: "The Star";
    readonly THE_MOON: "The Moon";
    readonly THE_SUN: "The Sun";
    readonly JUDGMENT: "Judgment";
    readonly THE_FOOL: "The Fool";
    readonly THE_WORLD: "The World";
    readonly KING_OF_WANDS: "King of Wands";
    readonly QUEEN_OF_WANDS: "Queen of Wands";
    readonly KNIGHT_OF_WANDS: "Knight of Wands";
    readonly PAGE_OF_WANDS: "Page of Wands";
    readonly TEN_OF_WANDS: "Ten of Wands";
    readonly NINE_OF_WANDS: "Nine of Wands";
    readonly EIGHT_OF_WANDS: "Eight of Wands";
    readonly SEVEN_OF_WANDS: "Seven of Wands";
    readonly SIX_OF_WANDS: "Six of Wands";
    readonly FIVE_OF_WANDS: "Five of Wands";
    readonly FOUR_OF_WANDS: "Four of Wands";
    readonly THREE_OF_WANDS: "Three of Wands";
    readonly TWO_OF_WANDS: "Two of Wands";
    readonly ACE_OF_WANDS: "Ace of Wands";
    readonly KING_OF_CUPS: "King of Cups";
    readonly QUEEN_OF_CUPS: "Queen of Cups";
    readonly KNIGHT_OF_CUPS: "Knight of Cups";
    readonly PAGE_OF_CUPS: "Page of Cups";
    readonly TEN_OF_CUPS: "Ten of Cups";
    readonly NINE_OF_CUPS: "Nine of Cups";
    readonly EIGHT_OF_CUPS: "Eight of Cups";
    readonly SEVEN_OF_CUPS: "Seven of Cups";
    readonly SIX_OF_CUPS: "Six of Cups";
    readonly FIVE_OF_CUPS: "Five of Cups";
    readonly FOUR_OF_CUPS: "Four of Cups";
    readonly THREE_OF_CUPS: "Three of Cups";
    readonly TWO_OF_CUPS: "Two of Cups";
    readonly ACE_OF_CUPS: "Ace of Cups";
    readonly KING_OF_SWORDS: "King of Swords";
    readonly QUEEN_OF_SWORDS: "Queen of Swords";
    readonly KNIGHT_OF_SWORDS: "Knight of Swords";
    readonly PAGE_OF_SWORDS: "Page of Swords";
    readonly TEN_OF_SWORDS: "Ten of Swords";
    readonly NINE_OF_SWORDS: "Nine of Swords";
    readonly EIGHT_OF_SWORDS: "Eight of Swords";
    readonly SEVEN_OF_SWORDS: "Seven of Swords";
    readonly SIX_OF_SWORDS: "Six of Swords";
    readonly FIVE_OF_SWORDS: "Five of Swords";
    readonly FOUR_OF_SWORDS: "Four of Swords";
    readonly THREE_OF_SWORDS: "Three of Swords";
    readonly TWO_OF_SWORDS: "Two of Swords";
    readonly ACE_OF_SWORDS: "Ace of Swords";
    readonly KING_OF_PENTACLES: "King of Pentacles";
    readonly QUEEN_OF_PENTACLES: "Queen of Pentacles";
    readonly KNIGHT_OF_PENTACLES: "Knight of Pentacles";
    readonly PAGE_OF_PENTACLES: "Page of Pentacles";
    readonly TEN_OF_PENTACLES: "Ten of Pentacles";
    readonly NINE_OF_PENTACLES: "Nine of Pentacles";
    readonly EIGHT_OF_PENTACLES: "Eight of Pentacles";
    readonly SEVEN_OF_PENTACLES: "Seven of Pentacles";
    readonly SIX_OF_PENTACLES: "Six of Pentacles";
    readonly FIVE_OF_PENTACLES: "Five of Pentacles";
    readonly FOUR_OF_PENTACLES: "Four of Pentacles";
    readonly THREE_OF_PENTACLES: "Three of Pentacles";
    readonly TWO_OF_PENTACLES: "Two of Pentacles";
    readonly ACE_OF_PENTACLES: "Ace of Pentacles";
};
declare const TAROT_DECKS: {
    readonly PAPUS_KAABALISTIC: "Papus Kaabalistic";
    readonly PAPUS_DIVINATORY: "Papus Divinatory";
    readonly KIER_EGYPTIAN: "Kier Egyptian";
};
declare const TAROT_ARKANNUS_DATA: Record<keyof typeof TAROT_ARKANNUS, NodeData<TarotTypes.TAROT_ARK_ANNU>>;
declare const MUSICAL_NOTES: {
    readonly DO: "DO";
    readonly DO_SHARP: "DO_SHARP";
    readonly RE: "RE";
    readonly RE_SHARP: "RE_SHARP";
    readonly MI: "MI";
    readonly FA: "FA";
    readonly FA_SHARP: "FA_SHARP";
    readonly SOL: "SOL";
    readonly SOL_SHARP: "SOL_SHARP";
    readonly LA: "LA";
    readonly LA_SHARP: "LA_SHARP";
    readonly SI: "SI";
};
declare const MUSICAL_NOTES_DATA: Record<keyof typeof MUSICAL_NOTES, MusicalNoteData>;
declare const COLORS: {
    readonly RED: "RED";
    readonly ORANGE: "ORANGE";
    readonly YELLOW: "YELLOW";
    readonly CHARTREUSE_GREEN: "CHARTREUSE_GREEN";
    readonly GREEN: "GREEN";
    readonly SPRING_GREEN: "SPRING_GREEN";
    readonly CYAN: "CYAN";
    readonly AZURE: "AZURE";
    readonly BLUE: "BLUE";
    readonly VIOLET: "VIOLET";
    readonly MAGENTA: "MAGENTA";
    readonly ROSE: "ROSE";
};
declare const COLORS_DATA: Record<keyof typeof COLORS, ColorData>;

/**
 * TreeOfLife represents a graph structure for mapping Kaabalah, Tarot, Astrology and other
 * esoteric correspondences. It can be used to create multiple independent instances
 * for different use cases or to isolate different sets of correspondences.
 */
declare class TreeOfLife {
    private nodes;
    private adjacent;
    private edges;
    private mutationSources;
    private modules;
    private getCurrentMutationSource;
    runWithMutationSource<T>(source: CorrespondenceSource, fn: () => T): T;
    /**
     * Loads the tree of life system to be used
     * @param systemKey - the key of the system to load
     */
    loadSystem(systemKey: SystemKey): void;
    /**
     * Loads a part of a system into the tree of life
     * @param partKey - the key of the part to load
     */
    loadPart(partKey: PartKey): void;
    /**
     * Unloads the tree of life system and all its parts
     */
    unloadSystem(): void;
    get activeSystem(): SystemKey | null;
    get availableParts(): string[];
    get loadedParts(): PartKey[];
    get availableBridges(): Bridge[];
    get bridgedParts(): string[];
    /**
     * Upserts a node to the tree
     * @param node - the node to upsert
     * @returns the id of the added node
     */
    upsertNode<T extends NodeType>(node: Node<T>): NodeId<T>;
    getNode<T extends NodeType>(id: NodeId<T>): Node<T> | undefined;
    getNodes(): Node<NodeType>[];
    getEdge(left: NodeId<NodeType>, right: NodeId<NodeType>): CorrespondenceEdge | undefined;
    getEdges(nodeId?: NodeId<NodeType>): CorrespondenceEdge[];
    /**
     * Links two nodes bi-directionally
     * @param firstNode - the id of the first node
     * @param secondNode - the id of the second node
     */
    link(firstNode: NodeId<NodeType>, secondNode: NodeId<NodeType>, options?: {
        metadata?: CorrespondenceMetadata;
        source?: CorrespondenceSource;
    }): void;
    /**
     * Gets the current node and all its direct relations, or, when filtered by node type, only the direct relations of that type.
     * @param id - the id of the node to get the relations for
     * @param nodeType - the node type to filter the relations by
     * @returns the current node and all its direct relations
     */
    related<T extends NodeType, U extends NodeType>(id: NodeId<T>, nodeType?: U): Node<U>[];
    /**
     * Sugar for `related(id, type)[0]`
     * @param id - the id of the node to get the related node for
     * @param type - the type of the node to get the related node for
     * @returns the related node
     */
    relatedFirst<T extends NodeType, U extends NodeType>(id: NodeId<T>, type: U): Node<U> | undefined;
    /**
     * Gets all the types of nodes that are directly connected to the given node
     * @param id - the id of the node to get related types for
     * @returns array of node types that are directly connected
     */
    relatedTypes<T extends NodeType>(id: NodeId<T>): T[];
    /**
     * BFS up to depth k, optional type filter for the result set
     * @param id - the id of the node to get the extended relations for
     * @param depth - the depth of the walk
     * @param type - the type of the nodes to filter the result set by
     * @returns the current node and all its extended relations
     */
    walk<T extends NodeType, U extends NodeType>(id: NodeId<T>, depth?: number, type?: U): Node<U>[];
    /**
     * Removes a node and all its relations from the graph, cleaning up adjacency sets.
     * @param id - the id of the node to remove
     */
    removeNode(id: NodeId<NodeType>): void;
    addNumber({ number, nodeId }: {
        number: number;
        nodeId?: NodeId<NodeType>;
    }): NodeId<NumerologyTypes>;
    /**
     * Adds a sphere (sephirah) to the tree with its Hebrew and English names
     * @param sphere - the identifier for the sphere
     * @param data - the sphere's Hebrew and English names
     * @returns the sphere's id
     */
    addSphere({ sphere, data, relatedNumber, }: {
        sphere: string;
        data: NodeData<KaabalahTypes.SPHERE>;
        relatedNumber: number;
    }): NodeId<KaabalahTypes.SPHERE>;
    /**
     * Adds a path between two spheres with its associated number
     * @param leftSphere - the id of the first sphere
     * @param rightSphere - the id of the second sphere
     * @param relatedNumber - the number associated with this path
     * @returns the path's id
     */
    addPath({ leftSphere, rightSphere, relatedNumber, data, }: {
        leftSphere: NodeId<KaabalahTypes.SPHERE>;
        rightSphere: NodeId<KaabalahTypes.SPHERE>;
        relatedNumber: number;
        data?: Omit<NodeData<KaabalahTypes.PATH>, "from" | "to">;
    }): NodeId<KaabalahTypes.PATH>;
    addLetters({ path, letters, }: {
        path: NodeId<KaabalahTypes.PATH>;
        letters: {
            letter: string;
            type: NodeType;
            data?: NodeData<NodeType>;
        }[];
    }): void;
    addWesternAstrologySign({ spheres, path, house, planets, element, modality, sign, relatedNumber, }: {
        spheres: NodeId<KaabalahTypes.SPHERE>[];
        path: NodeId<KaabalahTypes.PATH>;
        house: NodeId<WesternAstrologyTypes.HOUSE>;
        planets: NodeId<WesternAstrologyTypes.PLANET>[];
        element: NodeId<WesternAstrologyTypes.WESTERN_ELEMENT>;
        modality: NodeId<WesternAstrologyTypes.MODALITIES>;
        sign: string;
        relatedNumber: number;
    }): NodeId<WesternAstrologyTypes.WESTERN_ZODIAC_SIGN>;
    addTarotArkAnnu({ node, tarotArkAnnu, data, relatedNumber, suit, }: {
        node: NodeId<NodeType>;
        tarotArkAnnu: string;
        data: NodeData<TarotTypes.TAROT_ARK_ANNU>;
        relatedNumber: number;
        suit?: string;
    }): NodeId<TarotTypes.TAROT_ARK_ANNU>;
}

/**
 * Loads the Hermetic Qabalah system into the tree of life
 */
declare function loadHermeticQabalah(tree: TreeOfLife): TreeOfLife;
declare function loadColors(tree: TreeOfLife): TreeOfLife;
declare function loadMusicalNotes(tree: TreeOfLife): TreeOfLife;
declare const LOADERS$2: {
    base: typeof loadHermeticQabalah;
    colors: typeof loadColors;
    music: typeof loadMusicalNotes;
    westernAstrology: Loader;
};

declare const LOADERS$1: {
    base: Loader;
    colors: Loader;
    music: Loader;
    westernAstrology: Loader;
    tarot: Loader;
};

/**
 * Loads the Lurianic Kabbalah system into the tree of life
 */
declare function loadLurianicKabbalah(tree: TreeOfLife): TreeOfLife;
declare const LOADERS: {
    base: typeof loadLurianicKabbalah;
};

type System = {
    SYSTEM: "kaabalah" | "hermetic-qabalah" | "lurianic-kabbalah";
    LOADERS: Record<string, Loader>;
    UNLOADERS: Record<string, Unloader>;
    BRIDGES: Bridge[];
};
declare const SYSTEMS: System[];
type SystemKey = (typeof SYSTEMS)[number]["SYSTEM"];
type PartKey = keyof typeof LOADERS$1 | keyof typeof LOADERS$2 | keyof typeof LOADERS;
type Loader = (t: TreeOfLife) => TreeOfLife;
type Unloader = (t: TreeOfLife) => void;
type Bridge = {
    id: string;
    needs: PartKey[];
    run: (t: TreeOfLife) => void;
};

type CorrespondenceSource = {
    kind: "manual";
} | {
    kind: "system";
    system: SystemKey;
} | {
    kind: "part";
    system: SystemKey;
    part: PartKey;
} | {
    kind: "bridge";
    system: SystemKey;
    bridgeId: string;
    parts: PartKey[];
} | {
    kind: "overlay";
    overlayId: string;
    label?: string;
};
interface CorrespondenceMetadata {
    kind?: string;
    label?: string;
    tags?: string[];
    attributes?: Record<string, unknown>;
}
interface CorrespondenceEdge {
    id: string;
    left: NodeId<NodeType>;
    right: NodeId<NodeType>;
    metadata?: CorrespondenceMetadata;
    sources: readonly CorrespondenceSource[];
}
type TreeNoteTarget = {
    kind: "node";
    nodeId: NodeId<NodeType>;
} | {
    kind: "correspondence";
    left: NodeId<NodeType>;
    right: NodeId<NodeType>;
};
interface TreeNote {
    id: string;
    text: string;
    kind?: string;
    target: TreeNoteTarget;
    metadata?: Record<string, unknown>;
}
type TreeOverlayCorrespondence = {
    op: "add";
    left: NodeId<NodeType>;
    right: NodeId<NodeType>;
    metadata?: CorrespondenceMetadata;
} | {
    op: "remove";
    left: NodeId<NodeType>;
    right: NodeId<NodeType>;
} | {
    op: "annotate";
    left: NodeId<NodeType>;
    right: NodeId<NodeType>;
    metadata?: CorrespondenceMetadata;
};
interface TreeOverlay {
    id: string;
    name?: string;
    version?: string;
    nodes?: Node<NodeType>[];
    correspondences?: TreeOverlayCorrespondence[];
    notes?: TreeNote[];
}
interface TreeWorkspaceDescriptor {
    id?: string;
    name?: string;
    version?: string;
    system?: SystemKey;
    parts?: readonly string[];
    cacheKey?: string;
}
interface CorrespondenceStep {
    from: NodeId<NodeType>;
    to: NodeId<NodeType>;
    edge: CorrespondenceEdge;
}
interface CorrespondenceMatch<T extends NodeType = NodeType> {
    node: Node<T>;
    distance: number;
    path: readonly CorrespondenceStep[];
}
type CorrespondenceMap = Partial<{
    [K in NodeType]: CorrespondenceMatch<K>[];
}>;
declare function makeCorrespondenceId(left: NodeId<NodeType>, right: NodeId<NodeType>): string;

export { LetterTypes as $, type TreeNoteTarget as A, type TreeNote as B, type ColorData as C, type TreeOverlayCorrespondence as D, type TreeOverlay as E, FOUR_WORLDS as F, type TreeWorkspaceDescriptor as G, type HebrewLetterData as H, type CorrespondenceStep as I, type CorrespondenceMatch as J, type CorrespondenceMap as K, type LatinLetterData as L, type MusicalNoteData as M, makeCorrespondenceId as N, type System as O, type PathData as P, SYSTEMS as Q, type SystemKey as R, type SphereData as S, type TarotArkAnnuData as T, type PartKey as U, type Loader as V, type WorldData as W, type Unloader as X, type Bridge as Y, TreeOfLife as Z, KaabalahTypes as _, FOUR_WORLDS_DATA as a, WesternAstrologyTypes as a0, TarotTypes as a1, TantraTypes as a2, NumerologyTypes as a3, MiscTypes as a4, type NodeType as a5, type NodeId as a6, id as a7, parseId as a8, type NodeData as a9, type Node as aa, BaseNode as ab, SPHERES as b, SPHERES_DATA as c, PLANETS as d, MODALITIES as e, WESTERN_ZODIAC_SIGNS as f, WESTERN_ELEMENTS as g, WESTERN_HOUSES as h, WESTERN_ASPECTS as i, MELKITZEDEKI_PATHS as j, LURIANIC_PATHS as k, LATIN_LETTERS as l, LATIN_LETTERS_DATA as m, HEBREW_LETTERS as n, HEBREW_LETTERS_DATA as o, TAROT_SUITS as p, TAROT_ARKANNUS as q, TAROT_DECKS as r, TAROT_ARKANNUS_DATA as s, MUSICAL_NOTES as t, MUSICAL_NOTES_DATA as u, COLORS as v, COLORS_DATA as w, type CorrespondenceSource as x, type CorrespondenceMetadata as y, type CorrespondenceEdge as z };
