@myrmidon/cadmus-part-general-pg/types/myrmidon-cadmus-part-general-pg.d.ts

Cadmus - general parts wrappers.

import * as i0 from '@angular/core';
import { OnInit, OnDestroy } from '@angular/core';
import { MatSnackBar } from '@angular/material/snack-bar';
import { Router, ActivatedRoute, Routes } from '@angular/router';
import { ItemService, ThesaurusService, UserLevelService } from '@myrmidon/cadmus-api';
import { EditPartFeatureBase, PartEditorService, EditFragmentFeatureBase, FragmentEditorService, EditedLayerRepository } from '@myrmidon/cadmus-state';
import { LibraryRouteService, TokenLocation, ComponentCanDeactivate, LayerHint, TextLayerService } from '@myrmidon/cadmus-core';
import { Observable } from 'rxjs';
import { DialogService } from '@myrmidon/ngx-mat-tools';
import { TextTileRow, TextTile } from '@myrmidon/cadmus-part-general-ui';
import { EditedItemRepository } from '@myrmidon/cadmus-item-editor';

declare class AssertedHistoricalDateFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<AssertedHistoricalDateFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AssertedHistoricalDateFeatureComponent, "cadmus-asserted-historical-date-feature", never, {}, {}, never, never, true, never>;
}

declare class BibliographyPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<BibliographyPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BibliographyPartFeatureComponent, "cadmus-bibliography-part-feature", never, {}, {}, never, never, true, never>;
}

declare class CategoriesPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<CategoriesPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CategoriesPartFeatureComponent, "cadmus-categories-part-feature", never, {}, {}, never, never, true, never>;
}

declare class ChronologyFragmentFeatureComponent extends EditFragmentFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, editorService: FragmentEditorService, libraryRouteService: LibraryRouteService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ChronologyFragmentFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChronologyFragmentFeatureComponent, "cadmus-chronology-fragment-feature", never, {}, {}, never, never, true, never>;
}

declare class ChronotopesPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ChronotopesPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChronotopesPartFeatureComponent, "cadmus-chronotopes-part-feature", never, {}, {}, never, never, true, never>;
}

declare class CommentFragmentFeatureComponent extends EditFragmentFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, editorService: FragmentEditorService, libraryRouteService: LibraryRouteService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentFragmentFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommentFragmentFeatureComponent, "cadmus-comment-fragment-feature", never, {}, {}, never, never, true, never>;
}

declare class CommentPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<CommentPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommentPartFeatureComponent, "cadmus-comment-part-feature", never, {}, {}, never, never, true, never>;
}

declare class DecoratedCountsPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<DecoratedCountsPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DecoratedCountsPartFeatureComponent, "cadmus-decorated-counts-part-feature", never, {}, {}, never, never, true, never>;
}

declare class DistrictLocationPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<DistrictLocationPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DistrictLocationPartFeatureComponent, "cadmus-district-location-part-feature", never, {}, {}, never, never, true, never>;
}

declare class DocReferencesPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<DocReferencesPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DocReferencesPartFeatureComponent, "cadmus-doc-references-part-feature", never, {}, {}, never, never, true, never>;
}

declare class ExternalIdsPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalIdsPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExternalIdsPartFeatureComponent, "cadmus-refs-external-ids-part-feature", never, {}, {}, never, never, true, never>;
}

declare class FlagsPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FlagsPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FlagsPartFeatureComponent, "cadmus-flags-part-feature", never, {}, {}, never, never, true, never>;
}

declare class HistoricalDatePartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<HistoricalDatePartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HistoricalDatePartFeatureComponent, "cadmus-historical-date-part-feature", never, {}, {}, never, never, true, never>;
}

declare class HistoricalEventsPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<HistoricalEventsPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HistoricalEventsPartFeatureComponent, "cadmus-historical-events-part-feature", never, {}, {}, never, never, true, never>;
}

declare class IndexKeywordsPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IndexKeywordsPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IndexKeywordsPartFeatureComponent, "cadmus-index-keywords-part-feature", never, {}, {}, never, never, true, never>;
}

declare class KeywordsPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<KeywordsPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KeywordsPartFeatureComponent, "cadmus-keywords-part-feature", never, {}, {}, never, never, true, never>;
}

