gedcom-ts 2.0.2 → 2026.5.0

package/dist/edit/ActsEdit.d.ts

@@ -0,0 +1,34 @@
+import { Act, Acts, type TypeAct } from "../commons/Act";
+import { ActEdit } from "./ActEdit";
+import { type CreateActInit } from "./factories";
+/**
+ * API d’édition cohérente autour d’un {@link Acts}.
+ */
+export declare class ActsEdit {
+    private readonly target;
+    constructor(target: Acts);
+    get value(): Acts;
+    /**
+     * Crée un {@link Act}, l’ajoute en fin de liste et renvoie sa facade d’édition.
+     */
+    addNew(type: TypeAct, init?: CreateActInit | null): ActEdit;
+    add(act: Parameters<Acts["add"]>[0]): this;
+    /** Insère un acte existant à la position donnée (0 = début). */
+    insertAt(index: number, act: Act): this;
+    /**
+     * Crée un acte et l’insère à la position donnée.
+     */
+    insertNewAt(index: number, type: TypeAct, init?: CreateActInit | null): ActEdit;
+    /** Supprime le dernier acte s’il en existe au moins un. */
+    removeLast(): this;
+    /** Index de l’acte par identité de référence, ou `-1`. */
+    indexOfAct(act: Act): number;
+    /** Retire l’acte s’il appartient à la liste ; @returns si une entrée a été supprimée. */
+    removeAct(act: Act): boolean;
+    replaceAt(index: number, act: Parameters<Acts["updateFromIndex"]>[0]): this;
+    removeAt(index: number): this;
+    clear(): this;
+    sortByDate(): this;
+    at(index: number): ActEdit;
+}
+export declare function editActs(acts: Acts): ActsEdit;

package/dist/edit/DateActEdit.d.ts

@@ -0,0 +1,37 @@
+import { DateAct, type Day, type Month, type TypeDateActSimpleQualifier } from "../commons/DateAct";
+/**
+ * API d’édition cohérente autour d’un {@link DateAct} existant (mutation in-place).
+ */
+export declare class DateActEdit {
+    private readonly target;
+    constructor(target: DateAct);
+    get value(): DateAct;
+    clear(): this;
+    /** Parse GEDCOM `DATE` / `SDATE` (même règles que `new DateAct(line)`). */
+    applyGedcomPayload(line: string): this;
+    setExactDate(year?: number, month?: Month, day?: Day): this;
+    setQualified(typeDateAct: TypeDateActSimpleQualifier, year?: number, month?: Month, day?: Day): this;
+    setBetween(start: {
+        year: number;
+        month?: Month;
+        day?: Day;
+    }, end: {
+        year: number;
+        month?: Month;
+        day?: Day;
+    }): this;
+    setFromTo(start: {
+        year: number;
+        month?: Month;
+        day?: Day;
+    }, end: {
+        year: number;
+        month?: Month;
+        day?: Day;
+    }): this;
+    setTime(value: string | null): this;
+    setDatePhrase(value: string | null): this;
+    appendDatePhrase(fragment: string): this;
+    setVerbatimPayload(value: string | null): this;
+}
+export declare function editDateAct(date: DateAct): DateActEdit;

package/dist/edit/GedcomExportOptionsEdit.d.ts

@@ -0,0 +1,20 @@
+import type { GedcomExportOptions } from "../export/GEDCOM";
+/**
+ * Mutation in-place des {@link GedcomExportOptions} (export `.ged` / `.zip`).
+ */
+export declare class GedcomExportOptionsEdit {
+    private readonly target;
+    constructor(target: GedcomExportOptions);
+    get value(): GedcomExportOptions;
+    setExtraTopLevelRecords(lines: readonly string[] | null | undefined): this;
+    clearExtraTopLevelRecords(): this;
+    setHeadLanguageTag(tag: string | null | undefined): this;
+    setHeadCopyright(text: string | null | undefined): this;
+    setHeadDestination(dest: string | null | undefined): this;
+    setHeadSchemaTagDefs(defs: readonly {
+        readonly tag: string;
+        readonly uri: string;
+    }[] | null | undefined): this;
+    clearHeadSchemaTagDefs(): this;
+}
+export declare function editGedcomExportOptions(options: GedcomExportOptions): GedcomExportOptionsEdit;

