@myrmidon/cadmus-part-general-ui 12.0.2 → 14.0.0

package/index.d.ts

@@ -1,5 +1,4040 @@
+import { Part, ThesaurusEntry, EditedObject, Fragment } from '@myrmidon/cadmus-core';
+import { AssertedDate, AssertedChronotope } from '@myrmidon/cadmus-refs-asserted-chronotope';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ElementRef } from '@angular/core';
+import { FormControl, FormGroup, FormBuilder, UntypedFormGroup, FormArray } from '@angular/forms';
+import { Assertion } from '@myrmidon/cadmus-refs-assertion';
+import { HistoricalDateModel } from '@myrmidon/cadmus-refs-historical-date';
+import { DialogService } from '@myrmidon/ngx-mat-tools';
+import { AuthJwtService } from '@myrmidon/auth-jwt-login';
+import { ModelEditorComponentBase } from '@myrmidon/cadmus-ui';
+import { AssertedCompositeId, AssertedId } from '@myrmidon/cadmus-refs-asserted-ids';
+import { DocReference } from '@myrmidon/cadmus-refs-doc-references';
+import { CadmusTextEdService, CadmusTextEdBindings } from '@myrmidon/cadmus-text-ed';
+import { DecoratedCount } from '@myrmidon/cadmus-refs-decorated-counts';
+import { ProperName, AssertedProperName } from '@myrmidon/cadmus-refs-proper-name';
+import { PhysicalMeasurement } from '@myrmidon/cadmus-mat-physical-size';
+import { PhysicalState } from '@myrmidon/cadmus-mat-physical-state';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
 /**
- * Generated bundle index. Do not edit.
+ * The AssertedHistoricalDates part model.
  */
