import * as i0 from '@angular/core';
import { OnDestroy, Type, InjectionToken, OnInit, ChangeDetectorRef, EventEmitter } from '@angular/core';
import { HttpResponse } from '@angular/common/http';
import { Subject, Observable, Subscription } from 'rxjs';
import { ExportOutputFormat, ExportSourceType, UserSettingsWebService, QueryExportWebService, DownloadWebService, AuditEvents, AuditEvent, Record, Results } from '@sinequa/core/web-services';
import { ModalService, ModalResult, ModalButton, ModalRef } from '@sinequa/core/modal';
import { Query, AppService } from '@sinequa/core/app-utils';
import * as i16 from '@sinequa/components/selection';
import { SelectionService } from '@sinequa/components/selection';
import { SearchService } from '@sinequa/components/search';
import * as i18 from '@sinequa/components/action';
import { Action } from '@sinequa/components/action';
import * as i10 from '@angular/forms';
import { UntypedFormControl, UntypedFormGroup, UntypedFormBuilder, ValidatorFn } from '@angular/forms';
import * as i14 from '@sinequa/core/validation';
import { ValidationService } from '@sinequa/core/validation';
import { NotificationsService } from '@sinequa/core/notification';
import * as i11 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { LoginService } from '@sinequa/core/login';
import { AbstractFacet } from '@sinequa/components/facet';
import * as i9 from '@angular/common';
import * as i12 from '@sinequa/components/modal';
import * as i13 from '@sinequa/core/intl';
import * as i15 from '@angular/router';
import * as i17 from '@sinequa/components/utils';

interface SavedQuery {
    name: string;
    description?: string;
    query: Query;
}
declare const enum SavedQueryEventType {
    Loaded = "SavedQuery_Loaded",
    Patched = "SavedQuery_Patched",
    Add = "SavedQuery_Add",
    Delete = "SavedQuery_Delete",
    DeleteAll = "SavedQuery_DeleteAll",
    Rename = "SavedQuery_Rename",
    Update = "SavedQuery_Update",
    Search = "Search_SavedQuery"
}
declare const SAVED_QUERIES_CHANGE_EVENTS: SavedQueryEventType[];
interface SavedQueryChangeEvent {
    type: SavedQueryEventType;
    savedquery?: SavedQuery;
}
interface ManageSavedQueriesModel {
    savedQueries: SavedQuery[];
    auditEvents?: AuditEvent[];
}
interface ExportQueryModel {
    format: ExportOutputFormat;
    export: ExportSourceType;
    webService: string;
    maxCount?: number;
    queryName?: string;
    exportedColumns?: string[];
    filename?: string;
}
/**
 * The modal types are unknown to this service.
 * The module using this service must provide these components
 * in their forRoot() method
 *
 * Example below:
 *
 *     public static forRoot(): ModuleWithProviders<SavedQueriesModule> {
        return {
            ngModule: SavedQueriesModule,
            providers: [
                {
                    provide: SAVEDQUERY_COMPONENTS,
                    useValue: {
                        editSavedQueryModal: EditSavedQuery,
                        manageSavedQueriesModal: ManageSavedQueries,
                        exportSavedQueryModal: ExportQuery
                    }
                },
                SavedQueriesService,
                SelectionService
            ]
        };
    }
 *
 */