package/dist/edit/IndiAttributesEdit.d.ts

@@ -0,0 +1,38 @@
+import type { IndiGedcomSubLine } from "../commons/IndiGedcomSubLine";
+import type { IndiAttribute } from "../commons/IndiAttribute";
+/**
+ * API d’édition cohérente autour d’un {@link IndiAttribute} existant.
+ */
+export declare class IndiAttributeEdit {
+    private readonly target;
+    constructor(target: IndiAttribute);
+    get value(): IndiAttribute;
+    setTag(tag: string): this;
+    setValue(value: string): this;
+    setChildren(children: readonly IndiGedcomSubLine[]): this;
+    appendChild(child: IndiGedcomSubLine): this;
+    clearChildren(): this;
+}
+export declare function editIndiAttribute(attr: IndiAttribute): IndiAttributeEdit;
+/**
+ * Liste d’attributs individuels (`FACT`, `DSCR`, …) sur une {@link Person}.
+ */
+export declare class IndiAttributesEdit {
+    private readonly target;
+    constructor(target: {
+        attributes: IndiAttribute[];
+    });
+    get value(): IndiAttribute[];
+    add(attr: IndiAttribute): this;
+    addNew(tag: string, value?: string, children?: readonly IndiGedcomSubLine[]): IndiAttributeEdit;
+    insertAt(index: number, attr: IndiAttribute): this;
+    insertNewAt(index: number, tag: string, value?: string, children?: readonly IndiGedcomSubLine[]): IndiAttributeEdit;
+    removeLast(): this;
+    replaceAt(index: number, attr: IndiAttribute): this;
+    removeAt(index: number): this;
+    clear(): this;
+    at(index: number): IndiAttributeEdit;
+}
+export declare function editIndiAttributes(person: {
+    attributes: IndiAttribute[];
+}): IndiAttributesEdit;

package/dist/edit/MultimediaFileEdit.d.ts

@@ -0,0 +1,17 @@
+import { MultimediaFile } from "../commons/MultimediaFile";
+/**
+ * API d’édition cohérente autour d’un {@link MultimediaFile} existant.
+ */
+export declare class MultimediaFileEdit {
+    private readonly target;
+    constructor(target: MultimediaFile);
+    get value(): MultimediaFile;
+    setRelativePath(path: string): this;
+    setFile(file: File | undefined): this;
+    clearFile(): this;
+    setSourceUri(uri: string | null | undefined): this;
+    clearSourceUri(): this;
+    setObjeXrefId(id: number | null | undefined): this;
+    clearObjeXrefId(): this;
+}
+export declare function editMultimediaFile(file: MultimediaFile): MultimediaFileEdit;

package/dist/edit/NameVariantsEdit.d.ts

@@ -0,0 +1,43 @@
+import type { IndiGedcomSubLine } from "../commons/IndiGedcomSubLine";
+import { PersonNameTranslation, PersonNameVariant } from "../commons/PersonNameVariant";
+/**
+ * API d’édition cohérente autour d’un {@link PersonNameVariant} existant.
+ */
+export declare class PersonNameVariantEdit {
+    private readonly target;
+    constructor(target: PersonNameVariant);
+    get value(): PersonNameVariant;
+    setPayload(payload: string): this;
+    setType(type: string | null | undefined): this;
+    clearType(): this;
+    setParts(parts: readonly IndiGedcomSubLine[]): this;
+    appendPart(part: IndiGedcomSubLine): this;
+    clearParts(): this;
+    setTranslations(translations: readonly PersonNameTranslation[]): this;
+    appendTranslation(translation: PersonNameTranslation): this;
+    clearTranslations(): this;
+}
+export declare function editPersonNameVariant(variant: PersonNameVariant): PersonNameVariantEdit;
+/**
+ * Variants `1 NAME` sur une {@link Person}.
+ */
+export declare class NameVariantsEdit {
+    private readonly target;
+    constructor(target: {
+        nameVariants: PersonNameVariant[];
+    });
+    get value(): PersonNameVariant[];
+    add(variant: PersonNameVariant): this;
+    /** Ajoute un variant minimal (`1 NAME` / `2 TYPE` optionnel) et renvoie sa facade. */
+    addNew(payload: string, type?: string): PersonNameVariantEdit;
+    insertAt(index: number, variant: PersonNameVariant): this;
+    insertNewAt(index: number, payload: string, type?: string): PersonNameVariantEdit;
+    removeLast(): this;
+    replaceAt(index: number, variant: PersonNameVariant): this;
+    removeAt(index: number): this;
+    clear(): this;
+    at(index: number): PersonNameVariantEdit;
+}
+export declare function editNameVariants(person: {
+    nameVariants: PersonNameVariant[];
+}): NameVariantsEdit;

