gedcom-ts 2.0.2 → 2.1.0

package/dist/commons/Act.d.ts

@@ -1,20 +1,46 @@
 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.
@@ -24,8 +50,10 @@ export declare class Act {
     private mediaRelativePathsInUse;
     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 +62,17 @@ 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>): 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,16 +30,21 @@ 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}`.

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/gedcomEventTags.d.ts

@@ -0,0 +1,10 @@
+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];
+/** 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/edit/ActEdit.d.ts

@@ -0,0 +1,29 @@
+import { Act, type TypeAct } from "../commons/Act";
+import { DateAct } from "../commons/DateAct";
+import { Place } from "../commons/Place";
+/**
+ * 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;
+}
+export declare function editAct(act: Act): ActEdit;

package/dist/edit/ActsEdit.d.ts

@@ -0,0 +1,17 @@
+import { Acts } from "../commons/Act";
+import { ActEdit } from "./ActEdit";
+/**
+ * API d’édition cohérente autour d’un {@link Acts}.
+ */
+export declare class ActsEdit {
+    private readonly target;
+    constructor(target: Acts);
+    get value(): Acts;
+    add(act: Parameters<Acts["add"]>[0]): this;
+    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/NotesEdit.d.ts

@@ -0,0 +1,14 @@
+import { Note, Notes } from "../commons/Note";
+/**
+ * API d’édition cohérente autour d'un {@link Notes}.
+ */
+export declare class NotesEdit {
+    private readonly target;
+    constructor(target: Notes);
+    get value(): Notes;
+    add(note: Note): this;
+    replaceAt(index: number, note: Note): this;
+    removeAt(index: number): this;
+    clear(): this;
+}
+export declare function editNotes(notes: Notes): NotesEdit;

package/dist/edit/PersonEdit.d.ts

@@ -0,0 +1,27 @@
+import type { IndiAttribute } from "../commons/IndiAttribute";
+import { Person, Sex } from "../commons/Person";
+import type { PersonNameVariant } from "../commons/PersonNameVariant";
+import { ActsEdit } from "./ActsEdit";
+import { NotesEdit } from "./NotesEdit";
+/**
+ * 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;
+    /** Remplace la liste des unions (`FAMS`). */
+    setFams(fams: readonly number[]): this;
+    clearFams(): this;
+    appendFams(famId: number): this;
+    setNameVariants(variants: readonly PersonNameVariant[]): this;
+    setAttributes(attrs: readonly IndiAttribute[]): this;
+    acts(): ActsEdit;
+    notes(): NotesEdit;
+}
+export declare function editPerson(person: Person): PersonEdit;

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/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { ActsEdit, editActs } from "./ActsEdit";
+export { DateActEdit, editDateAct } from "./DateActEdit";
+export { NotesEdit, editNotes } from "./NotesEdit";
+export { PersonEdit, editPerson } from "./PersonEdit";
+export { PlaceEdit, editPlace } from "./PlaceEdit";

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>;