-/// <amd-module name="@myrmidon/cadmus-part-general-ui" />
-export * from './public-api';
+interface AssertedHistoricalDatesPart extends Part {
+    dates: AssertedDate[];
+}
+/**
+ * The type ID used to identify the AssertedHistoricalDatesPart type.
+ */
+declare const ASSERTED_HISTORICAL_DATES_PART_TYPEID = "it.vedph.asserted-historical-dates";
+/**
+ * JSON schema for the AssertedHistoricalDates part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const ASSERTED_HISTORICAL_DATES_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        dates: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        tag: {
+                            type: string;
+                        };
+                        a: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                value: {
+                                    type: string;
+                                };
+                                isCentury: {
+                                    type: string;
+                                };
+                                isSpan: {
+                                    type: string;
+                                };
+                                isApproximate: {
+                                    type: string;
+                                };
+                                isDubious: {
+                                    type: string;
+                                };
+                                day: {
+                                    type: string;
+                                };
+                                month: {
+                                    type: string;
+                                };
+                                hint: {
+                                    type: string[];
+                                };
+                            };
+                        };
+                        b: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                value: {
+                                    type: string;
+                                };
+                                isCentury: {
+                                    type: string;
+                                };
+                                isSpan: {
+                                    type: string;
+                                };
+                                isApproximate: {
+                                    type: string;
+                                };
+                                isDubious: {
+                                    type: string;
+                                };
+                                day: {
+                                    type: string;
+                                };
+                                month: {
+                                    type: string;
+                                };
+                                hint: {
+                                    type: string[];
+                                };
+                            };
+                        };
+                        assertion: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                tag: {
+                                    type: string;
+                                };
+                                rank: {
+                                    type: string;
+                                };
+                                note: {
+                                    type: string;
+                                };
+                                references: {
+                                    type: string;
+                                    items: {
+                                        anyOf: {
+                                            type: string;
+                                            required: string[];
+                                            properties: {
+                                                type: {
+                                                    type: string;
+                                                };
+                                                tag: {
+                                                    type: string;
+                                                };
+                                                citation: {
+                                                    type: string;
+                                                };
+                                                note: {
+                                                    type: string;
+                                                };
+                                            };
+                                        }[];
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+declare class AssertedHistoricalDateComponent {
+    readonly date: i0.ModelSignal<AssertedDate | undefined>;
+    readonly dateCancel: i0.OutputEmitterRef<void>;
+    tag: FormControl<string | null>;
+    hd: FormControl<HistoricalDateModel | null>;
+    assertion: FormControl<Assertion | null>;
+    form: FormGroup;
+    tagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    assertionTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    docReferenceTypeEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    docReferenceTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    constructor(formBuilder: FormBuilder);
+    private updateForm;
+    private getDate;
+    onAssertionChange(assertion: Assertion | undefined): void;
+    onDateChange(date?: HistoricalDateModel): void;
+    cancel(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssertedHistoricalDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AssertedHistoricalDateComponent, "cadmus-asserted-historical-date", never, { "date": { "alias": "date"; "required": false; "isSignal": true; }; "tagEntries": { "alias": "tagEntries"; "required": false; "isSignal": true; }; "assertionTagEntries": { "alias": "assertionTagEntries"; "required": false; "isSignal": true; }; "docReferenceTypeEntries": { "alias": "docReferenceTypeEntries"; "required": false; "isSignal": true; }; "docReferenceTagEntries": { "alias": "docReferenceTagEntries"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; "dateCancel": "dateCancel"; }, never, never, true, never>;
+}
+
+/**
+ * Asserted historical parts editor.
+ * Thesauri: asserted-historical-dates-tags, assertion-tags,
+ * doc-reference-types, doc-reference-tags.
+ */
+declare class AssertedHistoricalDatesPartComponent extends ModelEditorComponentBase<AssertedHistoricalDatesPart> implements OnInit {
+    private _dialogService;
+    maxDateCount: number;
+    editedIndex: number;
+    edited: AssertedDate | undefined;
+    tagEntries?: ThesaurusEntry[];
+    assertionTagEntries?: ThesaurusEntry[];
+    docReferenceTypeEntries?: ThesaurusEntry[];
+    docReferenceTagEntries?: ThesaurusEntry[];
+    dates: FormControl<AssertedDate[]>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<AssertedHistoricalDatesPart>): void;
+    protected getValue(): AssertedHistoricalDatesPart;
+    addDate(): void;
+    editDate(entry: AssertedDate, index: number): void;
+    closeDate(): void;
+    saveDate(entry: AssertedDate): void;
+    deleteDate(index: number): void;
+    moveDateUp(index: number): void;
+    moveDateDown(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssertedHistoricalDatesPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AssertedHistoricalDatesPartComponent, "cadmus-asserted-historical-dates-part", never, {}, {}, never, never, true, never>;
+}
+
+interface Keyword {
+    language: string;
+    value: string;
+}
+/**
+ * The Keywords part model.
+ */
+interface KeywordsPart extends Part {
+    keywords: Keyword[];
+}
+/**
+ * The type ID used to identify the KeywordsPart type.
+ */
+declare const KEYWORDS_PART_TYPEID = "it.vedph.keywords";
+/**
+ * JSON schema for the Keywords part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const KEYWORDS_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        keywords: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    language: {
+                        type: string;
+                    };
+                    value: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+};
+
+interface BibAuthor {
+    firstName?: string;
+    lastName: string;
+    roleId?: string;
+}
+interface BibEntry {
+    key?: string;
+    typeId: string;
+    tag?: string;
+    authors?: BibAuthor[];
+    title: string;
+    language: string;
+    container?: string;
+    contributors?: BibAuthor[];
+    edition?: number;
+    number?: string;
+    publisher?: string;
+    yearPub?: number;
+    placePub?: string;
+    location?: string;
+    accessDate?: Date;
+    firstPage?: number;
+    lastPage?: number;
+    keywords?: Keyword[];
+    note?: string;
+}
+/**
+ * The bibliography part model.
+ */
+interface BibliographyPart extends Part {
+    entries: BibEntry[];
+}
+/**
+ * The type ID used to identify the BibliographyPart type.
+ */
+declare const BIBLIOGRAPHY_PART_TYPEID = "it.vedph.bibliography";
+/**
+ * JSON schema for the Bibliography part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const BIBLIOGRAPHY_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        key: {
+            type: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        tag: {
+            type: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        entries: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        typeId: {
+                            type: string;
+                            pattern: string;
+                        };
+                        authors: {
+                            type: string;
+                            items: {
+                                anyOf: {
+                                    type: string;
+                                    required: string[];
+                                    properties: {
+                                        firstName: {
+                                            type: string;
+                                        };
+                                        lastName: {
+                                            type: string;
+                                        };
+                                        roleId: {
+                                            type: string;
+                                        };
+                                    };
+                                }[];
+                            };
+                        };
+                        title: {
+                            type: string;
+                        };
+                        language: {
+                            type: string;
+                        };
+                        container: {
+                            type: string;
+                        };
+                        contributors: {
+                            type: string[];
+                            items: {
+                                anyOf: {
+                                    type: string;
+                                    required: string[];
+                                    properties: {
+                                        firstName: {
+                                            type: string;
+                                        };
+                                        lastName: {
+                                            type: string;
+                                        };
+                                        roleId: {
+                                            type: string;
+                                        };
+                                    };
+                                }[];
+                            };
+                        };
+                        edition: {
+                            type: string;
+                        };
+                        number: {
+                            type: string;
+                        };
+                        publisher: {
+                            type: string;
+                        };
+                        yearPub: {
+                            type: string;
+                        };
+                        placePub: {
+                            type: string;
+                        };
+                        location: {
+                            type: string;
+                        };
+                        accessDate: {
+                            type: string;
+                            pattern: string;
+                        };
+                        firstPage: {
+                            title: string;
+                        };
+                        lastPage: {
+                            type: string;
+                        };
+                        keywords: {
+                            type: string[];
+                            items: {
+                                anyOf: {
+                                    type: string;
+                                    required: string[];
+                                    properties: {
+                                        language: {
+                                            type: string;
+                                        };
+                                        value: {
+                                            type: string;
+                                        };
+                                    };
+                                }[];
+                            };
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+declare class BibAuthorsEditorComponent implements OnInit {
+    private _formBuilder;
+    readonly parentForm: i0.InputSignal<FormGroup<any>>;
+    readonly controlName: i0.InputSignal<string>;
+    readonly roleEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    authors?: FormArray;
+    constructor(_formBuilder: FormBuilder);
+    ngOnInit(): void;
+    private getAuthorGroup;
+    addAuthor(item?: BibAuthor): void;
+    addAuthorBelow(index: number): void;
+    removeAuthor(index: number): void;
+    moveAuthorUp(index: number): void;
+    moveAuthorDown(index: number): void;
+    clearAuthors(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BibAuthorsEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BibAuthorsEditorComponent, "cadmus-bib-authors-editor", never, { "parentForm": { "alias": "parentForm"; "required": true; "isSignal": true; }; "controlName": { "alias": "controlName"; "required": false; "isSignal": true; }; "roleEntries": { "alias": "roleEntries"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Bibliography entry editor used by BibliographyPartComponent to edit a single
+ * entry in the bibliography part.
+ */
+declare class BibliographyEntryComponent implements OnInit, OnDestroy {
+    private _formBuilder;
+    private _sub?;
+    readonly entry: i0.ModelSignal<BibEntry | undefined>;
+    readonly langEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly typeEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly tagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly roleEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly editorClose: i0.OutputEmitterRef<void>;
+    key: FormControl<string | null>;
+    type: FormControl<string | null>;
+    tag: FormControl<string | null>;
+    language: FormControl<string | null>;
+    authors: FormArray;
+    title: FormControl<string | null>;
+    note: FormControl<string | null>;
+    contributors: FormArray;
+    container: FormControl<string | null>;
+    edition: FormControl<number | null>;
+    number: FormControl<string | null>;
+    publisher: FormControl<string | null>;
+    placePub: FormControl<string | null>;
+    yearPub: FormControl<number | null>;
+    location: FormControl<string | null>;
+    accessDate: FormControl<Date | null>;
+    firstPage: FormControl<number | null>;
+    lastPage: FormControl<number | null>;
+    keywords: Keyword[];
+    keyLanguage: FormControl<string | null>;
+    keyValue: FormControl<string | null>;
+    keyForm: FormGroup;
+    form: FormGroup;
+    constructor(_formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getAuthorGroup;
+    private setAuthors;
+    private updateForm;
+    private getAuthors;
+    private getEntry;
+    addKeyword(): void;
+    deleteKeyword(index: number): void;
+    moveKeywordUp(index: number): void;
+    moveKeywordDown(index: number): void;
+    cancel(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BibliographyEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BibliographyEntryComponent, "cadmus-bibliography-entry", never, { "entry": { "alias": "entry"; "required": false; "isSignal": true; }; "langEntries": { "alias": "langEntries"; "required": false; "isSignal": true; }; "typeEntries": { "alias": "typeEntries"; "required": false; "isSignal": true; }; "tagEntries": { "alias": "tagEntries"; "required": false; "isSignal": true; }; "roleEntries": { "alias": "roleEntries"; "required": false; "isSignal": true; }; }, { "entry": "entryChange"; "editorClose": "editorClose"; }, never, never, true, never>;
+}
+
+/**
+ * Bibliography part editor.
+ * Thesauri: bibliography-languages, bibliography-types (optional),
+ * bibliography-tags (optional), bibliography-author-roles (optional).
+ */
+declare class BibliographyPartComponent extends ModelEditorComponentBase<BibliographyPart> implements OnInit {
+    private _dialogService;
+    private _editedEntryIndex;
+    editedEntry?: BibEntry;
+    langEntries: ThesaurusEntry[] | undefined;
+    roleEntries: ThesaurusEntry[] | undefined;
+    tagEntries: ThesaurusEntry[] | undefined;
+    typeEntries: ThesaurusEntry[] | undefined;
+    entries: FormControl<BibEntry[]>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<BibliographyPart>): void;
+    entryTypeToString(id?: string): string;
+    protected getValue(): BibliographyPart;
+    addEntry(): void;
+    editEntry(entry: BibEntry, index: number): void;
+    closeEntry(): void;
+    saveEntry(entry: BibEntry): void;
+    removeEntry(index: number): void;
+    moveEntryUp(index: number): void;
+    moveEntryDown(index: number): void;
+    getAuthors(authors: BibAuthor[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BibliographyPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BibliographyPartComponent, "cadmus-bibliography-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The Categories part model.
+ */
+interface CategoriesPart extends Part {
+    categories: string[];
+}
+/**
+ * The type ID used to identify the CategoriesPart type.
+ */
+declare const CATEGORIES_PART_TYPEID = "it.vedph.categories";
+/**
+ * JSON schema for the Categories part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const CATEGORIES_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        categories: {
+            type: string;
+            items: {
+                type: string;
+            };
+        };
+    };
+};
+
+/**
+ * Categories component editor.
+ * Thesaurus: categories (required).
+ */
+declare class CategoriesPartComponent extends ModelEditorComponentBase<CategoriesPart> implements OnInit {
+    categories: FormControl<ThesaurusEntry[]>;
+    entries?: ThesaurusEntry[];
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateForm;
+    protected getValue(): CategoriesPart;
+    protected onDataSet(data?: EditedObject<CategoriesPart>): void;
+    onEntryChange(entry: ThesaurusEntry): void;
+    removeCategory(index: number): void;
+    renderLabel(label: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategoriesPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CategoriesPartComponent, "cadmus-categories-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The chronology layer fragment server model.
+ */
+interface ChronologyFragment extends Fragment {
+    date: HistoricalDateModel;
+    label?: string;
+    tag?: string;
+    eventId?: string;
+}
+declare const CHRONOLOGY_FRAGMENT_TYPEID = "fr.it.vedph.chronology";
+declare const CHRONOLOGY_FRAGMENT_SCHEMA: {
+    definitions: {};
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        location: {
+            $id: string;
+            type: string;
+        };
+        baseText: {
+            $id: string;
+            type: string;
+        };
+        date: {
+            type: string;
+            required: string[];
+            properties: {
+                a: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        value: {
+                            type: string;
+                        };
+                        isCentury: {
+                            type: string;
+                        };
+                        isSpan: {
+                            type: string;
+                        };
+                        isApproximate: {
+                            type: string;
+                        };
+                        isDubious: {
+                            type: string;
+                        };
+                        day: {
+                            type: string;
+                        };
+                        month: {
+                            type: string;
+                        };
+                        hint: {
+                            type: string[];
+                        };
+                    };
+                };
+                b: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        value: {
+                            type: string;
+                        };
+                        isCentury: {
+                            type: string;
+                        };
+                        isSpan: {
+                            type: string;
+                        };
+                        isApproximate: {
+                            type: string;
+                        };
+                        isDubious: {
+                            type: string;
+                        };
+                        day: {
+                            type: string;
+                        };
+                        month: {
+                            type: string;
+                        };
+                        hint: {
+                            type: string[];
+                        };
+                    };
+                };
+            };
+            label: {
+                type: string;
+            };
+            tag: {
+                type: string;
+            };
+            eventId: {
+                type: string;
+            };
+        };
+    };
+};
+
+/**
+ * Chronology fragment editor component.
+ * Thesauri: "chronology-tags" when you want to use a closed set of tags.
+ */
+declare class ChronologyFragmentComponent extends ModelEditorComponentBase<ChronologyFragment> implements OnInit {
+    tagEntries?: ThesaurusEntry[];
+    initialDate: HistoricalDateModel | undefined;
+    date: FormControl<HistoricalDateModel | null>;
+    tag: FormControl<string | null>;
+    label: FormControl<string | null>;
+    eventId: FormControl<string | null>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<ChronologyFragment>): void;
+    onDateChange(date: HistoricalDateModel): void;
+    protected getValue(): ChronologyFragment;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChronologyFragmentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChronologyFragmentComponent, "cadmus-chronology-fragment", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The chronotopes part model.
+ */
+interface ChronotopesPart extends Part {
+    chronotopes: AssertedChronotope[];
+}
+/**
+ * The type ID used to identify the ChronotopesPart type.
+ */
+declare const CHRONOTOPES_PART_TYPEID = "it.vedph.chronotopes";
+/**
+ * JSON schema for the Chronotopes part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const Chronotopes_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        chronotopes: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    properties: {
+                        chronotope: {
+                            place: {
+                                type: string;
+                                required: string[];
+                                properties: {
+                                    tag: {
+                                        type: string;
+                                    };
+                                    value: {
+                                        type: string;
+                                    };
+                                    assertion: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            tag: {
+                                                type: string;
+                                            };
+                                            rank: {
+                                                type: string;
+                                            };
+                                            note: {
+                                                type: string;
+                                            };
+                                            references: {
+                                                type: string;
+                                                items: {
+                                                    anyOf: {
+                                                        type: string;
+                                                        required: string[];
+                                                        properties: {
+                                                            type: {
+                                                                type: string;
+                                                            };
+                                                            tag: {
+                                                                type: string;
+                                                            };
+                                                            citation: {
+                                                                type: string;
+                                                            };
+                                                            note: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    }[];
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            date: {
+                                type: string;
+                                required: string[];
+                                properties: {
+                                    tag: {
+                                        type: string;
+                                    };
+                                    a: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            value: {
+                                                type: string;
+                                            };
+                                            isCentury: {
+                                                type: string;
+                                            };
+                                            isSpan: {
+                                                type: string;
+                                            };
+                                            isApproximate: {
+                                                type: string;
+                                            };
+                                            isDubious: {
+                                                type: string;
+                                            };
+                                            day: {
+                                                type: string;
+                                            };
+                                            month: {
+                                                type: string;
+                                            };
+                                            hint: {
+                                                type: string[];
+                                            };
+                                        };
+                                    };
+                                    b: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            value: {
+                                                type: string;
+                                            };
+                                            isCentury: {
+                                                type: string;
+                                            };
+                                            isSpan: {
+                                                type: string;
+                                            };
+                                            isApproximate: {
+                                                type: string;
+                                            };
+                                            isDubious: {
+                                                type: string;
+                                            };
+                                            day: {
+                                                type: string;
+                                            };
+                                            month: {
+                                                type: string;
+                                            };
+                                            hint: {
+                                                type: string[];
+                                            };
+                                        };
+                                    };
+                                    assertion: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            tag: {
+                                                type: string;
+                                            };
+                                            rank: {
+                                                type: string;
+                                            };
+                                            note: {
+                                                type: string;
+                                            };
+                                            references: {
+                                                type: string;
+                                                items: {
+                                                    anyOf: {
+                                                        type: string;
+                                                        required: string[];
+                                                        properties: {
+                                                            type: {
+                                                                type: string;
+                                                            };
+                                                            tag: {
+                                                                type: string;
+                                                            };
+                                                            citation: {
+                                                                type: string;
+                                                            };
+                                                            note: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    }[];
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * Chronotopes part editor component.
+ * Thesauri: chronotope-place-tags, chronotope-assertion-tags,
+ * doc-reference-types, doc-reference-tags (all optional).
+ */
+declare class ChronotopesPartComponent extends ModelEditorComponentBase<ChronotopesPart> implements OnInit {
+    private _dialogService;
+    private _editedChronotopeIndex;
+    editedChronotope: AssertedChronotope | undefined;
+    tagEntries: ThesaurusEntry[] | undefined;
+    assTagEntries?: ThesaurusEntry[];
+    refTypeEntries: ThesaurusEntry[] | undefined;
+    refTagEntries: ThesaurusEntry[] | undefined;
+    chronotopes: FormControl<AssertedChronotope[]>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<ChronotopesPart>): void;
+    protected getValue(): ChronotopesPart;
+    addChronotope(): void;
+    editChronotope(chronotope: AssertedChronotope, index: number): void;
+    onChronotopeChange(chronotope: AssertedChronotope): void;
+    saveChronotope(): void;
+    closeChronotope(): void;
+    deleteChronotope(index: number): void;
+    moveChronotopeUp(index: number): void;
+    moveChronotopeDown(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChronotopesPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChronotopesPartComponent, "cadmus-chronotopes-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Index keyword.
+ */
+interface IndexKeyword {
+    indexId?: string;
+    language: string;
+    value: string;
+    note?: string;
+    tag?: string;
+}
+/**
+ * Index keywords part.
+ */
+interface IndexKeywordsPart extends Part {
+    keywords: IndexKeyword[];
+}
+/**
+ * The type ID used to identify the IndexKeywordsPart type.
+ */
+declare const INDEX_KEYWORDS_PART_TYPEID = "it.vedph.index-keywords";
+/**
+ * JSON schema for the index keywords part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const INDEX_KEYWORDS_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        keywords: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    indexId: {
+                        type: string;
+                    };
+                    language: {
+                        type: string;
+                    };
+                    value: {
+                        type: string;
+                    };
+                    note: {
+                        type: string;
+                    };
+                    tag: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+};
+
+/**
+ * A comment.
+ */
+interface Comment {
+    tag?: string;
+    text: string;
+    references?: DocReference[];
+    links?: AssertedCompositeId[];
+    categories?: string[];
+    keywords?: IndexKeyword[];
+}
+/**
+ * The Comment part model.
+ */
+interface CommentPart extends Part, Comment {
+}
+/**
+ * The type ID used to identify the CommentPart type.
+ */
+declare const COMMENT_PART_TYPEID = "it.vedph.comment";
+/**
+ * JSON schema for the Comment part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const COMMENT_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        location: {
+            $id: string;
+            type: string;
+        };
+        baseText: {
+            $id: string;
+            type: string;
+        };
+        text: {
+            type: string;
+        };
+        tag: {
+            type: string[];
+        };
+        references: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        type: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        citation: {
+                            type: string;
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+        links: {
+            type: string;
+            items: {
+                type: string;
+                default: {};
+                required: string[];
+                properties: {
+                    target: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            gid: {
+                                type: string;
+                            };
+                            label: {
+                                type: string;
+                            };
+                            itemId: {
+                                type: string;
+                            };
+                            partId: {
+                                type: string;
+                            };
+                            partTypeId: {
+                                type: string;
+                            };
+                            roleId: {
+                                type: string;
+                            };
+                            name: {
+                                type: string;
+                            };
+                            value: {
+                                type: string;
+                            };
+                        };
+                    };
+                    scope: {
+                        type: string;
+                    };
+                    tag: {
+                        type: string;
+                    };
+                    assertion: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            tag: {
+                                type: string;
+                            };
+                            rank: {
+                                type: string;
+                            };
+                            note: {
+                                type: string;
+                            };
+                            references: {
+                                type: string;
+                                items: {
+                                    anyOf: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            type: {
+                                                type: string;
+                                            };
+                                            tag: {
+                                                type: string;
+                                            };
+                                            citation: {
+                                                type: string;
+                                            };
+                                            note: {
+                                                type: string;
+                                            };
+                                        };
+                                    }[];
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        categories: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                }[];
+            };
+        };
+        keywords: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    indexId: {
+                        type: string;
+                    };
+                    language: {
+                        type: string;
+                    };
+                    value: {
+                        type: string;
+                    };
+                    note: {
+                        type: string;
+                    };
+                    tag: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+};
+
+/**
+ * The comment layer fragment server model.
+ */
+interface CommentFragment extends Fragment, Comment {
+}
+declare const COMMENT_FRAGMENT_TYPEID = "fr.it.vedph.comment";
+declare const COMMENT_FRAGMENT_SCHEMA: {
+    definitions: {};
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        location: {
+            $id: string;
+            type: string;
+        };
+        baseText: {
+            $id: string;
+            type: string;
+        };
+        text: {
+            type: string;
+        };
+        tag: {
+            type: string[];
+        };
+        references: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        type: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        citation: {
+                            type: string;
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+        externalIds: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                }[];
+            };
+        };
+        categories: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                }[];
+            };
+        };
+        keywords: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    indexId: {
+                        type: string;
+                    };
+                    language: {
+                        type: string;
+                    };
+                    value: {
+                        type: string;
+                    };
+                    note: {
+                        type: string;
+                    };
+                    tag: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+};
+
+/**
+ * Comment part/fragment editor component.
+ * Thesauri: comment-tags, doc-reference-tags, doc-reference-types, comment-categories,
+ * languages, keyword-indexes, keyword-tags, comment-id-scopes, comment-id-tags,
+ * assertion-tags, pin-link-settings.
+ */
+declare class CommentEditorComponent extends ModelEditorComponentBase<CommentPart | CommentFragment> implements OnInit, OnDestroy {
+    private _editService;
+    private _editorBindings?;
+    private readonly _disposables;
+    private _editorModel?;
+    private _editor?;
+    tag: FormControl<string | null>;
+    text: FormControl<string | null>;
+    references: FormControl<DocReference[]>;
+    links: FormControl<AssertedCompositeId[]>;
+    categories: FormControl<ThesaurusEntry[]>;
+    keywords: FormArray;
+    comTagEntries: ThesaurusEntry[] | undefined;
+    refTagEntries: ThesaurusEntry[] | undefined;
+    refTypeEntries: ThesaurusEntry[] | undefined;
+    catEntries: ThesaurusEntry[] | undefined;
+    langEntries: ThesaurusEntry[] | undefined;
+    idxEntries: ThesaurusEntry[] | undefined;
+    keyTagEntries: ThesaurusEntry[] | undefined;
+    idScopeEntries: ThesaurusEntry[] | undefined;
+    idTagEntries: ThesaurusEntry[] | undefined;
+    assTagEntries: ThesaurusEntry[] | undefined;
+    setTagEntries?: ThesaurusEntry[];
+    pinByTypeMode?: boolean;
+    canSwitchMode?: boolean;
+    canEditTarget?: boolean;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _editService: CadmusTextEdService, _editorBindings?: CadmusTextEdBindings | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private applyEdit;
+    onCreateEditor(editor: monaco.editor.IEditor): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    /**
+     * Load settings from thesaurus entries.
+     *
+     * @param entries The thesaurus entries if any.
+     */
+    private loadSettings;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<CommentPart | CommentFragment>): void;
+    private updateComment;
+    protected getValue(): CommentPart | CommentFragment;
+    onReferencesChange(references: DocReference[]): void;
+    onIdsChange(ids: AssertedCompositeId[]): void;
+    onCategoryChange(entry: ThesaurusEntry): void;
+    removeCategory(index: number): void;
+    renderLabel(label: string): string;
+    private getKeywordGroup;
+    addKeyword(keyword?: IndexKeyword): void;
+    removeKeyword(index: number): void;
+    moveKeywordUp(index: number): void;
+    moveKeywordDown(index: number): void;
+    private getKeywords;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentEditorComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentEditorComponent, "cadmus-comment-editor", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The DecoratedCounts part model.
+ */
+interface DecoratedCountsPart extends Part {
+    counts: DecoratedCount[];
+}
+/**
+ * The type ID used to identify the DecoratedCountsPart type.
+ */
+declare const DECORATED_COUNTS_PART_TYPEID = "it.vedph.decorated-counts";
+/**
+ * JSON schema for the DecoratedCounts part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const DECORATED_COUNTS_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        counts: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        id: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        value: {
+                            type: string;
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * Decorated counts part editor component.
+ * Thesauri: decorated-count-ids, decorated-count-tags (all optional).
+ */
+declare class DecoratedCountsPartComponent extends ModelEditorComponentBase<DecoratedCountsPart> implements OnInit {
+    counts: FormControl<DecoratedCount[]>;
+    idEntries: ThesaurusEntry[] | undefined;
+    tagEntries: ThesaurusEntry[] | undefined;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<DecoratedCountsPart>): void;
+    protected getValue(): DecoratedCountsPart;
+    onCountsChange(counts: DecoratedCount[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DecoratedCountsPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DecoratedCountsPartComponent, "cadmus-decorated-counts-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The DistrictLocation part model.
+ */
+interface DistrictLocationPart extends Part {
+    place: ProperName;
+    note?: string;
+}
+/**
+ * The type ID used to identify the DistrictLocationPart type.
+ */
+declare const DISTRICT_LOCATION_PART_TYPEID = "it.vedph.district-location";
+/**
+ * JSON schema for the DistrictLocation part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const DISTRICT_LOCATION_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        place: {
+            type: string;
+            required: string[];
+            properties: {
+                language: {
+                    type: string;
+                };
+                tag: {
+                    type: string;
+                };
+                pieces: {
+                    type: string;
+                    items: {
+                        anyOf: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                type: {
+                                    type: string;
+                                };
+                                value: {
+                                    type: string;
+                                };
+                            };
+                        }[];
+                    };
+                };
+                note: {
+                    type: string;
+                };
+            };
+        };
+    };
+};
+
+/**
+ * DistrictLocation part editor component.
+ * Thesauri: district-name-piece-types (required), district-name-lang-entries.
+ */
+declare class DistrictLocationPartComponent extends ModelEditorComponentBase<DistrictLocationPart> implements OnInit {
+    place: FormControl<ProperName | null>;
+    note: FormControl<string | null>;
+    initialName?: ProperName | null;
+    typeEntries?: ThesaurusEntry[];
+    langEntries?: ThesaurusEntry[];
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    onNameChange(name: ProperName | undefined): void;
+    protected onDataSet(data?: EditedObject<DistrictLocationPart>): void;
+    protected getValue(): DistrictLocationPart;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DistrictLocationPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DistrictLocationPartComponent, "cadmus-district-location-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The document references part model.
+ */
+interface DocReferencesPart extends Part {
+    references: DocReference[];
+}
+/**
+ * The type ID used to identify the DocReferencesPart type.
+ */
+declare const DOC_REFERENCES_PART_TYPEID = "it.vedph.doc-references";
+/**
+ * JSON schema for the DocReferences part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const DOC_REFERENCES_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        references: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        type: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        citation: {
+                            type: string;
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * Document references part editor.
+ * Thesauri: doc-reference-tags, doc-reference-types (all optional).
+ */
+declare class DocReferencesPartComponent extends ModelEditorComponentBase<DocReferencesPart> implements OnInit {
+    references: FormControl<DocReference[]>;
+    typeEntries: ThesaurusEntry[] | undefined;
+    tagEntries: ThesaurusEntry[] | undefined;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<DocReferencesPart>): void;
+    protected getValue(): DocReferencesPart;
+    onReferencesChange(references: DocReference[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocReferencesPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DocReferencesPartComponent, "cadmus-doc-references-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The external ids part model.
+ */
+interface ExternalIdsPart extends Part {
+    ids: AssertedId[];
+}
+/**
+ * The type ID used to identify the ExternalIdsPart type.
+ */
+declare const EXTERNAL_IDS_PART_TYPEID = "it.vedph.external-ids";
+/**
+ * JSON schema for the external IDs part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const EXTERNAL_IDS_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        ids: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        value: {
+                            type: string;
+                        };
+                        type: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * External IDs part editor component. This is just a collection of asserted
+ * IDs.
+ * Thesauri: external-id-types, external-id-tags, assertion-tags,
+ * doc-reference-types, doc-reference-tags (all optional).
+ */
+declare class ExternalIdsPartComponent extends ModelEditorComponentBase<ExternalIdsPart> implements OnInit {
+    ids: FormControl<AssertedId[]>;
+    idScopeEntries: ThesaurusEntry[] | undefined;
+    idTagEntries: ThesaurusEntry[] | undefined;
+    assTagEntries: ThesaurusEntry[] | undefined;
+    refTypeEntries: ThesaurusEntry[] | undefined;
+    refTagEntries: ThesaurusEntry[] | undefined;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<ExternalIdsPart>): void;
+    protected getValue(): ExternalIdsPart;
+    onIdsChange(ids: AssertedId[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalIdsPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExternalIdsPartComponent, "cadmus-refs-external-ids-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The historical events part model.
+ */
+interface HistoricalEventsPart extends Part {
+    events: HistoricalEvent[];
+}
+/**
+ * Any entity related to an event in the EventsPart.
+ */
+interface RelatedEntity {
+    relation: string;
+    id: AssertedCompositeId;
+}
+/**
+ * An event in the EventsPart.
+ */
+interface HistoricalEvent {
+    eid: string;
+    type: string;
+    tag?: string;
+    chronotopes?: AssertedChronotope[];
+    assertion?: Assertion;
+    description?: string;
+    relatedEntities?: RelatedEntity[];
+    note?: string;
+}
+/**
+ * The type ID used to identify the EventsPart type.
+ */
+declare const HISTORICAL_EVENTS_PART_TYPEID = "it.vedph.historical-events";
+/**
+ * JSON schema for the Events part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const HISTORICAL_EVENTS_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        events: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        eid: {
+                            type: string;
+                        };
+                        type: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        chronotopes: {
+                            type: string;
+                            items: {
+                                anyOf: {
+                                    place: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            tag: {
+                                                type: string;
+                                            };
+                                            value: {
+                                                type: string;
+                                            };
+                                            assertion: {
+                                                type: string;
+                                                required: string[];
+                                                properties: {
+                                                    tag: {
+                                                        type: string;
+                                                    };
+                                                    rank: {
+                                                        type: string;
+                                                    };
+                                                    note: {
+                                                        type: string;
+                                                    };
+                                                    references: {
+                                                        type: string;
+                                                        items: {
+                                                            anyOf: {
+                                                                type: string;
+                                                                required: string[];
+                                                                properties: {
+                                                                    type: {
+                                                                        type: string;
+                                                                    };
+                                                                    tag: {
+                                                                        type: string;
+                                                                    };
+                                                                    citation: {
+                                                                        type: string;
+                                                                    };
+                                                                    note: {
+                                                                        type: string;
+                                                                    };
+                                                                };
+                                                            }[];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                    date: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            tag: {
+                                                type: string;
+                                            };
+                                            date: {
+                                                type: string;
+                                                required: string[];
+                                                properties: {
+                                                    a: {
+                                                        type: string;
+                                                        required: string[];
+                                                        properties: {
+                                                            value: {
+                                                                type: string;
+                                                            };
+                                                            isCentury: {
+                                                                type: string;
+                                                            };
+                                                            isSpan: {
+                                                                type: string;
+                                                            };
+                                                            isApproximate: {
+                                                                type: string;
+                                                            };
+                                                            isDubious: {
+                                                                type: string;
+                                                            };
+                                                            day: {
+                                                                type: string;
+                                                            };
+                                                            month: {
+                                                                type: string;
+                                                            };
+                                                            hint: {
+                                                                type: string[];
+                                                            };
+                                                        };
+                                                    };
+                                                    b: {
+                                                        type: string;
+                                                        required: string[];
+                                                        properties: {
+                                                            value: {
+                                                                type: string;
+                                                            };
+                                                            isCentury: {
+                                                                type: string;
+                                                            };
+                                                            isSpan: {
+                                                                type: string;
+                                                            };
+                                                            isApproximate: {
+                                                                type: string;
+                                                            };
+                                                            isDubious: {
+                                                                type: string;
+                                                            };
+                                                            day: {
+                                                                type: string;
+                                                            };
+                                                            month: {
+                                                                type: string;
+                                                            };
+                                                            hint: {
+                                                                type: string[];
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            assertion: {
+                                                type: string;
+                                                required: string[];
+                                                properties: {
+                                                    tag: {
+                                                        type: string;
+                                                    };
+                                                    rank: {
+                                                        type: string;
+                                                    };
+                                                    note: {
+                                                        type: string;
+                                                    };
+                                                    references: {
+                                                        type: string;
+                                                        items: {
+                                                            anyOf: {
+                                                                type: string;
+                                                                required: string[];
+                                                                properties: {
+                                                                    type: {
+                                                                        type: string;
+                                                                    };
+                                                                    tag: {
+                                                                        type: string;
+                                                                    };
+                                                                    citation: {
+                                                                        type: string;
+                                                                    };
+                                                                    note: {
+                                                                        type: string;
+                                                                    };
+                                                                };
+                                                            }[];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                }[];
+                            };
+                        };
+                        assertion: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                tag: {
+                                    type: string;
+                                };
+                                rank: {
+                                    type: string;
+                                };
+                                note: {
+                                    type: string;
+                                };
+                                references: {
+                                    type: string;
+                                    items: {
+                                        anyOf: {
+                                            type: string;
+                                            required: string[];
+                                            properties: {
+                                                type: {
+                                                    type: string;
+                                                };
+                                                tag: {
+                                                    type: string;
+                                                };
+                                                citation: {
+                                                    type: string;
+                                                };
+                                                note: {
+                                                    type: string;
+                                                };
+                                            };
+                                        }[];
+                                    };
+                                };
+                            };
+                        };
+                        description: {
+                            type: string;
+                        };
+                        relatedEntities: {
+                            type: string;
+                            items: {
+                                anyOf: {
+                                    type: string;
+                                    required: string[];
+                                    properties: {
+                                        relation: {
+                                            type: string;
+                                        };
+                                        id: {
+                                            type: string;
+                                            required: string[];
+                                            properties: {
+                                                target: {
+                                                    type: string;
+                                                    required: string[];
+                                                    properties: {
+                                                        gid: {
+                                                            type: string;
+                                                        };
+                                                        label: {
+                                                            type: string;
+                                                        };
+                                                        itemId: {
+                                                            type: string;
+                                                        };
+                                                        partId: {
+                                                            type: string;
+                                                        };
+                                                        partTypeId: {
+                                                            type: string;
+                                                        };
+                                                        roleId: {
+                                                            type: string;
+                                                        };
+                                                        name: {
+                                                            type: string;
+                                                        };
+                                                        value: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                    scope: {
+                                                        type: string;
+                                                    };
+                                                    tag: {
+                                                        type: string;
+                                                    };
+                                                    assertion: {
+                                                        type: string;
+                                                        required: string[];
+                                                        properties: {
+                                                            tag: {
+                                                                type: string;
+                                                            };
+                                                            rank: {
+                                                                type: string;
+                                                            };
+                                                            note: {
+                                                                type: string;
+                                                            };
+                                                            references: {
+                                                                type: string;
+                                                                items: {
+                                                                    anyOf: {
+                                                                        type: string;
+                                                                        required: string[];
+                                                                        properties: {
+                                                                            type: {
+                                                                                type: string;
+                                                                            };
+                                                                            tag: {
+                                                                                type: string;
+                                                                            };
+                                                                            citation: {
+                                                                                type: string;
+                                                                            };
+                                                                            note: {
+                                                                                type: string;
+                                                                            };
+                                                                        };
+                                                                    }[];
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                }[];
+                            };
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * Historical event editor.
+ */
+declare class HistoricalEventEditorComponent {
+    private _editedEntityIndex;
+    /**
+     * The event being edited.
+     */
+    readonly event: i0.ModelSignal<HistoricalEvent | undefined>;
+    /**
+     * Thesaurus event-types (hierarchical).
+     */
+    readonly eventTypeEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus event-tags.
+     */
+    readonly eventTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus event-relations (pseudo-hierarchical; the
+     * separator used is : rather than .).
+     */
+    readonly relationEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus chronotope-tags.
+     */
+    readonly ctTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus asserted-id-scopes.
+     */
+    readonly idScopeEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus asserted-id-tags.
+     */
+    readonly idTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus assertion-tags.
+     */
+    readonly assTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus doc-reference-tags.
+     */
+    readonly refTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus doc-reference-types.
+     */
+    readonly refTypeEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly setTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * The number of event type portions to cut from the event type ID when
+     * building the prefix used to filter the corresponding relations IDs.
+     * By default this is 0, i.e. the whole type ID (plus a final :) is
+     * used as prefix. For instance, the ID "person.birth" generates prefix
+     * "person:birth:". The portions of an ID are defined by splitting it at
+     * each dot: so, should this property be 1, we would split the ID into
+     * "person" and "birth", remove the last 1 tail(s), thus getting "person",
+     * join back the portions and append a final colon, generating "person:".
+     */
+    readonly eventTypeTailCut: i0.InputSignal<number>;
+    readonly pinByTypeMode: i0.InputSignal<boolean | undefined>;
+    readonly canSwitchMode: i0.InputSignal<boolean | undefined>;
+    readonly canEditTarget: i0.InputSignal<boolean | undefined>;
+    /**
+     * True to disable ID lookup via scoped pin lookup.
+     */
+    readonly noLookup: i0.InputSignal<boolean | undefined>;
+    readonly editorClose: i0.OutputEmitterRef<void>;
+    eid: FormControl<string | null>;
+    type: FormControl<string | null>;
+    tag: FormControl<string | null>;
+    description: FormControl<string | null>;
+    note: FormControl<string | null>;
+    relatedEntities: FormControl<RelatedEntity[]>;
+    chronotopes: FormControl<AssertedChronotope[]>;
+    hasAssertion: FormControl<boolean>;
+    assertion: FormControl<Assertion | null>;
+    form: FormGroup;
+    currentRelEntries: ThesaurusEntry[];
+    editedEntity?: RelatedEntity;
+    constructor(formBuilder: FormBuilder);
+    renderLabel(label: string): string;
+    private updateRelEntries;
+    private getTypeEntryPrefix;
+    onTypeEntryChange(entry: ThesaurusEntry): void;
+    private updateForm;
+    private getModel;
+    onChronotopesChange(chronotope: AssertedChronotope[]): void;
+    onAssertionChange(assertion: Assertion | undefined): void;
+    addEntity(): void;
+    editEntity(entity: RelatedEntity, index: number): void;
+    onEntityChange(entity: RelatedEntity): void;
+    closeEntity(): void;
+    deleteEntity(index: number): void;
+    cancel(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoricalEventEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HistoricalEventEditorComponent, "cadmus-historical-event-editor", never, { "event": { "alias": "event"; "required": false; "isSignal": true; }; "eventTypeEntries": { "alias": "eventTypeEntries"; "required": false; "isSignal": true; }; "eventTagEntries": { "alias": "eventTagEntries"; "required": false; "isSignal": true; }; "relationEntries": { "alias": "relationEntries"; "required": false; "isSignal": true; }; "ctTagEntries": { "alias": "ctTagEntries"; "required": false; "isSignal": true; }; "idScopeEntries": { "alias": "idScopeEntries"; "required": false; "isSignal": true; }; "idTagEntries": { "alias": "idTagEntries"; "required": false; "isSignal": true; }; "assTagEntries": { "alias": "assTagEntries"; "required": false; "isSignal": true; }; "refTagEntries": { "alias": "refTagEntries"; "required": false; "isSignal": true; }; "refTypeEntries": { "alias": "refTypeEntries"; "required": false; "isSignal": true; }; "setTagEntries": { "alias": "setTagEntries"; "required": false; "isSignal": true; }; "eventTypeTailCut": { "alias": "eventTypeTailCut"; "required": false; "isSignal": true; }; "pinByTypeMode": { "alias": "pinByTypeMode"; "required": false; "isSignal": true; }; "canSwitchMode": { "alias": "canSwitchMode"; "required": false; "isSignal": true; }; "canEditTarget": { "alias": "canEditTarget"; "required": false; "isSignal": true; }; "noLookup": { "alias": "noLookup"; "required": false; "isSignal": true; }; }, { "event": "eventChange"; "editorClose": "editorClose"; }, never, never, true, never>;
+}
+
+/**
+ * The HistoricalDate part model.
+ */
+interface HistoricalDatePart extends Part {
+    date: HistoricalDateModel;
+    references?: DocReference[];
+}
+/**
+ * The type ID used to identify the HistoricalDatePart type.
+ */
+declare const HISTORICAL_DATE_PART_TYPEID = "it.vedph.historical-date";
+/**
+ * JSON schema for the HistoricalDate part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const HISTORICAL_DATE_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        date: {
+            type: string;
+            required: string[];
+            properties: {
+                a: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        value: {
+                            type: string;
+                        };
+                        isCentury: {
+                            type: string;
+                        };
+                        isSpan: {
+                            type: string;
+                        };
+                        isApproximate: {
+                            type: string;
+                        };
+                        isDubious: {
+                            type: string;
+                        };
+                        day: {
+                            type: string;
+                        };
+                        month: {
+                            type: string;
+                        };
+                        hint: {
+                            type: string[];
+                        };
+                    };
+                };
+                b: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        value: {
+                            type: string;
+                        };
+                        isCentury: {
+                            type: string;
+                        };
+                        isSpan: {
+                            type: string;
+                        };
+                        isApproximate: {
+                            type: string;
+                        };
+                        isDubious: {
+                            type: string;
+                        };
+                        day: {
+                            type: string;
+                        };
+                        month: {
+                            type: string;
+                        };
+                        hint: {
+                            type: string[];
+                        };
+                    };
+                };
+            };
+        };
+        references: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        type: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        citation: {
+                            type: string;
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+declare class HistoricalDatePartComponent extends ModelEditorComponentBase<HistoricalDatePart> implements OnInit {
+    references: FormControl<DocReference[]>;
+    date: FormControl<HistoricalDateModel>;
+    typeEntries: ThesaurusEntry[] | undefined;
+    tagEntries: ThesaurusEntry[] | undefined;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateForm;
+    private updateThesauri;
+    protected onDataSet(data?: EditedObject<HistoricalDatePart>): void;
+    protected getValue(): HistoricalDatePart;
+    onDateChange(date: HistoricalDateModel): void;
+    onReferencesChange(references: DocReference[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoricalDatePartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HistoricalDatePartComponent, "cadmus-historical-date-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Historical events part.
+ * Thesauri: event-types, event-tags, event-relations, chronotope-tags,
+ * asserted-id-scopes, asserted-id-tags, assertion-tags, doc-reference-tags,
+ * doc-reference-types, pin-link-scopes, pin-link-tags, pin-link-settings.
+ */
+declare class HistoricalEventsPartComponent extends ModelEditorComponentBase<HistoricalEventsPart> implements OnInit {
+    private _dialogService;
+    editedEventIndex: number;
+    editedEvent: HistoricalEvent | undefined;
+    pinByTypeMode?: boolean;
+    canSwitchMode?: boolean;
+    canEditTarget?: boolean;
+    /**
+     * Thesaurus event-types.
+     */
+    eventTypeEntries: ThesaurusEntry[] | undefined;
+    /**
+     * Thesaurus event-tags.
+     */
+    eventTagEntries: ThesaurusEntry[] | undefined;
+    /**
+     * Thesaurus event-relations.
+     */
+    relationEntries: ThesaurusEntry[] | undefined;
+    /**
+     * Thesaurus chronotope-tags.
+     */
+    ctTagEntries: ThesaurusEntry[] | undefined;
+    /**
+     * Thesaurus assertion-tags.
+     */
+    assTagEntries: ThesaurusEntry[] | undefined;
+    /**
+     * Thesaurus doc-reference-tags.
+     */
+    refTagEntries: ThesaurusEntry[] | undefined;
+    /**
+     * Thesaurus doc-reference-types.
+     */
+    refTypeEntries: ThesaurusEntry[] | undefined;
+    idScopeEntries?: ThesaurusEntry[];
+    idTagEntries?: ThesaurusEntry[];
+    events: FormControl<HistoricalEvent[]>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    /**
+     * Load settings from thesaurus entries.
+     *
+     * @param entries The thesaurus entries if any.
+     */
+    private loadSettings;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<HistoricalEventsPart>): void;
+    protected getValue(): HistoricalEventsPart;
+    closeEvent(): void;
+    addEvent(): void;
+    editEvent(event: HistoricalEvent, index: number): void;
+    onEventSave(event: HistoricalEvent): void;
+    deleteEvent(index: number): void;
+    moveEventUp(index: number): void;
+    moveEventDown(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoricalEventsPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HistoricalEventsPartComponent, "cadmus-historical-events-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Related entity component to edit the entity related to a historical event.
+ */
+declare class RelatedEntityComponent {
+    readonly entity: i0.ModelSignal<RelatedEntity | undefined>;
+    readonly relationEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly idScopeEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus asserted-id-tags.
+     */
+    readonly idTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus assertion-tags.
+     */
+    readonly assTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus doc-reference-tags.
+     */
+    readonly refTagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * Thesaurus doc-reference-types.
+     */
+    readonly refTypeEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly pinByTypeMode: i0.InputSignal<boolean | undefined>;
+    readonly canSwitchMode: i0.InputSignal<boolean | undefined>;
+    readonly canEditTarget: i0.InputSignal<boolean | undefined>;
+    readonly editorClose: i0.OutputEmitterRef<void>;
+    relation: FormControl<string | null>;
+    id: FormControl<AssertedCompositeId | null>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder);
+    private updateForm;
+    private getEntity;
+    onIdChange(id: AssertedCompositeId): void;
+    cancel(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelatedEntityComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RelatedEntityComponent, "cadmus-related-entity", never, { "entity": { "alias": "entity"; "required": false; "isSignal": true; }; "relationEntries": { "alias": "relationEntries"; "required": false; "isSignal": true; }; "idScopeEntries": { "alias": "idScopeEntries"; "required": false; "isSignal": true; }; "idTagEntries": { "alias": "idTagEntries"; "required": false; "isSignal": true; }; "assTagEntries": { "alias": "assTagEntries"; "required": false; "isSignal": true; }; "refTagEntries": { "alias": "refTagEntries"; "required": false; "isSignal": true; }; "refTypeEntries": { "alias": "refTypeEntries"; "required": false; "isSignal": true; }; "pinByTypeMode": { "alias": "pinByTypeMode"; "required": false; "isSignal": true; }; "canSwitchMode": { "alias": "canSwitchMode"; "required": false; "isSignal": true; }; "canEditTarget": { "alias": "canEditTarget"; "required": false; "isSignal": true; }; }, { "entity": "entityChange"; "editorClose": "editorClose"; }, never, never, true, never>;
+}
+
+declare class IndexKeywordComponent {
+    readonly keyword: i0.ModelSignal<IndexKeyword | undefined>;
+    readonly idxEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly tagEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly langEntries: i0.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly editorClose: i0.OutputEmitterRef<void>;
+    indexId: FormControl<string | null>;
+    language: FormControl<string | null>;
+    value: FormControl<string | null>;
+    note: FormControl<string | null>;
+    tag: FormControl<string | null>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder);
+    private updateForm;
+    private getKeyword;
+    cancel(): void;
+    submit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexKeywordComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IndexKeywordComponent, "cadmus-index-keyword", never, { "keyword": { "alias": "keyword"; "required": false; "isSignal": true; }; "idxEntries": { "alias": "idxEntries"; "required": false; "isSignal": true; }; "tagEntries": { "alias": "tagEntries"; "required": false; "isSignal": true; }; "langEntries": { "alias": "langEntries"; "required": false; "isSignal": true; }; }, { "keyword": "keywordChange"; "editorClose": "editorClose"; }, never, never, true, never>;
+}
+
+/**
+ * Index keywords part editor.
+ * Thesauri: languages, keyword-indexes, keyword-tags.
+ */
+declare class IndexKeywordsPartComponent extends ModelEditorComponentBase<IndexKeywordsPart> implements OnInit {
+    editedKeyword?: IndexKeyword;
+    idxEntries: ThesaurusEntry[] | undefined;
+    langEntries: ThesaurusEntry[] | undefined;
+    tagEntries: ThesaurusEntry[] | undefined;
+    keywords: FormControl<IndexKeyword[]>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private compareKeywords;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<IndexKeywordsPart>): void;
+    protected getValue(): IndexKeywordsPart;
+    private addKeyword;
+    addNewKeyword(): void;
+    deleteKeyword(keyword: IndexKeyword): void;
+    editKeyword(keyword: IndexKeyword): void;
+    onKeywordClose(): void;
+    onKeywordChange(keyword: IndexKeyword): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexKeywordsPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IndexKeywordsPartComponent, "cadmus-index-keywords-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Keywords editor component.
+ * Thesauri: languages.
+ */
+declare class KeywordsPartComponent extends ModelEditorComponentBase<KeywordsPart> implements OnInit {
+    keywords: FormControl<Keyword[]>;
+    newLanguage: FormControl<string | null>;
+    newValue: FormControl<string | null>;
+    newForm: FormGroup;
+    langEntries?: ThesaurusEntry[];
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private compareKeywords;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<KeywordsPart>): void;
+    protected getValue(): KeywordsPart;
+    addKeyword(): void;
+    deleteKeyword(keyword: Keyword): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeywordsPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeywordsPartComponent, "cadmus-keywords-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The metadata part model.
+ */
+interface MetadataPart extends Part {
+    metadata: Metadatum[];
+}
+/**
+ * A metadata entry in MetadataPart.
+ */
+interface Metadatum {
+    type?: string;
+    name: string;
+    value: string;
+}
+/**
+ * The type ID used to identify the MetadataPart type.
+ */
+declare const METADATA_PART_TYPEID = "it.vedph.metadata";
+/**
+ * JSON schema for the metadata part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const METADATA_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        metadata: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        type: {
+                            type: string;
+                        };
+                        name: {
+                            type: string;
+                        };
+                        value: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * Metadata part editor component.
+ * Thesauri: metadata-types (optional).
+ */
+declare class MetadataPartComponent extends ModelEditorComponentBase<MetadataPart> implements OnInit, OnDestroy {
+    private _subs;
+    metadata: FormArray;
+    /**
+     * metadata-types thesaurus entries.
+     */
+    typeEntries: ThesaurusEntry[] | undefined;
+    /**
+     * metadata-names thesaurus entries.
+     */
+    nameEntries: ThesaurusEntry[] | undefined;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private unsubscribe;
+    ngOnDestroy(): void;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<MetadataPart>): void;
+    protected getValue(): MetadataPart;
+    private getMetadatumGroup;
+    addMetadatum(item?: Metadatum): void;
+    removeMetadatum(index: number): void;
+    moveMetadatumUp(index: number): void;
+    moveMetadatumDown(index: number): void;
+    private getMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataPartComponent, "cadmus-metadata-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The names part model.
+ */
+interface NamesPart extends Part {
+    names: AssertedProperName[];
+}
+/**
+ * The type ID used to identify the NamesPart type.
+ */
+declare const NAMES_PART_TYPEID = "it.vedph.names";
+/**
+ * JSON schema for the names part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const NAMES_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        names: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        language: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        pieces: {
+                            type: string;
+                            items: {
+                                anyOf: {
+                                    type: string;
+                                    required: string[];
+                                    properties: {
+                                        type: {
+                                            type: string;
+                                        };
+                                        value: {
+                                            type: string;
+                                        };
+                                    };
+                                }[];
+                            };
+                        };
+                        assertion: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                tag: {
+                                    type: string;
+                                };
+                                rank: {
+                                    type: string;
+                                };
+                                note: {
+                                    type: string;
+                                };
+                                references: {
+                                    type: string;
+                                    items: {
+                                        anyOf: {
+                                            type: string;
+                                            required: string[];
+                                            properties: {
+                                                type: {
+                                                    type: string;
+                                                };
+                                                tag: {
+                                                    type: string;
+                                                };
+                                                citation: {
+                                                    type: string;
+                                                };
+                                                note: {
+                                                    type: string;
+                                                };
+                                            };
+                                        }[];
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * Names part editor component.
+ * Thesauri: name-languages, name-tags, name-piece-types, assertion-tags,
+ * doc-reference-types, doc-reference-tags (all optional).
+ */
+declare class NamesPartComponent extends ModelEditorComponentBase<NamesPart> implements OnInit {
+    private _dialogService;
+    private _updatingForm?;
+    editedIndex: number;
+    editedName: AssertedProperName | undefined;
+    /**
+     * The optional thesaurus proper name languages entries (name-languages).
+     */
+    langEntries: ThesaurusEntry[] | undefined;
+    /**
+     * The optional thesaurus name's tag entries (name-tags).
+     */
+    tagEntries: ThesaurusEntry[] | undefined;
+    /**
+     * The optional thesaurus name piece's type entries (name-piece-types).
+     */
+    typeEntries: ThesaurusEntry[] | undefined;
+    assTagEntries?: ThesaurusEntry[];
+    refTypeEntries: ThesaurusEntry[] | undefined;
+    refTagEntries: ThesaurusEntry[] | undefined;
+    names: FormControl<AssertedProperName[]>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<NamesPart>): void;
+    protected getValue(): NamesPart;
+    addName(): void;
+    editName(index: number): void;
+    onNameChange(name: AssertedProperName | undefined): void;
+    onNameClose(): void;
+    deleteName(index: number): void;
+    moveNameUp(index: number): void;
+    moveNameDown(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NamesPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NamesPartComponent, "cadmus-names-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Note part.
+ */
+interface NotePart extends Part {
+    text: string;
+    tag?: string;
+}
+/**
+ * The type ID used to identify the NotePart type.
+ */
+declare const NOTE_PART_TYPEID = "it.vedph.note";
+/**
+ * JSON schema for the note part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const NOTE_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        text: {
+            type: string;
+        };
+        tag: {
+            type: string[];
+        };
+    };
+};
+
+/**
+ * Note part editor component.
+ * Thesauri: optionally "note-tags", when you want to use a closed set of tags.
+ */
+declare class NotePartComponent extends ModelEditorComponentBase<NotePart> implements OnInit, OnDestroy {
+    private _editService;
+    private _editorBindings?;
+    private readonly _disposables;
+    private _editorModel?;
+    private _editor?;
+    tag: FormControl<string | null>;
+    text: FormControl<string | null>;
+    tagEntries?: ThesaurusEntry[];
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _editService: CadmusTextEdService, _editorBindings?: CadmusTextEdBindings | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private applyEdit;
+    onCreateEditor(editor: monaco.editor.IEditor): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<NotePart>): void;
+    protected getValue(): NotePart;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotePartComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotePartComponent, "cadmus-note-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The PhysicalMeasurements part model.
+ */
+interface PhysicalMeasurementsPart extends Part {
+    measurements: PhysicalMeasurement[];
+}
+/**
+ * The type ID used to identify the PhysicalMeasurementsPart type.
+ */
+declare const PHYSICAL_MEASUREMENTS_PART_TYPEID = "it.vedph.physical-measurements";
+/**
+ * JSON schema for the PhysicalMeasurements part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const PHYSICAL_MEASUREMENTS_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        measurements: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        tag: {
+                            type: string;
+                        };
+                        value: {
+                            type: string;
+                        };
+                        unit: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * PhysicalMeasurements part editor component.
+ * Thesauri: physical-size-units, physical-size-dim-tags, physical-size-set-names (all optional).
+ */
+declare class PhysicalMeasurementsPartComponent extends ModelEditorComponentBase<PhysicalMeasurementsPart> implements OnInit {
+    measurements: FormControl<PhysicalMeasurement[]>;
+    unitEntries?: ThesaurusEntry[];
+    dimTagEntries?: ThesaurusEntry[];
+    nameEntries?: ThesaurusEntry[];
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<PhysicalMeasurementsPart>): void;
+    protected getValue(): PhysicalMeasurementsPart;
+    onMeasurementsChange(measurements: PhysicalMeasurement[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhysicalMeasurementsPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhysicalMeasurementsPartComponent, "cadmus-physical-measurements-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The PhysicalStates part model.
+ */
+interface PhysicalStatesPart extends Part {
+    states: PhysicalState[];
+}
+/**
+ * The type ID used to identify the PhysicalStatesPart type.
+ */
+declare const PHYSICAL_STATES_PART_TYPEID = "it.vedph.physical-states";
+/**
+ * JSON schema for the PhysicalStates part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const PHYSICAL_STATES_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        states: {
+            type: string;
+            items: {
+                anyOf: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        type: {
+                            type: string;
+                        };
+                        features: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                        date: {
+                            type: string;
+                        };
+                        reporter: {
+                            type: string;
+                        };
+                        note: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+
+/**
+ * PhysicalStatesPart editor component.
+ * Thesauri: physical-states (optional), physical-state-features (optional),
+ * physical-state-reporters (optional).
+ */
+declare class PhysicalStatesPartComponent extends ModelEditorComponentBase<PhysicalStatesPart> implements OnInit {
+    private _dialogService;
+    editedIndex: number;
+    edited: PhysicalState | undefined;
+    stateEntries?: ThesaurusEntry[];
+    featEntries?: ThesaurusEntry[];
+    reporterEntries?: ThesaurusEntry[];
+    entries: FormControl<PhysicalState[]>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<PhysicalStatesPart>): void;
+    protected getValue(): PhysicalStatesPart;
+    addState(): void;
+    editState(entry: PhysicalState, index: number): void;
+    closeState(): void;
+    saveState(entry: PhysicalState): void;
+    deleteState(index: number): void;
+    moveStateUp(index: number): void;
+    moveStateDown(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhysicalStatesPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhysicalStatesPartComponent, "cadmus-physical-states-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The PinLinks part model.
+ */
+interface PinLinksPart extends Part {
+    links: AssertedCompositeId[];
+}
+/**
+ * The type ID used to identify the PinLinksPart type.
+ */
+declare const PIN_LINKS_PART_TYPEID = "it.vedph.pin-links";
+/**
+ * JSON schema for the PinLinks part.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const PIN_LINKS_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        links: {
+            type: string;
+            items: {
+                type: string;
+                default: {};
+                required: string[];
+                properties: {
+                    target: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            gid: {
+                                type: string;
+                            };
+                            label: {
+                                type: string;
+                            };
+                            itemId: {
+                                type: string;
+                            };
+                            partId: {
+                                type: string;
+                            };
+                            partTypeId: {
+                                type: string;
+                            };
+                            roleId: {
+                                type: string;
+                            };
+                            name: {
+                                type: string;
+                            };
+                            value: {
+                                type: string;
+                            };
+                        };
+                    };
+                    scope: {
+                        type: string;
+                    };
+                    tag: {
+                        type: string;
+                    };
+                    assertion: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            tag: {
+                                type: string;
+                            };
+                            rank: {
+                                type: string;
+                            };
+                            note: {
+                                type: string;
+                            };
+                            references: {
+                                type: string;
+                                items: {
+                                    anyOf: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            type: {
+                                                type: string;
+                                            };
+                                            tag: {
+                                                type: string;
+                                            };
+                                            citation: {
+                                                type: string;
+                                            };
+                                            note: {
+                                                type: string;
+                                            };
+                                        };
+                                    }[];
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+
+/**
+ * PinLinksPart editor component.
+ * Thesauri: pin-link-scopes, pin-link-tags, pin-link-assertion-tags,
+ * pin-link-docref-types, pin-link-docref-tags, pin-link-settings.
+ */
+declare class PinLinksPartComponent extends ModelEditorComponentBase<PinLinksPart> implements OnInit {
+    links: FormControl<AssertedCompositeId[]>;
+    pinByTypeMode?: boolean;
+    canSwitchMode?: boolean;
+    canEditTarget?: boolean;
+    idScopeEntries?: ThesaurusEntry[];
+    idTagEntries?: ThesaurusEntry[];
+    assTagEntries?: ThesaurusEntry[];
+    refTypeEntries?: ThesaurusEntry[];
+    refTagEntries?: ThesaurusEntry[];
+    setTagEntries?: ThesaurusEntry[];
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    /**
+     * Load settings from thesaurus entries.
+     *
+     * @param entries The thesaurus entries if any.
+     */
+    private loadSettings;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<PinLinksPart>): void;
+    protected getValue(): PinLinksPart;
+    onIdsChange(ids: AssertedCompositeId[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinLinksPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PinLinksPartComponent, "cadmus-pin-links-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The pin-based links layer fragment server model.
+ */
+interface PinLinksFragment extends Fragment {
+    links: AssertedCompositeId[];
+}
+declare const PIN_LINKS_FRAGMENT_TYPEID = "fr.it.vedph.pin-links";
+declare const PIN_LINKS_FRAGMENT_SCHEMA: {
+    definitions: {};
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        location: {
+            $id: string;
+            type: string;
+        };
+        baseText: {
+            $id: string;
+            type: string;
+        };
+        links: {
+            type: string;
+            items: {
+                type: string;
+                default: {};
+                required: string[];
+                properties: {
+                    target: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            gid: {
+                                type: string;
+                            };
+                            label: {
+                                type: string;
+                            };
+                            itemId: {
+                                type: string;
+                            };
+                            partId: {
+                                type: string;
+                            };
+                            partTypeId: {
+                                type: string;
+                            };
+                            roleId: {
+                                type: string;
+                            };
+                            name: {
+                                type: string;
+                            };
+                            value: {
+                                type: string;
+                            };
+                        };
+                    };
+                    scope: {
+                        type: string;
+                    };
+                    tag: {
+                        type: string;
+                    };
+                    assertion: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            tag: {
+                                type: string;
+                            };
+                            rank: {
+                                type: string;
+                            };
+                            note: {
+                                type: string;
+                            };
+                            references: {
+                                type: string;
+                                items: {
+                                    anyOf: {
+                                        type: string;
+                                        required: string[];
+                                        properties: {
+                                            type: {
+                                                type: string;
+                                            };
+                                            tag: {
+                                                type: string;
+                                            };
+                                            citation: {
+                                                type: string;
+                                            };
+                                            note: {
+                                                type: string;
+                                            };
+                                        };
+                                    }[];
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+
+/**
+ * Pin-based links fragment editor component.
+ * Thesauri: pin-link-scopes, pin-link-tags, pin-link-assertion-tags,
+ * pin-link-docref-types, pin-link-docref-tags, pin-link-settings.
+ */
+declare class PinLinksFragmentComponent extends ModelEditorComponentBase<PinLinksFragment> implements OnInit {
+    links: FormControl<AssertedCompositeId[]>;
+    pinByTypeMode?: boolean;
+    canSwitchMode?: boolean;
+    canEditTarget?: boolean;
+    idScopeEntries?: ThesaurusEntry[];
+    idTagEntries?: ThesaurusEntry[];
+    assTagEntries?: ThesaurusEntry[];
+    refTypeEntries?: ThesaurusEntry[];
+    refTagEntries?: ThesaurusEntry[];
+    setTagEntries?: ThesaurusEntry[];
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    /**
+     * Load settings from thesaurus entries.
+     *
+     * @param entries The thesaurus entries if any.
+     */
+    private loadSettings;
+    private updateThesauri;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<PinLinksFragment>): void;
+    protected getValue(): PinLinksFragment;
+    onIdsChange(ids: AssertedCompositeId[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinLinksFragmentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PinLinksFragmentComponent, "cadmus-pin-links-fragment", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The name of the text tile part data representing its text.
+ */
+declare const TEXT_TILE_TEXT_DATA_NAME = "text";
+/**
+ * A tile in a tiled text row.
+ */
+interface TextTile {
+    x: number;
+    data?: {
+        [key: string]: any;
+    };
+}
+/**
+ * A row in the tiled text part.
+ */
+interface TextTileRow {
+    y: number;
+    tiles: TextTile[];
+    data?: {
+        [key: string]: any;
+    };
+}
+/**
+ * The tiled text part model.
+ */
+interface TiledTextPart extends Part {
+    citation?: string;
+    rows: TextTileRow[];
+}
+/**
+ * The type ID used to identify the TiledTextPart type.
+ */
+declare const TILED_TEXT_PART_TYPEID = "it.vedph.tiled-text";
+/**
+ * JSON schema for the tiled text part. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const TILEDTEXTPART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        citation: {
+            type: string[];
+        };
+        rows: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    y: {
+                        type: string;
+                        minimum: number;
+                    };
+                    tiles: {
+                        type: string;
+                        items: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                x: {
+                                    type: string;
+                                    minimum: number;
+                                };
+                                data: {
+                                    type: string;
+                                    patternProperties: {
+                                        '^.*$': {
+                                            anyOf: {
+                                                type: string;
+                                            }[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+                data: {
+                    type: string;
+                    patternProperties: {
+                        '^.*$': {
+                            anyOf: {
+                                type: string;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+
+declare class TextTileComponent implements OnInit, OnDestroy {
+    private _sub?;
+    private _checkedChangeFrozen?;
+    textElement?: ElementRef;
+    readonly selected: i0.InputSignal<boolean | undefined>;
+    readonly checkable: i0.InputSignal<boolean | undefined>;
+    readonly readonly: i0.InputSignal<boolean | undefined>;
+    readonly color: i0.InputSignal<string | undefined>;
+    readonly checked: i0.ModelSignal<boolean>;
+    readonly tile: i0.ModelSignal<TextTile | undefined>;
+    readonly editData: i0.OutputEmitterRef<TextTile>;
+    editedText: FormControl<string | null>;
+    checker: FormControl<boolean>;
+    form: FormGroup;
+    text?: string;
+    editing?: boolean;
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private updateForm;
+    requestDataEdit(): void;
+    toggleCheckedNonEdit(): void;
+    edit(): void;
+    requestEditData(): void;
+    cancel(): void;
+    private getTile;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextTileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextTileComponent, "cadmus-text-tile", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "checkable": { "alias": "checkable"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "tile": { "alias": "tile"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "tile": "tileChange"; "editData": "editData"; }, never, never, true, never>;
+}
+
+interface Data$1 {
+    [key: string]: any;
+}
+interface DataKey {
+    value: string;
+    visible: boolean;
+}
+declare class TiledDataComponent implements OnInit, OnDestroy {
+    private _formBuilder;
+    private _dialogService;
+    private _sub?;
+    private _hiddenData;
+    keys: DataKey[];
+    readonly title: i0.InputSignal<string | undefined>;
+    readonly data: i0.ModelSignal<Data$1>;
+    readonly hiddenKeys: i0.InputSignal<string[]>;
+    readonly cancel: i0.OutputEmitterRef<void>;
+    keyFilter: FormControl<string | null>;
+    filterForm: FormGroup;
+    newKey: FormControl<string | null>;
+    newValue: FormControl<string | null>;
+    newForm: FormGroup;
+    form: FormGroup;
+    constructor(_formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private matchesFilter;
+    isVisibleKey(key: string): boolean;
+    private updateForm;
+    private updateDataVisibility;
+    private getData;
+    deleteDatum(key: DataKey): void;
+    addDatum(): void;
+    close(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TiledDataComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TiledDataComponent, "cadmus-tiled-data", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "hiddenKeys": { "alias": "hiddenKeys"; "required": false; "isSignal": true; }; }, { "data": "dataChange"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+interface Data {
+    [key: string]: any;
+}
+declare class TiledTextPartComponent extends ModelEditorComponentBase<TiledTextPart> implements OnInit {
+    private _dialogService;
+    private _editedDataTile?;
+    private _editedDataRow?;
+    selectedTile?: TextTile;
+    citation: FormControl<string | null>;
+    rows: FormControl<TextTileRow[]>;
+    editedData?: Data;
+    editedDataTitle?: string;
+    currentTabIndex: number;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<TiledTextPart>): void;
+    /**
+     * Recalculate the coordinates of all the tiles in this set,
+     * according to the tiles position.
+     */
+    private adjustCoords;
+    protected getValue(): TiledTextPart;
+    /**
+     * Append a new row at the bottom.
+     */
+    addRow(): void;
+    /**
+     * Append a new tile at the end of the specified row.
+     * @param row The row to add the tile to.
+     */
+    addTile(row: TextTileRow): void;
+    /**
+     * Delete the selected tile, if any.
+     */
+    deleteSelectedTile(): void;
+    /**
+     * Delete the row at the specified index.
+     * @param rowIndex The row's index.
+     */
+    deleteRow(rowIndex: number): void;
+    /**
+     * Move the row at the specified index up.
+     * @param rowIndex The row index.
+     */
+    moveRowUp(rowIndex: number): void;
+    /**
+     * Move the row at the specified index down.
+     * @param rowIndex The row index.
+     */
+    moveRowDown(rowIndex: number): void;
+    drop(event: CdkDragDrop<TextTile[]>, row: TextTileRow): void;
+    onTileChange(tile: TextTile): void;
+    editRowData(row: TextTileRow): void;
+    editTileData(tile: TextTile): void;
+    closeDataEditor(): void;
+    saveEditedData(data: Data): void;
+    getTileCoords(tile?: TextTile): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TiledTextPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TiledTextPartComponent, "cadmus-tiled-text-part", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A single line in a TokenTextPart.
+ */
+interface TokenTextLine {
+    y: number;
+    text: string;
+}
+/**
+ * Token-based text part.
+ */
+interface TokenTextPart extends Part {
+    citation?: string;
+    lines: TokenTextLine[];
+}
+/**
+ * The type ID used to identify the TokenTextPart type.
+ */
+declare const TOKEN_TEXT_PART_TYPEID = "it.vedph.token-text";
+/**
+ * JSON schema for the TookenTextPart. This is used in the editor demo.
+ * You can use the JSON schema tool at https://jsonschema.net/.
+ */
+declare const TOKEN_TEXT_PART_SCHEMA: {
+    $schema: string;
+    $id: string;
+    type: string;
+    title: string;
+    required: string[];
+    properties: {
+        timeCreated: {
+            type: string;
+            pattern: string;
+        };
+        creatorId: {
+            type: string;
+        };
+        timeModified: {
+            type: string;
+            pattern: string;
+        };
+        userId: {
+            type: string;
+        };
+        id: {
+            type: string;
+            pattern: string;
+        };
+        itemId: {
+            type: string;
+            pattern: string;
+        };
+        typeId: {
+            type: string;
+            pattern: string;
+        };
+        roleId: {
+            type: string[];
+            pattern: string;
+        };
+        citation: {
+            type: string[];
+        };
+        lines: {
+            $id: string;
+            type: string;
+            title: string;
+            items: {
+                $id: string;
+                type: string;
+                required: string[];
+                properties: {
+                    y: {
+                        $id: string;
+                        type: string;
+                    };
+                    text: {
+                        $id: string;
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+};
+
+/**
+ * Editor component for base text, as referenced by token-based layers.
+ * Thesauri: none.
+ */
+declare class TokenTextPartComponent extends ModelEditorComponentBase<TokenTextPart> implements OnInit, OnDestroy {
+    private _dialogService;
+    private readonly _disposables;
+    private _editorModel?;
+    private _editor?;
+    citation: FormControl<string | null>;
+    text: FormControl<string | null>;
+    transform: FormControl<string | null>;
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder, _dialogService: DialogService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onCreateEditor(editor: monaco.editor.IEditor): void;
+    protected buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    private getTextFromModel;
+    private getLinesFromText;
+    private updateForm;
+    protected onDataSet(data?: EditedObject<TokenTextPart>): void;
+    protected getValue(): TokenTextPart;
+    private normalizeWs;
+    private splitAtStops;
+    applyTransform(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TokenTextPartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TokenTextPartComponent, "cadmus-token-text-part", never, {}, {}, never, never, true, never>;
+}
+
+export { ASSERTED_HISTORICAL_DATES_PART_SCHEMA, ASSERTED_HISTORICAL_DATES_PART_TYPEID, AssertedHistoricalDateComponent, AssertedHistoricalDatesPartComponent, BIBLIOGRAPHY_PART_SCHEMA, BIBLIOGRAPHY_PART_TYPEID, BibAuthorsEditorComponent, BibliographyEntryComponent, BibliographyPartComponent, CATEGORIES_PART_SCHEMA, CATEGORIES_PART_TYPEID, CHRONOLOGY_FRAGMENT_SCHEMA, CHRONOLOGY_FRAGMENT_TYPEID, CHRONOTOPES_PART_TYPEID, COMMENT_FRAGMENT_SCHEMA, COMMENT_FRAGMENT_TYPEID, COMMENT_PART_SCHEMA, COMMENT_PART_TYPEID, CategoriesPartComponent, ChronologyFragmentComponent, ChronotopesPartComponent, Chronotopes_PART_SCHEMA, CommentEditorComponent, DECORATED_COUNTS_PART_SCHEMA, DECORATED_COUNTS_PART_TYPEID, DISTRICT_LOCATION_PART_SCHEMA, DISTRICT_LOCATION_PART_TYPEID, DOC_REFERENCES_PART_SCHEMA, DOC_REFERENCES_PART_TYPEID, DecoratedCountsPartComponent, DistrictLocationPartComponent, DocReferencesPartComponent, EXTERNAL_IDS_PART_SCHEMA, EXTERNAL_IDS_PART_TYPEID, ExternalIdsPartComponent, HISTORICAL_DATE_PART_SCHEMA, HISTORICAL_DATE_PART_TYPEID, HISTORICAL_EVENTS_PART_SCHEMA, HISTORICAL_EVENTS_PART_TYPEID, HistoricalDatePartComponent, HistoricalEventEditorComponent, HistoricalEventsPartComponent, INDEX_KEYWORDS_PART_SCHEMA, INDEX_KEYWORDS_PART_TYPEID, IndexKeywordComponent, IndexKeywordsPartComponent, KEYWORDS_PART_SCHEMA, KEYWORDS_PART_TYPEID, KeywordsPartComponent, METADATA_PART_SCHEMA, METADATA_PART_TYPEID, MetadataPartComponent, NAMES_PART_SCHEMA, NAMES_PART_TYPEID, NOTE_PART_SCHEMA, NOTE_PART_TYPEID, NamesPartComponent, NotePartComponent, PHYSICAL_MEASUREMENTS_PART_SCHEMA, PHYSICAL_MEASUREMENTS_PART_TYPEID, PHYSICAL_STATES_PART_SCHEMA, PHYSICAL_STATES_PART_TYPEID, PIN_LINKS_FRAGMENT_SCHEMA, PIN_LINKS_FRAGMENT_TYPEID, PIN_LINKS_PART_SCHEMA, PIN_LINKS_PART_TYPEID, PhysicalMeasurementsPartComponent, PhysicalStatesPartComponent, PinLinksFragmentComponent, PinLinksPartComponent, RelatedEntityComponent, TEXT_TILE_TEXT_DATA_NAME, TILEDTEXTPART_SCHEMA, TILED_TEXT_PART_TYPEID, TOKEN_TEXT_PART_SCHEMA, TOKEN_TEXT_PART_TYPEID, TextTileComponent, TiledDataComponent, TiledTextPartComponent, TokenTextPartComponent };
+export type { AssertedHistoricalDatesPart, BibAuthor, BibEntry, BibliographyPart, CategoriesPart, ChronologyFragment, ChronotopesPart, Comment, CommentFragment, CommentPart, DecoratedCountsPart, DistrictLocationPart, DocReferencesPart, ExternalIdsPart, HistoricalDatePart, HistoricalEvent, HistoricalEventsPart, IndexKeyword, IndexKeywordsPart, Keyword, KeywordsPart, MetadataPart, Metadatum, NamesPart, NotePart, PhysicalMeasurementsPart, PhysicalStatesPart, PinLinksFragment, PinLinksPart, RelatedEntity, TextTile, TextTileRow, TiledTextPart, TokenTextLine, TokenTextPart };