package/dist/edit/NoteEdit.d.ts

@@ -0,0 +1,18 @@
+import { Note, type TypeNote } from "../commons/Note";
+/**
+ * API d’édition cohérente autour d’une {@link Note} existante (mutation in-place).
+ */
+export declare class NoteEdit {
+    private readonly target;
+    constructor(target: Note);
+    get value(): Note;
+    setType(type: TypeNote): this;
+    /** Remplace le texte de la note (y compris tableau vide). */
+    setLines(lines: readonly string[]): this;
+    appendLine(line: string): this;
+    clearLines(): this;
+    setIndis(ids: readonly number[]): this;
+    appendIndi(indi: number): this;
+    clearIndis(): this;
+}
+export declare function editNote(note: Note): NoteEdit;

package/dist/edit/NotesEdit.d.ts

@@ -0,0 +1,25 @@
+import { Note, Notes } from "../commons/Note";
+import { NoteEdit } from "./NoteEdit";
+/**
+ * API d’édition cohérente autour d'un {@link Notes}.
+ */
+export declare class NotesEdit {
+    private readonly target;
+    constructor(target: Notes);
+    get value(): Notes;
+    /**
+     * Crée une {@link Note}, l’ajoute en fin de liste et renvoie sa facade d’édition.
+     */
+    addNew(initialLines?: readonly string[] | null): NoteEdit;
+    add(note: Note): this;
+    insertAt(index: number, note: Note): this;
+    insertNewAt(index: number, initialLines?: readonly string[] | null): NoteEdit;
+    removeLast(): this;
+    indexOfNote(note: Note): number;
+    removeNote(note: Note): boolean;
+    replaceAt(index: number, note: Note): this;
+    removeAt(index: number): this;
+    clear(): this;
+    at(index: number): NoteEdit;
+}
+export declare function editNotes(notes: Notes): NotesEdit;

package/dist/edit/PersonEdit.d.ts

@@ -0,0 +1,47 @@
+import type { IndiAttribute } from "../commons/IndiAttribute";
+import { Person, Sex } from "../commons/Person";
+import type { PersonNameVariant } from "../commons/PersonNameVariant";
+import { ActsEdit } from "./ActsEdit";
+import { IndiAttributesEdit } from "./IndiAttributesEdit";
+import { NameVariantsEdit } from "./NameVariantsEdit";
+import { NotesEdit } from "./NotesEdit";
+import { PersonMediaEdit } from "./PersonMediaEdit";
+/**
+ * API d’édition cohérente autour d'un {@link Person} existant (identité, unions, actes, notes).
+ */
+export declare class PersonEdit {
+    private readonly target;
+    constructor(target: Person);
+    get value(): Person;
+    setSex(sex: Sex | undefined): this;
+    setLastname(lastname: string): this;
+    setFirstnames(firstnames: readonly string[]): this;
+    setSosa(sosa: number | undefined): this;
+    setFamc(famc: number | undefined): this;
+    /** Efface le lien de filiation (`FAMC`). */
+    clearFamc(): this;
+    /** Remplace la liste des unions (`FAMS`). */
+    setFams(fams: readonly number[]): this;
+    clearFams(): this;
+    appendFams(famId: number): this;
+    /** Retire l’identifiant de famille à l’index donné dans `FAMS`. */
+    removeFamsAt(index: number): this;
+    /** Retire la première occurrence de `familyId` dans `FAMS` (no-op si absent). */
+    removeFamsByFamilyId(familyId: number): this;
+    setNameVariants(variants: readonly PersonNameVariant[]): this;
+    /** Édition élément par élément des blocs `1 NAME`. */
+    nameVariants(): NameVariantsEdit;
+    setAttributes(attrs: readonly IndiAttribute[]): this;
+    /** Édition élément par élément des attributs de niveau 1 (`FACT`, …). */
+    attributes(): IndiAttributesEdit;
+    acts(): ActsEdit;
+    notes(): NotesEdit;
+    /** Médias de niveau individu (fichiers locaux via {@link Person.addMultimedia}). */
+    multimedia(): PersonMediaEdit;
+    clearActs(): this;
+    clearNotes(): this;
+    clearMultimedia(): this;
+    clearNameVariants(): this;
+    clearAttributes(): this;
+}
+export declare function editPerson(person: Person): PersonEdit;

