gedcom-ts 2.0.2 → 2026.5.0

package/dist/commons/Act.d.ts

@@ -1,31 +1,64 @@
 import { DateAct } from "./DateAct";
 import { Place } from "./Place";
-import { Identifier } from "./Identifier.enum";
+import { GEDCOM_7_ALL_EVENT_TAGS } from "./gedcomEventTags";
 import { MultimediaFile, MultimediaFiles } from "./MultimediaFile";
 import { Notes } from "./Note";
-export type TypeAct = Identifier.BIRT | Identifier.DEAT | Identifier.MARR | Identifier.BURI | Identifier.CHR | Identifier.DIV;
+export type TypeAct = (typeof GEDCOM_7_ALL_EVENT_TAGS)[number];
+export type ActConstructionOptions = {
+    /** GEDCOM 7 `1 EVEN` text payload (only used when `type` is `EVEN`). */
+    evenDescription?: string | null;
+    /** GEDCOM 7 required `2 TYPE` under `EVEN` (individual or family). */
+    evenTypeLabel?: string | null;
+    /** GEDCOM 7 `2 SDATE` (+ `3 TIME` / `3 PHRASE` importés comme pour `DATE`). */
+    sdateAct?: DateAct | null;
+    /** GEDCOM 7 `2 PHRASE` directement sous l’événement. */
+    eventPhrases?: readonly string[] | null;
+    /** Sous-lignes non modélisées avant la première balise d’ancrage (`DATE`, `PLAC`, …). */
+    preservedSubrecordPrefix?: readonly string[] | null;
+    /** Sous-lignes non modélisées après la première balise d’ancrage. */
+    preservedSubrecordSuffix?: readonly string[] | null;
+};
 export declare class Act {
     type: TypeAct;
     dateAct?: DateAct | null;
     place: Place | null;
     INDIS: number[];
+    evenDescription?: string | null;
+    evenTypeLabel?: string | null;
+    /** GEDCOM 7 `2 SDATE` (sous-structure analogue à `DATE`). */
+    sdateAct?: DateAct | null;
+    /** GEDCOM 7 `2 PHRASE` au niveau 2 sous l’événement. */
+    eventPhrases: string[];
+    /**
+     * Sous-lignes d’événement non modélisées (ex. `2 HUSB`, `4 PHRASE` sous `AGE`, `3 DATE` sous `STAT`, …),
+     * conservées pour limiter la perte à l’import / export.
+     */
+    preservedSubrecordPrefix: string[];
+    preservedSubrecordSuffix: string[];
     private newMultimediaFiles;
     multimediaFiles: MultimediaFiles;
     notes: Notes;
     get files(): MultimediaFile[];
     get keysFiles(): string[];
-    constructor(type: TypeAct, dateAct?: DateAct | null, place?: Place | null, indis?: number[] | null, multimediaFiles?: MultimediaFiles | null, newMultimediaFiles?: Map<string, MultimediaFile>, notes?: Notes);
+    constructor(type: TypeAct, dateAct?: DateAct | null, place?: Place | null, indis?: number[] | null, multimediaFiles?: MultimediaFiles | null, newMultimediaFiles?: Map<string, MultimediaFile>, notes?: Notes, options?: ActConstructionOptions | null);
     /**
      * Média rattaché à l’acte : `{indi}/{type}/{nomFichier}` (indi = premier INDI connu ou paramètre).
      * Suffixe `_1`, `_2`, … avant l’extension si le chemin est déjà pris sur cet acte.
      */
     addMultimedia(multimediaFile: MultimediaFile, ownerIndi?: number): void;
+    /**
+     * Média distant (URI) sans fichier local ; `ownerIndi` requis si {@link INDIS} est vide.
+     */
+    addMultimediaFromUri(sourceUri: string, ownerIndi?: number, objeXrefId?: number | null): void;
     removeMultimedia(index: number): void;
-    private mediaRelativePathsInUse;
+    /** Copie profonde de l’acte (nouvelle instance, mêmes valeurs). */
+    clone(): Act;
     updateType(typeAct: TypeAct): void;
     addIndis(INDIS: number[]): void;
-    updatePlace(place: Place): void;
-    updateDateAct(dateAct: DateAct): void;
+    updatePlace(place: Place | null): void;
+    updateDateAct(dateAct: DateAct | null): void;
+    /** Remplace ou efface la date de tri `SDATE`. */
+    updateSdateAct(sdateAct: DateAct | null): void;
 }
 export declare class Acts {
     list: Act[];
@@ -34,13 +67,19 @@ export declare class Acts {
     removeFromIndex(indexAct: number): void;
     removeAll(): void;
     sortByDate(): void;
+    /** Date utilisée pour le tri : `DATE` si exploitable, sinon `SDATE`. */
+    private sortDateAct;
     private hasSortableDate;
     private compareByTypeOrder;
     private compareMarriageAndDivorce;
     private haveSameParticipants;
 }
 export declare class ActsByExtraction extends Acts {
-    extractActsInfo(lines: string[], INDIS: number[], mapFiles: Map<string, File>): void;
+    extractActsInfo(lines: string[], INDIS: number[], mapFiles: Map<string, File>, objePayloadById?: ReadonlyMap<number, {
+        sourceUri: string;
+    }>, textualIndiXrefToIndi?: ReadonlyMap<string, number>, globalNotes?: Map<number, string[]>, importOptions?: {
+        notePointerToId?: ReadonlyMap<string, number>;
+    }): void;
     private convertToActs;
     private resolveTypeAct;
 }

package/dist/commons/DateAct.d.ts

@@ -2,10 +2,18 @@ export declare enum TypeDateAct {
     BEF = "BEF",
     ABT = "ABT",
     AFT = "AFT",
+    /** GEDCOM 5.5 / interop : date interprétée. */
+    INT = "INT",
+    /** Estimée. */
+    EST = "EST",
+    /** Calculée. */
+    CAL = "CAL",
     BET = "BET",
     FROM = "FROM",
     NULL = "NULL"
 }
+/** Qualificateur de date simple (hors BET/FROM). */
+export type TypeDateActSimpleQualifier = TypeDateAct.BEF | TypeDateAct.ABT | TypeDateAct.AFT | TypeDateAct.INT | TypeDateAct.EST | TypeDateAct.CAL;
 export declare enum MonthEnum {
     JAN = "JAN",
     FEB = "FEB",
@@ -32,10 +40,28 @@ export declare class DateAct {
     endDay?: Day;
     endMonth?: Month;
     endYear?: number;
+    /**
+     * Texte libre lié à la date : `3 PHRASE` sous `DATE` à l’import, ou fragment final `(...)` hérité 5.5.
+     */
+    datePhrase?: string | null;
+    /** `3 TIME` sous `DATE` / `SDATE` (GEDCOM 7). */
+    dateTime?: string | null;
+    /**
+     * Charge `DATE`/`SDATE` non résolvable en champs typés (URI GEDCOM 7, texte libre, combos exotiques) :
+     * conservée telle quelle pour l’export tant qu’aucune date structurée exploitable n’est présente.
+     */
+    verbatimDatePayload?: string | null;
     constructor(dateLine: string);
+    private applyVerbatimFallback;
+    /** Indique si l’on dispose d’une date structurée exportable (hors seul verbatim). */
+    private hasStructuredDateForExport;
     get date(): string | null;
+    /** Sous-ligne `3 TIME` (import GEDCOM 7). */
+    setDateTimeFromImport(fragment: string): void;
     updateExactDate(year?: number, month?: Month, day?: Day): void;
-    updateQualifiedDate(typeDateAct: TypeDateAct.ABT | TypeDateAct.BEF | TypeDateAct.AFT, year?: number, month?: Month, day?: Day): void;
+    /** Ajoute du texte issu d’un `3 PHRASE` sous `DATE` (import GEDCOM 7). */
+    appendDatePhraseFromImport(fragment: string): void;
+    updateQualifiedDate(typeDateAct: TypeDateActSimpleQualifier, year?: number, month?: Month, day?: Day): void;
     updateBetweenDates(start: {
         year: number;
         month?: Month;
@@ -55,17 +81,29 @@ export declare class DateAct {
         day?: Day;
     }): void;
     clearDate(): void;
+    /**
+     * Remplace l’état de cette instance par le résultat du parseur sur une charge `DATE` / `SDATE` GEDCOM
+     * (même logique que le constructeur), sans changer la référence d’objet — utile pour l’édition in-place.
+     */
+    applyGedcomDatePayload(dateLine: string): void;
+    private tryParseIsoYmd;
+    /** ISO `YYYY-MM` (GEDCOM 7 : précision au mois). */
+    private tryParseIsoYm;
+    /** Extrait une note finale `(...)` (style 5.5) du reste de la charge date. */
+    private static extractInlineParentheticalPhrase;
     private convertMonth;
     private parseSinglePart;
     private parseTwoParts;
     private parseThreeParts;
     private parseFourParts;
-    private assignMonthYearFromSlash;
+    private tryConsumeMonthYearSlash;
     private parseMonthToken;
     private formatCoreDate;
     private tryParseRangeDate;
     private parseCoreDateValue;
     private isRelativeType;
+    /** Retire les préfixes de calendrier GEDCOM (`@#DGREGORIAN@`, … — forme `@#NAME@`). */
+    private stripCalendarPrefixes;
     isValid(): boolean;
 }
 export declare const dateToDateLine: (year?: number, month?: Month, day?: Day) => string;

package/dist/commons/Identifier.enum.d.ts

@@ -58,6 +58,7 @@ export declare enum Identifier {
     FAMF = "FAMF",
     FAMS = "FAMS",
     FCOM = "FCOM",
+    FACT = "FACT",
     FILE = "FILE",
     FORM = "FORM",
     GEDC = "GEDC",
@@ -92,6 +93,7 @@ export declare enum Identifier {
     PAGE = "PAGE",
     PEDI = "PEDI",
     PHON = "PHON",
+    PHRASE = "PHRASE",
     PLAC = "PLAC",
     POST = "POST",
     PROB = "PROB",
@@ -114,6 +116,7 @@ export declare enum Identifier {
     SOUR = "SOUR",
     SPFX = "SPFX",
     SSN = "SSN",
+    SDATE = "SDATE",
     STAE = "STAE",
     STAT = "STAT",
     SUBM = "SUBM",

package/dist/commons/IndiAttribute.d.ts

@@ -0,0 +1,11 @@
+import type { IndiGedcomSubLine } from "./IndiGedcomSubLine";
+/**
+ * Attribut individuel de niveau 1 (`FACT`, `DSCR`, `CAST`, …) avec sous-structures conservées.
+ */
+export declare class IndiAttribute {
+    tag: string;
+    value: string;
+    children: IndiGedcomSubLine[];
+    constructor(tag: string, value: string, children?: IndiGedcomSubLine[]);
+    toGedcom(lineEnding: string): string;
+}

package/dist/commons/IndiGedcomSubLine.d.ts

@@ -0,0 +1,6 @@
+/** Sous-structure sous un `1 NAME` (niveau ≥ 2) ou sous un attribut individuel (niveau ≥ 2). */
+export type IndiGedcomSubLine = {
+    level: string;
+    tag: string;
+    value: string;
+};

package/dist/commons/MultimediaFile.d.ts

@@ -1,8 +1,19 @@
 export declare class MultimediaFile {
     relativePath: string;
-    file: File;
-    constructor(file?: File);
+    /** Fichier local ; peut être absent si seulement {@link sourceUri} ou {@link objeXrefId}. */
+    file?: File;
+    /**
+     * URI ou chemin pour `FILE` en GEDCOM 7 sans binaire embarqué (export `.ged`, média hors zip).
+     */
+    sourceUri?: string | null;
+    /**
+     * Référence `OBJE` (`@O{n}@`) : exporte `1 OBJE` / `2 OBJE` + enregistrement `0 @O{n}@ OBJE` si {@link sourceUri} est défini.
+     */
+    objeXrefId?: number | null;
+    constructor(file?: File, sourceUri?: string | null, objeXrefId?: number | null);
     get filename(): string;
+    /** Peut être sérialisé en GEDCOM (fichier local, URI, ou pointeur OBJE). */
+    hasExportablePayload(): boolean;
 }
 export declare class MultimediaFiles {
     /** Répertoire logique (sans slash final), ex. `1` ou `1/BIRT`. */

package/dist/commons/Person.d.ts

@@ -1,10 +1,23 @@
 import { Acts } from './Act';
+import { IndiAttribute } from "./IndiAttribute";
 import { MultimediaFile, MultimediaFiles } from "./MultimediaFile";
 import { Notes } from "./Note";
+import { PersonNameVariant } from "./PersonNameVariant";
 export declare enum Sex {
     M = "M",
-    F = "F"
+    F = "F",
+    /** GEDCOM 7 « sexe inconnu ». */
+    U = "U",
+    /** GEDCOM 7 « non binaire » / intersexe selon fichier source. */
+    X = "X"
 }
+export type PersonGedcomImportOptions = {
+    famPointerToId?: ReadonlyMap<string, number>;
+    notePointerToId?: ReadonlyMap<string, number>;
+    objePayloadById?: ReadonlyMap<number, {
+        sourceUri: string;
+    }>;
+};
 export declare class Person {
     sosa: number | undefined;
     INDI: number;
@@ -17,24 +30,34 @@ export declare class Person {
     multimediaFiles: MultimediaFiles;
     acts: Acts;
     notes: Notes;
+    /** Tous les blocs `1 NAME` (alias, traductions, etc.) ; vide si seulement le couple prénom/nom classique. */
+    nameVariants: PersonNameVariant[];
+    /** Attributs de niveau 1 (`FACT`, `DSCR`, …) avec sous-structures conservées. */
+    attributes: IndiAttribute[];
     get files(): MultimediaFile[];
     get keysFiles(): string[];
-    constructor(sosa?: number, SEX?: Sex, firstnames?: Array<string>, lastname?: string, FAMC?: number, FAMS?: number[], INDI?: number, multimediaFiles?: MultimediaFiles, newMultimediaFiles?: Map<string, MultimediaFile>, acts?: Acts);
-    createPersonJson(personLines: string[], informationFamilies?: Map<number, string[]>, mapFiles?: Map<string, File>, globalNotes?: Map<number, string[]>): void;
+    constructor(sosa?: number, SEX?: Sex, firstnames?: Array<string>, lastname?: string, FAMC?: number, FAMS?: number[], INDI?: number, multimediaFiles?: MultimediaFiles, newMultimediaFiles?: Map<string, MultimediaFile>, acts?: Acts, nameVariants?: PersonNameVariant[], attributes?: IndiAttribute[]);
+    createPersonJson(personLines: string[], informationFamilies?: Map<number, string[]>, mapFiles?: Map<string, File>, globalNotes?: Map<number, string[]>, textualIndiXrefToIndi?: ReadonlyMap<string, number>, importOptions?: PersonGedcomImportOptions): void;
     private parsePersonLine;
     private createIndiFromZeroLine;
     private createSexFromValue;
     private createFAMCFromValue;
     private createFAMSFromValue;
     private createMultimediaFilesFromValue;
+    private createMultimediaFromObjePointer;
     private addNoteFromGedcom;
     /**
      * Média au niveau individu (hors acte) : chemin logique `{INDI}/{nomFichier}`.
      * Si le même nom existe déjà pour cet individu, suffixe `_1`, `_2`, etc. avant l’extension.
      */
     addMultimedia(multimediaFile: MultimediaFile): void;
+    /**
+     * Média distant (`FILE` / OBJE avec URI) sans fichier local : chemins relatifs uniques comme {@link addMultimedia}.
+     */
+    addMultimediaFromUri(sourceUri: string, objeXrefId?: number | null): void;
     deleteMultimedia(path: string): void;
-    private mediaRelativePathsInUse;
+    /** Copie profonde avec un nouvel `INDI` (actes via {@link Act.clone}, notes, médias, variants, attributs). */
+    clone(newIndi: number): Person;
     private createFirstnamesAndLastnameJson;
 }
 export declare class TreePerson extends Person {

package/dist/commons/PersonNameVariant.d.ts

@@ -0,0 +1,21 @@
+import type { IndiGedcomSubLine } from "./IndiGedcomSubLine";
+/** Traduction `2 TRAN` sous un `1 NAME` (GEDCOM 7). */
+export declare class PersonNameTranslation {
+    payload: string;
+    lang?: string;
+    parts: IndiGedcomSubLine[];
+    constructor(payload: string, lang?: string, parts?: IndiGedcomSubLine[]);
+    toGedcom(lineEnding: string): string;
+}
+/**
+ * Un bloc `1 NAME` complet (type, pièces NPFX/GIVN/…, traductions).
+ * Permet un aller-retour GEDCOM sans perdre alias / traductions.
+ */
+export declare class PersonNameVariant {
+    payload: string;
+    type?: string;
+    parts: IndiGedcomSubLine[];
+    translations: PersonNameTranslation[];
+    constructor(payload: string, type?: string, parts?: IndiGedcomSubLine[], translations?: PersonNameTranslation[]);
+    toGedcom(lineEnding: string): string;
+}

package/dist/commons/Place.d.ts

@@ -1,7 +1,26 @@
 export declare class Place {
     city: string | null;
+    /** Jurisdiction level 2 in GEDCOM 7 `PLAC` list (after city), when `FORM` is City, County, State, Country. */
+    county: string | null;
+    state: string | null;
+    country: string | null;
+    /** Texte `3 PHRASE` sous `PLAC` (GEDCOM 7). */
+    placPhrase: string | null;
     coordinate: CoordinateGPS;
     constructor(city?: string, coordinate?: CoordinateGPS);
+    /**
+     * Remplit les champs à partir d’une charge `PLAC` GEDCOM 7 (liste séparée par des virgules).
+     * Ordre attendu avec le `HEAD`.`PLAC`.`FORM` par défaut de l’export : City, County, State, Country.
+     *
+     * Heuristique : 1 segment → ville seule ; 2 → ville + pays (sans county/state) ;
+     * 3 → ville, county, pays (state vide) ; 4 → les quatre niveaux ; 5+ → les trois premiers niveaux
+     * puis le reste concaténé dans `country` (ex. subdivisions multiples).
+     */
+    setFromGedcom7PlacPayload(payload: string): void;
+    /** Ajoute du texte issu d’un `3 PHRASE` sous `PLAC` (import GEDCOM 7). */
+    appendPlacPhraseFromImport(fragment: string): void;
+    /** Charge `PLAC` pour l’export GEDCOM 7 (liste `,`). */
+    toGedcom7PlacPayload(): string | null;
     addCity(city: string): void;
 }
 export declare class CoordinateGPS {

package/dist/commons/clonePrimitives.d.ts

@@ -0,0 +1,17 @@
+import { DateAct } from "./DateAct";
+import { IndiAttribute } from "./IndiAttribute";
+import { MultimediaFile, MultimediaFiles } from "./MultimediaFile";
+import { Note, Notes } from "./Note";
+import { PersonNameVariant } from "./PersonNameVariant";
+import { Place } from "./Place";
+export declare function cloneDateAct(d: DateAct): DateAct;
+export declare function clonePlace(p: Place): Place;
+export declare function cloneNote(note: Note): Note;
+export declare function cloneNotesColl(notes: Notes): Notes;
+export declare function cloneMultimediaFile(m: MultimediaFile): MultimediaFile;
+export declare function cloneMultimediaBundle(files: readonly MultimediaFile[], relativePathRoot: string): {
+    files: MultimediaFiles;
+    map: Map<string, MultimediaFile>;
+};
+export declare function cloneNameVariant(v: PersonNameVariant): PersonNameVariant;
+export declare function cloneAttribute(a: IndiAttribute): IndiAttribute;

package/dist/commons/gedcomEventTags.d.ts

@@ -0,0 +1,17 @@
+import { Identifier } from "./Identifier.enum";
+/**
+ * GEDCOM 7 standard event tags: `INDIVIDUAL_EVENT_STRUCTURE` ∪ `FAMILY_EVENT_STRUCTURE`
+ * (LDS ordinances excluded).
+ */
+export declare const GEDCOM_7_ALL_EVENT_TAGS: readonly [Identifier.ADOP, Identifier.BAPM, Identifier.BARM, Identifier.BASM, Identifier.BIRT, Identifier.BLES, Identifier.BURI, Identifier.CENS, Identifier.CHR, Identifier.CHRA, Identifier.CONF, Identifier.CREM, Identifier.DEAT, Identifier.EMIG, Identifier.EVEN, Identifier.FCOM, Identifier.GRAD, Identifier.IMMI, Identifier.NATU, Identifier.ORDN, Identifier.PROB, Identifier.RETI, Identifier.WILL, Identifier.ANUL, Identifier.DIV, Identifier.DIVF, Identifier.ENGA, Identifier.MARB, Identifier.MARC, Identifier.MARL, Identifier.MARR, Identifier.MARS];
+export type Gedcom7EventTag = (typeof GEDCOM_7_ALL_EVENT_TAGS)[number];
+/**
+ * Sous-ensemble des tags GEDCOM 7 typiquement utilisés pour lier deux personnes à une même famille `F`
+ * (fiançailles, bans, contrat, mariage, etc.). D’autres tags (`EVEN`, …) restent utilisables via
+ * {@link CreateUnionFamilyOptions.eventTag} s’ils figurent dans {@link GEDCOM_7_ALL_EVENT_TAGS}.
+ */
+export declare const GEDCOM_7_PAIR_UNION_EVENT_TAGS: readonly [Identifier.ENGA, Identifier.MARB, Identifier.MARC, Identifier.MARL, Identifier.MARR, Identifier.MARS];
+export type Gedcom7PairUnionEventTag = (typeof GEDCOM_7_PAIR_UNION_EVENT_TAGS)[number];
+/** Document order when two acts have no usable sortable date (`Acts.sortByDate`). */
+export declare const GEDCOM_7_EVENT_SORT_ORDER: readonly Gedcom7EventTag[];
+export declare const GEDCOM_7_EVENT_TAG_SET: ReadonlySet<string>;

package/dist/dataset/ReadGedEdit.d.ts

@@ -0,0 +1,27 @@
+import type { ReadGed } from "../import/ReadGed";
+import type { Person } from "../commons/Person";
+/**
+ * Édition des blocs `0 …` conservés pour round-trip (voir {@link ReadGed.preservedTopLevelRecords}).
+ */
+export declare class PreservedTopLevelEdit {
+    private readonly target;
+    constructor(target: ReadGed);
+    get value(): ReadonlyArray<string>;
+    append(block: string): this;
+    insertAt(index: number, block: string): this;
+    replaceAt(index: number, block: string): this;
+    removeAt(index: number): this;
+    clear(): this;
+}
+/**
+ * Facade d’édition sur un {@link ReadGed} (personnes + enregistrements préservés).
+ */
+export declare class ReadGedEdit {
+    private readonly target;
+    constructor(target: ReadGed);
+    get value(): ReadGed;
+    addPerson(person: Person): this;
+    removePersonByIndi(indi: number): boolean;
+    preserved(): PreservedTopLevelEdit;
+}
+export declare function editReadGed(readGed: ReadGed): ReadGedEdit;

package/dist/dataset/cloneModels.d.ts

@@ -0,0 +1,8 @@
+import type { Act } from "../commons/Act";
+import type { Person } from "../commons/Person";
+/** Copie profonde d’un {@link Act} (nouvelle instance, mêmes valeurs). */
+export declare function cloneAct(act: Act): Act;
+/**
+ * Copie profonde d’une {@link Person} avec un nouvel `INDI` (identité, actes, notes, médias, variants, attributs).
+ */
+export declare function clonePerson(person: Person, newIndi: number): Person;

package/dist/dataset/graphOps.d.ts

@@ -0,0 +1,29 @@
+import type { ReadGed } from "../import/ReadGed";
+import type { TypeAct } from "../commons/Act";
+import { Person } from "../commons/Person";
+import type { CreateActInit } from "../edit/factories";
+/** Prochain identifiant de famille `F` libre d'après les `FAMC` / `FAMS` du jeu. */
+export declare function nextFamilyId(persons: readonly Person[]): number;
+/** Rattache un enfant à une famille (`FAMC`). */
+export declare function linkChildToFamily(readGed: ReadGed, child: Person, familyId: number): void;
+/** Retire le rattachement `FAMC` d'un enfant. */
+export declare function unlinkChildFromFamily(readGed: ReadGed, child: Person): void;
+/**
+ * Retire toutes les références à une famille `familyId` : `FAMS` (toutes occurrences) et `FAMC` si égal.
+ * Puis {@link ReadGed.groupPartners}.
+ */
+export declare function removeFamilyReferencesFromDataset(readGed: ReadGed, familyId: number): void;
+export type CreateUnionFamilyOptions = {
+    /**
+     * Type d’acte créé sur chaque conjoint pour matérialiser l’union (défaut : {@link Identifier.MARR}).
+     * Doit appartenir à {@link GEDCOM_7_EVENT_TAG_SET} (ex. {@link Identifier.ENGA}, ou `EVEN` avec
+     * `CreateActInit.construction` pour une union civile / custom).
+     */
+    eventTag?: TypeAct;
+};
+/**
+ * Crée une famille `F` (nouvel id), rattache les deux conjoints en `FAMS` et ajoute le même type d’acte
+ * sur chacun (par défaut `MARR`). Voir {@link CreateUnionFamilyOptions} pour fiançailles, bans, etc.
+ * @returns l'identifiant interne de famille créé.
+ */
+export declare function createMarriageFamily(readGed: ReadGed, spouseA: Person, spouseB: Person, init?: CreateActInit | null, unionOptions?: CreateUnionFamilyOptions | null): number;

package/dist/dataset/index.d.ts

@@ -0,0 +1,9 @@
+export { addPersonToReadGed, removePersonFromReadGedByIndi } from "./readGedMutations";
+export { commandBlockingIssues, tryAddPersonToReadGed, tryCreateMarriageFamily, tryLinkChildToFamily, tryRemovePersonFromReadGedByIndi, tryUnlinkChildFromFamily, validateAddPersonCommand, validateCreateMarriageCommand, validateLinkChildCommand, validateUnlinkChildCommand, } from "./readGedCommands";
+export type { CommandFail, CommandOk, CommandResult } from "./readGedCommands";
+export { createMarriageFamily, linkChildToFamily, nextFamilyId, removeFamilyReferencesFromDataset, unlinkChildFromFamily, } from "./graphOps";
+export type { CreateUnionFamilyOptions } from "./graphOps";
+export { PreservedTopLevelEdit, ReadGedEdit, editReadGed } from "./ReadGedEdit";
+export { cloneAct, clonePerson } from "./cloneModels";
+export { assertPersonConsistent, assertReadGedConsistent, validatePerson, validateReadGed, } from "./validation";
+export type { AssertConsistencyOptions, ConsistencySeverity, ModelConsistencyIssue, ModelConsistencyIssueCode, ValidatePersonContext, ValidateReadGedOptions, } from "./validation";

package/dist/dataset/readGedCommands.d.ts

@@ -0,0 +1,46 @@
+import type { ReadGed } from "../import/ReadGed";
+import type { Person } from "../commons/Person";
+import type { CreateActInit } from "../edit/factories";
+import { type CreateUnionFamilyOptions } from "./graphOps";
+import type { ModelConsistencyIssue } from "./validation";
+export type CommandOk<T = void> = {
+    ok: true;
+    value: T;
+    warnings?: ModelConsistencyIssue[];
+};
+export type CommandFail = {
+    ok: false;
+    issues: ModelConsistencyIssue[];
+};
+export type CommandResult<T = void> = CommandOk<T> | CommandFail;
+/** Filtre les problèmes qui bloquent une commande (`severity === "error"`). */
+export declare function commandBlockingIssues(issues: readonly ModelConsistencyIssue[]): ModelConsistencyIssue[];
+/** Préconditions pour {@link tryAddPersonToReadGed} (sans effet de bord). */
+export declare function validateAddPersonCommand(readGed: ReadGed, person: Person): ModelConsistencyIssue[];
+/**
+ * Ajoute une personne au graphe après validation des préconditions.
+ * Effets en cas de succès : `mapPersons`, `persons`, lieux, `groupPartners()` (voir {@link addPersonToReadGed}).
+ */
+export declare function tryAddPersonToReadGed(readGed: ReadGed, person: Person): CommandResult;
+/**
+ * Retire une personne par `INDI`. Si absent, `ok: false` et aucune mutation.
+ */
+export declare function tryRemovePersonFromReadGedByIndi(readGed: ReadGed, indi: number): CommandResult;
+/** Préconditions pour rattacher un enfant à une famille. */
+export declare function validateLinkChildCommand(readGed: ReadGed, child: Person, familyId: number): ModelConsistencyIssue[];
+/**
+ * Rattache `child.FAMC = familyId` puis `groupPartners()`.
+ * Les avertissements (famille sans conjoints) n’empêchent pas la mutation ; ils sont renvoyés dans `warnings`.
+ */
+export declare function tryLinkChildToFamily(readGed: ReadGed, child: Person, familyId: number): CommandResult;
+/** Préconditions pour {@link tryUnlinkChildFromFamily}. */
+export declare function validateUnlinkChildCommand(readGed: ReadGed, child: Person): ModelConsistencyIssue[];
+/** Retire `FAMC` sur l’enfant puis `groupPartners()`. */
+export declare function tryUnlinkChildFromFamily(readGed: ReadGed, child: Person): CommandResult;
+/** Préconditions pour {@link tryCreateMarriageFamily}. */
+export declare function validateCreateMarriageCommand(readGed: ReadGed, spouseA: Person, spouseB: Person): ModelConsistencyIssue[];
+/**
+ * Crée une union (nouvel id `F`, actes MARR) après validation.
+ * @returns l’identifiant de famille en cas de succès.
+ */
+export declare function tryCreateMarriageFamily(readGed: ReadGed, spouseA: Person, spouseB: Person, init?: CreateActInit | null, unionOptions?: CreateUnionFamilyOptions | null): CommandResult<number>;

package/dist/dataset/readGedMutations.d.ts

@@ -0,0 +1,12 @@
+import type { ReadGed } from "../import/ReadGed";
+import { Person } from "../commons/Person";
+/**
+ * Ajoute une personne au graphe (met à jour `mapPersons`, `persons`, lieux, `groupPartners`).
+ * Si `person.INDI` n’est pas défini, un nouvel identifiant unique est attribué.
+ */
+export declare function addPersonToReadGed(readGed: ReadGed, person: Person): void;
+/**
+ * Retire une personne par `INDI` et purge les références à cet `INDI` dans les actes et notes du jeu.
+ * @returns `false` si aucune personne ne correspond.
+ */
+export declare function removePersonFromReadGedByIndi(readGed: ReadGed, indi: number): boolean;

package/dist/dataset/validation.d.ts

@@ -0,0 +1,36 @@
+import type { ReadGed } from "../import/ReadGed";
+import { Person } from "../commons/Person";
+export type ConsistencySeverity = "error" | "warn";
+export type ModelConsistencyIssueCode = "person_missing_indi" | "act_unknown_indi" | "note_unknown_indi" | "marr_missing_spouse_indi" | "duplicate_indi_in_dataset" | "add_person_already_registered" | "add_person_indi_conflict" | "remove_person_not_found" | "link_child_indi_missing" | "link_child_not_bound_to_readged" | "link_child_family_has_no_spouses" | "unlink_child_indi_missing" | "unlink_child_not_bound_to_readged" | "marriage_spouses_same_person" | "marriage_spouses_same_indi" | "marriage_spouse_indi_missing" | "marriage_spouse_not_in_readged" | "famc_family_without_spouses" | "fams_family_without_spouses" | "fams_duplicate_family_id" | "famc_ancestor_cycle";
+export type ModelConsistencyIssue = {
+    code: ModelConsistencyIssueCode;
+    severity: ConsistencySeverity;
+    message: string;
+    detail?: unknown;
+};
+export type ValidatePersonContext = {
+    knownIndis?: ReadonlySet<number>;
+    checkMarrParticipants?: boolean;
+};
+export type ValidateReadGedOptions = ValidatePersonContext & {
+    checkDuplicateIndis?: boolean;
+    /** `FAMC` pointant vers une famille sans entrée dans `partnersMap` ou liste vide. */
+    checkFamcWithoutSpouses?: boolean;
+    /** Chaque `FAMS` sans conjoints dans `partnersMap` (souvent import incomplet). */
+    checkFamsWithoutSpouses?: boolean;
+    /** Même identifiant de famille plusieurs fois dans `FAMS` d’une même personne. */
+    checkDuplicateFamsEntries?: boolean;
+    /** Cycle dans la remontée `FAMC` → parents (données impossibles biologiquement). */
+    checkAncestorCycles?: boolean;
+};
+export type AssertConsistencyOptions = {
+    failOn?: ConsistencySeverity;
+};
+/** Contrôles de base sur une personne (INDI, références d’actes). */
+export declare function validatePerson(person: Person, context?: ValidatePersonContext): ModelConsistencyIssue[];
+/** Agrège {@link validatePerson} pour toutes les personnes du graphe, plus les contrôles optionnels sur FAM. */
+export declare function validateReadGed(readGed: ReadGed, options?: ValidateReadGedOptions): ModelConsistencyIssue[];
+/** Lève une erreur si {@link validatePerson} retourne des problèmes selon `failOn` (défaut : seulement `error`). */
+export declare function assertPersonConsistent(person: Person, context?: ValidatePersonContext & AssertConsistencyOptions): void;
+/** Lève une erreur si {@link validateReadGed} retourne des problèmes selon `failOn` (défaut : seulement `error`). */
+export declare function assertReadGedConsistent(readGed: ReadGed, options?: ValidateReadGedOptions & AssertConsistencyOptions): void;

package/dist/edit/ActEdit.d.ts

@@ -0,0 +1,37 @@
+import { Act, type TypeAct } from "../commons/Act";
+import { DateAct } from "../commons/DateAct";
+import { Place } from "../commons/Place";
+import { ActMediaEdit } from "./ActMediaEdit";
+import { NotesEdit } from "./NotesEdit";
+/**
+ * API d’édition cohérente autour d’un {@link Act} existant (mutation in-place).
+ */
+export declare class ActEdit {
+    private readonly target;
+    constructor(target: Act);
+    get value(): Act;
+    setType(type: TypeAct): this;
+    setIndis(ids: readonly number[]): this;
+    setDateAct(date: DateAct | null): this;
+    setSdateAct(sdate: DateAct | null): this;
+    /** Remplace le lieu ; `null` efface le lieu attaché à l’acte. */
+    setPlace(place: Place | null): this;
+    setEvenDescription(text: string | null): this;
+    setEvenTypeLabel(label: string | null): this;
+    setEventPhrases(phrases: readonly string[]): this;
+    clearEventPhrases(): this;
+    appendEventPhrase(phrase: string): this;
+    setPreservedPrefix(lines: readonly string[]): this;
+    appendPreservedPrefixLine(line: string): this;
+    clearPreservedPrefix(): this;
+    setPreservedSuffix(lines: readonly string[]): this;
+    appendPreservedSuffixLine(line: string): this;
+    clearPreservedSuffix(): this;
+    notes(): NotesEdit;
+    multimedia(): ActMediaEdit;
+    /** Supprime toutes les notes rattachées à l’acte. */
+    clearNotes(): this;
+    /** Supprime tous les médias rattachés à l’acte. */
+    clearMultimedia(): this;
+}
+export declare function editAct(act: Act): ActEdit;

package/dist/edit/ActMediaEdit.d.ts

@@ -0,0 +1,21 @@
+import { MultimediaFile } from "../commons/MultimediaFile";
+import type { Act } from "../commons/Act";
+import { MultimediaFileEdit } from "./MultimediaFileEdit";
+/**
+ * Médias rattachés à un {@link Act} : délègue à {@link Act.addMultimedia} / {@link Act.removeMultimedia}.
+ */
+export declare class ActMediaEdit {
+    private readonly target;
+    constructor(target: Act);
+    get value(): Act;
+    /**
+     * Crée un {@link MultimediaFile} à partir d'un fichier local, l'ajoute et renvoie sa facade.
+     */
+    addNewFromFile(file: File, ownerIndi?: number): MultimediaFileEdit;
+    addNewFromUri(uri: string, ownerIndi?: number, objeXrefId?: number | null): MultimediaFileEdit;
+    add(multimediaFile: MultimediaFile, ownerIndi?: number): this;
+    removeAt(index: number): this;
+    clear(): this;
+    at(index: number): MultimediaFileEdit;
+}
+export declare function editActMedia(act: Act): ActMediaEdit;