@treeviz/gedcom-parser 1.0.13 → 1.0.15

package/dist/index-BvW-KWJP.d.ts

@@ -0,0 +1,1654 @@
+import { Locale } from 'date-fns';
+
+interface IFam extends Common<string, FamKey> {
+    _IS_ORPHAN_FAMILY?: Common<"Y" | "N">;
+    getChildren: () => Individuals;
+    getHusband: () => Individuals;
+    getWife: () => Individuals;
+}
+
+interface IObje extends Common<string, ObjeKey> {
+    _PRIM?: Common<"Y" | "N">;
+}
+
+interface IMultimediaLinkStructure extends Common {
+    RIN?: Common;
+    OBJE?: Common & {
+        CROP?: Common & {
+            TOP?: Common;
+            LEFT?: Common;
+            HEIGHT?: Common;
+            WIDTH?: Common;
+        };
+        TITL?: Common;
+        _PRIM?: Common<"Y" | "N">;
+    };
+}
+
+declare class Obje extends Common<string, ObjeKey> implements IObje {
+    standardizeMedia(namespace?: string | number, override?: boolean, urlGetter?: (namespace?: string | number, imgId?: string) => string | undefined): this | ProxyOriginal<ObjeType>;
+}
+type ObjeType = Obje & IMultimediaLinkStructure;
+declare const createObje: (gedcom: GedComType, id?: ObjeKey, main?: Common, parent?: Common) => ProxyOriginal<ObjeType>;
+
+declare class Objects extends List<ObjeKey, ObjeType> {
+    copy(): Objects;
+    except(item: ObjeType): Objects;
+}
+
+interface IRepositoryStructure {
+    NAME?: Common;
+}
+
+interface IRepo extends Common<string, RepoKey>, IRepositoryStructure {
+}
+
+declare class Repo extends Common<string, RepoKey> implements IRepo {
+}
+type RepoType = Repo & IRepositoryStructure;
+declare const createRepo: (gedcom: GedComType, id?: RepoKey, main?: Common, parent?: Common) => ProxyOriginal<RepoType>;
+
+declare class Repositories extends List<RepoKey, RepoType> {
+    copy(): Repositories;
+    except(item: RepoType): Repositories;
+}
+
+interface ISour extends Common<string, SourKey> {
+    _APID?: Common;
+}
+
+type PrimitiveRange = "" | "-" | `-${number}` | `${number}-` | `${number}-${number}`;
+type Range$1 = PrimitiveRange | [(string | number)?, (string | number)?] | [string | number, (string | number)?];
+interface SplitResult {
+    range: PrimitiveRange;
+    to?: boolean;
+    by?: boolean;
+}
+declare const fromTuple: (s?: number, e?: number) => PrimitiveRange;
+declare const inRange: (year: string | number | undefined, range: Range$1, trueIfNoYear?: boolean) => boolean;
+declare const isIntersectedRange: (range1: Range$1, range2: Range$1) => boolean;
+declare const splitRange: (to: Range$1, by: Range$1) => SplitResult[];
+declare function parseRangeBounds(rangeKey: PrimitiveRange): [number | undefined, number | undefined];
+declare function isRangeContained(containedRange: PrimitiveRange, containerRange: PrimitiveRange): boolean;
+declare function extractSplitPoints(ranges: PrimitiveRange[]): number[];
+declare function generateSplitRanges(splitPoints: number[]): PrimitiveRange[];
+declare function splitOverlappingRanges<T>(rangesToValues: Array<[PrimitiveRange, T]>): Array<[PrimitiveRange, T[]]>;
+declare function findMatchingRangeForSplitRange<T>(splitRange: PrimitiveRange, rangesToValues: Array<[PrimitiveRange, T]>): T[];
+declare function extractSeparationYears(childName: string, ranges: Record<string, unknown[]>, parentName: string, ensureArray: (x: unknown) => unknown[]): number[];
+
+declare class CommonDate extends Common<string> {
+    private _date?;
+    DAY?: Common;
+    MONTH?: Common;
+    YEAR?: Common;
+    NOTE?: Common;
+    constructor(gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common);
+    set value(value: string | undefined);
+    get value(): string | undefined;
+    get rawValue(): Date;
+    assign<T extends Common | List = Common | List>(name: MultiTag, value: T, unique?: boolean): T;
+    private isValidDateFormat;
+    toNote(short?: boolean): string | undefined;
+    toValue(dateFormat?: string, locale?: Locale | null): string | undefined;
+    exportValue(): string;
+    inRange(range: Range$1, trueIfNoYear?: boolean): boolean;
+}
+declare const createCommonDate: (gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common) => ProxyOriginal<CommonDate>;
+declare const isCommonDate: (value?: unknown) => value is CommonDate;
+
+interface IDateStructure extends Common {
+    DATE?: CommonDate & {
+        TIME?: Common;
+    };
+}
+
+interface IChangeDateStructure extends Common, INoteStructure {
+    CHAN?: Common & IDateStructure;
+}
+
+interface ICreationDateStructure extends Common {
+    CREA?: Common & IDateStructure;
+}
+
+interface IPlaceStructure extends Common {
+    PLAC?: Common & {
+        FORM?: Common;
+        LANG?: Common;
+        TRAN?: Common & {
+            LANG?: Common;
+        };
+        MAP?: Common & {
+            LATI?: Common;
+            LONG?: Common;
+        };
+        EXID?: Common & {
+            TYPE?: Common;
+        };
+    } & INoteStructure;
+}
+
+interface ISourceRepositoryCitationStructure extends Common {
+    REPO?: Common & {
+        CALN?: Common & {
+            MEDI?: Common & {
+                PHRASE?: Common;
+            };
+        };
+    } & INoteStructure;
+}
+
+interface ISourceStructure extends Common, IChangeDateStructure, ICreationDateStructure, ISourceRepositoryCitationStructure, IMultimediaLinkStructure, INoteStructure {
+    DATA?: Common & {
+        EVEN?: Common & {
+            DATE?: Common & {
+                PHRASE?: Common;
+            };
+        } & IPlaceStructure;
+        AGNC?: Common;
+    } & INoteStructure;
+    AUTH?: Common;
+    TITL?: Common;
+    ABBR?: Common;
+    PUBL?: Common;
+    TEXT?: Common & {
+        MIME?: Common;
+        LANG?: Common;
+    };
+    _APID?: Common;
+}
+
+declare class Sour extends Common<string, SourKey> implements ISour {
+}
+type SourType = Sour & ISourceStructure;
+declare const createSour: (gedcom: GedComType, id?: SourKey, main?: Common, parent?: Common) => ProxyOriginal<SourType>;
+
+declare class Sources extends List<SourKey, SourType> {
+    copy(): Sources;
+    except(item: SourType): Sources;
+}
+
+interface ISubm extends Common<string, SubmKey> {
+}
+
+declare class Subm extends Common<string, SubmKey> implements ISubm {
+}
+type SubmType = Subm & ISubm;
+declare const createSubm: (gedcom: GedComType, id?: SubmKey, main?: Common, parent?: Common) => ProxyOriginal<SubmType>;
+
+declare class Submitters extends List<SubmKey, SubmType> {
+    copy(): Submitters;
+    except(item: SubmType): Submitters;
+}
+
+interface IGedcom extends Common {
+    indis: () => Individuals | undefined;
+    fams: () => Families | undefined;
+    objes: () => Objects | undefined;
+    sours: () => Sources | undefined;
+    repos: () => Repositories | undefined;
+    subms: () => Submitters | undefined;
+    indi: (index: number | IndiKey) => IndiType | undefined;
+    fam: (index: number | FamKey) => FamType | undefined;
+    obje: (index: number | ObjeKey) => ObjeType | undefined;
+    sour: (index: number | SourKey) => SourType | undefined;
+    repo: (index: number | RepoKey) => RepoType | undefined;
+    subm: (index: number | SubmKey) => SubmType | undefined;
+}
+
+interface IAddressStructure extends Common {
+    ADDR?: Common & {
+        ADR1?: Common;
+        ADR2?: Common;
+        ADR3?: Common;
+        CITY?: Common;
+        STAE?: Common;
+        POST?: Common;
+        CTRY?: Common;
+    };
+}
+
+interface IGedComStructure extends Common, Omit<NonStandard, "id" | "value">, Partial<Record<`${ListTag}`, List>> {
+    "@@INDI"?: Individuals;
+    "@@_INDI"?: Individuals;
+    "@@FAM"?: Families;
+    "@@OBJE"?: Objects;
+    "@@REPO"?: Repositories;
+    "@@SOUR"?: Sources;
+    "@@SUBM"?: Submitters;
+    HEAD?: Common & {
+        GEDC?: Common & {
+            VERS?: Common;
+        };
+        SCHMA?: Common & {
+            TAG?: Common;
+        };
+        SOUR?: Common & {
+            VERS?: Common;
+            NAME?: Common;
+            CORP?: Common & {
+                PHON?: Common;
+                EMAIL?: Common;
+                FAX?: Common;
+                WWW?: Common;
+            } & IAddressStructure;
+            DATA?: Common & {
+                DATE?: Common & {
+                    TIME?: Common;
+                };
+                CORP?: Common;
+            };
+            _TREE?: Common & {
+                RIN?: Common;
+            };
+        };
+        DEST?: Common;
+        DATE?: Common & {
+            TIME?: Common;
+        };
+        SUBM?: Common;
+        CORP?: Common;
+        LANG?: Common;
+        PLAC?: Common & {
+            FORM?: Common;
+        };
+    } & INoteStructure;
+}
+
+declare class GedCom extends Common implements IGedcom {
+    tagMembers: Record<string, {
+        tag: Common;
+        indis: Individuals;
+    }>;
+    reflist: Record<string, Common>;
+    refcount: number;
+    constructor();
+    private getMain;
+    getList<T extends List = List>(type: MultiTag): T | undefined;
+    indis(): Individuals;
+    cloneIndis(target?: IndiKey | IndiType, source?: IndiKey | IndiType, avoidKeys?: MultiTag[], removeFromOriginalList?: boolean): this;
+    mergeIndis(target?: IndiKey | IndiType, source?: IndiKey | IndiType, removeFromOriginalList?: boolean): this;
+    fams(): Families;
+    objes(): Objects;
+    sours(): Sources;
+    repos(): Repositories;
+    subms(): Submitters;
+    tags(): List<IdType, Common<string, IdType>>;
+    customTags(): List<IdType, Common<string, IdType>>;
+    indi(index: number | IndiKey): IndiType;
+    fam(index: number | FamKey): FamType;
+    obje(index: number | ObjeKey): ObjeType;
+    sour(index: number | SourKey): SourType;
+    repo(index: number | RepoKey): RepoType;
+    subm(index: number | SubmKey): SubmType;
+    tag(index: number | SubmKey): Common<string, IdType>;
+    fromList(id?: string): Common<string, IdType>;
+    tagByName(name?: string): Common<string, IdType>;
+    customTag(index: number | SubmKey): Common<string, IdType>;
+    private getIndiRelatedLists;
+    private getDownloadHeader;
+    toFiltered(indis: IndiKey[]): this | GedComType;
+    toJson(tag?: MultiTag | undefined, options?: (ConvertOptions & {
+        indis?: IndiKey[];
+    }) | undefined): string;
+    toGedcom(tag?: MultiTag | undefined, level?: number, options?: (ConvertOptions & {
+        indis?: IndiKey[];
+    }) | undefined): string;
+    hasTag(tag?: string | Common): boolean;
+    hasUnknownAncestor(): boolean;
+    hasIgnoredMember(): boolean;
+    hasUnattachedMember(): boolean;
+    hasUnknownGivenname(): boolean;
+    hasUnknownSurname(): boolean;
+    hasNonRelevant(): boolean;
+    /**
+     * Get all places from the GEDCOM with occurrence counts
+     * @returns Record mapping place names to their occurrence count
+     */
+    getAllPlaces(): Record<string, number>;
+    /**
+     * Get all places from the GEDCOM with associated individual IDs
+     * @param usedIndis Optional array of individual IDs to filter by
+     * @returns Record mapping place names to arrays of individual IDs
+     */
+    getAllPlacesWithIndis(usedIndis?: IndiKey[]): Record<string, (`@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`)[]>;
+    /**
+     * Generate statistics about the GEDCOM file
+     * @param individuals Optional list of individuals to calculate statistics for. If not provided, all individuals from the GEDCOM will be used.
+     * @returns Object containing various statistics about the GEDCOM data
+     */
+    stats(individuals?: Individuals): {
+        totalIndividuals: number;
+        totalFamilies: number;
+        byGender: {
+            males: number;
+            females: number;
+            unknown: number;
+        };
+        dateRange: {
+            earliest: number;
+            latest: number;
+        };
+        averageLifespan: number;
+        topSurnames: {
+            surname: string;
+            count: number;
+        }[];
+        topBirthPlaces: {
+            place: string;
+            count: number;
+        }[];
+        firstPersonEvent: any;
+        lastPersonEvent: any;
+    };
+}
+type GedComType = GedCom & IGedComStructure;
+declare const createGedCom: () => GedComType;
+declare const isGedcomString: (gedcomString?: string) => boolean;
+/**
+ * Validates if a string is a valid GEDCOM file content
+ * @param content - The file content to validate
+ * @returns An object with `valid` boolean and optional `error` message
+ */
+declare const validateGedcomContent: (content?: string) => {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Merge two GEDCOM objects into a single result using a configurable matching strategy
+ * @param targetGedcom - The base GEDCOM (kept as the primary source)
+ * @param sourceGedcom - The GEDCOM to be merged into the target
+ * @param strategy - Matching strategy: "id" (default) to match by individual ID, or any MultiTag (e.g., "NAME", "BIRT.DATE") to match by that field's value
+ * @returns The merged GedComType with all individuals and families combined
+ *
+ * @example
+ * // Merge by ID (individuals with same ID are considered the same person)
+ * const merged = await mergeGedcoms(target, source, "id");
+ *
+ * @example
+ * // Merge by NAME (individuals with same name are considered the same person)
+ * const merged = await mergeGedcoms(target, source, "NAME");
+ *
+ * @remarks
+ * - Source individuals are always assigned new unique IDs to avoid conflicts
+ * - When individuals match by strategy, they are merged (data and relationships combined)
+ * - All family relationships (FAMS/FAMC) are preserved with updated ID references
+ */
+declare const mergeGedcoms: (targetGedcom: GedComType, sourceGedcom: GedComType, strategy?: MultiTag | "id") => GedComType;
+
+declare class CommonNote extends Common<string> {
+    constructor(gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common);
+    set value(value: string | undefined);
+    get value(): string | undefined;
+    exportValue(): string;
+}
+declare const createCommonNote: (gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common) => ProxyOriginal<CommonNote>;
+
+interface ISourceCitationStructure extends Common, IMultimediaLinkStructure {
+    SOUR?: Common & {
+        PAGE?: Common;
+        DATA?: Common & {
+            DATE?: Common & {
+                TIME?: Common;
+                PHRASE?: Common;
+            };
+            TEXT?: Common & {
+                MIME?: Common;
+                LANG?: Common;
+            };
+        };
+        EVEN?: Common & {
+            PHRASE?: Common;
+            ROLE?: Common & {
+                PHRASE?: Common;
+            };
+        };
+        QUAY?: Common;
+    } & INoteStructure;
+}
+
+interface INoteStructure extends Common {
+    NOTE?: CommonNote & {
+        MIME?: Common;
+        LANG?: Common;
+        TRAN?: Common & {
+            MIME?: Common;
+            LANG?: Common;
+        };
+    } & ISourceCitationStructure;
+    SNOTE?: Common;
+}
+
+interface IAssociationStructure extends Common, INoteStructure, ISourceCitationStructure {
+    ASSO?: Common & {
+        PHRASE?: Common;
+        ROLE?: Common & {
+            PHRASE?: Common;
+        };
+    };
+}
+
+interface ILdsOrdinanceDetailStructure extends Common, INoteStructure, ISourceCitationStructure, IPlaceStructure {
+    DATE?: Common & {
+        TIME?: Common;
+        PHRASE?: Common;
+    };
+    TEMP?: Common;
+    STAT?: Common & {
+        DATE?: Common;
+        TIME?: Common;
+    };
+}
+
+interface ILdsSpouseSealingStructure extends Common {
+    SLSG?: Common & ILdsOrdinanceDetailStructure;
+}
+
+interface IMarriageDateStructure extends Common, INoteStructure {
+    MARR?: Common & IDateStructure & IPlaceStructure;
+    HUSB?: Common;
+    WIFE?: Common;
+}
+
+interface INonEventStructure extends Common {
+    NO?: Common & {
+        DATE?: Common & {
+            PHRASE?: Common;
+        };
+    } & INoteStructure & ISourceCitationStructure;
+}
+
+interface IFamilyStructure extends Common, IMarriageDateStructure, IChangeDateStructure, ICreationDateStructure, IAssociationStructure, ILdsSpouseSealingStructure, IMultimediaLinkStructure, INonEventStructure, INoteStructure, ISourceCitationStructure {
+    RESN?: Common;
+    HUSB?: Common & {
+        PHRASE?: Common;
+    };
+    WIFE?: Common & {
+        PHRASE?: Common;
+    };
+    CHIL?: Common & {
+        PHRASE?: Common;
+    };
+    SUBM?: Common;
+    /**
+     * Custom tag indicating this family is not connected to the root person's ancestry.
+     * This means none of the family members (spouses or children) are:
+     * - Direct ancestors of the root person
+     * - Spouses of direct ancestors
+     * - Descendants of direct ancestors (recursive)
+     * - Spouses of descendants (recursive)
+     */
+    _IS_ORPHAN_FAMILY?: Common;
+}
+
+declare class Fam extends Common<string, FamKey> implements IFam {
+    private getFamilyMembers;
+    getChildren(): Individuals;
+    getHusband(): Individuals;
+    getWife(): Individuals;
+    getParents(): Individuals;
+    toList(): Families;
+}
+type FamType = Fam & IFamilyStructure;
+declare const createFam: (gedcom: GedComType, id: FamKey, main?: Common, parent?: Common) => ProxyOriginal<FamType>;
+
+interface IFamilies extends IList<FamKey, FamType> {
+    getParents: () => Individuals;
+    getChildren: () => Individuals;
+}
+
+declare class Families extends List<FamKey, FamType> implements IFamilies {
+    copy(): Families;
+    except(item: FamType): Families;
+    filter(filters: Filter | FilterIterator<FamType, FamKey>): Families;
+    find(filters: Filter | FilterIterator<FamType, FamKey>): FamType | undefined;
+    orderBy(orders: Order | OrderIterator<FamType, FamKey>): Families;
+    getParents(): Individuals;
+    getChildren(): Individuals;
+    toList(): Families;
+}
+
+type GeneratorKey = `${"2nd" | "3rd" | `${4 | 5 | 6 | 7 | 8 | 9}th`}`;
+type GeneratorType = "Cousins" | "GreatGrandParents" | "GreatGrandChildren";
+type GeneratedIndiMethods = Record<`get${GeneratorKey}${GeneratorType}`, () => Individuals>;
+type MediaList = Record<string, {
+    key: string;
+    id: string;
+    imgId: string;
+    tree: string;
+    person: IndiKey;
+    title: string;
+    url: string;
+    contentType: string;
+    downloadName: string;
+}>;
+interface IIndi extends Common<string, IndiKey> {
+    getBirthDate: (showDays?: boolean, shortNote?: boolean, showNote?: boolean) => string | undefined;
+    getDeathDate: (showDays?: boolean, shortNote?: boolean, showNote?: boolean) => string | undefined;
+    getBirthPlace: () => string | undefined;
+    getDeathPlace: () => string | undefined;
+    isParentOf: (indi?: IndiKey | IndiType) => IndiKey | boolean;
+    isChildOf: (indi?: IndiKey | IndiType) => IndiKey | boolean;
+    isSiblingOf: (indi?: IndiKey | IndiType) => IndiKey | boolean;
+    isSpouseOf: (indi?: IndiKey | IndiType) => IndiKey | boolean;
+    isParentInLawOf: (indi?: IndiKey | IndiType) => IndiKey | boolean;
+    isChildInLawOf: (indi?: IndiKey | IndiType) => IndiKey | boolean;
+    isSiblingInLawOf: (indi?: IndiKey | IndiType) => IndiKey | boolean;
+    toFamilies: (list?: List) => Families;
+    getAscendants: () => Individuals;
+    getDescendants: () => Individuals;
+    getRelativesOnLevel: () => Individuals;
+    getRelativesOnDegree: () => Individuals;
+    getAllDescendants: () => Individuals;
+    getAllAscendants: () => Individuals;
+    getSiblings: () => Individuals;
+    getBrothers: () => Individuals;
+    getSisters: () => Individuals;
+    getChildren: () => Individuals;
+    getAdoptedChildren: () => Individuals;
+    getBirthChildren: () => Individuals;
+    getFosterChildren: () => Individuals;
+    getSealingChildren: () => Individuals;
+    getStepChildren: () => Individuals;
+    getSons: () => Individuals;
+    getAdoptedSons: () => Individuals;
+    getBirthSons: () => Individuals;
+    getFosterSons: () => Individuals;
+    getSealingSons: () => Individuals;
+    getStepSons: () => Individuals;
+    getDaughters: () => Individuals;
+    getAdoptedDaughters: () => Individuals;
+    getBirthDaughters: () => Individuals;
+    getFosterDaughters: () => Individuals;
+    getSealingDaughters: () => Individuals;
+    getStepDaughters: () => Individuals;
+    getParents: () => Individuals;
+    getAdoptedParents: () => Individuals;
+    getBirthParents: () => Individuals;
+    getFosterParents: () => Individuals;
+    getSealingParents: () => Individuals;
+    getStepParents: () => Individuals;
+    getFathers: () => Individuals;
+    getAdoptedFathers: () => Individuals;
+    getBirthFathers: () => Individuals;
+    getFosterFathers: () => Individuals;
+    getSealingFathers: () => Individuals;
+    getStepFathers: () => Individuals;
+    getMothers: () => Individuals;
+    getAdoptedMothers: () => Individuals;
+    getBirthMothers: () => Individuals;
+    getFosterMothers: () => Individuals;
+    getSealingMothers: () => Individuals;
+    getStepMothers: () => Individuals;
+    getSpouses: () => Individuals;
+    getCoParents: () => Individuals;
+    getWives: () => Individuals;
+    getHusbands: () => Individuals;
+    getCousins: () => Individuals;
+    getGrandParents: () => Individuals;
+    getGrandFathers: () => Individuals;
+    getGrandMothers: () => Individuals;
+    getGrandChildren: () => Individuals;
+    getGrandSons: () => Individuals;
+    getGrandDaughters: () => Individuals;
+    getGreatGrandParents: () => Individuals;
+    getGreatGrandFathers: () => Individuals;
+    getGreatGrandMothers: () => Individuals;
+    getGreatGrandChildren: () => Individuals;
+    getGreatGrandSons: () => Individuals;
+    getGreatGrandDaughters: () => Individuals;
+    getNiblings: () => Individuals;
+    getNieces: () => Individuals;
+    getNephews: () => Individuals;
+    getAuncles: () => Individuals;
+    getAunts: () => Individuals;
+    getUncles: () => Individuals;
+    getParentsInLaw: () => Individuals;
+    getFathersInLaw: () => Individuals;
+    getMothersInLaw: () => Individuals;
+    getChildrenInLaw: () => Individuals;
+    getSonsInLaw: () => Individuals;
+    getDaughtersInLaw: () => Individuals;
+    getSiblingsInLaw: () => Individuals;
+    getBrothersInLaw: () => Individuals;
+    getSistersInLaw: () => Individuals;
+}
+
+type Kinship = "self" | "spouse" | "child" | "parent";
+interface IKinshipTranslator {
+    isOfSpouse: boolean;
+    isSpouseOf: boolean;
+    displayName: "none" | "givenname" | "surname" | "all";
+    parent: () => string | undefined;
+    child: () => string | undefined;
+    sibling: () => string | undefined;
+    spouse: () => string | undefined;
+    indirect: () => string | undefined;
+    removal: () => string | undefined;
+    inLaw: (relation?: string) => string | undefined;
+    ofSpouse: (relation?: string) => string | undefined;
+    spouseOf: (relation?: string) => string | undefined;
+    relationType: (relation?: string) => string | undefined;
+    of: (relation?: string) => string | undefined;
+}
+
+type Language = "en" | "hu" | "de" | "es" | "fr";
+interface Cases {
+    nominativus: string;
+    dativus: string;
+    possessivus: string;
+}
+type CrossCase = Record<string, Cases>;
+type CrossCases = Record<keyof Cases, CrossCase>;
+
+declare class CommonName extends Common<string> {
+    NPFX?: Common;
+    GIVN?: Common;
+    NICK?: Common;
+    SPFX?: Common;
+    SURN?: Common;
+    NSFX?: Common;
+    DISPLAY?: Common;
+    _MARNM?: Common;
+    constructor(gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common);
+    set value(value: string | undefined);
+    get value(): string | undefined;
+    name(value: string | undefined): this;
+}
+declare const createCommonName: (gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common) => ProxyOriginal<CommonName>;
+
+interface IEventDetailStructure extends IDateStructure, IPlaceStructure, IAddressStructure, IAssociationStructure, INoteStructure, ISourceCitationStructure, IMultimediaLinkStructure {
+    PHON?: Common;
+    EMAIL?: Common;
+    FAX?: Common;
+    WWW?: Common;
+    AGNC?: Common;
+    RELI?: Common;
+    CAUS?: Common;
+    RESN?: Common;
+    SDATE?: Common & {
+        TIME?: Common;
+        PHRASE?: Common;
+    };
+    UID?: Common;
+}
+
+interface IIndividualEventDetailStructure extends IEventDetailStructure {
+    AGE?: Common & {
+        PHRASE?: Common;
+    };
+}
+
+interface IIndividualEventStructure extends IIndividualEventDetailStructure {
+    BAPM?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    BARM?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    BASM?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    BLES?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    BURI?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    CENS?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    CHRA?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    CONF?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    CREM?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    DEAT?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    EMIG?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    FCOM?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    GRAD?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    IMMI?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    NATU?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    ORDN?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    PROB?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    RETI?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    WILL?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+    ADOP?: Common & {
+        TYPE?: Common;
+        FAMC?: Common & {
+            ADOP?: Common & {
+                PHRASE?: Common;
+            };
+        };
+    } & IEventDetailStructure;
+    BIRT?: Common & {
+        TYPE?: Common;
+        FAMC?: Common;
+    } & IEventDetailStructure;
+    CHR?: Common & {
+        TYPE?: Common;
+        FAMC?: Common;
+    } & IEventDetailStructure;
+    EVEN?: Common & {
+        TYPE?: Common;
+    } & IEventDetailStructure;
+}
+
+interface IIndividualStructure extends Common, IIndividualEventStructure, IChangeDateStructure, ICreationDateStructure, IAssociationStructure, IMultimediaLinkStructure, INonEventStructure, INoteStructure, ISourceCitationStructure {
+    NAME?: CommonName;
+    RESN?: Common;
+    SEX?: Common<"F" | "M">;
+    FAMC?: Common & {
+        PEDI?: Common & {
+            PHRASE?: Common;
+        };
+        STAT?: Common & {
+            PHRASE?: Common;
+        };
+    } & INoteStructure;
+    FAMS?: Common & INoteStructure;
+    SUBM?: Common;
+    ALIA?: Common & {
+        PHRASE?: Common;
+    };
+    ANCI?: Common;
+    DESI?: Common;
+    _WLNK?: Common & {
+        TITL?: Common;
+        NOTE?: CommonNote;
+    };
+    _FS_LINK?: Common;
+    _FS_ID?: Common;
+    INDIVIDUALINTERNALHYPERLINK?: Common;
+}
+
+interface Place {
+    key: string;
+    index: number;
+    obj?: Common;
+    ref?: Common;
+    place?: string;
+}
+declare enum PlaceType {
+    All = "ALL",
+    Birth = "BIRT",
+    Marriage = "MARR",
+    Death = "DEAT",
+    Events = "EVEN",
+    Military = "_MILT",
+    MilitaryId = "_MILTID"
+}
+declare const getPlaces: (common: Common | List, type?: PlaceType | Tag | Array<PlaceType | Tag>, maxLevel?: number, level?: number, mainKey?: string) => Place[];
+
+declare enum Existed {
+    SPOUSE = "spouse",
+    YES = "yes"
+}
+declare enum CustomTags {
+    UnknownGivenname = "Unknown givenname",
+    UnknownSurname = "Unknown surname",
+    UnattachedMember = "Unattached member",
+    IgnoredMember = "Ignored member",
+    UnknownAncestor = "Unknown Ancestor"
+}
+declare class Indi extends Common<string, IndiKey> implements IIndi {
+    private _isUnknownAncestor?;
+    private _isUnattachedMember?;
+    private _isOrphanFamilyMember?;
+    private _isUnknownGivenname?;
+    private _isUnknownSurname?;
+    private _isIgnoredPerson?;
+    private _isEmpty?;
+    private readonly _places?;
+    toName(): string;
+    toNaturalName(): string;
+    toList(): Individuals;
+    private generateTree;
+    getPlaces(type?: PlaceType | PlaceType[], maxLevel?: number): Place[];
+    getTree(props?: {
+        descendants?: boolean;
+        offspringSpouses?: boolean;
+        ancestorSpouses?: boolean;
+        onlyDescendants?: boolean;
+        maxGen?: number;
+        minGen?: number;
+        drawNonBiologicalAncestors?: boolean;
+        ancestorSiblings?: boolean;
+    }): {
+        gen: number;
+        indis: TreeMember<IndiType>[];
+        half: number;
+    }[];
+    getGenealogy(onlyStraight?: boolean, showDescendants?: boolean): MemberSide<IndiType, {
+        gen: number;
+    }>[];
+    ancestryLink(): string;
+    ancestryMedia(namespace?: string | number): Promise<MediaList>;
+    myheritageLink(poolId?: number): string;
+    myheritageMedia(): MediaList;
+    familySearchLink(): string | undefined;
+    hasFamilySearchMatches(): boolean;
+    getFamilySearchMatches(): FamilySearchMatch[];
+    hasFamilySearchSources(): boolean;
+    getFamilySearchSources(): FamilySearchSource[];
+    multimedia(namespace?: string | number): Promise<MediaList | undefined>;
+    link(poolId?: number): string;
+    toFamilies(list?: List): Families;
+    getFamilies(type: "FAMC" | "FAMS"): Families;
+    getFamiliesBiologicalFirst(type: "FAMC" | "FAMS"): Families;
+    getBirthDate(showDays?: boolean, shortNote?: boolean, showNote?: boolean): string;
+    getDeathDate(showDays?: boolean, shortNote?: boolean, showNote?: boolean): string;
+    getBirthPlace(): string;
+    getDeathPlace(): string;
+    isDead(): boolean;
+    isEmpty(): boolean;
+    isUnknownAncestor(): boolean;
+    isIgnoredMember(): boolean;
+    isUnattachedMember(): boolean;
+    isOrphanFamilyMember(): boolean;
+    isUnknownGivenname(): boolean;
+    isUnknownSurname(): boolean;
+    isNonRelevantMember(): boolean;
+    isMale(): boolean;
+    isFemale(): boolean;
+    isUnknownSex(): boolean;
+    getParentType(id: IndiType | IndiKey): RelationType;
+    hasFacts(): boolean;
+    getLinks(): List<IdType, Required<IIndividualStructure>["_WLNK"]> | undefined;
+    getAkas(limit?: number): List<IdType, Common<string, IdType>>;
+    getFacts(limit?: number, filter?: MultiTag | MultiTag[]): List<IdType, Common<string, IdType>>;
+    commonAncestor(person?: IndiKey | IndiType, options?: {
+        breakAfterSpouse?: boolean;
+        breakAfterNonBiological?: boolean;
+    }): IndiType | undefined;
+    path(person?: IndiKey | IndiType, options?: {
+        breakAfterSpouse?: boolean;
+        breakAfterNonBiological?: boolean;
+    }): ReducedPath | undefined;
+    kinship<T extends boolean | undefined>(other?: IndiKey | IndiType, showMainPerson?: boolean, lang?: Language, entirePath?: T, displayName?: "none" | "givenname" | "surname" | "all"): (T extends false | undefined ? string : Array<{
+        id?: IndiKey;
+        gen: number;
+        relative?: string;
+        absolute?: string;
+    }>) | undefined;
+    private isRelativeOf;
+    isSiblingOf(indi?: IndiKey | IndiType): boolean;
+    isFullSiblingOf(indi?: IndiKey | IndiType): boolean;
+    isHalfSiblingOf(indi?: IndiKey | IndiType): boolean;
+    isSpouseOf(indi?: IndiKey | IndiType): boolean;
+    isParentOf(indi?: IndiKey | IndiType): boolean;
+    isChildOf(indi?: IndiKey | IndiType): boolean;
+    isSiblingInLawOf(indi?: IndiKey | IndiType): boolean;
+    isParentInLawOf(indi?: IndiKey | IndiType): boolean;
+    isChildInLawOf(indi?: IndiKey | IndiType): boolean;
+    getRelativesOnDegree(degree?: number): Individuals;
+    getRelativesOnLevel(level?: number, filter?: Filter): Individuals;
+    getAscendants(level?: number, filter?: Filter): Individuals;
+    getDescendants(level?: number, filter?: Filter): Individuals;
+    getAllDescendantsRaw(individuals?: Individuals, containDescendantsInLaw?: boolean): {
+        relatives: Individuals;
+        generations: Record<number, Individuals>;
+    };
+    getAllDescendants(individuals?: Individuals, containDescendantsInLaw?: boolean): Individuals;
+    getAllAscendantsRaw(individuals?: Individuals): {
+        relatives: Individuals;
+        generations: Record<number, Individuals>;
+    };
+    getAllAscendants(individuals?: Individuals): Individuals;
+    getHalfSiblings(): Individuals;
+    getFullSiblings(): Individuals;
+    getSiblings(): Individuals;
+    getBrothers(): Individuals;
+    getSisters(): Individuals;
+    getChildren(filter?: Filter): Individuals;
+    private getChildrenFilteredByPedigree;
+    getBiologicalChildren(): Individuals;
+    getAdoptedChildren(): Individuals;
+    getBirthChildren(): Individuals;
+    getFosterChildren(): Individuals;
+    getSealingChildren(): Individuals;
+    getStepChildren(): Individuals;
+    getSons(): Individuals;
+    getBiologicalSons(): Individuals;
+    getAdoptedSons(): Individuals;
+    getBirthSons(): Individuals;
+    getFosterSons(): Individuals;
+    getSealingSons(): Individuals;
+    getStepSons(): Individuals;
+    getDaughters(): Individuals;
+    getBiologicalDaugthers(): Individuals;
+    getAdoptedDaughters(): Individuals;
+    getBirthDaughters(): Individuals;
+    getFosterDaughters(): Individuals;
+    getSealingDaughters(): Individuals;
+    getStepDaughters(): Individuals;
+    getParents(filter?: Filter): Individuals;
+    private getParentsFilteredByPedigree;
+    private getSpousesFilteredByPartner;
+    getBiologicalParents(): Individuals;
+    getAdoptedParents(): Individuals;
+    getBirthParents(): Individuals;
+    getFosterParents(): Individuals;
+    getSealingParents(): Individuals;
+    getStepParents(): Individuals;
+    getFathers(): Individuals;
+    getBiologicalFathers(): Individuals;
+    getAdoptedFathers(): Individuals;
+    getBirthFathers(): Individuals;
+    getFosterFathers(): Individuals;
+    getSealingFathers(): Individuals;
+    getStepFathers(): Individuals;
+    getMothers(): Individuals;
+    getBiologicalMothers(): Individuals;
+    getAdoptedMothers(): Individuals;
+    getBirthMothers(): Individuals;
+    getFosterMothers(): Individuals;
+    getSealingMothers(): Individuals;
+    getStepMothers(): Individuals;
+    getCoParents(): Individuals;
+    getSpouses(): Individuals;
+    getPartners(): Individuals;
+    getFriends(): Individuals;
+    getWives(): Individuals;
+    getHusbands(): Individuals;
+    getCousins(): Individuals;
+    getGrandParents(): Individuals;
+    getGrandFathers(): Individuals;
+    getGrandMothers(): Individuals;
+    getGrandChildren(): Individuals;
+    getGrandSons(): Individuals;
+    getGrandDaughters(): Individuals;
+    getGreatGrandParents(): Individuals;
+    getGreatGrandFathers(): Individuals;
+    getGreatGrandMothers(): Individuals;
+    getGreatGrandChildren(): Individuals;
+    getGreatGrandSons(): Individuals;
+    getGreatGrandDaughters(): Individuals;
+    getAuncles(): Individuals;
+    getAunts(): Individuals;
+    getUncles(): Individuals;
+    getNiblings(): Individuals;
+    getNieces(): Individuals;
+    getNephews(): Individuals;
+    getParentsInLaw(): Individuals;
+    getFathersInLaw(): Individuals;
+    getMothersInLaw(): Individuals;
+    getSiblingsInLaw(): Individuals;
+    getBrothersInLaw(): Individuals;
+    getSistersInLaw(): Individuals;
+    getChildrenInLaw(): Individuals;
+    getSonsInLaw(): Individuals;
+    getDaughtersInLaw(): Individuals;
+    get2ndCousins(): Individuals;
+    get2ndGreatGrandParents(): Individuals;
+    get2ndGreatGrandChildren(): Individuals;
+    get3rdCousins(): Individuals;
+    get3rdGreatGrandParents(): Individuals;
+    get3rdGreatGrandChildren(): Individuals;
+    get4thCousins(): Individuals;
+    get4thGreatGrandParents(): Individuals;
+    get4thGreatGrandChildren(): Individuals;
+    get5thCousins(): Individuals;
+    get5thGreatGrandParents(): Individuals;
+    get5thGreatGrandChildren(): Individuals;
+    get6thCousins(): Individuals;
+    get6thGreatGrandParents(): Individuals;
+    get6thGreatGrandChildren(): Individuals;
+    get7thCousins(): Individuals;
+    get7thGreatGrandParents(): Individuals;
+    get7thGreatGrandChildren(): Individuals;
+    get8thCousins(): Individuals;
+    get8thGreatGrandParents(): Individuals;
+    get8thGreatGrandChildren(): Individuals;
+    get9thCousins(): Individuals;
+    get9thGreatGrandParents(): Individuals;
+    get9thGreatGrandChildren(): Individuals;
+}
+type IndiType = Indi & IIndividualStructure & GeneratedIndiMethods;
+interface FamilySearchMatch {
+    id?: string;
+    title?: string;
+    type?: string;
+    ref?: string;
+    score?: number;
+    text?: string;
+    www?: string;
+    notes?: string[];
+    status?: string;
+    gender?: string;
+    lifespan?: string;
+    birthDate?: string;
+    birthPlace?: string;
+    deathDate?: string;
+    deathPlace?: string;
+    marriageDate?: string;
+    marriagePlace?: string;
+}
+interface FamilySearchSource {
+    id?: string;
+    title?: string;
+    text?: string;
+    www?: string;
+    notes?: string[];
+}
+interface TreeMember<T = IndiType> {
+    id: FamKey | IndiKey;
+    index: number;
+    father?: T;
+    mother?: T;
+    fatherSpouses?: T[];
+    motherSpouses?: T[];
+}
+type GenealogyMember<T = IndiType> = TreeMember<T> & {
+    fatherSiblings?: T[];
+    motherSiblings?: T[];
+};
+interface IndiTree<T = IndiType> {
+    existed: Record<IndiKey, Existed | undefined>;
+    tree: Record<number, Array<TreeMember<T> | undefined>>;
+    halves: Record<number, number | undefined>;
+    lastItems: Record<number, TreeMember<T> | undefined>;
+}
+type IndiGenealogy<T = IndiType> = Pick<IndiTree<T>, "existed" | "halves" | "lastItems"> & {
+    tree: Record<number, Array<GenealogyMember<T> | undefined>>;
+};
+interface IndiMarker<T = IndiType> {
+    isPrev?: boolean;
+    isNext?: boolean;
+    items: Array<T | undefined>;
+}
+type MemberSide<T = IndiType, O extends object = object> = {
+    left: Array<Array<T | undefined> | undefined>;
+    right: Array<Array<T | undefined> | undefined>;
+} & O;
+type MemberMain<T = IndiType> = MemberSide<T> & {
+    main: MemberSide<T>;
+};
+interface GenerationSpouseType {
+    indi: IndiType;
+    extra?: boolean;
+    normal?: boolean;
+}
+interface GenerationIndiType {
+    indi: IndiType;
+    leftSpouses?: GenerationSpouseType[];
+    rightSpouses?: GenerationSpouseType[];
+}
+type IndiGenealogyGenerations<T = IndiType> = Record<number, MemberMain<T>>;
+type IndiGenealogyResult<T = IndiType> = Record<number, MemberSide<T>>;
+type NonNullIndiGenealogyResult<T = IndiType> = Record<number, Array<Array<T | undefined>>>;
+interface PathItem {
+    indi: IndiType;
+    level: number;
+    levelUp: number;
+    levelDown: number;
+    degree: number;
+    kinship: Kinship;
+    relation?: RelationType;
+    inLaw?: boolean;
+    breakOnNext?: boolean;
+    breakAfterNext?: boolean;
+}
+type Path = PathItem[];
+type ReducedPath = Array<Omit<PathItem, "breakOnNext" | "breakAfterNext">>;
+type QueueItem = {
+    path: Path;
+} & PathItem;
+type Queue = QueueItem[];
+declare const createIndi: (gedcom: GedComType, id: IndiKey, main?: Common, parent?: Common) => ProxyOriginal<IndiType>;
+
+interface IIndividuals extends IList<IndiKey, IndiType> {
+    toName: () => List;
+    isParentOf: (indi?: IndiKey | IndiType, every?: boolean) => IndiKey | boolean;
+    isChildOf: (indi?: IndiKey | IndiType, every?: boolean) => IndiKey | boolean;
+    isSiblingOf: (indi?: IndiKey | IndiType, every?: boolean) => IndiKey | boolean;
+    isSpouseOf: (indi?: IndiKey | IndiType, every?: boolean) => IndiKey | boolean;
+    isParentInLawOf: (indi?: IndiKey | IndiType, every?: boolean) => IndiKey | boolean;
+    isChildInLawOf: (indi?: IndiKey | IndiType, every?: boolean) => IndiKey | boolean;
+    splitByFamily: (type: "Spouses" | "Children") => {
+        items: Record<FamKey, Individuals | undefined>;
+        lengthOfFamily: number;
+        lengthOfIndividuals: number;
+    };
+    getAscendants: () => Individuals;
+    getDescendants: () => Individuals;
+    getAllAscendants: () => Individuals;
+    getAllDescendants: () => Individuals;
+    getRelativesOnLevel: () => Individuals;
+    getRelativesOnDegree: () => Individuals;
+    getSpouses: () => Individuals;
+    getCoParents: () => Individuals;
+    getSiblings: () => Individuals;
+    getChildren: () => Individuals;
+    getParents: () => Individuals;
+}
+
+interface Settings {
+    maxGivennames: number;
+    maxSurnames: number;
+    showSuffix: boolean;
+    dateFormatPattern: string;
+    nameOrder: NameOrder;
+    placeOrder: PlaceOrder;
+    linkedPersons?: LinkedPersons;
+    linkingKey?: MultiTag;
+}
+
+declare class Individuals extends List<IndiKey, IndiType> implements IIndividuals {
+    copy(): Individuals;
+    except(item: IndiType): Individuals;
+    filter(filters: Filter | FilterIterator<IndiType, IndiKey>): Individuals;
+    find(filters: Filter | FilterIterator<IndiType, IndiKey>): IndiType | undefined;
+    unattachedFilter(useUnattached: boolean): Individuals;
+    orderBy(orders: Order | OrderIterator<IndiType, IndiKey>): Individuals;
+    getFirstEvent(): IndiType;
+    getLastEvent(): IndiType;
+    getFirstBirth(): IndiType;
+    getLastBirth(): IndiType;
+    getFirstDeath(): IndiType;
+    getLastDeath(): IndiType;
+    groupBy(group: Group | GroupIterator<IndiType, IndiKey>, sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, lessOccuranceLabel?: string): Record<string, Individuals>;
+    groupByFirstLetters(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, settings?: Settings): Record<string, Individuals>;
+    groupBySurnames(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number): Record<string, Individuals>;
+    groupByTimeRanges(range: Range, sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number): Record<string, Individuals>;
+    nestedGroupByPlacesAndTimeRanges(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, uniqueCounting?: boolean): NestedGroup;
+    nestedGroupByTimeRangesAndPlaces(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, uniqueCounting?: boolean): NestedGroup;
+    nestedGroupByPlaces(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, partOrder?: "original" | "reverse", translate?: boolean, uniqueCounting?: boolean, groupKeyTranslator?: (parts: string[]) => string | undefined): NestedGroup;
+    groupByPlaces(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, partOrder?: "original" | "reverse", translate?: boolean, groupKeyTranslator?: (parts: string[]) => string | undefined): Record<string, Individuals>;
+    getFacts(): List<IdType, Common<string, IdType>>;
+    private isRelativeOf;
+    isSiblingOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isSpouseOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isParentOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isChildOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isParentInLawOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isChildInLawOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    splitByFamily(type: "Spouses" | "Parents" | "Children", relativeTo?: IndiType): {
+        items: Record<`@F${number}@` | `@XF${number}@` | `@XXF${number}@`, Individuals>;
+        lengthOfFamily: number;
+        lengthOfIndividuals: number;
+    };
+    getRelativesOnDegree(degree?: number): Individuals;
+    getRelativesOnLevel(level?: number, filter?: Filter): Individuals;
+    getAscendants(level?: number, filter?: Filter): Individuals;
+    getDescendants(level?: number, filter?: Filter): Individuals;
+    getAllAscendants(individuals?: Individuals): Individuals;
+    getAllDescendants(individuals?: Individuals, containDescendantsInLaw?: boolean): Individuals;
+    getSiblings(): Individuals;
+    getChildren(): Individuals;
+    getParents(): Individuals;
+    getCoParents(): Individuals;
+    getSpouses(): Individuals;
+    toName(): List<IdType, Common<string, IdType>>;
+    toList(): Individuals;
+}
+
+type ConvertType = "FAM" | "INDI" | "_INDI" | "OBJE" | "SOUR" | "REPO" | "SUBM";
+type IndiKey = `@${"I" | "P" | "XI" | "XXI"}${number}@`;
+type FamKey = `@${"F" | "XF" | "XXF"}${number}@`;
+type ObjeKey = `@O${number}@`;
+type RepoKey = `@R${number}@`;
+type SourKey = `@S${number}@`;
+type SubmKey = `@SUBM${number}@`;
+type TagKey = `@T${number}@`;
+type UnknownKey = `@U${number}@`;
+type IdType = IndiKey | FamKey | ObjeKey | SourKey | RepoKey | SubmKey | UnknownKey;
+declare enum RelationType {
+    BIOLOGICAL = "biological",
+    ADOPTED = "adopted",
+    FOSTER = "foster",
+    SEALING = "sealing",
+    BIRTH = "birth",
+    STEP = "step"
+}
+declare enum PartnerType {
+    SPOUSE = "spouse",
+    PARTNER = "partner",
+    FRIEND = "friend",
+    SINGLE = "single",
+    OTHER = "other",
+    UNKOWN = "unknown"
+}
+interface NonStandard {
+    value?: any;
+    id?: any;
+}
+interface Tags {
+    _PRIM?: Common<"Y" | "N">;
+    _EXPORTED_FROM_SITE_ID?: Common;
+    _CLON?: Common;
+    _MSER?: Common;
+    _OID?: Common;
+    _LKID?: Common;
+    _PHOTO_RIN?: Common;
+    _MTTAG?: Common & {
+        NAME?: Common;
+    };
+    _MTCAT?: Common & {
+        NAME?: Common;
+    };
+    _SREL?: Common;
+    _FREL?: Common;
+    _MREL?: Common;
+    _MILT?: Common;
+    _MILTID?: Common;
+    _ORIG?: Common;
+    _LABEL?: Common;
+    _WLNK?: Common;
+    _MARNM?: Common;
+    _INDI?: Common;
+    _GUESSEDORIGINAL?: Common;
+    _FS_LINK?: Common;
+    _FS_ID?: Common;
+    _FS_MATCH?: Common;
+    _FS_SOUR?: Common;
+    _IS_ORPHAN_FAMILY?: Common<"Y" | "N">;
+    SCORE?: Common;
+    TEXT?: Common;
+    REF?: Common;
+    DISPLAYTEXT?: Common;
+    FAM?: Common;
+    INDIVIDUALINTERNALHYPERLINK?: Common;
+    OBJE?: Common;
+    FAMS?: Common;
+    FAMC?: Common;
+    ABBR?: Common;
+    ADDR?: Common;
+    ADR1?: Common;
+    ADR2?: Common;
+    ADOP?: Common;
+    AFN?: Common;
+    AGE?: Common;
+    ALIA?: Common;
+    ANUL?: Common;
+    ARVL?: Common;
+    AUTH?: Common;
+    BAPL?: Common;
+    BAPM?: Common;
+    BARM?: Common;
+    BASM?: Common;
+    BIRT?: Common;
+    CAST?: Common;
+    CAUS?: Common;
+    CENS?: Common;
+    CHIL?: Common;
+    CHR?: Common;
+    CHRA?: Common;
+    CITY?: Common;
+    CONC?: Common;
+    CONF?: Common;
+    CONT?: Common;
+    CONL?: Common;
+    CORP?: Common;
+    CTRY?: Common;
+    DATE?: Common;
+    YEAR?: Common;
+    MONTH?: Common;
+    DAY?: Common;
+    DEAT?: Common;
+    DESC?: Common;
+    DIV?: Common;
+    DIVF?: Common;
+    DSCR?: Common;
+    EDUC?: Common;
+    EMIG?: Common;
+    ENDL?: Common;
+    ENGA?: Common;
+    EVEN?: Common;
+    FCOM?: Common;
+    FOST?: Common;
+    GIVN?: Common;
+    GRAD?: Common;
+    HEAD?: Common;
+    HUSB?: Common;
+    ILLE?: Common;
+    IMMI?: Common;
+    INDI?: Common;
+    LANG?: Common;
+    LEGA?: Common;
+    LVG?: Common;
+    MARB?: Common;
+    MARC?: Common;
+    MARL?: Common;
+    MARR?: Common;
+    MARS?: Common;
+    MISC?: Common;
+    NAME?: Common;
+    NATI?: Common;
+    NATU?: Common;
+    NICK?: Common;
+    NOTE?: Common;
+    NPFX?: Common;
+    NSFX?: Common;
+    OCCU?: Common;
+    OCCUPATION?: Common;
+    OCCUPATIONS?: Common;
+    ORDI?: Common;
+    ORDL?: Common;
+    ORDN?: Common;
+    PEDI?: Common;
+    PART?: Common;
+    PHON?: Common;
+    PLAC?: Common;
+    POST?: Common;
+    PRIV?: Common;
+    PROB?: Common;
+    RACE?: Common;
+    RELI?: Common;
+    RESI?: Common;
+    RETI?: Common;
+    SEX?: Common<"F" | "M">;
+    SLGC?: Common;
+    SLGS?: Common;
+    SOUR?: Common;
+    SPFX?: Common;
+    SSN?: Common;
+    STAE?: Common;
+    STAT?: Common;
+    STIL?: Common;
+    SUBM?: Common;
+    SURN?: Common;
+    REPO?: Common;
+    TEL?: Common;
+    TEMP?: Common;
+    TIME?: Common;
+    TITL?: Common;
+    WIFE?: Common;
+    WILL?: Common;
+    RIN?: Common;
+    FILE?: Common;
+    AKA?: Common;
+    FACT?: Common;
+    TYPE?: Common;
+    VERS?: Common;
+    FORM?: Common;
+    WWW?: Common;
+    BAPT?: Common;
+    CHRI?: Common;
+    BURI?: Common;
+}
+type Tag = keyof Tags | keyof NonStandard;
+type ListTag = `@@${keyof Tags}`;
+type MultiTag = ListTag | Tag | `${Tag}.${Tag}`;
+type FilterIterator<T, K> = (item: T, key: K | number, index: number) => boolean;
+type Filter<T = unknown> = Partial<Record<MultiTag, T>>;
+type RequiredFilter<T extends Tag, F = unknown> = Required<Pick<Filter<F>, T>> & Partial<Omit<Filter<F>, T>>;
+interface OrderDefinition {
+    direction: "ASC" | "DESC";
+    getter?: (orig: unknown, raw?: Common) => unknown;
+}
+type Order = MultiTag | Partial<Record<MultiTag, OrderDefinition>>;
+type OrderIterator<T, K> = (itemA: T, keyA: K | number, itemB: T, keyB: K | number) => number;
+interface GroupDefinition {
+    getter?: (orig: unknown, raw?: Common) => unknown;
+}
+type Group = MultiTag | Partial<Record<MultiTag, GroupDefinition>>;
+type GroupMarker = {
+    marker?: string;
+    group: string;
+};
+type GroupIterator<T, K> = (item: T, key: K | number) => string | string[] | GroupMarker[];
+declare enum Range {
+    Year = 1,
+    FiveYear = 5,
+    Decade = 10,
+    FiftyYear = 50,
+    Century = 100
+}
+type NestedGroup = {
+    [Key: string]: NestedGroup;
+} & {
+    items?: Individuals;
+    length?: number;
+};
+type NameOrder = "first-last" | "last-first";
+type PlaceOrder = "country-to-city" | "city-to-country";
+type LinkedPersons = "merge" | "clone" | "skip";
+
+interface IList<K extends IdType = IdType, T extends Common = Common> {
+    readonly length: number;
+    marker?: string;
+    isListable: boolean;
+    has: (item?: K | T) => boolean;
+    get: (name: MultiTag) => List;
+    keys: () => K[];
+    values: () => Array<T | undefined>;
+    entries: () => Array<[K, T | undefined]>;
+    getIf: (name: MultiTag, condition: string, name2: MultiTag) => List;
+    setLength: () => void;
+    item: (name: K, value?: T) => T | undefined;
+    removeItem: (name: K) => void;
+    exclude: (mergedList: List<K, T>) => List<K, T>;
+    prepend: (item: T) => List<K, T>;
+    append: (item: T) => List<K, T>;
+    merge: (mergedList: List<K, T>) => List<K, T>;
+    intersection: (mergedList: List<K, T>) => List<K, T>;
+    difference: (mergedList: List<K, T>) => List<K, T>;
+    concat: (items: Partial<Record<K, T>>) => List<K, T>;
+    delete: (item: T) => List<K, T>;
+    copy: (ClassName?: typeof List<K, T>) => List<K, T>;
+    except: (item: T, ClassName?: typeof List<K, T>) => List<K, T>;
+    filter: (filters: Filter | FilterIterator<T, K>, ClassName?: typeof List<K, T>) => List<K, T>;
+    find: (filters: Filter | FilterIterator<T, K>, ClassName?: typeof List<K, T>) => T | undefined;
+    orderBy: (orders: Order | OrderIterator<T, K>, ClassName?: typeof List<K, T>) => List<K, T>;
+    groupBy: (orders: Group | GroupIterator<T, K>, sort?: "length" | "group", minOccurance?: number, lessOccuranceLabel?: string, ClassName?: typeof List<K, T>) => Record<string, List<K, T>>;
+    forEach: (iterate: (item: T, key: K | number, index: number) => void) => void;
+    map: <R>(iterate: (item: T, key: K | number, index: number) => R) => void;
+    findIndex: (item: T) => number;
+    first: () => T | undefined;
+    index: (index: number) => T | undefined;
+    last: () => T | undefined;
+    getItems: () => Partial<Record<K, T>>;
+    toValue: (tag: MultiTag) => List;
+    toProp: (tag: MultiTag) => List;
+    toList: () => List;
+    toValueList: () => List;
+    toJson: (tag: MultiTag, options?: ConvertOptions) => string;
+    toObject: (tag: MultiTag, options?: ConvertOptions) => Record<string, string | undefined | ({
+        value?: string;
+    } & Record<string, unknown>) | Array<string | undefined | ({
+        value?: string;
+    } & Record<string, unknown>)>>;
+    toGedcomLines: (tag: MultiTag, level?: number, options?: ConvertOptions) => string[];
+    toGedcom: (tag: MultiTag, level?: number, options?: ConvertOptions) => string;
+}
+
+declare class List<K extends IdType = IdType, T extends Common = Common> implements IList<K, T> {
+    private items;
+    isListable: boolean;
+    marker: string | undefined;
+    constructor(items?: Partial<Record<K, T>> | T[]);
+    get length(): number;
+    has(indi?: K | T): boolean;
+    get(name: MultiTag): List<IdType, Common<string, IdType>>;
+    getIf(name: MultiTag, condition: string, name2: MultiTag): List<IdType, Common<string, IdType>>;
+    keys(): K[];
+    values(): (T | undefined)[];
+    entries(): [K, T | undefined][];
+    setLength(_type?: "increase" | "decrease"): void;
+    first(): Partial<Record<K, T>>[K];
+    last(): Partial<Record<K, T>>[K];
+    index(index: number): Partial<Record<K, T>>[K];
+    item(name: K, value?: T): T | undefined;
+    removeItem(name: K): void;
+    exclude(excludedList: List<K, T>): this;
+    concat(items?: Partial<Record<K, T>> | T[]): this;
+    merge(mergedList?: List<K, T>): this;
+    intersection(mergedList?: List<K, T>): List<K, T>;
+    difference(mergedList?: List<K, T>): List<K, T>;
+    prepend(item: T): this;
+    append(item: T): this;
+    delete(item: T): this;
+    copy(ClassName?: typeof List<K, T>): List<K, T>;
+    except(item: T, ClassName?: typeof List<K, T>): List<K, T>;
+    forEach(iterate: (item: T, key: K, index: number) => void): void;
+    map<R>(iterate: (item: T, key: K, index: number) => R): R[];
+    reduce<R>(iterate: (acc: R, item: T, key: K, index: number) => R, initialValue: R): R;
+    filter(filters: Filter | FilterIterator<T, K>, ClassName?: typeof List<K, T>): List<K, T>;
+    find(filters: Filter | FilterIterator<T, K>, _ClassName?: typeof List<K, T>): T;
+    orderBy(orders: Order | OrderIterator<T, K>, ClassName?: typeof List<K, T>): List<K, T>;
+    groupBy(groups: Group | GroupIterator<T, K>, sort?: "length" | "group" | OrderIterator<List<K, T>, string>, minOccurance?: number, lessOccuranceLabel?: string, ClassName?: typeof List<K, T>): Record<string, List<K, T>>;
+    findIndex(item: T): number;
+    getItems(): Partial<Record<K, T>>;
+    toJson(tag: MultiTag, options?: ConvertOptions): string;
+    toObject(tag: MultiTag, options?: ConvertOptions): Record<string, string | ({
+        value?: string;
+    } & Record<string, unknown>) | (string | ({
+        value?: string;
+    } & Record<string, unknown>))[]>;
+    toGedcom(tag: MultiTag, level?: number, options?: ConvertOptions): string;
+    toGedcomLines(tag: MultiTag, level?: number, options?: ConvertOptions): string[];
+    toValue(): List<IdType, Common<string, IdType>>;
+    toProp(tag: MultiTag): List<IdType, Common<string, IdType>>;
+    toList(): List<IdType, Common<string, IdType>>;
+    toValueList(): List<IdType, Common<string, IdType>>;
+}
+
+interface ConvertOptions {
+    original?: boolean;
+    obje?: {
+        standardize?: boolean;
+        override?: boolean;
+        namespace?: string | number;
+    };
+    super?: boolean;
+}
+interface ICommon<P = string, I extends IdType = IdType> {
+    set value(value: P | undefined);
+    get value(): P | undefined;
+    isListable: boolean;
+    refType?: MultiTag;
+    id?: I;
+    removeValue: () => void;
+    set: <T extends Common | List = Common | List>(name: MultiTag, value: T) => T | undefined;
+    get: <T extends Common | List = Common | List>(name: MultiTag) => T | undefined;
+    remove: (name: MultiTag) => void;
+    getIf: <T extends Common | List = Common | List>(name: MultiTag, condition: string, name2: MultiTag) => T | undefined;
+    assign: <T extends Common | List = Common | List>(name: MultiTag, value: T) => T | undefined;
+    toString: () => string;
+    toValue: () => P | undefined;
+    exportValue: () => P | undefined;
+    toProp: (tag: MultiTag) => Common<P, I> | undefined;
+    toList: () => List;
+    toValueList: () => List;
+    toJson: (tag?: MultiTag, options?: ConvertOptions) => string;
+    toObject: (tag?: MultiTag, options?: ConvertOptions) => Record<string, string | undefined | ({
+        value?: string;
+    } & Record<string, unknown>) | Array<string | undefined | ({
+        value?: string;
+    } & Record<string, unknown>)>>;
+    toGedcomLines: (tag?: MultiTag, level?: number, options?: ConvertOptions) => string[];
+    toGedcom: (tag?: MultiTag, level?: number, options?: ConvertOptions) => string;
+    fromGedcom: (value: string) => void;
+}
+
+declare class Common<T = string, I extends IdType = IdType> implements ICommon<T, I> {
+    protected _gedcom?: GedComType;
+    protected _value?: T;
+    protected _id?: I;
+    protected _main?: Common;
+    protected _parent?: Common;
+    protected _uniqueId?: string | undefined;
+    protected _type?: MultiTag;
+    protected _refs?: List;
+    isListable: boolean;
+    refType?: ListTag;
+    cloneOf?: string;
+    clonedBy?: string;
+    constructor(gedcom?: GedComType, id?: I, main?: Common, parent?: Common);
+    set type(type: MultiTag | undefined);
+    get type(): MultiTag | undefined;
+    initUniqueId(): void;
+    set uniqueId(id: string | undefined);
+    get uniqueId(): string | undefined;
+    set id(id: I | undefined);
+    get id(): I | undefined;
+    set value(value: T | undefined);
+    get value(): T | undefined;
+    /**
+     * Set the gedcom reference for this object
+     * @param gedcom - The GedComType to set as the gedcom reference
+     */
+    setGedcom(gedcom: GedComType): void;
+    get originalValue(): T;
+    get ref(): Common<T, I> | undefined;
+    get main(): Common<string, IdType>;
+    get parent(): Common<string, IdType>;
+    addRef(refNode: Common): void;
+    getRefs(): List<IdType, Common<string, IdType>>;
+    exportValue(): T;
+    removeValue(): void;
+    set<T extends Common | List = Common | List>(name: MultiTag, value: T | string): T | undefined;
+    assign<T extends Common | List = Common | List>(name: MultiTag, value: T, unique?: boolean): T | undefined;
+    get<T extends Common | List = Common | List>(name: MultiTag): T;
+    remove(name: MultiTag): void;
+    getGedcom(): GedComType;
+    getIf<T extends Common | List = Common | List>(name: MultiTag, condition: string, name2: MultiTag): T;
+    toString(): string;
+    toValue(): T;
+    toProp(tag: MultiTag): Common<T, I> | undefined;
+    toList(): List<IdType, Common<string, IdType>>;
+    toValueList(): List<IdType, Common<string, IdType>>;
+    private standardizeObject;
+    toJson(tag?: MultiTag, options?: ConvertOptions): string;
+    toObject(tag?: MultiTag, options?: ConvertOptions): Record<string, string | ({
+        value?: string;
+    } & Record<string, unknown>) | (string | ({
+        value?: string;
+    } & Record<string, unknown>))[]>;
+    merge(other: Common<T, I>, override?: boolean, avoidKeys?: MultiTag[]): this;
+    clone(newId?: boolean, avoidKeys?: MultiTag[]): Common<T, I>;
+    fromGedcom(_value: string): void;
+    toGedcom(tag?: MultiTag, level?: number, options?: ConvertOptions): string;
+    toGedcomLines(tag?: MultiTag, level?: number, options?: ConvertOptions): string[];
+    isGenoPro(): boolean;
+    isAhnenblatt(): boolean;
+    isGeni(): boolean;
+    isAncestry(): boolean;
+    isMyHeritage(): boolean;
+    isFamilySearch(): boolean;
+    getAncestryTreeId(): string | undefined;
+    getMyHeritageTreeId(): string | undefined;
+    getTreeId(): string;
+    getAncestryTreeName(): string | undefined;
+    getMyHeritageTreeName(): string;
+    getTreeName(): string;
+}
+type ProxyOriginal<T extends Common> = T & {
+    unwrapped: T;
+};
+declare const createProxy: <T extends Common>(target: T) => T;
+declare const createCommon: (gedcom?: GedComType, id?: IdType, main?: Common, parent?: Common) => ProxyOriginal<Common>;
+declare const isOnlyMainProp: (key: string | symbol) => key is MultiTag | "_value" | "value";
+declare const isValidKey: <T>(common: Common<T>, key: string | symbol) => key is MultiTag | "_value" | "value" | "id" | "_id";
+declare const getValidKeys: <T>(common: Common<T>) => Array<MultiTag | "_value" | "value" | "id" | "_id">;
+declare const getValidTag: (tag: string) => string;
+declare const getListTag: (tag: string) => ListTag;
+declare const getValidKey: (tag: string, id: string) => string;
+declare const isId: (string: string) => string is IdType;
+declare const idGetter: <T extends IdType>(id?: T) => T;
+
+export { type RepoType as $, type Order as A, type OrderIterator as B, type Cases as C, type Group as D, type GroupMarker as E, type FamKey as F, type GroupDefinition as G, type GroupIterator as H, type IKinshipTranslator as I, type NestedGroup as J, type NameOrder as K, type Language as L, type MultiTag as M, type NonStandard as N, type ObjeKey as O, type PrimitiveRange as P, type PlaceOrder as Q, type Range$1 as R, type SplitResult as S, type TagKey as T, type UnknownKey as U, type LinkedPersons as V, RelationType as W, PartnerType as X, Range as Y, type ProxyOriginal as Z, type SourType as _, isIntersectedRange as a, createSour as a$, type SubmType as a0, type IndiType as a1, type TreeMember as a2, type GenealogyMember as a3, type IndiTree as a4, type IndiGenealogy as a5, type IndiMarker as a6, type MemberSide as a7, type MemberMain as a8, type GenerationSpouseType as a9, createCommonDate as aA, isCommonDate as aB, Fam as aC, createFam as aD, Families as aE, GedCom as aF, createGedCom as aG, isGedcomString as aH, validateGedcomContent as aI, mergeGedcoms as aJ, Indi as aK, type FamilySearchMatch as aL, type FamilySearchSource as aM, createIndi as aN, Individuals as aO, List as aP, CommonName as aQ, createCommonName as aR, CommonNote as aS, createCommonNote as aT, Obje as aU, createObje as aV, Objects as aW, Repo as aX, createRepo as aY, Repositories as aZ, Sour as a_, type GenerationIndiType as aa, type IndiGenealogyGenerations as ab, type IndiGenealogyResult as ac, type NonNullIndiGenealogyResult as ad, type PathItem as ae, type Path as af, type ReducedPath as ag, type QueueItem as ah, type Queue as ai, type FamType as aj, type GedComType as ak, type ObjeType as al, Existed as am, CustomTags as an, Common as ao, createProxy as ap, createCommon as aq, isOnlyMainProp as ar, isValidKey as as, getValidKeys as at, getValidTag as au, getListTag as av, getValidKey as aw, isId as ax, idGetter as ay, CommonDate as az, isRangeContained as b, Sources as b0, Subm as b1, createSubm as b2, Submitters as b3, type ICommon as b4, type IFam as b5, type IFamilies as b6, type IGedcom as b7, type IIndi as b8, type GeneratedIndiMethods as b9, type ISourceRepositoryCitationStructure as bA, type ISourceStructure as bB, type Place as bC, PlaceType as bD, getPlaces as bE, type IIndividuals as ba, type IList as bb, type IObje as bc, type IRepo as bd, type ISour as be, type ISubm as bf, type IAddressStructure as bg, type IAssociationStructure as bh, type IChangeDateStructure as bi, type ICreationDateStructure as bj, type IDateStructure as bk, type IEventDetailStructure as bl, type IFamilyStructure as bm, type IGedComStructure as bn, type IIndividualEventDetailStructure as bo, type IIndividualEventStructure as bp, type IIndividualStructure as bq, type ILdsOrdinanceDetailStructure as br, type ILdsSpouseSealingStructure as bs, type IMarriageDateStructure as bt, type IMultimediaLinkStructure as bu, type INonEventStructure as bv, type INoteStructure as bw, type IPlaceStructure as bx, type IRepositoryStructure as by, type ISourceCitationStructure as bz, splitOverlappingRanges as c, findMatchingRangeForSplitRange as d, extractSplitPoints as e, fromTuple as f, generateSplitRanges as g, extractSeparationYears as h, inRange as i, type CrossCase as j, type CrossCases as k, type Settings as l, type ConvertType as m, type IndiKey as n, type RepoKey as o, parseRangeBounds as p, type SourKey as q, type SubmKey as r, splitRange as s, type IdType as t, type Tag as u, type ListTag as v, type FilterIterator as w, type Filter as x, type RequiredFilter as y, type OrderDefinition as z };