interface SavedQueryComponents {
    editSavedQueryModal: Type<any>;
    manageSavedQueriesModal: Type<any>;
    exportSavedQueryModal: Type<any>;
}
declare const SAVEDQUERY_COMPONENTS: InjectionToken<SavedQueryComponents>;
declare class SavedQueriesService implements OnDestroy {
    userSettingsService: UserSettingsWebService;
    searchService: SearchService;
    modalService: ModalService;
    appService: AppService;
    queryExportService: QueryExportWebService;
    downloadService: DownloadWebService;
    selectionService: SelectionService;
    savedQueryComponents: SavedQueryComponents;
    private readonly _events;
    private readonly _changes;
    selectedRecordsAction: Action;
    constructor(userSettingsService: UserSettingsWebService, searchService: SearchService, modalService: ModalService, appService: AppService, queryExportService: QueryExportWebService, downloadService: DownloadWebService, selectionService: SelectionService, savedQueryComponents: SavedQueryComponents);
    /**
     * Returns the list of this user's saved queries.
     * The list is stored in the user settings (this is a redirection).
     * Using this service creates the list of saved queries if it does not already exist.
     */
    get savedqueries(): SavedQuery[];
    /**
     * Triggers any event among SavedQueryChangeEvent
     * (use for fine-grained control of saved queries workflow)
     */
    get events(): Subject<SavedQueryChangeEvent>;
    /**
     * Triggers when events affect the list of saved queries
     * (use to refresh saved queries menus)
     * Cf. CHANGE_EVENTS list
     */
    get changes(): Subject<SavedQueryChangeEvent>;
    /**
     * @returns true if there is at least one saved query
     */
    get hasSavedQuery(): boolean;
    /**
     * @returns a saved query with the given name or null if it does not exist
     * @param name
     */
    savedquery(name: string): SavedQuery | undefined;
    private savedqueryIndex;
    /**
     * Creates a new saved query unless it already exists.
     * Emits an savedquery event.
     * Update the data on the server.
     * @param savedquery the savedquery to create
     * @returns true if savedquery was created
     */
    createSavedQuery(savedquery: SavedQuery): boolean;
    /**
     * Update the saved query at the given index, unless a saved query with the same name
     * already exists in the list of saved queries.
     * Emits an Saved Query event.
     * Update the data on the server.
     * @param savedquery the saved query to update
     * @param index the index at which to update the saved query
     * @returns true if saved query was updated
     */
    updateSavedQuery(savedquery: SavedQuery, index: number): boolean;
    /**
     * Updates the full list of saved queries.
     * Emits an SavedQuery event.
     * Update the data on the server.
     * @param savedqueries the new list of saved queries
     * @param auditEvents the list of audit events to log
     */
    updateSavedQueries(savedqueries: SavedQuery[], auditEvents?: AuditEvents): boolean;
    /**
     * Deletes the given SavedQuery (based on its name)
     * Emits an SavedQuery event.
     * Update the data on the server.
     * @param savedquery
     * @returns true if saved query was deleted
     */
    deleteSavedQuery(savedquery: SavedQuery): boolean;
    /**
     * Sets this saved query to the current search context, using the search service
     */
    setSavedQueryToCurrentQuery(savedquery: SavedQuery): void;
    /**
     * Updates Saved Queries in User settings.
     * @param auditEvents : Audit Events to be triggered
     * @returns an Observable which can be used to trigger further events
     */
    private patchSavedQueries;
    rssHref(item: SavedQuery): string;
    hasRssEnabled(): boolean;
    /**
     * Checks if there is a configuration for the export web service.
     *
     * @returns true if there is a configuration for the export web service.
     */
    hasExportConfig(): boolean;
    download(model: ExportQueryModel): Observable<HttpResponse<Blob>>;
    private requestExport;
    /**
     * Uses the SearchService to perform a search returning all
     * the documents matching this saved query.
     * @param saved query
     * @returns the search service promise
     */
    searchSavedQuery(savedquery: SavedQuery, path?: string): Promise<boolean>;
    /**
     * Opens a dialog allowing a user to save the current query.
     * @returns a boolean promise resolved when the user closes the dialog
     * the result is true if the query was saved.
     */
    createSavedQueryModal(query?: Query): Promise<boolean>;
    /**
     * Opens a dialog allowing a user to reorganize and edit the
     * list of saved queries.
     * @returns a boolean promise resolved when the user closes the dialog
     * the result is true is the list was updated.
     */
    manageSavedQueriesModal(): Promise<boolean>;
    /**
     * Exports a query via a modal dialog.
     *
     * @param exportType type of export to perform (selection, saved query, results)
     * @param savedQuery The saved query
     */
    exportModal(exportType: ExportSourceType, savedQuery?: SavedQuery, filename?: string): Promise<ModalResult>;
    notifyOpenSavedQuery(savedquery: SavedQuery): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SavedQueriesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SavedQueriesService>;
}