package/dist/edit/PersonMediaEdit.d.ts

@@ -0,0 +1,27 @@
+import { MultimediaFile } from "../commons/MultimediaFile";
+import type { Person } from "../commons/Person";
+import { MultimediaFileEdit } from "./MultimediaFileEdit";
+/**
+ * Médias au niveau individu : s'appuie sur {@link Person.addMultimedia} / {@link Person.deleteMultimedia}.
+ */
+export declare class PersonMediaEdit {
+    private readonly target;
+    constructor(target: Person);
+    get value(): Person;
+    /**
+     * Crée un {@link MultimediaFile} à partir d'un fichier local, l'ajoute et renvoie sa facade.
+     */
+    addNewFromFile(file: File): MultimediaFileEdit;
+    /**
+     * Ajoute un média à partir d’une URI (sans fichier local), voir {@link Person.addMultimediaFromUri}.
+     */
+    addNewFromUri(uri: string, objeXrefId?: number | null): MultimediaFileEdit;
+    /**
+     * Ajoute un média avec fichier local (chemins relatifs gérés comme dans {@link Person.addMultimedia}).
+     */
+    add(multimediaFile: MultimediaFile): this;
+    removeAt(index: number): this;
+    clear(): this;
+    at(index: number): MultimediaFileEdit;
+}
+export declare function editPersonMedia(person: Person): PersonMediaEdit;

package/dist/edit/PlaceEdit.d.ts

@@ -0,0 +1,23 @@
+import { CoordinateGPS, Place } from "../commons/Place";
+/**
+ * API d’édition cohérente autour d’un {@link Place} existant.
+ */
+export declare class PlaceEdit {
+    private readonly target;
+    constructor(target: Place);
+    get value(): Place;
+    setFromGedcom7Payload(payload: string): this;
+    setCity(city: string | null): this;
+    setCounty(county: string | null): this;
+    setState(state: string | null): this;
+    setCountry(country: string | null): this;
+    setPlacPhrase(phrase: string | null): this;
+    appendPlacPhrase(fragment: string): this;
+    clearPlacPhrase(): this;
+    setCoordinates(latitude: number, longitude: number): this;
+    clearCoordinates(): this;
+    /** Remplace le bloc coordonnées (ex. nouveau `CoordinateGPS`). */
+    replaceCoordinateModel(coordinate: CoordinateGPS): this;
+    clearStructured(): this;
+}
+export declare function editPlace(place: Place): PlaceEdit;

package/dist/edit/factories.d.ts

@@ -0,0 +1,35 @@
+import { Act, type ActConstructionOptions, type TypeAct } from "../commons/Act";
+import { DateAct } from "../commons/DateAct";
+import type { IndiGedcomSubLine } from "../commons/IndiGedcomSubLine";
+import { IndiAttribute } from "../commons/IndiAttribute";
+import { Note, Notes } from "../commons/Note";
+import { Person, Sex } from "../commons/Person";
+import { PersonNameVariant } from "../commons/PersonNameVariant";
+import { Place } from "../commons/Place";
+export type CreateActInit = {
+    dateAct?: DateAct | null;
+    place?: Place | null;
+    indis?: readonly number[] | null;
+    construction?: ActConstructionOptions | null;
+    notes?: Notes;
+};
+/** Construit un {@link Act} (pour `ActsEdit.add`, `addNew`, etc.). */
+export declare function createAct(type: TypeAct, init?: CreateActInit | null): Act;
+/**
+ * Construit une {@link Note} avec des lignes initialisées (tableau vide par défaut).
+ */
+export declare function createNote(initialLines?: readonly string[] | null): Note;
+export type CreatePersonStubInit = {
+    sosa?: number;
+    sex?: Sex;
+    firstnames?: readonly string[];
+    lastname?: string;
+    famc?: number;
+    fams?: readonly number[];
+};
+/**
+ * Crée un {@link Person} minimal avec un `INDI` connu (arbre vide ou ajout manuel).
+ */
+export declare function createPersonStub(indi: number, init?: CreatePersonStubInit | null): Person;
+export declare function createPersonNameVariant(payload: string, type?: string): PersonNameVariant;
+export declare function createIndiAttribute(tag: string, value?: string, children?: readonly IndiGedcomSubLine[]): IndiAttribute;

