import * as i0 from '@angular/core';
import { OnInit, OnDestroy } from '@angular/core';
import { MatSnackBar } from '@angular/material/snack-bar';
import * as i3 from '@angular/router';
import { Router, ActivatedRoute, RouterModule } 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';
import * as i1 from '@angular/common';
import * as i2 from '@angular/forms';
import * as i4 from '@angular/material/button';
import * as i5 from '@angular/material/checkbox';
import * as i6 from '@angular/material/card';
import * as i7 from '@angular/material/expansion';
import * as i8 from '@angular/material/icon';
import * as i9 from '@angular/material/input';
import * as i10 from '@angular/material/progress-bar';
import * as i11 from '@angular/material/progress-spinner';
import * as i12 from '@angular/material/select';
import * as i13 from '@angular/material/tooltip';
import * as i14 from '@angular/material/toolbar';

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 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?;
    view?: TiledTextLayerView;
    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 RouterModuleForChild: i0.ModuleWithProviders<RouterModule>;
declare class CadmusPartGeneralPgModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CadmusPartGeneralPgModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CadmusPartGeneralPgModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.RouterModule, typeof i4.MatButtonModule, typeof i5.MatCheckboxModule, typeof i6.MatCardModule, typeof i7.MatExpansionModule, typeof i8.MatIconModule, typeof i9.MatInputModule, typeof i10.MatProgressBarModule, typeof i11.MatProgressSpinnerModule, typeof i12.MatSelectModule, typeof i13.MatTooltipModule, typeof i14.MatToolbarModule, typeof AssertedHistoricalDateFeatureComponent, typeof BibliographyPartFeatureComponent, typeof CategoriesPartFeatureComponent, typeof ChronologyFragmentFeatureComponent, typeof ChronotopesPartFeatureComponent, typeof CommentFragmentFeatureComponent, typeof CommentPartFeatureComponent, typeof DecoratedCountsPartFeatureComponent, typeof DistrictLocationPartFeatureComponent, typeof DocReferencesPartFeatureComponent, typeof ExternalIdsPartFeatureComponent, typeof HistoricalDatePartFeatureComponent, typeof HistoricalEventsPartFeatureComponent, typeof IndexKeywordsPartFeatureComponent, typeof KeywordsPartFeatureComponent, typeof MetadataPartFeatureComponent, typeof NamesPartFeatureComponent, typeof NotePartFeatureComponent, typeof PhysicalMeasurementsPartFeatureComponent, typeof PhysicalStatesPartFeatureComponent, typeof PinLinksFragmentFeatureComponent, typeof PinLinksPartFeatureComponent, typeof TiledTextLayerPartFeatureComponent, typeof TiledTextPartFeatureComponent, typeof TokenTextLayerPartFeatureComponent, typeof TokenTextPartFeatureComponent], [typeof AssertedHistoricalDateFeatureComponent, typeof BibliographyPartFeatureComponent, typeof CategoriesPartFeatureComponent, typeof ChronologyFragmentFeatureComponent, typeof ChronotopesPartFeatureComponent, typeof CommentFragmentFeatureComponent, typeof CommentPartFeatureComponent, typeof DecoratedCountsPartFeatureComponent, typeof DistrictLocationPartFeatureComponent, typeof DocReferencesPartFeatureComponent, typeof ExternalIdsPartFeatureComponent, typeof HistoricalDatePartFeatureComponent, typeof HistoricalEventsPartFeatureComponent, typeof IndexKeywordsPartFeatureComponent, typeof KeywordsPartFeatureComponent, typeof MetadataPartFeatureComponent, typeof NamesPartFeatureComponent, typeof NotePartFeatureComponent, typeof PhysicalMeasurementsPartFeatureComponent, typeof PhysicalStatesPartFeatureComponent, typeof PinLinksFragmentFeatureComponent, typeof PinLinksPartFeatureComponent, typeof TiledTextLayerPartFeatureComponent, typeof TiledTextPartFeatureComponent, typeof TokenTextLayerPartFeatureComponent, typeof TokenTextPartFeatureComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CadmusPartGeneralPgModule>;
}

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