declare class MetadataPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataPartFeatureComponent, "cadmus-metadata-part-feature", never, {}, {}, never, never, true, never>;
}

declare class NamesPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<NamesPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NamesPartFeatureComponent, "cadmus-names-part-feature", never, {}, {}, never, never, true, never>;
}

declare class NotePartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<NotePartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotePartFeatureComponent, "cadmus-note-part-feature", never, {}, {}, never, never, true, never>;
}

declare class PhysicalMeasurementsPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<PhysicalMeasurementsPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PhysicalMeasurementsPartFeatureComponent, "cadmus-physical-measurements-part-feature", never, {}, {}, never, never, true, never>;
}

declare class PhysicalStatesPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<PhysicalStatesPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PhysicalStatesPartFeatureComponent, "cadmus-physical-states-part-feature", never, {}, {}, never, never, true, never>;
}

declare class PinLinksFragmentFeatureComponent extends EditFragmentFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, editorService: FragmentEditorService, libraryRouteService: LibraryRouteService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<PinLinksFragmentFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PinLinksFragmentFeatureComponent, "cadmus-pin-links-fragment-feature", never, {}, {}, never, never, true, never>;
}

declare class PinLinksPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    protected getReqThesauriIds(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<PinLinksPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PinLinksPartFeatureComponent, "cadmus-pin-links-part-feature", never, {}, {}, never, never, true, never>;
}

/**
 * The layer view model for a text tile.
 */
interface TextTileLayerView {
    checked: boolean;
    frIndex: number;
    model: TextTile;
}
/**
 * The layer view model for a row of text tiles.
 */
interface TextTileRowLayerView {
    tiles: TextTileLayerView[];
}
/**
 * The layer view model for a tiled text.
 */
declare class TiledTextLayerView {
    private _rows;
    /**
     * Create a new view from the specified tiled text.
     * @param rows The tiled text rows.
     */
    constructor(rows: TextTileRow[]);
    /**
     * The internal rows view models.
     */
    get rows(): TextTileRowLayerView[];
    /**
     * Get the tile at the specified coordinates.
     *
     * @param y The tile's y coordinate.
     * @param x The tile's x coordinate.
     */
    getTileAt(y: number, x: number): TextTileLayerView;
    /**
     * Set the view state of all the tiles.
     *
     * @param state The state values to set in each tile's state.
     * @param setChecked True to set the checked property of states.
     * @param setFrIndex True to set the frIndex property of states.
     */
    setAllTilesViewState(state: {
        checked?: boolean;
        frIndex?: number;
    }): void;
    /**
     * Set the fragment index of each tile in this view. This is equal to the
     * index to the fragment including the tile, when the tile is inside that
     * fragment, or to -1, when the tile is outside any fragment. Fragment indexes
     * refer to their locations, as received by this function.
     *
     * @param locations Fragments locations.
     */
    setFragmentLocations(locations: TokenLocation[]): void;
    /**
     * Find the coordinates of the first tile having the specified checked state,
     * starting from the specified coordinates.
     *
     * @param y The y coordinates to start from.
     * @param x The x coordinates to start from.
     * @param checked True to find checked tiles, false to find unchecked tiles.
     * @param reverse True to find in reverse direction.
     * @returns The coordinates, or null if not found.
     */
    findFirstCheckedCoords(y: number, x: number, checked: boolean, reverse?: boolean): {
        y: number;
        x: number;
    } | null;
    /**
     * "Linearly" set the checked state in the specified range of checked tiles.
     *
     * @param y1 The start y coordinate.
     * @param x1 The start x coordinate.
     * @param y2 The end y coordinate (included).
     * @param x2 The end x coordinate (included).
     * @param checked The state to be set.
     */
    linearSetCheck(y1: number, x1: number, y2: number, x2: number, checked: boolean): void;
    /**
     * Get the coordinates of the next tile starting from the specified origin
     * tile. The next tile is the tile to the right of the origin tile in the
     * same row, or the first tile of the next row (if any) when the origin is
     * the last tile in its row.
     *
     * @param y The y coordinate of the origin tile.
     * @param x The x coordinate of the origin tile.
     * @returns The coordinates, or null if no other tiles after origin.
     */
    getNextTileCoords(y: number, x: number): {
        y: number;
        x: number;
    } | null;
    /**
     * Get the coordinates of the previous tile starting from the specified origin
     * tile. The previous tile is the tile to the left of the origin tile in the
     * same row, or the last tile of the previous row (if any) when the origin is
     * the first tile in its row.
     *
     * @param y The y coordinate of the origin tile.
     * @param x The x coordinate of the origin tile.
     * @returns The coordinates, or null if no other tiles before origin.
     */
    getPrevTileCoords(y: number, x: number): {
        y: number;
        x: number;
    } | null;
    /**
     * "Linearly" toggle the tiles according to the specified toggle action
     * in the specified set of tiles rows. When users toggle a tile from unchecked
     * to checked, and any other tile was checked, the checked state must be
     * extended so that all the tiles between the newly checked tile and the old
     * one(s) are checked, so that they form a continuous "line", eventually
     * spanning rows. The same inversely applies when un-checking tiles. This
     * ensures that users can select a single range of tiles by toggling at any
     * of its ends.
     *
     * @param y The y coordinate of the tile which was toggled.
     * @param x The x coordinate of the tile which was toggled.
     * @param checked The new checked state after toggling the tile.
     */
    toggleLinearTileCheck(y: number, x: number, checked: boolean): void;
    /**
     * Get the location of the checked tiles, if any. As tiles are checked
     * only as an uninterrupted sequence, there can be only 0 or 1 location
     * in a set.
     *
     * @returns The location, or null if no tiles are checked.
     */
    getCheckedLocation(): TokenLocation | null;
    /**
     * Get the location of the checked tiles, together with the index to the
     * fragment including them (or a part of them). Should the tiles be included
     * in more than 1 fragment, no fragment will be returned.
     *
     * @returns Object with fragment=fragment index or -1, and location=location
     * of checked tiles; or null if no checked tile.
     */
    getCheckedLocationAndFragment(): {
        fragment: number;
        location: TokenLocation;
    } | null;
}