interface RecentQuery {
    query: Query;
    date: Date;
}
declare const enum RecentQueryEventType {
    Loaded = "RecentQuery_Loaded",
    Patched = "RecentQuery_Patched",
    Add = "RecentQuery_Add",
    Update = "RecentQuery_Update",
    Delete = "RecentQuery_Delete",
    Search = "Search_RecentQuery"
}
declare const RECENT_QUERIES_CHANGE_EVENTS: RecentQueryEventType[];
interface RecentQueryChangeEvent {
    type: RecentQueryEventType;
    recentquery?: RecentQuery;
}
declare const MAX_QUERIES: InjectionToken<unknown>;
declare class RecentQueriesService implements OnDestroy {
    userSettingsService: UserSettingsWebService;
    searchService: SearchService;
    private maxQueries;
    private readonly _events;
    private readonly _changes;
    constructor(userSettingsService: UserSettingsWebService, searchService: SearchService, maxQueries: number);
    /**
     * Returns the list of this user's recent queries.
     * The list is stored in the user settings (this is a redirection).
     * Using this service creates the list of recent queries if it does not already exist.
     */
    get recentqueries(): RecentQuery[];
    /**
     * Triggers any event among RecentQueryChangeEvent
     * (use for fine-grained control of recent queries workflow)
     */
    get events(): Subject<RecentQueryChangeEvent>;
    /**
     * Triggers when events affect the list of recent queries
     * (use to refresh recent queries menus)
     * Cf. CHANGE_EVENTS list
     */
    get changes(): Subject<RecentQueryChangeEvent>;
    /**
     * @returns true if there is at least one recent query
     */
    get hasRecentQuery(): boolean;
    /**
     * @returns a recent query with the given name or undefined if it does not exist
     * @param name
     */
    recentquery(text: string): RecentQuery | undefined;
    private recentqueryIndex;
    private comparator;
    /**
     * Creates a new recent query unless it already exists, in which case the existing query is updated.
     * Emits an recentquery event.
     * Update the data on the server.
     * @param recentquery the recentquery to create
     * @returns true if recentquery was created
     */
    addRecentQuery(recentquery: RecentQuery): boolean;
    /**
     * Deletes the given RecentQuery (based on its name)
     * Emits an RecentQuery event.
     * Update the data on the server.
     * @param recentquery
     * @returns true if recent query was deleted
     */
    deleteRecentQuery(recentquery: RecentQuery): boolean;
    /**
     * Updates Recent Queries in User settings.
     * @param auditEvents : Audit Events to be triggered
     * @returns an Observable which can be used to trigger further events
     */
    private patchRecentQueries;
    /**
     * Uses the SearchService to perform a search returning all
     * the documents matching this recent query.
     * @param recentquery
     * @returns the search service promise
     */
    searchRecentQuery(recentquery: RecentQuery, path?: string): Promise<boolean>;
    notifyOpenRecentQuery(recentquery: RecentQuery): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecentQueriesService, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RecentQueriesService>;
}

interface RecentDocument {
    /**
     * Fields from Record that we want to store/display/index for recent documents
     */
    id: string;
    title: string;
    url1: string;
    treepath: string[];
    docformat: string;
    authors: string[];
    /**
     * Date at which the document was last opened
     */
    date: Date;
    /**
     * Store whether the doc was opened in the preview or directly via url
     */
    original: boolean;
}
declare const enum RecentDocumentEventType {
    Loaded = "RecentDocument_Loaded",
    Patched = "RecentDocument_Patched",
    Add = "RecentDocument_Add",
    Update = "RecentDocument_Update",
    Delete = "RecentDocument_Delete",
    Search = "Search_RecentDocument"
}
declare const RECENT_DOCUMENTS_CHANGE_EVENTS: RecentDocumentEventType[];
interface RecentDocumentChangeEvent {
    type: RecentDocumentEventType;
    recentdocument?: RecentDocument;
}
declare const MAX_DOCUMENTS: InjectionToken<unknown>;
declare class RecentDocumentsService implements OnDestroy {
    userSettingsService: UserSettingsWebService;
    searchService: SearchService;
    private maxDocuments;
    private readonly _events;
    private readonly _changes;
    constructor(userSettingsService: UserSettingsWebService, searchService: SearchService, maxDocuments: number);
    /**
     * Returns the list of this user's recent documents.
     * The list is stored in the user settings (this is a redirection).
     * Using this service creates the list of recent documents if it does not already exist.
     */
    get recentdocuments(): RecentDocument[];
    /**
     * Triggers any event among RecentDocumentChangeEvent
     * (use for fine-grained control of recent documents workflow)
     */
    get events(): Subject<RecentDocumentChangeEvent>;
    /**
     * Triggers when events affect the list of recent documents
     * (use to refresh recent documents menus)
     * Cf. CHANGE_EVENTS list
     */
    get changes(): Subject<RecentDocumentChangeEvent>;
    /**
     * @returns true if there is at least one recent document
     */
    get hasRecentDocument(): boolean;
    /**
     * @returns a recent document with the given name or null if it does not exist
     * @param name
     */
    recentdocument(text: string): RecentDocument | undefined;
    private recentdocumentIndex;
    private comparator;
    /**
     * Creates a new recent document unless it already exists, in which case the existing document is updated.
     * Emits an recentdocument event.
     * Update the data on the server.
     * @param record Record to add to the service
     * @param original Whether the original doc was opened or the preview
     * @returns true if recentdocument was created
     */
    addDocument(record: Record, original: boolean): boolean;
    /**
     * Creates a new recent document unless it already exists, in which case the existing document is updated.
     * Emits an recentdocument event.
     * Update the data on the server.
     * @param recentdocument the recentdocument to create
     * @returns true if recentdocument was created
     */
    addRecentDocument(recentdocument: RecentDocument): boolean;
    /**
     * Deletes the given RecentDocument (based on its name)
     * Emits an RecentDocument event.
     * Update the data on the server.
     * @param recentdocument
     * @returns true if recent document was deleted
     */
    deleteRecentDocument(recentdocument: RecentDocument): boolean;
    /**
     * Updates Recent Documents in User settings.
     * @param auditEvents : Audit Events to be triggered
     * @returns an Observable which can be used to trigger further events
     */
    private patchRecentDocuments;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecentDocumentsService, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RecentDocumentsService>;
}