package/dist/edit/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Couche d’édition cohérente (chaînage `this`, noms `set*` / `clear*` / `append*`) sur le modèle existant.
+ *
+ * @example
+ * ```ts
+ * import { editPerson, editDateAct } from "gedcom-ts";
+ * editPerson(person)
+ *   .setLastname("Dupont")
+ *   .acts()
+ *   .at(0)
+ *   .setDateAct(new DateAct("1 JAN 1900"));
+ * ```
+ */
+export { ActEdit, editAct } from "./ActEdit";
+export { ActMediaEdit, editActMedia } from "./ActMediaEdit";
+export { ActsEdit, editActs } from "./ActsEdit";
+export { cloneAct, clonePerson } from "../dataset/cloneModels";
+export { DateActEdit, editDateAct } from "./DateActEdit";
+export { createAct, createIndiAttribute, createNote, createPersonNameVariant, createPersonStub, type CreateActInit, type CreatePersonStubInit, } from "./factories";
+export { editGedcomExportOptions, GedcomExportOptionsEdit } from "./GedcomExportOptionsEdit";
+export { addPersonToReadGed, commandBlockingIssues, createMarriageFamily, linkChildToFamily, nextFamilyId, removeFamilyReferencesFromDataset, removePersonFromReadGedByIndi, tryAddPersonToReadGed, tryCreateMarriageFamily, tryLinkChildToFamily, tryRemovePersonFromReadGedByIndi, tryUnlinkChildFromFamily, unlinkChildFromFamily, validateAddPersonCommand, validateCreateMarriageCommand, validateLinkChildCommand, validateUnlinkChildCommand, } from "../dataset";
+export type { CommandFail, CommandOk, CommandResult, CreateUnionFamilyOptions } from "../dataset";
+export { IndiAttributeEdit, IndiAttributesEdit, editIndiAttribute, editIndiAttributes } from "./IndiAttributesEdit";
+export { MultimediaFileEdit, editMultimediaFile } from "./MultimediaFileEdit";
+export { NameVariantsEdit, PersonNameVariantEdit, editNameVariants, editPersonNameVariant } from "./NameVariantsEdit";
+export { NoteEdit, editNote } from "./NoteEdit";
+export { NotesEdit, editNotes } from "./NotesEdit";
+export { PersonEdit, editPerson } from "./PersonEdit";
+export { PersonMediaEdit, editPersonMedia } from "./PersonMediaEdit";
+export { PlaceEdit, editPlace } from "./PlaceEdit";
+export { PreservedTopLevelEdit, ReadGedEdit, editReadGed } from "../dataset/ReadGedEdit";
+export { assertPersonConsistent, assertReadGedConsistent, validatePerson, validateReadGed, } from "../dataset/validation";
+export type { AssertConsistencyOptions, ConsistencySeverity, ModelConsistencyIssue, ModelConsistencyIssueCode, ValidatePersonContext, ValidateReadGedOptions, } from "../dataset/validation";

package/dist/export/GEDCOM.d.ts

@@ -1,16 +1,42 @@
 import { Person } from '../commons/Person';