/**
 * Tiled text layer part editor.
 * This editor allows picking any layer and see all the text tiles included
 * in a fragment with a color highlight. Users can check any number of tiles
 * not belonging to any fragment in the selected layer, and add a new fragment
 * in the selected layer; or check any number of tiles belonging to a fragment
 * of the selected layer, and edit or delete it.
 * Tiles are thus colorized by the UI to render the fragments extent; and freely
 * checked by users to select the fragments to operate with.
 * All the checked tiles must follow each other, in one or more rows. Users can
 * just check the first and the last of a sequence to get the whole sequence
 * checked.
 */
declare class TiledTextLayerPartFeatureComponent implements OnInit, OnDestroy, ComponentCanDeactivate {
    private _router;
    private _repository;
    private _libraryRouteService;
    private _editedItemRepository;
    private _dialogService;
    private _sub?;
    readonly view: i0.WritableSignal<TiledTextLayerView | undefined>;
    selectedTile?: TextTileLayerView;
    itemId: string;
    partId?: string;
    roleId?: string;
    loading$: Observable<boolean>;
    saving$: Observable<boolean>;
    baseText$: Observable<string | undefined>;
    locations$: Observable<TokenLocation[]>;
    rows$: Observable<TextTileRow[]>;
    breakChance$: Observable<number | undefined>;
    layerHints$: Observable<LayerHint[]>;
    pickedLocation?: string;
    userLevel: number;
    constructor(route: ActivatedRoute, _router: Router, _repository: EditedLayerRepository, _libraryRouteService: LibraryRouteService, _editedItemRepository: EditedItemRepository, _dialogService: DialogService, userLevelService: UserLevelService);
    canDeactivate(): boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    refreshBreakChance(): void;
    onTileChecked(y: number, x: number, checked: boolean): void;
    private getSelectedTileCoords;
    selectPrevTile(): void;
    selectNextTile(): void;
    deleteFragment(): void;
    deleteFragmentFromHint(hint: LayerHint): void;
    private navigateToFragmentEditor;
    editFragment(): void;
    editFragmentFromHint(hint: LayerHint): void;
    moveFragmentFromHint(hint: LayerHint): void;
    addFragment(): void;
    pickLocation(): void;
    clearTileChecks(): void;
    applyLayerPatches(patches: string[]): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TiledTextLayerPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TiledTextLayerPartFeatureComponent, "cadmus-tiled-text-layer-part-feature", never, {}, {}, never, never, true, never>;
}