declare class BsEditSavedQuery implements OnInit, OnDestroy {
    model: SavedQuery;
    private formBuilder;
    nameControl: UntypedFormControl;
    form: UntypedFormGroup;
    formChanges: Subscription;
    buttons: ModalButton[];
    constructor(model: SavedQuery, formBuilder: UntypedFormBuilder);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BsEditSavedQuery, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BsEditSavedQuery, "sq-edit-saved-query", never, {}, {}, never, never, false, never>;
}

/**
 * Component representing the Export dialog where user can customize the query export action.
 *
 */
declare class BsExportQuery implements OnInit, OnDestroy {
    model: ExportQueryModel;
    private formBuilder;
    private appService;
    private selectionService;
    private savedQueriesService;
    private validationService;
    private notificationsService;
    private changeDetectorRef;
    modalRef: ModalRef;
    readonly supportedFormats: ExportOutputFormat[];
    readonly outputFormats: typeof ExportOutputFormat;
    readonly sourceTypes: typeof ExportSourceType;
    form: UntypedFormGroup;
    savedQueries: string[];
    buttons: ModalButton[];
    isDownloading: boolean;
    exportableColumns: string[];
    private formChanges;
    maxCount: number;
    constructor(model: ExportQueryModel, formBuilder: UntypedFormBuilder, appService: AppService, selectionService: SelectionService, savedQueriesService: SavedQueriesService, validationService: ValidationService, notificationsService: NotificationsService, changeDetectorRef: ChangeDetectorRef, modalRef: ModalRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private getQueryExportConfig;
    /**
     * Check if the client has selected some records.
     *
     * @returns true if the client has selected some records.
     */
    hasSelectedRecords(): boolean;
    /**
     * Checks if the user chosen export source is the same as the given one.
     * <p>
     * Used to control the radio button state.
     *
     * @param type The source to check.
     * @returns true if the user chosen export source is the same as the given one.
     */
    sourceChosen(type: ExportSourceType): boolean;
    /**
     * Callback called when user chooses a new export source.
     *
     * @param event The related UI event.
     * @param type The new chosen source.
     */
    sourceChanged(event: UIEvent, type: ExportSourceType): void;
    /**
     * Checks if the dialog allows user to choose export source.
     * Generally, it returns false when the input model export type is already saved query.
     *
     * @returns true if the dialog allows user to choose export source.
     */
    showSourceChooser(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BsExportQuery, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BsExportQuery, "sq-export-query", never, {}, {}, never, never, false, never>;
}

declare class BsManageSavedQueries implements OnInit {
    model: ManageSavedQueriesModel;
    savedQueriesService: SavedQueriesService;
    reordering: boolean;
    buttons: ModalButton[];
    removeAllButton: ModalButton;
    nameValidators: ValidatorFn[];
    constructor(model: ManageSavedQueriesModel, savedQueriesService: SavedQueriesService);
    ngOnInit(): void;
    addAuditEvent(auditEvent: AuditEvent): void;
    reorder(): void;
    setName(savedQuery: SavedQuery, name: string): void;
    remove(savedQuery: SavedQuery, index: number): boolean;
    export(savedQuery: SavedQuery): boolean;
    dropped(drop: CdkDragDrop<SavedQuery[]>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BsManageSavedQueries, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BsManageSavedQueries, "sq-manage-saved-queries", never, {}, {}, never, never, false, never>;
}

/**
 * Toolbar component for Export query feature.
 *
 */
declare class BsQueryExporter {
    private selectionService;
    private savedQueriesService;
    results: Results;
    rightAligned: boolean;
    exportAction: Action;
    constructor(selectionService: SelectionService, savedQueriesService: SavedQueriesService);
    /**
     * Check if the client has selected some records.
     *
     * @returns true if the client has selected some records.
     */
    hasSelectedRecords(): boolean;
    /**
     * Generic export function.
     * <p>
     * Opens up a dialog to let user choose the export source, export format and other parameters.
     *
     * @memberof QueryExporter
     */
    export(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BsQueryExporter, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BsQueryExporter, "sq-query-exporter", never, { "results": { "alias": "results"; "required": false; }; "rightAligned": { "alias": "rightAligned"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BsSavedQueriesMenuComponent implements OnInit, OnDestroy {
    loginService: LoginService;
    savedQueriesService: SavedQueriesService;
    searchService: SearchService;
    searchRoute: string;
    icon: string;
    autoAdjust: boolean;
    autoAdjustBreakpoint: string;
    collapseBreakpoint: string;
    size: string;
    menu: Action | undefined;
    manageAction: Action;
    saveAction: Action;
    constructor(loginService: LoginService, savedQueriesService: SavedQueriesService, searchService: SearchService);
    ngOnInit(): void;
    private _savedQueriesSubscription;
    private _loginSubscription;
    private _searchSubscription;
    ngOnDestroy(): void;
    updateMenu(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BsSavedQueriesMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BsSavedQueriesMenuComponent, "sq-saved-queries-menu", never, { "searchRoute": { "alias": "searchRoute"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "autoAdjust": { "alias": "autoAdjust"; "required": false; }; "autoAdjustBreakpoint": { "alias": "autoAdjustBreakpoint"; "required": false; }; "collapseBreakpoint": { "alias": "collapseBreakpoint"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BsFacetSavedQueries extends AbstractFacet {
    savedQueriesService: SavedQueriesService;
    searchRoute: string;
    maxQueries: number;
    enableDelete: boolean;
    page: number;
    manageSavedQueries: Action;
    previousPage: Action;
    nextPage: Action;
    constructor(savedQueriesService: SavedQueriesService);
    get maxPage(): number;
    get startIndex(): number;
    get endIndex(): number;
    get actions(): Action[];
    openSavedQuery(query: SavedQuery): boolean;
    deleteQuery(query: SavedQuery, event: Event): boolean;
    getQueryParams(savedQuery: SavedQuery): {
        query: string;
    };
    getRouterState(savedQuery: SavedQuery): {
        audit: {
            type: SavedQueryEventType;
            detail: {
                savedquery: string;
            };
        };
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<BsFacetSavedQueries, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BsFacetSavedQueries, "sq-facet-saved-queries", never, { "searchRoute": { "alias": "searchRoute"; "required": false; }; "maxQueries": { "alias": "maxQueries"; "required": false; }; "enableDelete": { "alias": "enableDelete"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BsFacetRecentQueries extends AbstractFacet {
    searchService: SearchService;
    recentQueriesService: RecentQueriesService;
    savedQueriesService: SavedQueriesService;
    searchRoute: string;
    maxQueries: number;
    enableDelete: boolean;
    enableSave: boolean;
    page: number;
    previousPage: Action;
    nextPage: Action;
    constructor(searchService: SearchService, recentQueriesService: RecentQueriesService, savedQueriesService: SavedQueriesService);
    get maxPage(): number;
    get startIndex(): number;
    get endIndex(): number;
    get actions(): Action[];
    openRecentQuery(query: RecentQuery): boolean;
    deleteQuery(query: RecentQuery, event: Event): boolean;
    saveQuery(query: RecentQuery, event: Event): boolean;
    getQueryParams(recentQuery: Query): {
        query: string;
    };
    getRouterState(recentQuery: Query): {
        audit: {
            type: RecentQueryEventType;
            detail: {
                recentquery: string | undefined;
            };
        };
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<BsFacetRecentQueries, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BsFacetRecentQueries, "sq-facet-recent-queries", never, { "searchRoute": { "alias": "searchRoute"; "required": false; }; "maxQueries": { "alias": "maxQueries"; "required": false; }; "enableDelete": { "alias": "enableDelete"; "required": false; }; "enableSave": { "alias": "enableSave"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BsFacetRecentDocuments extends AbstractFacet {
    recentDocumentsService: RecentDocumentsService;
    searchService: SearchService;
    searchRoute: string;
    maxDocuments: number;
    enableDelete: boolean;
    openOriginal: boolean;
    documentOpened: EventEmitter<RecentDocument>;
    page: number;
    previousPage: Action;
    nextPage: Action;
    constructor(recentDocumentsService: RecentDocumentsService, searchService: SearchService);
    get maxPage(): number;
    get startIndex(): number;
    get endIndex(): number;
    get actions(): Action[];
    openRecentDocument(document: RecentDocument): boolean;
    deleteDocument(document: RecentDocument, event: Event): boolean;
    getQueryParams(document: RecentDocument): {
        id: string;
        query: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<BsFacetRecentDocuments, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BsFacetRecentDocuments, "sq-facet-recent-documents", never, { "searchRoute": { "alias": "searchRoute"; "required": false; }; "maxDocuments": { "alias": "maxDocuments"; "required": false; }; "enableDelete": { "alias": "enableDelete"; "required": false; }; "openOriginal": { "alias": "openOriginal"; "required": false; }; }, { "documentOpened": "documentOpened"; }, never, never, false, never>;
}

declare class BsSavedQueriesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BsSavedQueriesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BsSavedQueriesModule, [typeof BsEditSavedQuery, typeof BsManageSavedQueries, typeof BsExportQuery, typeof BsQueryExporter, typeof BsSavedQueriesMenuComponent, typeof BsFacetSavedQueries, typeof BsFacetRecentQueries, typeof BsFacetRecentDocuments], [typeof i9.CommonModule, typeof i10.FormsModule, typeof i10.ReactiveFormsModule, typeof i11.DragDropModule, typeof i12.BsModalModule, typeof i13.IntlModule, typeof i14.ValidationModule, typeof i15.RouterModule, typeof i16.BsSelectionModule, typeof i12.BsModalModule, typeof i17.UtilsModule, typeof i18.BsActionModule], [typeof BsEditSavedQuery, typeof BsManageSavedQueries, typeof BsExportQuery, typeof BsQueryExporter, typeof BsSavedQueriesMenuComponent, typeof BsFacetSavedQueries, typeof BsFacetRecentQueries, typeof BsFacetRecentDocuments]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BsSavedQueriesModule>;
}

declare const enSavedQueries: any;
declare const frSavedQueries: any;
declare const deSavedQueries: any;

export { BsEditSavedQuery, BsExportQuery, BsFacetRecentDocuments, BsFacetRecentQueries, BsFacetSavedQueries, BsManageSavedQueries, BsQueryExporter, BsSavedQueriesMenuComponent, BsSavedQueriesModule, MAX_DOCUMENTS, MAX_QUERIES, RECENT_DOCUMENTS_CHANGE_EVENTS, RECENT_QUERIES_CHANGE_EVENTS, RecentDocumentEventType, RecentDocumentsService, RecentQueriesService, RecentQueryEventType, SAVEDQUERY_COMPONENTS, SAVED_QUERIES_CHANGE_EVENTS, SavedQueriesService, SavedQueryEventType, deSavedQueries, enSavedQueries, frSavedQueries };
export type { ExportQueryModel, ManageSavedQueriesModel, RecentDocument, RecentDocumentChangeEvent, RecentQuery, RecentQueryChangeEvent, SavedQuery, SavedQueryChangeEvent, SavedQueryComponents };