+/** Options d’export `.ged` / `.zip` (round-trip partiel avec {@link ReadGed.preservedTopLevelRecords}). */
+export type GedcomExportOptions = {
+    /** Blocs `0 …` à recoller avant `SUBM` / `TRLR` (ex. `readGed.preservedTopLevelRecords`). */
+    extraTopLevelRecords?: readonly string[] | null;
+    /** Balise BCP 47 pour `1 LANG` sous `HEAD` (défaut `en-US`). */
+    headLanguageTag?: string | null;
+    /** Texte `1 COPR` sous `HEAD` (copyright / mention légale), une ligne logique. */
+    headCopyright?: string | null;
+    /**
+     * Définitions d’extensions `HEAD`.`SCHMA` (`2 TAG …`), ex. `{ tag: "_FOO", uri: "https://…" }`.
+     * Les tags sont émis tels quels (GEDCOM 7 : souvent préfixe `_`).
+     */
+    headSchemaTagDefs?: readonly {
+        readonly tag: string;
+        readonly uri: string;
+    }[] | null;
+    /**
+     * Valeur `1 DEST` sous `HEAD` (URI ou identifiant d’application cible, ex. `https://gedcom.io/`).
+     */
+    headDestination?: string | null;
+};
 declare class GEDCOM {
     protected title: string;
     protected persons: Array<Person>;
     protected onCreate: number;
     private haveFiles;
-    constructor(title: string | undefined, persons: Array<Person>, haveFiles: boolean);
+    private readonly exportOptions;
+    constructor(title: string | undefined, persons: Array<Person>, haveFiles: boolean, exportOptions?: GedcomExportOptions | null);
     private get beginGedcom();
+    private get defaultSubmitterRecord();
+    /** Enregistrements `OBJE` pour les médias avec {@link MultimediaFile.objeXrefId} et {@link MultimediaFile.sourceUri}. */
+    private collectObjeRecords;
+    private joinExtraTopLevelRecords;
     private get contentGedcom();
     gedcomBlob(): Blob;
 }
 export declare class ExportGedzipFile extends GEDCOM {
-    constructor(...args: [persons: Array<Person>] | [title: string, persons: Array<Person>]);
+    constructor(...args: [Person[]] | [string, Person[]] | [Person[], GedcomExportOptions] | [string, Person[], GedcomExportOptions]);
     download(): Promise<void>;
     private resolvePersonIndi;
     private resolveActIndis;
@@ -18,7 +44,7 @@ export declare class ExportGedzipFile extends GEDCOM {
     private zipFile;
 }
 export declare class ExportGedcomFile extends GEDCOM {
-    constructor(...args: [persons: Array<Person>] | [title: string, persons: Array<Person>]);
+    constructor(...args: [Person[]] | [string, Person[]] | [Person[], GedcomExportOptions] | [string, Person[], GedcomExportOptions]);
     download(): void;
 }
 export declare class FamilyLine {
@@ -31,17 +57,20 @@ export declare class PersonLine {
     private readonly INDI;
     private readonly NAME;
     private readonly SEX;
+    private readonly ATTRS;
     private readonly FAMS;
     private readonly FAMC;
     private readonly FILES;
     private readonly ACTS;
     private readonly NOTES;
+    private readonly haveFiles;
     constructor(person: Person, haveFiles: boolean);
     line(): string;
     private getIndi;
     private getName;
+    private getIndiAttributes;
     private getSex;
-    private getFiles;
+    private buildPersonMultimediaLines;
     private getFams;
     private getFamc;
 }

package/dist/import/LoadFile.d.ts

@@ -1,2 +1,16 @@
 import { ReadGed } from './ReadGed';
+import type { Place } from '../commons/Place';
+/**
+ * Erreur levée quand une entrée `.ged` dans un ZIP ne se décode pas comme du GEDCOM valide
+ * (en-tête `0 HEAD` absent au début). Cause la plus fréquente : **ZIP chiffré** (mot de passe),
+ * non pris en charge par le décompresseur utilisé ici.
+ *
+ * Les applications peuvent comparer `error.message === IMPORT_ERR_ZIP_GED_UNREADABLE`.
+ */
+export declare const IMPORT_ERR_ZIP_GED_UNREADABLE = "ZIP chiffr\u00E9 (mot de passe) ou .ged illisible dans l\u2019archive : extrayez le fichier .ged avec votre explorateur ou utilitaire ZIP, puis importez uniquement ce .ged. L\u2019import direct des archives prot\u00E9g\u00E9es par mot de passe n\u2019est pas pris en charge.";
+/** Same as {@link ReadGed.empty}; use when starting a tree without a `.ged` / `.zip` import. */
+export declare const createEmptyReadGed: (options?: {
+    mapFiles?: Map<string, File>;
+    placesMap?: Map<string, Place>;
+}) => ReadGed;
 export declare const importGedFile: (file: File) => Promise<ReadGed>;

package/dist/import/PreservedRecordsBuffer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Liste interne des blocs `0 …` conservés pour diagnostic / round-trip (hors `0 TRLR`).
+ */
+export declare class PreservedRecordsBuffer {
+    private readonly items;
+    get length(): number;
+    /** Vue en lecture seule (référence au tableau interne, comme l’ancien `_preservedTopLevelRecords`). */
+    asReadonly(): readonly string[];
+    at(index: number): string | undefined;
+    /**
+     * Ajoute le bloc tel quel (sauf filtre `0 TRLR`), pour l’ingestion GEDCOM — aligné sur l’ancien `preserveTopLevelRecord`.
+     */
+    appendRaw(block: string): void;
+    append(block: string): void;
+    insertAt(index: number, block: string): void;
+    replaceAt(index: number, block: string): void;
+    removeAt(index: number): void;
+    clear(): void;
+    /** Retire l’élément à l’index sans normalisation (usage interne parse / absorb). */
+    spliceRemoveAt(index: number): void;
+}

package/dist/import/ReadGed.d.ts

@@ -1,21 +1,70 @@
 import { Person } from '../commons/Person';
 import { SplitGedcom } from "./SplitedInformations";
 import { Place } from "../commons/Place";
+import { type GedcomDatasetVersion } from "../utils/gedcom/datasetVersion";
+/**
+ * Graphe importé depuis un fichier GEDCOM. Les enregistrements de niveau `0` non intégrés au modèle
+ * typé (OBJE, REPO, SOUR, etc.) restent accessibles via {@link preservedTopLevelRecords}.
+ */
 export declare class ReadGed extends SplitGedcom {
+    private resolvedInformationFamilies;
+    private resolvedInformationNotes;
+    private famPointerToId;
+    private notePointerToId;
+    private objePayloadById;
+    /** Déduit du bloc `HEAD` (`GEDC`.`VERS`). */
+    datasetVersion: GedcomDatasetVersion;
     persons: Person[];
     mapPersons: Map<number, Person>;
     partnersMap: Map<number, Person[]>;
     childsMap: Map<number, Person[]>;
     mapFiles: Map<string, File>;
     placesMap: Map<string, Place>;
+    /**
+     * Index des pointeurs d’individu GEDCOM vers {@link Person.INDI} interne.
+     * Clés typiques : `Homer_Simpson` (xref textuelle), `I12` (xref `@I12@`).
+     */
+    private individualPointerToIndiNumber;
     constructor(gedcomContent?: string, mapFiles?: Map<string, File>, placesMap?: Map<string, Place>, mapPersons?: Map<number, Person>);
+    /**
+     * Empty genealogy (no INDI/FAM), same runtime shape as after {@link importGedFile}:
+     * `persons`, `partnersMap`, `childsMap`, `mapPersons`, `placesMap`, `mapFiles` are initialized.
+     */
+    static empty(options?: {
+        mapFiles?: Map<string, File>;
+        placesMap?: Map<string, Place>;
+    }): ReadGed;
     static fromGedcomFile(gedcomFile: File, mapFiles?: Map<string, File>, placesMap?: Map<string, Place>, mapPersons?: Map<number, Person>): Promise<ReadGed>;
     private finalizeAfterParse;
+    /**
+     * Reconstruit {@link partnersMap} et {@link childsMap} à partir des pointeurs `FAMS` / `FAMC`
+     * de chaque personne. Peut être rappelé après édition des liens ; chaque appel remplace les
+     * cartes (pas d’accumulation).
+     */
     groupPartners(): void;
     createDirectAncestries(person: Person): Person[];
     generateUniqueIndi(): number;
+    /**
+     * Résout un pointeur GEDCOM d’individu (`@Homer_Simpson@`, `Homer_Simpson`, `@I5@`, `I5`) vers la personne importée.
+     * Utile pour interpréter `1 CHIL @…@` ou `1 HUSB @…@` dans des fichiers à xref textuelle.
+     */
+    resolveIndividualPointer(raw: string): Person | undefined;
+    /** Enfants rattachés aux unions listées dans `parent.FAMS` (même logique que {@link childsMap}). */
+    getChildrenForParent(parent: Person): Person[];
+    /** Enfants d’une famille donnée (identifiant interne `F`, ex. `0` pour `@F0000@`). */
+    getChildrenOfFamily(familyId: number): Person[];
+    /**
+     * Reconstruit {@link placesMap} à partir des lieux des actes (après édition du graphe).
+     * Préférez la façade `editReadGed` pour les mutations ; cette méthode est utile si vous modifiez
+     * les personnes hors façade.
+     */
+    rehydratePlacesFromActs(): void;
     private haveParentsOfPerson;
     private createPersons;
+    /**
+     * Xrefs textuelles `0 @Homer_Simpson@ INDI` → entiers uniques (après le max des `@I{n}@` du fichier).
+     */
+    private buildTextualIndiXrefToSyntheticIdMap;
     private buildPerson;
     private hydratePlacesFromActs;
     private upsertPlace;

package/dist/import/SplitedInformations.d.ts

@@ -1,13 +1,45 @@
 export declare class SplitGedcom {
+    /** Lignes du premier enregistrement `0 HEAD` (y compris la ligne `0 HEAD`), si présent. */
+    protected informationHeaderLines: string[] | null;
     protected informationPersons: string[][];
-    protected informationFamilies: Map<number, string[]>;
-    protected informationNotes: Map<number, string[]>;
+    /** Lignes sous `0 @F…@ FAM` indexées par libellé xref canonique (`1`, `famA`, …). */
+    protected informationFamiliesByLabel: Map<string, string[]>;
+    /** Lignes sous `0 @N…@ NOTE|SNOTE` indexées par libellé xref canonique. */
+    protected informationNotesByLabel: Map<string, string[]>;
+    /**
+     * Enregistrements `0 …` non intégrés au modèle typé (OBJE, REPO, SOUR, SUBM, FAM/NOTE à xref non
+     * numérique, etc.). Conservés dans l’ordre du fichier pour diagnostic ou futur re‑export.
+     * `0 TRLR` n’est pas conservé (terminaison standard).
+     */
+    private readonly preservedRecords;
+    get preservedTopLevelRecords(): readonly string[];
+    /** Ajoute un bloc `0 …` complet (multi-lignes) en fin de liste préservée. */
+    appendPreservedTopLevelRecord(block: string): void;
+    insertPreservedTopLevelRecordAt(index: number, block: string): void;
+    replacePreservedTopLevelRecordAt(index: number, block: string): void;
+    removePreservedTopLevelRecordAt(index: number): void;
+    clearPreservedTopLevelRecords(): void;
     constructor(gedcomContent?: string);
     protected ingestGedcomText(gedcomContent: string): void;
     protected ingestGedcomFileStream(file: File): Promise<void>;
     private ingestRecordBlock;
+    /** N’ajoute pas `0 TRLR` (terminaison du fichier). */
+    private preserveTopLevelRecord;
+    /** Tout enregistrement `0 @xref@ INDI` (xref numérique `@I1@` ou textuelle `@Homer_Simpson@`). */
+    private isIndiRecordFirstLine;
+    /**
+     * Retire de {@link preservedTopLevelRecords} les blocs `0 @O…@ OBJE` décodables et renvoie leurs
+     * charges utiles pour l’hydratation des pointeurs `OBJE` sous `INDI` / actes.
+     */
+    protected absorbStandaloneObjeBlocksInto(): Map<number, {
+        sourceUri: string;
+    }>;
+    private splitInformationHeader;
     private splitInformationPersons;
+    /** @returns `true` si le bloc a été stocké dans {@link informationFamiliesByLabel}. */
     private splitInformationFamilies;
+    /** @returns `true` si le bloc a été stocké dans {@link informationNotesByLabel}. */
     private splitInformationNotes;
-    private extractXrefId;
+    private extractFamRecordLabel;
+    private extractNoteRecordLabel;
 }