declare class TiledTextPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    static ɵfac: i0.ɵɵFactoryDeclaration<TiledTextPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TiledTextPartFeatureComponent, "cadmus-tiled-text-part-feature", never, {}, {}, never, never, true, never>;
}

/**
 * Token-based text layer part feature editor. This is a special type of editor,
 * rather than being a simple wrapper like the others; it is used for editing
 * any text layer (using token-based coordinates), whatever the type of its
 * fragments. Being a sort of portal for accessing a fragments editor, it has
 * no save capability: the single fragments are edited and saved as needed.
 */
declare class TokenTextLayerPartFeatureComponent implements OnInit, ComponentCanDeactivate {
    private _router;
    private _repository;
    private _textLayerService;
    private _libraryRouteService;
    private _editedItemRepository;
    private _dialogService;
    itemId: string;
    partId?: string;
    roleId?: string;
    loading$: Observable<boolean>;
    saving$: Observable<boolean>;
    baseText$: Observable<string | undefined>;
    locations$: Observable<TokenLocation[] | undefined>;
    breakChance$: Observable<number>;
    layerHints$: Observable<LayerHint[]>;
    pickedLocation?: string;
    userLevel: number;
    textSize: number;
    constructor(route: ActivatedRoute, _router: Router, _repository: EditedLayerRepository, _textLayerService: TextLayerService, _libraryRouteService: LibraryRouteService, _editedItemRepository: EditedItemRepository, _dialogService: DialogService, userLevelService: UserLevelService);
    canDeactivate(): boolean;
    makeLarger(): void;
    makeSmaller(): void;
    ngOnInit(): void;
    deleteFragment(): void;
    deleteFragmentFromHint(hint: LayerHint): void;
    refreshBreakChance(): void;
    private navigateToFragmentEditor;
    editFragment(): void;
    editFragmentFromHint(hint: LayerHint): void;
    addFragment(): void;
    moveFragmentFromHint(hint: LayerHint): void;
    applyLayerPatches(patches: string[]): void;
    pickLocation(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TokenTextLayerPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TokenTextLayerPartFeatureComponent, "cadmus-token-text-layer-part-feature", never, {}, {}, never, never, true, never>;
}

declare class TokenTextPartFeatureComponent extends EditPartFeatureBase implements OnInit {
    constructor(router: Router, route: ActivatedRoute, snackbar: MatSnackBar, itemService: ItemService, thesaurusService: ThesaurusService, editorService: PartEditorService);
    static ɵfac: i0.ɵɵFactoryDeclaration<TokenTextPartFeatureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TokenTextPartFeatureComponent, "cadmus-token-text-part-feature", never, {}, {}, never, never, true, never>;
}

declare const CADMUS_PART_GENERAL_PG_ROUTES: Routes;

export { AssertedHistoricalDateFeatureComponent, BibliographyPartFeatureComponent, CADMUS_PART_GENERAL_PG_ROUTES, CategoriesPartFeatureComponent, ChronologyFragmentFeatureComponent, ChronotopesPartFeatureComponent, CommentFragmentFeatureComponent, CommentPartFeatureComponent, DecoratedCountsPartFeatureComponent, DistrictLocationPartFeatureComponent, DocReferencesPartFeatureComponent, ExternalIdsPartFeatureComponent, FlagsPartFeatureComponent, HistoricalDatePartFeatureComponent, HistoricalEventsPartFeatureComponent, IndexKeywordsPartFeatureComponent, KeywordsPartFeatureComponent, MetadataPartFeatureComponent, NamesPartFeatureComponent, NotePartFeatureComponent, PhysicalMeasurementsPartFeatureComponent, PhysicalStatesPartFeatureComponent, PinLinksFragmentFeatureComponent, PinLinksPartFeatureComponent, TiledTextLayerPartFeatureComponent, TiledTextPartFeatureComponent, TokenTextLayerPartFeatureComponent, TokenTextPartFeatureComponent };