import * as i0 from '@angular/core';
import { InjectionToken, Injector, OnInit, OnDestroy, EventEmitter, AfterViewInit, OnChanges, SimpleChanges, ChangeDetectorRef, PipeTransform, ElementRef, Renderer2, Provider, ModuleWithProviders } from '@angular/core';
import { FormGroup, FormControl, FormBuilder, UntypedFormGroup, UntypedFormBuilder, FormGroupDirective, UntypedFormControl } from '@angular/forms';
import { HttpClient, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
import * as rxjs from 'rxjs';
import { Subject, Observable, Subscription, BehaviorSubject } from 'rxjs';
import { BBox } from 'geojson';
import { Filter, CollectionReferenceParameters, ExploreApi, Configuration, CollectionReferenceDescription, AggregationResponse, Hits, Aggregation } from 'arlas-api';
import { CollaborativesearchService, ConfigService, Contributor, Collaboration } from 'arlas-web-core';
import { DrawTheme, MapSettingsService, GeometrySelectModel, OperationSelectModel, AbstractArlasMapGL } from 'arlas-map';
import { OverlayRef } from '@angular/cdk/overlay';
import { ARLASDonutTooltip, TimelineTooltip, Granularity, TimelineData, HistogramParams, XBucket, HistogramTooltip as HistogramTooltip$1 } from 'arlas-d3';
import * as i1 from 'arlas-web-components';
import { HistogramTooltip, TranslationDirection, CalendarTimelineComponent, BaseCollectionService, ArlasColorService, Position, HistogramComponent, ChartType, PowerBar, ColorGeneratorLoader } from 'arlas-web-components';
import { Resource } from 'arlas-permissions-api';
import { Observable as Observable$1 } from 'rxjs/internal/Observable';
import { DataWithLinks, Exists, DataResource } from 'arlas-persistence-api';
import { TranslateService } from '@ngx-translate/core';
import { LoginData, UserData, ArlasMessage, PermissionDef, PermissionData, DefaultApi, Configuration as Configuration$1 } from 'arlas-iam-api';
import * as i1$2 from '@angular/router';
import { Router, ActivatedRoute, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import { MatSnackBar } from '@angular/material/snack-bar';
import * as i5 from 'angular-oauth2-oidc';
import { AuthConfig, OAuthService, OAuthErrorEvent, UserInfo } from 'angular-oauth2-oidc';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { DataSource, SelectionModel } from '@angular/cdk/collections';
import { MatMenu } from '@angular/material/menu';
import { MatSelectionList, MatListOption } from '@angular/material/list';
import { DeviceDetectorService } from 'ngx-device-detector';
import { PageEvent, MatPaginatorIntl } from '@angular/material/paginator';
import { DetailedHistogramContributor, SelectedOutputValues, HistogramContributor, SearchContributor, LayerSourceConfig, StringifiedTimeShortcut, ResultListContributor, MapContributor } from 'arlas-web-contributors';
import { NgxSpinnerService } from 'ngx-spinner';
import { MatCheckboxChange } from '@angular/material/checkbox';
import { TagRefRequest } from 'arlas-tagger-api';
import { OwlDateTimeIntl, OwlDateTimeFormats } from '@danielmoncada/angular-datetime-picker';
import * as _moment from 'moment';
import { OwlMomentDateTimeAdapterOptions } from '@danielmoncada/angular-datetime-picker-moment-adapter';
import * as i3 from 'ngx-markdown';
import * as i1$1 from '@angular/platform-browser/animations';
import { Location } from '@angular/common';
import * as i3$1 from '@angular/platform-browser';

declare class AdmonitionCardComponent {
    title: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdmonitionCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdmonitionCardComponent, "arlas-admonition-card", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

interface Process {
    id?: string;
    version?: string;
    title?: string;
    description?: string;
    inputs?: ProcessInputs;
    additionalParameters?: {
        parameters: any[];
    };
}
interface ProcessInputs {
    [key: string]: ProcessInput;
}
interface ProcessProjection {
    label: string;
    value: string;
    bbox: BBox;
}
interface ProcessInput {
    schema: {
        type: string;
        enum?: string[] | ProcessProjection[];
        format?: string;
        items?: {
            type: string;
            enum?: string[];
        };
        required?: boolean;
    };
}
interface ProcessOutput {
    processID: 'download' | 'ingest' | 'directory_ingest' | 'enrich' | 'dc3build';
    type: string;
    jobID: string;
    status: ProcessStatus;
    message: string;
    created: number;
    started: number;
    finished: number;
    updated: number;
    progress: number;
    links: any;
    resourceID: string;
}
declare enum ProcessStatus {
    accepted = "accepted",
    running = "running",
    successful = "successful",
    failed = "failed",
    dismissed = "dismissed"
}

declare class ArlasCollaborativesearchService extends CollaborativesearchService {
    constructor();
    endOfUrlCollaboration: boolean;
    /**
     * @param filter The filter query parameter
     * @param changeOperator Whether to change the operator of the filters applied for TreeContributors
     * @returns A dictionnary of the current collaborations
     */
    dataModelBuilder(filter: any, changeOperator?: boolean): any;
    getCollectionsFromFilters(dataModel: any): Set<string>;
    getFilters(collection: string): Array<Filter>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasCollaborativesearchService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasCollaborativesearchService>;
}

interface ARLASPowerbarTooltip {
    title: string;
    key: string;
    value: any;
    progression: number;
    color: string;
}
declare class PowerbarTooltipOverlayComponent {
    overlayRef: ArlasOverlayRef;
    tooltip: ARLASPowerbarTooltip;
    constructor(overlayRef: ArlasOverlayRef, tooltip: ARLASPowerbarTooltip);
    static ɵfac: i0.ɵɵFactoryDeclaration<PowerbarTooltipOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PowerbarTooltipOverlayComponent, "arlas-powerbar-tooltip-overlay", never, {}, {}, never, never, true, never>;
}

declare class ArlasSearchField {
    /**
     * @description The field label
     */
    label: string;
    /**
     * @description The type of the field.
     */
    type: string;
    constructor(label: string, type: string);
}

/** Generic error for Arlas */
declare abstract class ArlasError {
    protected actionSeekerSource: Subject<any>;
    actionSeeker$: Observable<any>;
    protected status: number;
    title: string;
    message: string;
    showAction: boolean;
    actionMessage: string;
    actionType: ActionType;
    constructor(status: number);
    abstract executeAction(): any;
}
type ActionType = 'link' | 'button';

declare const CONFIG_ID_QUERY_PARAM = "config_id";
declare const GET_OPTIONS: InjectionToken<Function>;
declare const NOT_CONFIGURED = "NOT_CONFIGURED";
interface ConfigAction {
    type: ConfigActionEnum;
    enabled?: boolean;
    name?: string;
    url?: string;
    configIdParam?: string;
    config: Config;
}
interface Config {
    id: string;
    name: string;
    value: string;
    lastUpdate: number;
    readers: Array<string>;
    writers: Array<string>;
    zone: string;
    org: string;
    displayPublic: boolean;
}
declare enum ConfigActionEnum {
    VIEW = 0,
    DELETE = 1,
    EDIT = 2,
    DUPLICATE = 3,
    SHARE = 4,
    CREATE = 5,
    RENAME = 6
}
interface ArlasStorageObject {
    id: string;
    date: Date;
    name: string;
}
declare enum ArlasStorageType {
    local = 0,
    persistence = 1
}
interface SpinnerOptions {
    color?: string;
    diameter?: number;
    strokeWidth?: number;
}
interface CollectionUnit {
    collection: string;
    unit: string;
    ignored: boolean;
}
interface CollectionCount {
    count: number;
    collection: string;
    color: string;
    hasCentroidPath: boolean;
    hasGeometryPath: boolean;
    ignored: boolean;
    unit?: string;
}
interface AuthentSetting {
    use_discovery: boolean;
    force_connect: boolean;
    use_authent: boolean;
    auth_mode?: 'openid' | 'iam';
    client_id: string;
    issuer: string;
    scope?: string;
    response_type?: string;
    redirect_uri?: string;
    silent_refresh_redirect_uri?: string;
    silent_refresh_timeout?: number;
    timeout_factor?: number;
    session_checks_enabled?: boolean;
    show_debug_information?: boolean;
    clear_hash_after_login?: boolean;
    disable_at_hash_check?: boolean;
    require_https?: boolean;
    dummy_client_secret?: string;
    userinfo_endpoint?: string;
    token_endpoint?: string;
    jwks_endpoint?: string;
    login_url?: string;
    logout_url?: string;
    post_logout_redirect_uri?: string;
    storage?: string;
    customQueryParams?: Object;
    threshold?: number;
    url?: string;
    sign_up_enabled?: boolean;
}
interface GeocodingSetting {
    enabled?: boolean;
    find_place_url?: string;
    find_place_zoom_to?: number;
}
interface DeniedAccessData {
    error: ArlasError;
    forceAction?: boolean;
}
declare enum ZoomToDataStrategy {
    NONE = "none",
    CENTROID = "centroid",
    GEOMETRY = "geometry"
}
/**
 * This interface lists the possible methods to apply on a Map object of a given cartographic client
 */
interface MapService {
    zoomToData(collection: string, geoPointField: string, map: any): any;
}
declare function hashCode(str: any): number;
declare function intToRGB(i: any): string;
declare function sortOnDate(data: ArlasStorageObject[]): ArlasStorageObject[];
declare function getKeyForColor(dataModel: Object): string;
declare function getFieldProperties(fieldList: any, parentPrefix?: string, arlasFields?: Array<{
    label: string;
    type: string;
}>, isFirstLevel?: boolean): Array<{
    label: string;
    type: string;
}>;
declare class ArlasOverlayRef {
    private overlayRef;
    constructor(overlayRef: OverlayRef);
    close(): void;
}
/**
 * Extended structure for an histogram tooltip used to communicate to the overlay what kind of render to apply
 */
interface HistogramTooltipExtended extends HistogramTooltip {
    chartType: 'histogram' | 'swimlane';
}
declare const HISTOGRAM_TOOLTIP_DATA: InjectionToken<HistogramTooltipExtended>;
declare const DONUT_TOOLTIP_DATA: InjectionToken<ARLASDonutTooltip>;
interface WidgetConfiguration {
    /**
     * @description Identifier of the contributor that serves data to the graphic component.
     */
    contributorId: string;
    uuid: string;
    /**
     * @description swimlane | histogram | donut | powerbars | resultlist
     */
    componentType?: string;
    /**
   * @description whether we display export csv button
   */
    showExportCsv?: boolean;
    /**
     * @description Set of inputs of a ARLAS-web-component.
     */
    input: any;
}
/**
 * @param param Parameter to extract
 * @returns Value of the parameter contained in the URL
 */
declare function getParamValue(param: string): any;

declare class PermissionService {
    private getOptions;
    private settingsService;
    private authorizeApi;
    private options;
    constructor(getOptions: any, settingsService: ArlasSettingsService);
    setOptions(options: any): void;
    createPermissionApiInstance(): void;
    get(filter: string): Observable$1<Resource[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionService>;
}
interface PermissionSetting {
    url: string;
}

declare class PersistenceService {
    private getOptions;
    private settingsService;
    private persistenceApi;
    options: any;
    isAvailable: boolean;
    constructor(getOptions: any, settingsService: ArlasSettingsService);
    createPersistenceApiInstance(): void;
    delete(id: string, options?: any): Observable<DataWithLinks>;
    create(zone: string, name: string, body: string, readers?: string[], writers?: string[], options?: any): Observable<DataWithLinks>;
    get(id: string, options?: any): Observable<DataWithLinks>;
    exists(id: string, options?: any): Observable<Exists>;
    list(zone: string, size: number, page: number, order: string, key?: any, options?: any): Observable<DataResource>;
    update(id: string, body: string, lastUpdate: number, name?: string, readers?: string[], writers?: string[], options?: any): Observable<DataWithLinks>;
    duplicate(zone: string, id: string, newName?: string, options?: any): Observable<DataWithLinks>;
    rename(id: string, newName: string, options?: any): Observable<DataWithLinks>;
    getGroupsByZone(zone: string, options?: any): Observable<string>;
    setOptions(options: any): void;
    /** updates the resource's name, readers and writers */
    updateResource(id: string, readers: string[], writers: string[], newValue?: string, options?: any): void;
    renameResource(id: string, newName: string, options?: any): void;
    dashboardToResourcesGroups(dashboardReaders: string[], dashboardWiters: string[]): {
        readers: string[];
        writers: string[];
    };
    getOptionsSetOrg(org: string): any;
    /** deletes the resource by its id */
    deleteResource(previewId: string, options?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersistenceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PersistenceService>;
}
interface PersistenceSetting {
    use_local_config?: boolean;
    url: string;
}

interface AnalyticGroupConfiguration {
    /**
     * @description Id of the group of widgets
     */
    groupId: string;
    /**
     * @description List of widgets within this group
     */
    components: Array<WidgetConfiguration>;
    /**
     * @description Tab identifiant this group is part of
     */
    tab: string;
    /**
     * @description Title of the group
     */
    title?: string;
    /**
     * @description Values used to filter the display of group
     */
    filterValues?: Array<string>;
    /**
     * @description icon name (from Material icons)
     */
    icon?: string;
    /**
     * @description Whether the group of Widgets is collapsed on application start.
     */
    collapsed?: boolean;
}
interface AnalyticsTabs {
    name: string;
    icon: string;
    showName: boolean;
    showIcon: boolean;
}

interface FilterShortcutConfiguration {
    uuid: string;
    title: string;
    order: 1;
    component?: WidgetConfiguration;
}

declare class ArlasAuthentificationService {
    authConfigValue: AuthentSetting;
    protected emitSessionEnd(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasAuthentificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasAuthentificationService>;
}

declare const ARLAS_ORG_FILTER = "arlas-org-filter";
declare class ArlasIamService extends ArlasAuthentificationService {
    private router;
    private settings;
    private options;
    private arlasIamApi;
    private refreshTokenTimer$;
    private unsubscribe;
    private tokenRefreshedSource;
    private currentOrganisation;
    tokenRefreshed$: Observable$1<LoginData>;
    user: UserData;
    reloadState: string;
    storage: Map<any, any>;
    constructor(router: Router, settings: ArlasSettingsService);
    declareReloadState(reloadState: any): void;
    consumeReloadState(): void;
    setOptions(options: any): void;
    setArlasIamApi(api: ArlasIamApi): void;
    /**
     * - Strores the given access token in localstorage
     * - Set the headers of iamService with an already stored organisation in localstorage.  */
    setHeadersFromAccesstoken(accessToken: string): void;
    /** Stores the given org and access token in localstorage + set iamService headers. */
    setHeaders(org: string, accessToken: string): void;
    storeAccessToken(accessToken: string): void;
    getAccessToken(): string;
    /** Gets organisation from localstorage.
     * The method checks if the organisation is defined
     * If not returned the first of the list in user's organisations.
     */
    getOrganisation(): string;
    storeOrganisation(organisation: string): void;
    notifyTokenRefresh(loginData: LoginData): void;
    private clearTokens;
    private clearOrganisation;
    /** This method should be called right after being logged in
     * THUS; there is no need to refresh the token at 0; we can wait for the moment the token is about to expire to **start** the timer.
     * By doing this we avoid refreshing the token twice in a row.
     * Also starting the refresh at 0 causes some incoherence in localstorage when we activate 'redirect_uri' parameter in settings.yaml
     */
    startRefreshTokenTimer(loginData: LoginData): void;
    initAuthService(): Promise<void>;
    private checkForceConnect;
    private needsRedirection;
    private forceConnect;
    isAuthenticated(): boolean;
    areSettingsValid(authentSetting: AuthentSetting): [boolean, string];
    stopRefreshTokenTimer(): void;
    clearStore(): void;
    logoutWithoutRedirection$(): Observable$1<ArlasMessage>;
    logout(redirectPageAfterLogout?: string[]): void;
    refresh(): Observable$1<LoginData>;
    login(email: string, password: string): Observable$1<LoginData>;
    signUp(email: string): Observable$1<UserData>;
    verify(userId: string, token: string, password: string): Observable$1<UserData>;
    reset(userId: string, token: string, password: string): Observable$1<UserData>;
    forgot(email: string): Observable$1<ArlasMessage>;
    change(oldPassword: string, newPassword: string): Observable$1<UserData>;
    createPermission(oid: string, permissionDef: PermissionDef): Observable$1<PermissionData>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasIamService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasIamService>;
}

declare class ArlasConfigurationUpdaterService {
    constructor();
    /**
     * Parses the configuration and returns a list of contributors that should be removed from the config.
     * @param data configuration object
     * @param availableFieldsPerCollection list of fields available for exploration for each collection.
     * @returns configuration object
     */
    getContributorsToRemove(data: any, availableFieldsPerCollection: Map<string, Set<string>>): Set<string>;
    /**
     * Removes contributors that have non-available fields
     * @param data configuration objects
     * @param contributorsToRemove list of contributors identifiers to remove from the configuration
     * @returns configuration object
     */
    removeContributors(data: any, contributorsToRemove: Set<string>): any;
    /**
     * Removes widgets that are associated with removed contributors
     * @param data
     * @param contributorsToRemove
     * @returns configuration object
     */
    removeWidgets(data: any, contributorsToRemove: Set<string>): any;
    /**
     * Removes timelines that are associated with removed timeline contributors
     * @param data
     * @param contributorsToRemove
     * @returns configuration object
     */
    removeTimelines(data: any, contributorsToRemove: Set<string>): any;
    /**
     * Add the default collection as the contributor's collection if not present
     * @param data configuration object
     * @returns configuration object
     */
    addCollectionIfMissing(data: any): any;
    /**
     * Removes the properties -from all contributors- including fields that are not available for exploration
     * @param data configuration object
     * @param availableFieldsPerCollection List of available fields for exploration
     * @returns configuration object
     */
    updateContributors(data: any, availableFieldsPerCollection: Map<string, Set<string>>): any;
    /**
     * Removes the properties -from map component - including fields that are not available for exploration
     * @param data configuration object
     * @param availableFieldsPerCollection List of available fields for exploration for each collection.
     * @returns configuration object
     */
    updateMapComponent(data: any, availableFieldsPerCollection: Map<string, Set<string>>): any;
    /**
     * Removes the properties -from ResultListContributor- that define fields not available for exploration
     * @param data configuration object
     * @param availableFieldsPerCollection List of available fields for exploration for each collection.
     * @returns configuration object
     */
    updateResultListContributors(data: any, availableFieldsPerCollection: Map<string, Set<string>>): any;
    /**
     * Removes the properties -from ResultListContributor- that define fields not available for exploration
     * @param data configuration object
     * @param availableFieldsPerCollection List of available fields for exploration for each collection.
     * @returns configuration object
     */
    updateHistogramContributors(data: any, availableFieldsPerCollection: Map<string, Set<string>>): any;
    /**
     * Removes the properties -from MapConributor- that define fields not available for exploration
     * @param data configuration object
     * @param availableFieldsPerCollection List of available fields for exploration for each collection.
     * @returns configuration object
     */
    updateMapContributors(data: any, availableFieldsPerCollection: Map<string, Set<string>>): any;
    /**
     * Removes the properties -from SearchContributor- that define fields not available for exploration
     * @param data configuration object
     * @param availableFieldsPerCollection List of available fields for exploration for each collection.
     * @returns configuration object
     */
    updateChipSearchContributors(data: any, availableFieldsPerCollection: Map<string, Set<string>>): any;
}

/** Error sent when the user lacks authorization to view something */
declare class AuthorisationError extends ArlasError {
    constructor(status: number);
    executeAction(): void;
}

declare class ErrorService {
    private readonly dialog;
    private readonly settingsService;
    private readonly arlasCollaborationService;
    private readonly snackBar;
    private readonly translate;
    private arlasErrorsSubscription;
    constructor(dialog: MatDialog, settingsService: ArlasSettingsService, arlasCollaborationService: ArlasCollaborativesearchService, snackBar: MatSnackBar, translate: TranslateService);
    emitAuthorisationError(error: AuthorisationError, forceAction?: boolean): void;
    /**
     * Displays a dialog asking the user to login again after their session expired
     * @param code 401 or 403
     */
    emitSessionExpiredError(code: number): void;
    emitUnavailableService(service: string): void;
    emitSettingsError(): void;
    emitBackendError(status: number, message: string, service: string, mode?: 'snackbar' | 'dialog'): void;
    emitInvalidDashboardError(forceAction: boolean, message?: string): void;
    emitUnauthorizedActionError(status: number, message: string, forceAction: boolean): void;
    closeAll(): MatDialog;
    listenToArlasCollaborativeErrors(): void;
    unlistenToArlasCollaborativeErrors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorService>;
}

declare class AuthentificationService extends ArlasAuthentificationService {
    private readonly oauthService;
    private readonly http;
    authConfig: AuthConfig;
    private isAuthenticatedSubject;
    isAuthenticated: Observable<boolean>;
    private isDoneLoadingSubject;
    isDoneLoading: Observable<boolean>;
    /**
     * Publishes `true` if and only if (a) all the asynchronous initial
     * login calls have completed or errorred, and (b) the user ended up
     * being authenticated.
     *
     * In essence, it combines:
     *
     * - the latest known state of whether the user is authorized
     * - whether the ajax calls for initial log in have all been done
     */
    canActivateProtectedRoutes: Observable<boolean>;
    constructor(oauthService: OAuthService, http: HttpClient);
    refreshErrors$(): Observable<OAuthErrorEvent>;
    initAuthService(): Promise<void>;
    runInitialLoginSequence(useDiscovery?: boolean, forceConnect?: boolean): Promise<void>;
    login(): void;
    logout(): void;
    refresh(): void;
    hasValidAccessToken(): boolean;
    hasValidIdToken(): boolean;
    get accessToken(): string;
    get identityClaims(): Record<string, any>;
    get idToken(): string;
    get logoutUrl(): string;
    areSettingsValid(authentSetting: AuthentSetting): [boolean, string];
    /**
     * Return an observable of the user Auth0 profile
     */
    loadUserInfo(): Observable<UserInfo>;
    private setupAuthService;
    private getAuthConfig;
    private getQueryParam;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthentificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthentificationService>;
}

declare class FetchInterceptorService {
    private readonly arlasSettings;
    private readonly errorService;
    private readonly router;
    private readonly authService;
    private readonly iamService;
    constructor(arlasSettings: ArlasSettingsService, errorService: ErrorService, router: Router, authService: AuthentificationService, iamService: ArlasIamService);
    interceptLogout(): void;
    /**
     * Intercepts any errored fetch request.
     * If the url of the request has been whitelisted, then any potential error is ignored.
     */
    applyInterceptor(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FetchInterceptorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FetchInterceptorService>;
}

declare class ArlasConfigService extends ConfigService {
    errorsQueue: Error[];
    appName: string;
    constructor();
    /** Returns the preview identifier stored in the config.json */
    getPreviewId(): string | undefined;
    parse(stringifiedConfig: string): any;
    getPreview(config: any): any;
    hasPreview(config: any): boolean;
    getI18n(config: any): any;
    getTours(config: any): any;
    hasI18n(config: any): boolean;
    hasTours(config: any): boolean;
    hasResources(config: any): boolean;
    updateI18n(config: any, lang: string, i18nId: string): void;
    updateTour(config: any, lang: string, tourId: string): void;
    updatePreview(config: any, previewId: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasConfigService>;
}
declare class ArlasExploreApi extends ExploreApi {
    constructor(conf: Configuration, basePath: string, fetch: any);
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasExploreApi, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasExploreApi>;
}
declare class ArlasIamApi extends DefaultApi {
    constructor(conf: Configuration$1, basePath: string, fetch: any);
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasIamApi, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasIamApi>;
}
declare const CONFIG_UPDATER: InjectionToken<Function>;
declare const FETCH_OPTIONS: InjectionToken<any>;
interface Error {
    origin: string;
    message: string;
    reason: string;
}
declare class ArlasStartupService {
    private readonly settingsService;
    private readonly configService;
    private readonly collaborativesearchService;
    private readonly injector;
    private readonly fetchOptions;
    private readonly getOptions;
    private readonly http;
    private readonly translateService;
    private readonly configUpdater;
    private readonly persistenceService;
    private readonly permissionService;
    private readonly errorService;
    private readonly fetchInterceptorService;
    private readonly arlasIamService;
    private readonly processService;
    contributorRegistry: Map<string, Contributor>;
    shouldRunApp: boolean;
    emptyMode: boolean;
    analytics: Array<AnalyticGroupConfiguration>;
    filtersShortcuts: Array<FilterShortcutConfiguration>;
    collectionsMap: Map<string, CollectionReferenceParameters>;
    collectionId: string;
    selectorById: string;
    temporalContributor: Array<string>;
    private readonly errorMessagesList;
    errorStartUpServiceBus: Subject<any>;
    arlasIsUp: Subject<boolean>;
    arlasExploreApi: ArlasExploreApi;
    configurationUpdaterService: ArlasConfigurationUpdaterService;
    arlasIamApi: ArlasIamApi;
    constructor(settingsService: ArlasSettingsService, configService: ArlasConfigService, collaborativesearchService: ArlasCollaborativesearchService, injector: Injector, fetchOptions: any, getOptions: any, http: HttpClient, translateService: TranslateService, configUpdater: any, persistenceService: PersistenceService, permissionService: PermissionService, errorService: ErrorService, fetchInterceptorService: FetchInterceptorService, arlasIamService: ArlasIamService, processService: ProcessService);
    getFGAService(): ArlasConfigurationUpdaterService;
    errorStartUp(): void;
    validateSettings(settings: any): Promise<any>;
    validateConfiguration(data: any): Promise<any>;
    translationLoaded(data: any): Promise<any>;
    /**
     * - Sets the configuration object in ArlasConfigService.
     * - Sets the ArlasConfigService instance in ArlasCollaborativeSearchService
     * @param data configation object
     * @returns the same configuration object
     */
    setConfigService(data: any): any;
    /**
     * Updates configuration by keeping only components/widgets that are availbale for exploration
     * @param data configuration object
     * @param availableFields list of fields that are available for exploration
     * @returns the updated configuration object
     */
    updateConfiguration(data: any, availableFields: Map<string, Set<string>>): any;
    /**
     * Retrieves fields that are available for exploration and updates the configuration to keep only corresponding widgets and components
     * @param data configuration object
     */
    applyFGA(data: any): Promise<any>;
    /**
     * - Fetches and parses the `settings.yaml`.
     * - Validates it against the correponding schema
     * @returns ARLAS settings object Promise
     */
    applyAppSettings(): Promise<ArlasSettings>;
    /**
     * if authentication is configured, trigger authentication service that redirects to login page if it's the first time and fetches
     * the appropriate token
     * @param settings ArlasSettings object
     */
    authenticate(settings: ArlasSettings): Promise<ArlasSettings>;
    /**
     * Enriches headers of calls sent to ARLAS-server & ARLAS-persistence
     * @param settings
     */
    enrichHeaders(settings: ArlasSettings): Promise<ArlasSettings>;
    /**
     * - Fetches the configuration file from ARLAS-persistence if it's configurated, otherwise fetches the config.json in "src" folder.
     * - Validates the configuration against the corresponding schema
     * @param settings Arlas Settings object
     * @returns ARLAS Configuration object Promise
     */
    getAppConfigurationObject(settings: ArlasSettings): Promise<any>;
    setCollaborativeService(data: any): Promise<any>;
    testArlasUp(configData: any): Promise<any>;
    /**
     * Fetches from ARLAS-Server all of the available collections and initialises the map of CollectionReferenceParameters
     */
    getCollections(data: any): Promise<any>;
    /**
    * Lists the fields for each collection in `collectionNames` list; that are available for exploration with `arlasExploreApi`
    * @param collectionNames collection names
    * @returns available fields per collection
    */
    listAvailableFields(collectionNames: Set<string>): Promise<Map<string, Set<string>>>;
    buildContributor(data: any): Promise<any>;
    /**
     * Loads extra configuration declared in the main configuration file.
     * @param extraConfig This object specifies
     * the path to the extra configuration file,
     * the attribute to change in the main configuration file,
     * and the attribute to take from the extra configuration file.
     * @param data Content of the extra configuration file
     */
    loadExtraConfig(extraConfig: ExtraConfig, data: Object): Promise<any>;
    changeOrgHeader(org: string, accessToken: string): void;
    load(): Promise<any>;
    private setAttribute;
    private getShortcutComponent;
    private fixLayerStyleInfinity;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasStartupService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasStartupService>;
}
interface ExtraConfig {
    configPath: string;
    replacedAttribute: string;
    replacer: string;
}
interface ArlasSettings {
    authentication?: AuthentSetting;
    persistence?: PersistenceSetting;
    permission?: PermissionSetting;
    arlas_wui_url?: string;
    arlas_builder_url?: string;
    arlas_hub_url?: string;
    arlas_iam_wui_url?: string;
    links?: Array<LinkSettings>;
    ticketing_key?: string;
    tab_name?: string;
    dashboards_shortcut?: boolean;
    histogram?: HistogramSettings;
    resultlist?: ResultlistSettings;
    processes?: Array<ProcessSettings>;
    geocoding?: GeocodingSetting;
    /**
     * Urls that are ignored by the FetchInterceptorService.
     * Check is performed on whether the intercepted url matches the beginning of any whitelisted url.
     */
    whitelistedUrls?: string[];
    /**
     * Theme to use for the draw in an ARLAS map
     */
    drawTheme?: DrawTheme;
}
interface LinkSettings {
    name: string;
    url: string;
    icon: string;
    tooltip?: string;
    check_url: string;
    check_url_response_type?: string;
}
interface HistogramSettings {
    max_buckets: number;
    export_nb_buckets: number;
}
interface ResultlistSettings {
    enable_export: boolean;
    export_size: number;
}
interface ProcessSettings {
    name: string;
    url?: string;
    check_url?: string;
    max_items?: number;
    settings: {
        url: string;
    };
    status: {
        url: string;
    };
}

declare class ArlasSettingsService {
    settings: ArlasSettings;
    setSettings(settings: ArlasSettings): void;
    getSettings(): ArlasSettings;
    getPersistenceSettings(): PersistenceSetting;
    getPermissionSettings(): PermissionSetting;
    getGeocodingSettings(): GeocodingSetting;
    getArlasWuiUrl(): string;
    getArlasBuilderUrl(): string;
    getArlasHubUrl(): string;
    getArlasIAMWuiUrl(): string;
    getLinksSettings(): LinkSettings[];
    getTicketingKey(): string;
    getHistogramMaxBucket(): number;
    isResultListExportEnabled(): boolean;
    getResultlistSettings(): ResultlistSettings;
    getHistogramNbBucketAtExport(): number;
    getAuthentSettings(): AuthentSetting;
    getProcessSettings(name: string): ProcessSettings;
    getDrawTheme(): DrawTheme;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasSettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasSettingsService>;
}

declare class ProcessService {
    private http;
    private arlasSettingsService;
    private collaborativeSearchService;
    private processInputs;
    private options;
    constructor(http: HttpClient, arlasSettingsService: ArlasSettingsService, collaborativeSearchService: ArlasCollaborativesearchService);
    setOptions(options: any): void;
    /**
     *
     * @param ids List of products ids
     * @param payload Values of the dynamic form
     * @param collection Collection of selectied items
     */
    process(processName: string, ids: string[], payload: any, collection: string): Observable<ProcessOutput>;
    check(processName: string): Observable<any>;
    getProcessInputs(): ProcessInputs;
    setProcessInputs(process: ProcessInputs): void;
    load(processName: string): Observable<Process>;
    getJobStatus(processName: string, jobId: string): Observable<ProcessOutput>;
    getItemsDetail(idFieldName: string, itemsId: string[], collection: string): Observable<Map<string, any>>;
    private resolve;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProcessService>;
}

/** Base data communicated to an AIAS process dialog window */
interface AiasProcessDialogData {
    nbProducts: number;
    itemDetail: Map<string, any>;
    ids: string[] | null;
    collection: string;
}
/** Data for the AIAS Download */
interface AiasDownloadDialogData extends AiasProcessDialogData {
    wktAoi: string | null;
}
/** Data for the AIAS Enrich */
type AiasEnrichDialogData = AiasProcessDialogData;
declare abstract class AiasProcess {
    protected processService: ProcessService;
    protected data: AiasProcessDialogData;
    private processName;
    processStarted: boolean;
    isProcessing: boolean;
    hasError: boolean;
    statusSub: Subscription;
    unsubscribeStatus: Subject<boolean>;
    statusResult: ProcessOutput;
    constructor(processService: ProcessService, data: AiasProcessDialogData, processName: string);
    protected abstract preparePayload(): any;
    submit(): void;
    private getStatus;
}

declare const DOWNLOAD_PROCESS_NAME: "download";
declare class AiasDownloadComponent extends AiasProcess implements OnInit, OnDestroy {
    protected processService: ProcessService;
    protected data: AiasDownloadDialogData;
    formGroup: FormGroup;
    pictureFormats: Array<string>;
    projections: ProcessProjection[];
    hasAoi: boolean;
    displayAoiForms: boolean;
    displayFormatFrom: boolean;
    displayProjectionFrom: boolean;
    tooltipDelay: number;
    private _onDestroy$;
    constructor(processService: ProcessService, data: AiasDownloadDialogData);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private _initPictureFormatList;
    private _initProjectionList;
    private _listenFormsChanges;
    hasOneItemToDownload(): boolean;
    downloadAllElements(): boolean;
    protected preparePayload(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AiasDownloadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AiasDownloadComponent, "arlas-aias-download", never, {}, {}, never, never, true, never>;
}

declare const ENRICH_PROCESS_NAME: "enrich";
declare class AiasEnrichComponent extends AiasProcess implements OnInit {
    protected processService: ProcessService;
    protected data: AiasEnrichDialogData;
    enrichments: Array<string>;
    formGroup: FormGroup<{
        asset_type: FormControl<string>;
    }>;
    constructor(processService: ProcessService, data: AiasEnrichDialogData);
    ngOnInit(): void;
    private _initEnrichmentsList;
    protected preparePayload(): Partial<{
        asset_type: string;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AiasEnrichComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AiasEnrichComponent, "arlas-aias-enrich", never, {}, {}, never, never, true, never>;
}

declare class AiasResultComponent {
    isProcessing: boolean;
    statusResult: ProcessOutput;
    hasError: boolean;
    processName: string;
    processAction: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AiasResultComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AiasResultComponent, "arlas-aias-result", never, { "isProcessing": { "alias": "isProcessing"; "required": false; }; "statusResult": { "alias": "statusResult"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "processName": { "alias": "processName"; "required": false; }; "processAction": { "alias": "processAction"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AnalyticsService {
    private configService;
    private collaborativeService;
    private activatedRoute;
    private router;
    /**
     * @description Emits the name of the tab when the selected tab in the menu has changed
     */
    tabChange: EventEmitter<string>;
    /**
     * @description Whether drag and drop is active for the groups inside of the analytics board
     */
    isActiveDragDrop: boolean;
    /**
     * @description List of groups. Each group contains one or more widgets.
     */
    private _groups;
    /**
     * @description List of tabs. Each tab contains one or more groups.
     */
    private _tabs;
    /**
     * @description Map of which group(s) each contributor belong to
     */
    private _contributorGroup;
    /**
     * @description Map of which tab each group belong to
     */
    private _groupTab;
    /**
     * @description List of groups with their tab's name
     */
    private _groupsByTab;
    /**
     * @description Map of the open/close state of groups
     */
    private _wasClosedMap;
    /**
     * @description Map of whether to display each group
     */
    private _groupsDisplayStatusMap;
    /**
     * @description Index of the currently selected tab. Can be undefined when no tab is selected.
     */
    private _activeTab;
    /**
     * @description Map of which groups are currently filtered on
     */
    private _activeFilterGroup;
    /**
     * @description Map of which tabs are currently filtered on
     */
    private _activeFilterTab;
    /**
     * @description Name of the tab in which groups are put by default if they don't belong in one.
     */
    private defaultGroupTabName;
    constructor(configService: ArlasConfigService, collaborativeService: ArlasCollaborativesearchService, activatedRoute: ActivatedRoute, router: Router);
    setGroupsDisplayStatusMap(statusMap: Map<string, boolean>): void;
    getActiveGroups(): AnalyticGroupConfiguration[];
    /**
     * Triggered when a tab is selected by the menu.
     * Updates the URL to store which tab the user is currently on.
     * Deactivates data updating of the widgets of the hidden tabs.
     * Emits a tab change event.
     * @param tabIndex Index of the tab selected. Can be undefined if none is selected.
     */
    selectTab(tabIndex: number | undefined): void;
    /**
     * Activates the data upating of the contributors of every widget of the group.
     * @param group Configuration of the group to display
     */
    openPanel(group: AnalyticGroupConfiguration): void;
    /**
     * Deactivates the data upating of the contributors of every widget of the group.
     * @param group Configuration of the group to hide
     */
    closePanel(group: AnalyticGroupConfiguration): void;
    cancelAllOtherTabsContribution(tabIndex: number): void;
    cancelAllTabsContribution(): void;
    /**
     * Deactivates all the contributors of the group that are not present in the active tab.
     * @param group Configuration of the group to deactivate
     */
    cancelGroupContribution(group: AnalyticGroupConfiguration): void;
    /**
     * Activates all the contributors of the group.
     * @param group Configuration of the group to activate
     */
    activateGroupContribution(group: AnalyticGroupConfiguration): void;
    /**
     *
     * @param group Group declared in configuration file
     * @param display Whether to display the widget
     */
    addWidget(group: AnalyticGroupConfiguration, display: boolean): void;
    /**
     * Removes all the filters of the given group
     * @param groupId Group id
     */
    removeFilter(groupId: string): void;
    /**
     * Removes all the filters of the given tab
     * @param tabId Tab id
     */
    removeTabFilter(tabId: string): void;
    /**
     * Updates the map of which groups are currently filtered on
     */
    setActiveFilterGroup(): void;
    /**
     * Updates the map of which tabs are currently filtered on
     */
    setActiveFilterTab(): void;
    /**
     * Updates the order of the groups of the current tab.
     * Stores in the local storage this new order.
     * @param event Drop event of a group being moved
     */
    dropGroup(event: CdkDragDrop<string[]>): void;
    /**
     * Initialize the mapping of the designated tab with its groups if not already done
     * @param tabName The considered tab's name
     */
    private initTabMapping;
    /**
     * Stores group in the correct tab, and indicates the correct tab for the group
     * @param group The considered group
     * @param tabName The considered tab name
     */
    private fillTabMapping;
    private updateFromCollaboration;
    /**
     * @description List of groups. Each group contains one or more widgets.
     */
    get groups(): AnalyticGroupConfiguration[];
    initializeGroups(groups: Array<AnalyticGroupConfiguration>): void;
    /**
     * In case of using the service with several instances of AnalyticsBoardComponent, the global variables should
     * be reset if we re-initialize groups.
     */
    private reset;
    /**
     * @description List of tabs. Each tab contains one or more groups.
     */
    get tabs(): AnalyticsTabs[];
    /**
     * @description Map of whether to display each group
     */
    get groupsDisplayStatusMap(): Map<string, boolean>;
    /**
     * @description Map of which tabs are currently filtered on
     */
    get activeFilterTab(): Map<string, boolean>;
    /**
     * @description Map of which groups are currently filtered on
     */
    get activeFilterGroup(): Map<string, boolean>;
    /**
     * @description Index of the currently selected tab. Can be undefined when no tab is selected.
     */
    get activeTab(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsService>;
}

/**
 * This component organizes the `Widgets` in a board.
 * A Widget is declared within a "group" in the configuration. A group contains one or more Widgets
 */
declare class AnalyticsBoardComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy {
    protected readonly collaborativeService: ArlasCollaborativesearchService;
    protected readonly analyticsService: AnalyticsService;
    /**
     * @Input : Angular
     * @description Display mode of the analytics tab. Can be 'normal' or 'compact'.
     */
    mode: 'normal' | 'compact';
    /**
     * @Input : Angular
     * @description Id of the element to scroll to inside of the analytics board.
     */
    target: string;
    /**
     * @Input : Angular
     * @description Whether or not the spinner is displayed when a component is loading data
     */
    showSpinner: boolean;
    colorSpinner: string;
    diameterSpinner: number;
    strokeWidthSpinner: number;
    /**
     * @Input : Angular
     * @description Whether or not the indicators are displayed when a filter is active on a group or tab
     */
    showIndicators: boolean;
    /**
     * @Output : Angular
     * @description Emits an event coming from one of the Widgets.
     * The emitted output has information about
     * the `origin` which is the contributor id of the Widget; `event` the name of the event; and eventually `data` which contains
     * the emitted data from the component.
     */
    boardOutputs: EventEmitter<{
        origin: string;
        event: string;
        data?: any;
    }>;
    /**
     * @Output : Angular
     * @description Emits an event when the display mode of a group is changed. The value transmitted is the group id
     */
    modeChange: EventEmitter<string>;
    spinnerOptions: SpinnerOptions;
    /**
     * @description List of groups. Each group contains one or more widgets.
     */
    groups: Array<AnalyticGroupConfiguration>;
    expandedHeaderHeight: number;
    collapsedHeaderHeight: number;
    private tabChangeSubscription;
    constructor(collaborativeService: ArlasCollaborativesearchService, analyticsService: AnalyticsService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    scrollToAnalyticsComponent(target: string): void;
    /**
     * Emits the widgets output events.
     * @param source Contributor identifier
     * @param event Name of the event
     * @param data Emitted data
     */
    listenOutput(event: {
        origin: string;
        event: string;
        data?: any;
    }): void;
    drop(event: CdkDragDrop<string[]>): void;
    changeMode(event: any): void;
    removeFilter(groupId: string, event: any): void;
    openPanel(group: AnalyticGroupConfiguration): void;
    closePanel(group: AnalyticGroupConfiguration): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsBoardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AnalyticsBoardComponent, "arlas-analytics-board", never, { "mode": { "alias": "mode"; "required": false; }; "target": { "alias": "target"; "required": false; }; "showSpinner": { "alias": "showSpinner"; "required": false; }; "colorSpinner": { "alias": "colorSpinner"; "required": false; }; "diameterSpinner": { "alias": "diameterSpinner"; "required": false; }; "strokeWidthSpinner": { "alias": "strokeWidthSpinner"; "required": false; }; "showIndicators": { "alias": "showIndicators"; "required": false; }; }, { "boardOutputs": "boardOutputs"; "modeChange": "modeChange"; }, never, never, true, never>;
}

declare class AnalyticsMenuComponent implements OnInit {
    analyticsService: AnalyticsService;
    /**
     * @Input : Angular
     * @description If no tab is selected based on the url, indicates which tab index to select by default.
     * If none is supplied, then no tab is displayed by default
     */
    tabIndexByDefault?: number;
    /**
     * @Input : Angular
     * @description List of groups. Each group contains one or more widgets.
     */
    groups: Array<AnalyticGroupConfiguration>;
    /**
     * @Input : Angular
     * @description Whether to show the indicator of filters applied on this tab.
     */
    showIndicators: boolean;
    constructor(analyticsService: AnalyticsService);
    ngOnInit(): void;
    /**
     * Method called when clicking on a tab to select or unselect it. If already selected, unselects it.
     * @param index Index of the tab selected in the list of tabs
     */
    selectTab(index: number): void;
    /**
     * Remove all the filters linked to the contributors of the clicked tab
     * @param tabId The name of the tab clicked
     * @param event The click event fired when clicked
     */
    removeTabFilter(tabId: string, event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AnalyticsMenuComponent, "arlas-analytics-menu", never, { "tabIndexByDefault": { "alias": "tabIndexByDefault"; "required": false; }; "groups": { "alias": "groups"; "required": false; }; "showIndicators": { "alias": "showIndicators"; "required": false; }; }, {}, never, never, true, never>;
}

interface Aoi extends ArlasStorageObject {
    geometry: any;
    private: boolean;
}

declare class ArlasLocalDatabase<T extends ArlasStorageObject> {
    /** Stream that emits whenever the data has been modified. */
    dataChange: BehaviorSubject<T[]>;
    get data(): T[];
    storageObjectMap: Map<string, T>;
    storageKey: string;
    constructor(storageKey?: string, additionalObject?: any);
    /**
     * Method call for each element at init
     * @param obj Object to init of type <T>
     * @param additionnalObj Addtionnal object
     */
    init(obj: T, additionnalObj?: any): T;
    add(storageObject: T): Observable<void>;
    remove(id: string): Observable<void>;
    update(id: string, storageObject: T): Observable<void>;
}

declare class AoiDatabase extends ArlasLocalDatabase<Aoi> {
    constructor();
    init(aoi: Aoi): Aoi;
    createAoi(name: string, geometry: any, visibility?: boolean, date?: Date, id?: string): Aoi;
}

declare class ArlasAoiService {
    private arlasStartupService;
    dataBase: AoiDatabase;
    aoiMap: Map<string, Aoi>;
    constructor(arlasStartupService: ArlasStartupService);
    addAoi(name: string, geometry: any): void;
    removeAoi(id: string): void;
    getAoiById(id: string): Aoi;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasAoiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasAoiService>;
}

declare class ArlasDataSource extends DataSource<any> {
    arlasLocalDatabase: ArlasLocalDatabase<ArlasStorageObject>;
    private _filterChange;
    get filter(): string;
    set filter(filter: string);
    constructor(arlasLocalDatabase: ArlasLocalDatabase<ArlasStorageObject>);
    /** Connect function called by the table to retrieve one stream containing the data to render. */
    connect(): Observable<ArlasStorageObject[]>;
    disconnect(): void;
    getSortedData(): ArlasStorageObject[];
}

declare class AoiComponent {
    private aoiService;
    aois: ArlasDataSource;
    columnsToDisplay: string[];
    itemsCheck: Array<string>;
    actions: Subject<{
        action: string;
        id: string;
        geometry?: any;
    }>;
    constructor(aoiService: ArlasAoiService);
    selectAoi(event: any, id: any): void;
    viewAoi(id: string): void;
    removeAoi(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AoiComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AoiComponent, "arlas-aoi", never, {}, { "actions": "actions"; }, never, never, true, never>;
}

declare enum BookMarkType {
    enumIds = 0,
    filterWithTime = 1,
    filterWithoutTime = 2
}
interface BookMark extends ArlasStorageObject {
    prettyFilter: string;
    url: string;
    type: BookMarkType;
    color: string;
    count: Observable<number>;
    /** @deprecated */
    views: number;
    collections: string;
}

declare class BookmarkLocalDatabase extends ArlasLocalDatabase<BookMark> {
    bookmarkService: ArlasBookmarkService;
    arlasCollaborativesearchService: ArlasCollaborativesearchService;
    startupService: ArlasStartupService;
    constructor(bookmarkService: ArlasBookmarkService, arlasCollaborativesearchService: ArlasCollaborativesearchService, startupService: ArlasStartupService);
    init(bookmark: BookMark, service: ArlasBookmarkService): BookMark;
    createBookmark(name: string, prettyFilter: string, url: string, collections: Set<string>, type: BookMarkType, color: string, id?: string, date?: Date, views?: number): BookMark;
}

declare class ArlasPersistenceDatabase<T extends ArlasStorageObject> {
    /** Stream that emits whenever the data has been modified. */
    dataChange: BehaviorSubject<{
        total: number;
        items: T[];
    }>;
    get data(): {
        total: number;
        items: T[];
    };
    storageObjectMap: Map<string, T>;
    storageKey: string;
    persistenceService: PersistenceService;
    additionalObject: any;
    private page;
    constructor(storageKy: string, persistenceService: PersistenceService, additionalObject?: any);
    /**
     * Method call for each element at init
     * @param obj Object to init of type <T>
     * @param additionnalObj Addtionnal object
     */
    init(obj: T, additionnalObj?: any): T;
    add(storageObject: T): Observable<void>;
    remove(id: string): Observable<void>;
    list(size: number, page: number, order: string, key?: any): Observable<void>;
    update(id: string, storageObject: T): Observable<void>;
    setPage(page: {
        size: number;
        number: number;
    }): void;
}

declare class BookmarkPersistenceDatabase extends ArlasPersistenceDatabase<BookMark> {
    bookmarkService: ArlasBookmarkService;
    persistenceService: PersistenceService;
    startupService: ArlasStartupService;
    constructor(bookmarkService: ArlasBookmarkService, persistenceService: PersistenceService, startupService: ArlasStartupService);
    init(bookmark: BookMark, service: ArlasBookmarkService): BookMark;
    createBookmark(name: string, prettyFilter: string, url: string, collections: Set<string>, type: BookMarkType, color: string, id?: string, date?: Date, views?: number): BookMark;
}

/** Constants used to fill up our data base. */
declare class ArlasBookmarkService {
    private collaborativesearchService;
    private activatedRoute;
    snackBar: MatSnackBar;
    arlasStartupService: ArlasStartupService;
    private authentService;
    private arlasIamService;
    private persistenceService;
    private settingsService;
    private router;
    private translate;
    dataBase: BookmarkLocalDatabase | BookmarkPersistenceDatabase;
    bookMarkMap: Map<string, BookMark>;
    selectorById: string;
    count: number;
    maxSize: number;
    pageNumber: number;
    onAction: Subject<{
        action: string;
        id: string;
    }>;
    constructor(collaborativesearchService: ArlasCollaborativesearchService, activatedRoute: ActivatedRoute, snackBar: MatSnackBar, arlasStartupService: ArlasStartupService, authentService: AuthentificationService, arlasIamService: ArlasIamService, persistenceService: PersistenceService, settingsService: ArlasSettingsService, router: Router, translate: TranslateService);
    /**
     * List all bookmark for the user to update dataBase
     */
    listBookmarks(size: number, pageNumber: number): Observable<void>;
    setPage(size: number, pageNumber: number): void;
    addBookmark(newBookMarkName: string, selectedItem?: Set<string>): Observable<void>;
    createCombineBookmark(newBookMarkName: string, selectedBookmark: Set<string>): Observable<void>;
    removeBookmark(id: string): void;
    viewBookMark(id: string): void;
    openSnackBar(message: string): void;
    setBookMarkCount(bookMark: BookMark): void;
    viewCombineBookmark(selectedBookmark: Set<string>): void;
    init(bookmark: BookMark): BookMark;
    updateBookmarkName(bookmarkName: string, id: string): void;
    private viewFromDataModel;
    private combineBookmarkFromIds;
    private combineBookmarkFromFilter;
    private getCountFromUrl;
    private getBookmarkById;
    private getUrlFomSetIds;
    private isTemporalFilter;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasBookmarkService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasBookmarkService>;
}

declare class BookmarkMenuComponent implements OnInit, OnDestroy {
    dialog: MatDialog;
    bookmarkService: ArlasBookmarkService;
    private collabrativeSearchService;
    /**
     * @Input : Angular
     * @description Icon to use for the 'Manage dataset' action
     */
    icon: string;
    /**
     * @deprecated Top bookmarks are no longer displayed
     */
    nbTopBookmarks: number;
    isSelectMultipleBookmarks: boolean;
    nbCollaborations: number;
    addBookmarkDisabled: boolean;
    private _onDestroy$;
    infoMessage: string;
    matMenu: MatMenu;
    constructor(dialog: MatDialog, bookmarkService: ArlasBookmarkService, collabrativeSearchService: ArlasCollaborativesearchService);
    ngOnInit(): void;
    private checkAddButtonState;
    openDatasetListDialog(): void;
    openDialogAdd(): void;
    viewBookmark(id: string): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BookmarkMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BookmarkMenuComponent, "arlas-bookmark-menu", never, { "icon": { "alias": "icon"; "required": false; }; "nbTopBookmarks": { "alias": "nbTopBookmarks"; "required": false; }; "isSelectMultipleBookmarks": { "alias": "isSelectMultipleBookmarks"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BookmarkAddDialogComponent {
    private bookmarkService;
    private translateService;
    dialogRef: MatDialogRef<BookmarkAddDialogComponent>;
    protected data: {
        name: string | undefined;
    };
    bookmarkName: FormControl<string>;
    errorMessage: string;
    disableSubmit: boolean;
    constructor(bookmarkService: ArlasBookmarkService, translateService: TranslateService, dialogRef: MatDialogRef<BookmarkAddDialogComponent>, data: {
        name: string | undefined;
    });
    cancel(): void;
    submit(): void;
    pressEvent(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BookmarkAddDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BookmarkAddDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare class BookmarkDataSource extends ArlasDataSource {
    dataBase: BookmarkLocalDatabase;
    constructor(dataBase: BookmarkLocalDatabase);
    getSortedData(): BookMark[];
    sortOnDate(data: BookMark[]): BookMark[];
}

declare class BookmarkComponent implements OnDestroy {
    private readonly bookmarkService;
    private readonly dialog;
    private readonly arlasCollaborativesearchService;
    data: {
        isSelect: boolean;
    };
    bookmarks: BookmarkDataSource | BookMark[];
    columnsToDisplay: string[];
    itemsCheck: Array<string>;
    disableCombine: boolean;
    showCombine: boolean;
    isPersistenceActive: boolean;
    currentCollectionsSet: Set<string>;
    actions: Subject<{
        action: string;
        id: string;
        geometry?: any;
    }>;
    private readonly _onDestroy$;
    constructor(bookmarkService: ArlasBookmarkService, dialog: MatDialog, arlasCollaborativesearchService: ArlasCollaborativesearchService, data: {
        isSelect: boolean;
    });
    ngOnDestroy(): void;
    getDisplayableBookmarks(items: BookMark[]): BookMark[];
    getBookmarksList(): void;
    selectBookmark(event: {
        checked: boolean;
    }, id: string): void;
    viewBookmark(id: string): void;
    removeBookmark(id: string): void;
    combine(): void;
    viewCombine(): void;
    updateBookMarkName(id: string, name: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BookmarkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BookmarkComponent, "arlas-bookmark", never, {}, { "actions": "actions"; }, never, never, true, never>;
}

declare class CalendarTimelineTooltipOverlayComponent {
    overlayRef: ArlasOverlayRef;
    tooltip: TimelineTooltip;
    constructor(overlayRef: ArlasOverlayRef, tooltip: TimelineTooltip);
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarTimelineTooltipOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarTimelineTooltipOverlayComponent, "arlas-calendar-timeline-tooltip-overlay", never, {}, {}, never, never, true, never>;
}

interface ToolTipConfig<T> {
    panelClass?: string;
    hasBackdrop?: boolean;
    backdropClass?: string;
    data?: T;
}
declare class ArlasOverlayService {
    private readonly overlay;
    private readonly injector;
    openHistogramTooltip(config: ToolTipConfig<HistogramTooltip>, elementRef: HTMLDivElement, xOffset: number, yOffset: number, right: boolean): ArlasOverlayRef;
    openCalendarTimelineTooltip(config: ToolTipConfig<TimelineTooltip>, element: HTMLDivElement, xOffset: number, yOffset: number, right: boolean): ArlasOverlayRef;
    openDonutTooltip(config: ToolTipConfig<ARLASDonutTooltip>, element: HTMLDivElement, xOffset: number, yOffset: number, right: boolean): ArlasOverlayRef;
    openPowerbarTooltip(config: ToolTipConfig<ARLASPowerbarTooltip>, element: HTMLDivElement, xOffset: number, yOffset: number, right: boolean): ArlasOverlayRef;
    openSwimlaneTooltip(config: ToolTipConfig<HistogramTooltip>, elementRef: HTMLDivElement, xOffset: number, yOffset: number, right: boolean): ArlasOverlayRef;
    /**
     * For a Histogram or Swimlane chart, opens the tooltip
     */
    private openChartTooltip;
    private openTooltip;
    private createTooltipOverlay;
    private createTooltipInjector;
    private attachTooltipContainer;
    private getOverlayConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasOverlayService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasOverlayService>;
}

/**
 * A Widget wraps a component from ARLAS-web-components and bind it to its contributor. The component has thus input data to plot.
 * Note: This component is binded to ARLAS-wui configuration
 */
declare class CalendarTimelineToolComponent implements OnInit, OnDestroy {
    private arlasOverlayService;
    tooltipEvent: Subject<TimelineTooltip>;
    timelineOverlayRef: ArlasOverlayRef;
    granularity: Granularity;
    climatological: boolean;
    boundDates: Date[];
    data: TimelineData[];
    cursorPosition: Date;
    hideLeftButton: boolean;
    hideRightButton: boolean;
    selectedDate: Subject<TimelineData>;
    hoveredDate: Subject<TimelineTooltip>;
    translate: Subject<TranslationDirection>;
    calendarTimelineComponent: CalendarTimelineComponent;
    constructor(arlasOverlayService: ArlasOverlayService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    showCalendarTimelineooltip(tooltip: TimelineTooltip, e: HTMLDivElement, xOffset: number, yOffset: number, right: boolean): void;
    hideHistogramTooltip(): void;
    emitTooltip(tooltip: TimelineTooltip, e: HTMLDivElement): void;
    onSelectedDate(data: TimelineData): void;
    onTranslate(td: TranslationDirection): void;
    plot(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarTimelineToolComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarTimelineToolComponent, "arlas-tool-calendar-timeline", never, { "granularity": { "alias": "granularity"; "required": false; }; "climatological": { "alias": "climatological"; "required": false; }; "boundDates": { "alias": "boundDates"; "required": false; }; "data": { "alias": "data"; "required": false; }; "cursorPosition": { "alias": "cursorPosition"; "required": false; }; "hideLeftButton": { "alias": "hideLeftButton"; "required": false; }; "hideRightButton": { "alias": "hideRightButton"; "required": false; }; }, { "selectedDate": "selectedDate"; "hoveredDate": "hoveredDate"; "translate": "translate"; }, never, never, true, never>;
}

declare class ChangePasswordComponent implements OnInit {
    private formBuilder;
    private iamService;
    changeForm: FormGroup;
    validated: boolean;
    displayForm: boolean;
    constructor(formBuilder: FormBuilder, iamService: ArlasIamService);
    ngOnInit(): void;
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChangePasswordComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChangePasswordComponent, "arlas-tool-change-password", never, {}, {}, never, never, true, never>;
}

declare class ActionModalComponent {
    private dialogRef;
    private persistenceService;
    private configurationService;
    private errorService;
    action: ConfigAction;
    value: string;
    ConfigAction: typeof ConfigActionEnum;
    errorMessage: string;
    constructor(data: ConfigAction, dialogRef: MatDialogRef<ActionModalComponent>, persistenceService: PersistenceService, configurationService: ArlasConfigService, errorService: ErrorService);
    duplicate(newName: string, config: Config): void;
    private duplicateConfig$;
    private duplicateResourcesThenConfig$;
    create(name: string): void;
    duplicateResources$(arlasConfig: any, newConfigName: string, org: string): Observable<string>;
    private duplicatePreview$;
    private duplicateI18n$;
    private duplicateTour$;
    rename(newName: string, config: Config): void;
    closeShare(event: [boolean, any]): void;
    raiseError(err: any): void;
    private getOptionsSetOrg;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActionModalComponent, "arlas-action-modal", never, {}, {}, never, never, true, never>;
}

declare class ArlasCollectionService extends BaseCollectionService {
    private collaborativeService;
    private configService;
    private arlasStartupeService;
    private appUnits;
    private displayName;
    displayFieldName: Map<string, string>;
    FLAT_CHAR: string;
    constructor(collaborativeService: ArlasCollaborativesearchService, configService: ArlasConfigService, arlasStartupeService: ArlasStartupService);
    protected _initUnits(): void;
    protected _initDisplayNames(): void;
    getUnit(collectionName: string): string;
    getAllUnits(): CollectionUnit[];
    getDisplayName(collectionName: string): string;
    getDisplayFieldName(fieldName: string): string;
    isUnitIgnored(collectionName: string): boolean;
    getCollectionFromDashboard(config: any): Set<string>;
    flatten(f: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasCollectionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasCollectionService>;
}

declare class ConfigMenuComponent {
    private readonly dialog;
    private readonly persistenceService;
    private readonly configService;
    private readonly collectionService;
    private readonly errorService;
    private readonly arlasIamService;
    private readonly arlasSettings;
    private readonly authenService;
    actions: Array<ConfigAction>;
    zone: string;
    actionExecutedEmitter: Subject<ConfigAction>;
    ConfigAction: typeof ConfigActionEnum;
    constructor(dialog: MatDialog, persistenceService: PersistenceService, configService: ArlasConfigService, collectionService: ArlasCollectionService, errorService: ErrorService, arlasIamService: ArlasIamService, arlasSettings: ArlasSettingsService, authenService: AuthentificationService);
    onActionClick(action: ConfigAction): void;
    private getDialogRef;
    private openUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigMenuComponent, "arlas-config-menu", never, { "actions": { "alias": "actions"; "required": false; }; "zone": { "alias": "zone"; "required": false; }; }, { "actionExecutedEmitter": "actionExecutedEmitter"; }, never, never, true, never>;
}

declare class ConfirmModalComponent {
    dialogRef: MatDialogRef<ConfirmModalComponent>;
    confirmMessage: string;
    confirmHTLMMessage: string;
    constructor(dialogRef: MatDialogRef<ConfirmModalComponent>);
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmModalComponent, "arlas-tool-confirm-modal-msg", never, {}, {}, never, never, true, never>;
}

declare class DeniedAccessDialogComponent implements OnInit, OnDestroy {
    private settingsService;
    private authentService;
    private arlasIamService;
    private dialog;
    private router;
    private isAuthentActivated;
    private authentMode;
    forceAction: boolean;
    arlasError: ArlasError;
    private actionSubscription;
    constructor(data: DeniedAccessData, settingsService: ArlasSettingsService, authentService: AuthentificationService, arlasIamService: ArlasIamService, dialog: MatDialogRef<DeniedAccessDialogComponent>, router: Router);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private login;
    private checkIamCurrentUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeniedAccessDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeniedAccessDialogComponent, "arlas-denied-access-dialog", never, {}, {}, never, never, true, never>;
}

declare class DonutTooltipOverlayComponent {
    tooltip: ARLASDonutTooltip;
    /** Computes the style for the columns of the x and y values based on the number of data in the tooltip */
    protected valueStyle: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DonutTooltipOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DonutTooltipOverlayComponent, "arlas-donut-tooltip-overlay", never, {}, {}, never, never, true, never>;
}

declare class DownloadComponent {
    private readonly dialog;
    collections: string[];
    openDialog(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DownloadComponent, "arlas-download", never, { "collections": { "alias": "collections"; "required": false; }; }, {}, never, never, true, never>;
}
declare class DownloadDialogComponent implements OnInit {
    data: string[];
    private readonly formBuilder;
    private readonly collaborativeService;
    private readonly configService;
    private readonly authService;
    private readonly iamService;
    private readonly settingsService;
    private readonly deviceService;
    allFields: ArlasSearchField[];
    selectedFields: ArlasSearchField[];
    selectedSortableFields: ArlasSearchField[];
    selectedFieldString: string;
    selectedFirstOrderField: ArlasSearchField;
    selectedSecondOrderField: ArlasSearchField;
    selectedThirdOrderField: ArlasSearchField;
    filterUrl: string;
    exportedTypeCommand: string;
    authTypeCommand: string;
    isCopied: boolean;
    exportTypeGroup: UntypedFormGroup;
    paramFormGroup: UntypedFormGroup;
    collectionRef: CollectionReferenceDescription;
    operatingSystems: string[];
    detectedOs: string;
    arlasHitsExporterVersion: number;
    collections: any;
    selectedCollection: any;
    serverUrl: any;
    selectionList: MatSelectionList;
    constructor(data: string[], formBuilder: UntypedFormBuilder, collaborativeService: ArlasCollaborativesearchService, configService: ArlasConfigService, authService: AuthentificationService, iamService: ArlasIamService, settingsService: ArlasSettingsService, deviceService: DeviceDetectorService);
    ngOnInit(): void;
    onSelectionChange(selectedOptionsList: SelectionModel<MatListOption>): void;
    collectionChange(event: any): void;
    setCollectionField(collection: any): void;
    /**
     * Switches between dialog steps
     * @param event The step index
     */
    changeStep(event: any): void;
    /**
     * Get the good token according to user connection mode
     * @returns {string | null}
     * @protected
     */
    protected getToken(): string;
    copyCommand(downloadCommand: any, downloadCommandWindows: any): void;
    /**
     * Copies a text in your clipboard
     * @param text Text to copy
     */
    copyTextToClipboard(text: string): void;
    private getFieldProperties;
    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DownloadDialogComponent, "arlas-download-dialog", never, {}, {}, never, never, true, never>;
}

interface Extend extends ArlasStorageObject {
    geometry: any;
    private: boolean;
}

declare class ExtendLocalDatabase extends ArlasLocalDatabase<Extend> {
    constructor();
    init(extend: Extend): Extend;
    createExtend(name: string, geometry: any, visibility?: boolean, date?: Date, id?: string): Extend;
}

declare class ExtendPersistenceDatabase extends ArlasPersistenceDatabase<Extend> {
    persistenceService: PersistenceService;
    constructor(persistenceService: PersistenceService);
    init(extend: Extend): Extend;
    createExtend(name: string, geometry: any, visibility?: boolean, date?: Date, id?: string): Extend;
}

declare class ArlasExtendService {
    private arlasStartupService;
    private authentService;
    private persistenceService;
    dataBase: ExtendLocalDatabase | ExtendPersistenceDatabase;
    extendMap: Map<string, Extend>;
    constructor(arlasStartupService: ArlasStartupService, authentService: AuthentificationService, persistenceService: PersistenceService);
    init(extend: Extend): Extend;
    /**
   * List all bookmark for the user to update dataBase
   */
    listExtends(size: number, pageNumber: number): Observable<void>;
    setPage(size: number, pageNumber: number): void;
    addExtend(name: string, geometry: any): Observable<void>;
    removeExtend(id: string): Observable<void>;
    getExtendById(id: string): Extend;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasExtendService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasExtendService>;
}

declare class ExtendComponent {
    private extendService;
    extends: ArlasDataSource | Extend[];
    columnsToDisplay: string[];
    itemsCheck: Array<string>;
    resultsLength: number;
    pageSize: number;
    pageNumber: number;
    isPersistenceActive: boolean;
    actions: Subject<{
        action: string;
        id: string;
        geometry?: any;
    }>;
    constructor(extendService: ArlasExtendService);
    getExtendsList(): void;
    pageChange(pageEvent: PageEvent): void;
    selectExtend(event: {
        checked: boolean;
    }, id: string): void;
    viewExtend(id: string): void;
    removeExtend(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtendComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExtendComponent, "arlas-extend", never, {}, { "actions": "actions"; }, never, never, true, never>;
}

declare class FilterShortcutChipComponent {
    label: string;
    hide: boolean;
    shortenValues: boolean;
    clearEmitter: EventEmitter<string>;
    clear(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterShortcutChipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterShortcutChipComponent, "arlas-filter-shortcut-chip", never, { "label": { "alias": "label"; "required": false; }; "hide": { "alias": "hide"; "required": false; }; "shortenValues": { "alias": "shortenValues"; "required": false; }; }, { "clearEmitter": "clearEmitter"; }, never, never, true, never>;
}

declare class FilterShortcutComponent implements OnInit {
    private collaborativeSearchService;
    cdr: ChangeDetectorRef;
    /**
     * @Input : Angular
     * @description Configuration of the shortcut to display
    */
    shortcut: FilterShortcutConfiguration;
    /**
     * @Input : Angular
     * @description Width of the shortcut when opened
     */
    shortcutWidth: number;
    /**
     * @Input : Angular
     * @description Height of the chart contained in the shortcut
     */
    chartHeight: number;
    /**
     * @Input : Angular
     * @description Whether to display the value of the first filter.
     * If false, it will allow the user to only see the values by clicking the chip.
     */
    displayFilterFirstValue: boolean;
    /**
     * @Input : Angular
     * @description Whether the shortcut is opened and displays its widget
     */
    isOpen: boolean;
    /**
     * @Input : Angular
     * @description Spinner options when data is loading
     */
    spinnerOptions: SpinnerOptions;
    /**
     * @Output : Angular
     * @description Event emitted when the shortcut is opened or closed
     */
    isOpenChange: EventEmitter<boolean>;
    inputs: any;
    histogramUnit: string;
    histogramDatatype: string;
    constructor(collaborativeSearchService: ArlasCollaborativesearchService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    toggle(): void;
    private activateContributor;
    private triggerContributorCollaboration;
    private setHistogramInput;
    private setPowerbarsInput;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterShortcutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterShortcutComponent, "arlas-filter-shortcut", never, { "shortcut": { "alias": "shortcut"; "required": false; }; "shortcutWidth": { "alias": "shortcutWidth"; "required": false; }; "chartHeight": { "alias": "chartHeight"; "required": false; }; "displayFilterFirstValue": { "alias": "displayFilterFirstValue"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "spinnerOptions": { "alias": "spinnerOptions"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, never, never, true, never>;
}

declare class ShortcutFiltersHandlerComponent implements OnInit, OnDestroy {
    private collaborativeSearchService;
    private translate;
    /**
     * @Input : Angular
     * @description The contributor Id of the shortcut
     */
    contributorId: string;
    /**
     * @Input : Angular
     * @description The type of widget represented by the shortcut. can be 'powerbars' or 'histogram'.
     */
    widgetType: string;
    /**
     * @Input : Angular
     * @description Whether to display the value of the first filter. It will allow the user to only see the values by clicking the +X chip.
     */
    displayFilterFirstValue: boolean;
    /**
     * @Input : Angular
     * @description The unit of the histogram values
     */
    histogramUnit: string;
    /**
     * @Input : Angular
     * @description The type of data of the histogram. It can have the same values as a non-shortcut histogram.
     */
    histogramDatatype: string;
    /**
     * @Input : Angular
     * @description The format to use for the date ticks of the shortcut's histogram
     */
    ticksDateFormat: string;
    histogramParams: HistogramParams;
    showMore: boolean;
    moreClicked: boolean;
    labels: string[];
    rawLabels: string[];
    firstLabel: string | undefined;
    private _onDestroy$;
    constructor(collaborativeSearchService: ArlasCollaborativesearchService, translate: TranslateService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    showFilters(clickEvent: Event): void;
    clearFilter(label: string, idx: number): void;
    private checkCollaboration;
    private setLabels;
    private setHistogramParams;
    private histogramSelectionToLabel;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShortcutFiltersHandlerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShortcutFiltersHandlerComponent, "arlas-shortcut-filters-handler", never, { "contributorId": { "alias": "contributorId"; "required": false; }; "widgetType": { "alias": "widgetType"; "required": false; }; "displayFilterFirstValue": { "alias": "displayFilterFirstValue"; "required": false; }; "histogramUnit": { "alias": "histogramUnit"; "required": false; }; "histogramDatatype": { "alias": "histogramDatatype"; "required": false; }; "ticksDateFormat": { "alias": "ticksDateFormat"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GetContributorLabelPipe implements PipeTransform {
    transform(value: string, registry?: Map<string, Contributor>): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetContributorLabelPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetContributorLabelPipe, "getContributorLabel", true>;
}
declare class GetColorFilterPipe implements PipeTransform {
    transform(value: string, type: string, collaborationsMap: Map<string, Collaboration>): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetColorFilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetColorFilterPipe, "getColorFilter", true>;
}
declare class GetGlobalColorFilterPipe implements PipeTransform {
    transform(value: string, type: string, color: any, backgroundColor: any, collaborationsMap: Map<string, Collaboration>): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetGlobalColorFilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetGlobalColorFilterPipe, "getGlobalColorFilter", true>;
}
declare class GetCollaborationIconPipe implements PipeTransform {
    transform(value: string, contributorsIcons: Map<string, string>): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetCollaborationIconPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetCollaborationIconPipe, "getCollaborationIcon", true>;
}
declare class FiltersComponent implements OnInit, OnChanges {
    private collaborativeSearchService;
    private arlasStartupService;
    private configService;
    private arlasColorService;
    private cdr;
    private collectionService;
    /**
     * @Input : Angular
     * @description Background color of the filters chips
     */
    backgroundColorFilter: string;
    /**
      * @Input : Angular
      * @description Color of the filters icon
      */
    colorFilter: string;
    /**
     * @Input : Angular
     * @description Contributors identifier array which will be ignored from the filter summary
     */
    ignoredContributors: string[];
    /**
     * @Input : Angular
     * @description Map of collectionName, collection params. This input allows us to verify if the collection has a centroid path and
     * therefore propose or not the 'Zoom to Data' button
     */
    collectionToDescription: Map<string, CollectionReferenceParameters>;
    /**
     * @Input : Angular
     * @description Specifies which space in pixels is available to display the collection counts,
     * in order to hide the one that would overflow. If not set, this behavior is not put in place.
     */
    availableSpace: number;
    /**
     * @Input : Angular
     * @description Spacing used between collection count elements.
     * Used to compute how much space is available for the counts.
     */
    spacing: number;
    /**
     * @Input : Angular
     * @description Whether the zoom to data icon is displayed or not
     */
    showZoomToData: boolean;
    /**
     * @Input : Angular
     * @description Type of zoom to data
     */
    zoomToStrategy: ZoomToDataStrategy;
    /**
     * @Output : Angular
     * @description This output emit contributor id  on click on filter chip
     */
    clickOnFilter: Subject<string>;
    /**
     * @Output : Angular
     * @description This output emits the order of zooming on the extent of the given collection name
     */
    zoomEvent: Subject<string>;
    collaborations: Set<string>;
    contributors: Map<string, Contributor>;
    contributorsIcons: Map<string, string>;
    collaborationByCollection: Array<{
        collection: string;
        collaborationId: string;
    }>;
    countAll: CollectionCount[];
    extraCountAll: CollectionCount[];
    readonly NUMBER_FORMAT_CHAR = "NUMBER_FORMAT_CHAR";
    collaborationsMap: Map<string, Collaboration>;
    isExtraOpen: boolean;
    ZoomToDataStrategy: typeof ZoomToDataStrategy;
    /**
     * @description Whether to exceptionally display the extra collections for space computations
     */
    showExtraCollections: boolean;
    private _onDestroy$;
    constructor(collaborativeSearchService: ArlasCollaborativesearchService, arlasStartupService: ArlasStartupService, configService: ArlasConfigService, arlasColorService: ArlasColorService, cdr: ChangeDetectorRef, collectionService: ArlasCollectionService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    removeCollaboration(contributorId: string): void;
    changeCollaborationState(contributorId: any): void;
    removeAllFilters(): void;
    getAllContributorsIcons(): any;
    zoomToData(collection: string): void;
    toggleExtraCounts(): void;
    private retrieveCurrentCollaborations;
    private subscribeToFutureCollaborations;
    /**
     * Based on the space available, decide which collection count go in a 'See more' section. If no 'availableSpace' is set, nothing is done.
     */
    private hideExtraCollections;
    static ɵfac: i0.ɵɵFactoryDeclaration<FiltersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FiltersComponent, "arlas-filter", never, { "backgroundColorFilter": { "alias": "backgroundColorFilter"; "required": false; }; "colorFilter": { "alias": "colorFilter"; "required": false; }; "ignoredContributors": { "alias": "ignoredContributors"; "required": false; }; "collectionToDescription": { "alias": "collectionToDescription"; "required": false; }; "availableSpace": { "alias": "availableSpace"; "required": false; }; "spacing": { "alias": "spacing"; "required": false; }; "showZoomToData": { "alias": "showZoomToData"; "required": false; }; "zoomToStrategy": { "alias": "zoomToStrategy"; "required": false; }; }, { "clickOnFilter": "clickOnFilter"; "zoomEvent": "zoomEvent"; }, never, never, true, never>;
}

declare class ForgotComponent implements OnInit {
    private formBuilder;
    private iamService;
    forgotForm: FormGroup;
    validated: boolean;
    displayForm: boolean;
    constructor(formBuilder: FormBuilder, iamService: ArlasIamService);
    ngOnInit(): void;
    onSubmit(formDirective: FormGroupDirective): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForgotComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ForgotComponent, "arlas-tool-forgot", never, {}, {}, never, never, true, never>;
}

declare class HistogramTooltipOverlayComponent {
    overlayRef: ArlasOverlayRef;
    tooltip: HistogramTooltipExtended;
    interval: {
        start: Date | number | string;
        end?: Date | number | string;
    };
    displayText: boolean;
    constructor(overlayRef: ArlasOverlayRef, tooltip: HistogramTooltipExtended);
    calculateDate(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HistogramTooltipOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HistogramTooltipOverlayComponent, "arlas-histogram-tooltip-overlay", never, {}, {}, never, never, true, never>;
}

/**
 * This service is a notifier of events occuring on a widget, so that any other component can intercept it and consume it if needed
 * for its own behaviour.
 */
declare class WidgetNotifierService {
    private readonly hoveredBucketSource;
    hoveredBucket$: rxjs.Observable<XBucket>;
    /**
     * Notifies the event of hovering a histogram bucket.
     * @param b The hovered x-bucket on the histogram.
     */
    notifyBucketHover(b: XBucket): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetNotifierService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetNotifierService>;
}

/**
 * A Widget wraps a component from ARLAS-web-components and bind it to its contributor. The component has thus input data to plot.
 * Note: This component is binded to ARLAS-wui configuration
 */
declare class HistogramWidgetComponent implements OnInit, OnDestroy, AfterViewInit {
    protected arlasCollaborativesearchService: ArlasCollaborativesearchService;
    private readonly arlasConfigurationService;
    private readonly cdr;
    private readonly arlasOverlayService;
    protected widgetNotifier: WidgetNotifierService;
    showDetailedHistogram: boolean;
    detailedContributor: DetailedHistogramContributor;
    detailedTimelineIntervalSelection: SelectedOutputValues;
    showSpinner: boolean;
    private histogramIsFiltered;
    private applicationFirstLoad;
    private isDetailedIntervalBrushed;
    tooltipEvent: Subject<HistogramTooltip>;
    histogramOverlayRef: ArlasOverlayRef;
    protected readonly Position: typeof Position;
    protected readonly isHover: i0.WritableSignal<boolean>;
    contributor: HistogramContributor;
    componentInputs: any;
    /**
     * @Input : Angular
     * @description Whether we dispylay the export csv button
     */
    showExportCsv: boolean;
    /**
     * @Input : Angular
     * @description Position of the widget in the group
     */
    position: number;
    /**
     * @Input : Angular
     * @description Number of widgets in the group to whom this widget belongs
     */
    groupLength: number;
    /**
     * @Input : Angular
     * @description Spinner options
     */
    spinnerOptions: SpinnerOptions;
    /**
     * @Input : Angular
     * @description Whether to display a detailed histogram
     */
    noDetail: boolean;
    exportCsvEvent: Subject<{
        contributor: HistogramContributor;
        type: string;
        firstLevel: boolean;
    }>;
    /**
     * @Output : Angular
     * @description Emits an output that comes from the component (ARLAS-web-components). The emitted output has information about
     * the `origin` which is the contributor id of the component; `event` the name of the event; and eventually `data` which contains
     * the emitted data from the component.
     */
    outEvents: Subject<{
        origin: string;
        event: string;
        data?: any;
    }>;
    currentInterval: EventEmitter<string>;
    histogramComponent: HistogramComponent;
    detailedHistogramComponent: HistogramComponent;
    private readonly _onDestroy$;
    constructor(arlasCollaborativesearchService: ArlasCollaborativesearchService, arlasConfigurationService: ArlasConfigService, cdr: ChangeDetectorRef, arlasOverlayService: ArlasOverlayService, widgetNotifier: WidgetNotifierService);
    initDetailedContributor(): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    exportCsv(contributor: HistogramContributor): void;
    /**
     * Recalculates the new data of detailed histogram and resets its own current selection.
     * @param selections List containing only the current selection of detailed histogram
     */
    onDetailedIntervalBrushed(selections: SelectedOutputValues[]): void;
    /** When the main histogram selection is brushed
     * Hide the detailed histogram if the selection range is greater than 20% of the histogram range
     */
    onMainIntervalBrushed(event: any): void;
    /** reposition interval of the main histogram after the detail histogram finishes plotting */
    afterDetailedDataPlotted(e: string): void;
    showHistogramTooltip(tooltip: HistogramTooltip, e: HTMLDivElement, xOffset: number, yOffset: number): void;
    hideHistogramTooltip(): void;
    emitTooltip(tooltip: HistogramTooltip, e: HTMLDivElement, detailed: boolean): void;
    private resizeMainHistogram;
    /** show detailed histogram if selection range is less than 20% of the main histogram range */
    private showDetailedHistogramOnCollaborationEnd;
    /**
     * Based on the extent of the selection of the histogram, checks whether the detailed histogram should be displayed.
     * If so, resizes the histograms and fetches data if no data is present for the detailed histogram.
     * Otherwise, hides the detailed histogram, and resizes the main one.
     */
    private checkDisplayDetailedHistogram;
    private hideDetailedHistogram;
    static ɵfac: i0.ɵɵFactoryDeclaration<HistogramWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HistogramWidgetComponent, "arlas-tool-histogram-widget", never, { "contributor": { "alias": "contributor"; "required": false; }; "componentInputs": { "alias": "componentInputs"; "required": false; }; "showExportCsv": { "alias": "showExportCsv"; "required": false; }; "position": { "alias": "position"; "required": false; }; "groupLength": { "alias": "groupLength"; "required": false; }; "spinnerOptions": { "alias": "spinnerOptions"; "required": false; }; "noDetail": { "alias": "noDetail"; "required": false; }; }, { "exportCsvEvent": "exportCsvEvent"; "outEvents": "outEvents"; "currentInterval": "currentInterval"; }, never, never, true, never>;
}

/**
 * This component changes the `lg` parameter of ARLAS-wui url.
 */
declare class LanguageSwitcherComponent implements OnInit {
    /**
     * @Input : Angular
     * @description List of available languages for translation
     */
    availablesLanguages: string[];
    currentLanguage: string;
    constructor();
    ngOnInit(): void;
    /**
     * Sets the given language in `lg` parameter of ARLAS-wui url
     * @param lang Language name
     */
    setLanguage(lang: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageSwitcherComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LanguageSwitcherComponent, "arlas-language-switcher", never, { "availablesLanguages": { "alias": "availablesLanguages"; "required": false; }; "currentLanguage": { "alias": "currentLanguage"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LoginComponent implements OnInit {
    private formBuilder;
    private iamService;
    private settingsService;
    private errorService;
    private router;
    showPassword: boolean;
    loginForm: FormGroup;
    isLoading: boolean;
    showPage: boolean;
    displayNoAccount: boolean;
    constructor(formBuilder: FormBuilder, iamService: ArlasIamService, settingsService: ArlasSettingsService, errorService: ErrorService, router: Router);
    ngOnInit(): void;
    onSubmit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoginComponent, "arlas-login", never, {}, {}, never, never, true, never>;
}

interface PermissionDialogData {
    /** h:partition-filter:{collection:{f:[xxx], q:[yyy]}, ....} */
    partitionFilterHeader: string;
    mainCollection: string;
    oid: string;
}

declare class PermissionsCreatorDialogComponent {
    private readonly iamService;
    data: PermissionDialogData;
    private readonly settingsService;
    createPermissionForm: FormGroup<{
        description: FormControl<string>;
    }>;
    CREATE_TEXT: string;
    CLOSE_TEXT: "Close";
    descriptionInputDisabled: boolean;
    descriptionInputHidden: boolean;
    creationButtonDisabled: boolean;
    creationButtonHidden: boolean;
    creationStatus: 'successful' | 'errored';
    creationError: any;
    showErrorDetails: boolean;
    showSpinner: boolean;
    showAction: boolean;
    private readonly destroyRef;
    constructor(iamService: ArlasIamService, data: PermissionDialogData, settingsService: ArlasSettingsService);
    createPermission(): void;
    goToArlasIAMWui(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionsCreatorDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PermissionsCreatorDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

/** Creates an IAM permission based on the current filter of the main collection. */
declare class PermissionsCreatorComponent implements OnInit {
    private readonly collaborativeSearchService;
    private readonly iamService;
    private readonly createPermissionDialog;
    show: boolean;
    private readonly destroyRef;
    constructor(collaborativeSearchService: ArlasCollaborativesearchService, iamService: ArlasIamService, createPermissionDialog: MatDialog);
    ngOnInit(): void;
    createPermission(): void;
    /** Checks if the current user is owner of the current organisation.
     * If it is the case, we continue
     * Otherwise, the creation of the permission is stopped.
     */
    private hasCreationRight;
    private hasMainCollection;
    private getOrganisationId;
    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionsCreatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PermissionsCreatorComponent, "arlas-permissions-creator", never, {}, {}, never, never, true, never>;
}

declare const DEFAULT_SPINNER_OPTIONS: SpinnerOptions;
declare class ProgressSpinnerComponent implements OnInit {
    color: string;
    diameter: number;
    strokeWidth: number;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressSpinnerComponent, "arlas-tool-progress-spinner", never, { "color": { "alias": "color"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ReconnectDialogComponent {
    private readonly authentService;
    code: number;
    constructor(authentService: AuthentificationService, data: {
        code: number;
    });
    login(): void;
    logout(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReconnectDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReconnectDialogComponent, "arlas-tool-reconnect-dialog", never, {}, {}, never, never, true, never>;
}

declare class RegisterComponent implements OnInit {
    private formBuilder;
    private iamService;
    private settingsService;
    signUpForm: FormGroup;
    validated: boolean;
    displayForm: boolean;
    allowRegister: boolean;
    constructor(formBuilder: FormBuilder, iamService: ArlasIamService, settingsService: ArlasSettingsService);
    ngOnInit(): void;
    onSubmit(formDirective: FormGroupDirective): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RegisterComponent, "arlas-tool-register", never, {}, {}, never, never, true, never>;
}

declare class ResetComponent implements OnInit {
    private formBuilder;
    private iamService;
    private route;
    resetForm: FormGroup;
    validated: boolean;
    userId: any;
    token: any;
    constructor(formBuilder: FormBuilder, iamService: ArlasIamService, route: ActivatedRoute);
    ngOnInit(): void;
    onSubmit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResetComponent, "arlas-tool-reset", never, {}, {}, never, never, true, never>;
}

declare class SearchComponent implements OnInit, OnDestroy, OnChanges {
    private readonly arlasColorService;
    private readonly collaborativeService;
    private readonly translate;
    private readonly dialog;
    private readonly configService;
    private readonly snackbar;
    /**
     * @Input : Angular
     * @description Search contributor
     */
    searchContributors: SearchContributor[];
    /**
     * @Input : Angular
     * @description Top position of the search dialog in pixels
     */
    dialogPositionTop: number;
    /**
     * @Input : Angular
     * @description Left position of the search dialog in pixels
     */
    dialogPositionLeft: number;
    /**
     * @Input : Angular
     * @description Value of the search filter
     */
    searchValue: string;
    /**
   * @Input : Angular
   * @description Wether display or not the button to select the collections
   */
    displayCollectionSettings: boolean;
    /**
     * @description Placeholder value as retrieved from the search contributor
     */
    searchPlaceholder: string;
    retrieveSearchValueSubs: Subscription[];
    collectionsState: Map<string, boolean>;
    collections: {
        label: string;
        checked: boolean;
    }[];
    constructor(arlasColorService: ArlasColorService, collaborativeService: ArlasCollaborativesearchService, translate: TranslateService, dialog: MatDialog, configService: ArlasConfigService, snackbar: MatSnackBar);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    search(value: string): void;
    openDialog(): void;
    clearSearch(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchComponent, "arlas-search", never, { "searchContributors": { "alias": "searchContributors"; "required": true; }; "dialogPositionTop": { "alias": "dialogPositionTop"; "required": false; }; "dialogPositionLeft": { "alias": "dialogPositionLeft"; "required": false; }; "searchValue": { "alias": "searchValue"; "required": false; }; "displayCollectionSettings": { "alias": "displayCollectionSettings"; "required": false; }; }, {}, never, never, true, never>;
}
declare class SearchDialogComponent {
    private readonly arlasColorService;
    private readonly collaborativeService;
    private readonly dialogRef;
    data: {
        'searchContributors': SearchContributor[];
        'value': string;
        'collections': {
            label: string;
            checked: boolean;
            color: string;
        }[];
        'collectionsState': Map<string, boolean>;
        'displayCollectionSettings': boolean;
    };
    private readonly translate;
    /**
     * @description Search contributor
     */
    searchContributors: SearchContributor[];
    onLastBackSpace: Subject<boolean>;
    /**
     * @description Form for the search
     */
    searchCtrl: UntypedFormControl;
    /**
     * @description List of results displayed in the autocomplete
     */
    filteredSearch: Observable<any[]>;
    private readonly keyEvent;
    /**
     * @description Placeholder value as retrieved from the search contributor
     */
    searchPlaceholder: string;
    /**
     * @description Indicates whether a search request has been launched
     */
    searching: boolean;
    /**
   * @description Indicates whether display the collections settings button
   */
    displayCollectionSettings: boolean;
    collectionsState: Map<string, boolean>;
    collections: {
        label: string;
        checked: boolean;
        color: string;
    }[];
    updateAutoCompleteResult: Subject<void>;
    constructor(arlasColorService: ArlasColorService, collaborativeService: ArlasCollaborativesearchService, dialogRef: MatDialogRef<SearchDialogComponent>, data: {
        'searchContributors': SearchContributor[];
        'value': string;
        'collections': {
            label: string;
            checked: boolean;
            color: string;
        }[];
        'collectionsState': Map<string, boolean>;
        'displayCollectionSettings': boolean;
    }, translate: TranslateService);
    onKeyUp(event: KeyboardEvent): void;
    clickItemSearch(keyAsString: string): void;
    clearSearch(): void;
    onChangeCollection(event: any): void;
    private mergeAutoComplete;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare class ExcludeTypePipe implements PipeTransform {
    transform(allField: ArlasSearchField[], type: Set<string>): ArlasSearchField[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ExcludeTypePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ExcludeTypePipe, "excludeType", true>;
}

interface ShareLayerSourceConfig extends LayerSourceConfig {
    visualisationName: string;
}
/**
 * This component allows to build a _geoaggregate and/or _geosearch requests through a guiding stepper and download the request result
 * as a json file after clicking on a "Download" button
 * Note: This component is binded to ARLAS-wui configuration.
 */
declare class ShareComponent {
    private readonly dialog;
    openDialog(visibilityStatus?: Map<string, boolean>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShareComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShareComponent, "arlas-share", never, {}, {}, never, never, true, never>;
}
declare class ShareDialogComponent implements OnInit {
    data: Map<string, boolean>;
    private readonly formBuilder;
    private readonly collaborativeService;
    private readonly configService;
    private readonly dialogRef;
    private readonly spinner;
    private readonly translate;
    private readonly snackBar;
    sharableLayers: Array<ShareLayerSourceConfig>;
    private request;
    private maxForFeature;
    private maxForTopology;
    displayedUrl: string;
    precisions: (string | number)[][];
    geojsonTypeGroup: UntypedFormGroup;
    paramFormGroup: UntypedFormGroup;
    selectedFields: ArlasSearchField[];
    selectedOrderField: ArlasSearchField;
    sortDirection: 'asc' | 'desc';
    allFields: ArlasSearchField[];
    excludedType: Set<string>;
    excludedTypeString: string;
    shareConfig: any;
    layerCollectionMap: Map<string, string>;
    constructor(data: Map<string, boolean>, formBuilder: UntypedFormBuilder, collaborativeService: ArlasCollaborativesearchService, configService: ArlasConfigService, dialogRef: MatDialogRef<ShareDialogComponent>, spinner: NgxSpinnerService, translate: TranslateService, snackBar: MatSnackBar);
    isSelected(field: ArlasSearchField): boolean;
    ngOnInit(): void;
    /**
     * Switches between dialog steps
     * @param event The step index
     */
    changeStep(event: any): void;
    /**
     * @param geojsonType Param containing info about the chosen layer to export
     * @description Builds and executes a geosearch/geoaggregate request based on the chosen param of the form
     * and export the result as json file.
     * The exported file name is layerId-date-geojson.json
     */
    exportGeojson(geojsonType: any): void;
    exportShapefile(geojsonType: any): void;
    onSelectionChange(selectedOptionsList: SelectionModel<MatListOption>): void;
    private getFieldProperties;
    private saveJson;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShareDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShareDialogComponent, "arlas-share-dialog", never, {}, {}, never, never, true, never>;
}

interface TaggerResponse {
    id: string;
    endTime: number;
    failed: number;
    label: string;
    processingTimes: number;
    progress: number;
    propagated: number;
    startTime: number;
    updated: number;
}

/** Constants used to fill up our data base. */
declare class ArlasTagService implements OnDestroy {
    private getOptions;
    private collaborativeSearchService;
    private configService;
    private snackBar;
    private authService;
    private arlasSettingsService;
    taggableFields: Array<any>;
    isProcessing: boolean;
    status: Subject<Map<string, boolean>>;
    processStatus: Map<string, TaggerResponse>;
    private taggerApi;
    private statusApi;
    private options;
    private tagger;
    private onGoingSubscription;
    constructor(getOptions: any, collaborativeSearchService: ArlasCollaborativesearchService, configService: ArlasConfigService, snackBar: MatSnackBar, authService: AuthentificationService, arlasSettingsService: ArlasSettingsService);
    addTag(path: string, value: string | number, propagateField?: string, propagateUrl?: string, operationName?: string): void;
    removeTag(path: string, value?: string | number, propagateField?: string, propagateUrl?: string, operationName?: string): void;
    createPayload(label: string, path: string, value?: string | number): {
        search: any;
        tag?: any;
        label?: string;
        propagation?: any;
    };
    createPropagationPayload(propagateField?: string, propagateUrl?: string): {
        field: string;
        filter?: any;
    };
    postTagData(data: any, mode?: string): void;
    followStatus(response: any): void;
    list(): Observable<TagRefRequest[]>;
    unfollowStatus(responseId: string): void;
    setOptions(options: any): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasTagService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasTagService>;
}

/**
 * This component allows to tag your selected data (documents). The tag value is set on taggable fields.
 * The list of taggable fields is available on the dialog`.
 * Note : This component is binded to ARLAS-wui configuration.
 */
declare class TagComponent {
    dialog: MatDialog;
    tagService: ArlasTagService;
    /**
     * @Input : Angular
     * @description Name of the icon (Material icons)
     */
    icon: string;
    /**
     * @Output : Angular
     * @description A subject that emits the tag string
     */
    tagEvent: Subject<string>;
    dialogRef: MatDialogRef<TagDialogComponent>;
    dialogManagementRef: MatDialogRef<TagManagementDialogComponent>;
    hoveredDiv: string;
    constructor(dialog: MatDialog, tagService: ArlasTagService);
    openDialog(): void;
    openManagement(): void;
    removeProgress(itemId: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TagComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TagComponent, "arlas-tag", never, { "icon": { "alias": "icon"; "required": false; }; }, { "tagEvent": "tagEvent"; }, never, never, true, never>;
}
declare class TagDialogComponent implements OnInit {
    private formBuilder;
    tagService: ArlasTagService;
    private configService;
    private collaborativeSearchService;
    private dialog;
    private bookmarkService;
    dialogRef: MatDialogRef<TagDialogComponent>;
    /**
     * @Output : Angular
     * @description A subject that emits the tag string
     */
    tagEvent: Subject<string>;
    private server;
    tagFormGroup: UntypedFormGroup;
    taggableFields: Array<any>;
    keywordFields: Array<any>;
    bookmarks: Array<any>;
    existingTags: Array<string>;
    confirmDialogRef: MatDialogRef<ConfirmModalComponent>;
    constructor(formBuilder: UntypedFormBuilder, tagService: ArlasTagService, configService: ArlasConfigService, collaborativeSearchService: ArlasCollaborativesearchService, dialog: MatDialog, bookmarkService: ArlasBookmarkService, dialogRef: MatDialogRef<TagDialogComponent>);
    ngOnInit(): void;
    fieldChange(event: any): void;
    /**
     * Adds a tag on a taggable field.
     * @param path Taggable field path
     * @param value Value of the tag
     */
    addTag(): void;
    /**
     * Removes a tag from a taggable field. If the tag value is not specified, all the tags of this field are removed
     * @param path Taggable field path
     * @param value Value of the tag
     */
    removeTag(): void;
    propagationChange(propagate: boolean): void;
    private getFieldProperties;
    static ɵfac: i0.ɵɵFactoryDeclaration<TagDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TagDialogComponent, "arlas-tag-dialog", never, {}, { "tagEvent": "tagEvent"; }, never, never, true, never>;
}
declare class TagManagementDialogComponent {
    private tagService;
    private elem;
    private renderer;
    dialogRef: MatDialogRef<TagManagementDialogComponent>;
    tagsRef: TagRefRequest[];
    columnsToDisplay: string[];
    isLoading: boolean;
    selectedsTag: TagRefRequest[];
    constructor(tagService: ArlasTagService, elem: ElementRef, renderer: Renderer2, dialogRef: MatDialogRef<TagManagementDialogComponent>);
    selectTag(event: MatCheckboxChange, index: number, tag: TagRefRequest): void;
    replay(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TagManagementDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TagManagementDialogComponent, "arlas-management-tag-dialog", never, {}, {}, never, never, true, never>;
}

declare class ArlasTranslateIntl extends OwlDateTimeIntl {
    private readonly translateService;
    /** A label for the up second button (used by screen readers).  */
    upSecondLabel: any;
    /** A label for the down second button (used by screen readers).  */
    downSecondLabel: any;
    /** A label for the up minute button (used by screen readers).  */
    upMinuteLabel: any;
    /** A label for the down minute button (used by screen readers).  */
    downMinuteLabel: any;
    /** A label for the up hour button (used by screen readers).  */
    upHourLabel: any;
    /** A label for the down hour button (used by screen readers).  */
    downHourLabel: any;
    /** A label for the previous month button (used by screen readers). */
    prevMonthLabel: any;
    /** A label for the next month button (used by screen readers). */
    nextMonthLabel: any;
    /** A label for the previous year button (used by screen readers). */
    prevYearLabel: any;
    /** A label for the next year button (used by screen readers). */
    nextYearLabel: any;
    /** A label for the previous multi-year button (used by screen readers). */
    prevMultiYearLabel: any;
    /** A label for the next multi-year button (used by screen readers). */
    nextMultiYearLabel: any;
    /** A label for the 'switch to month view' button (used by screen readers). */
    switchToMonthViewLabel: any;
    /** A label for the 'switch to year view' button (used by screen readers). */
    switchToMultiYearViewLabel: any;
    /** A label for the cancel button */
    cancelBtnLabel: any;
    /** A label for the set button */
    setBtnLabel: any;
    /** A label for the range 'from' in picker info */
    rangeFromLabel: any;
    /** A label for the range 'to' in picker info */
    rangeToLabel: any;
    /** A label for the hour12 button (AM) */
    hour12AMLabel: any;
    /** A label for the hour12 button (PM) */
    hour12PMLabel: any;
}

/**
 * The component allows to set start/end values of a temporal selection on the timeline
 */
declare class DatePickerComponent implements OnInit, OnChanges {
    private arlasStartupService;
    translate: TranslateService;
    /**
     * @Input : Angular
     * @description Start value of the date picker. It must be date or a timestamp.
     */
    startSelectedDate: Date | number;
    /**
     * @Input : Angular
     * @description End value of the date picker. It must be date or a timestamp.
     */
    endSelectedDate: Date | number;
    /**
     * @Input : Angular
     * @description In this object, all the necessary inputs of HistogramComponent (ARLAS-web-components)
     * must be set as well as the identifier of the contributor that fetches timeline data. The `HistogramContributor`
     * should be declared before in the `contributorRegistry` of `ArlasStartupService`.
     */
    timelineComponent: any;
    timelineContributor: HistogramContributor;
    startSelectedMoment: _moment.Moment;
    endSelectedMoment: _moment.Moment;
    constructor(arlasStartupService: ArlasStartupService, translate: TranslateService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Applies a temporal filter on the timeline when a date is selected on the date picker
     */
    setDate(): void;
    convertDateToMoment(date: Date | number): any;
    /** Owl-datetime-picker produces a moment that is based on the local.
     * Offsets the time by the UTC offset to receive a correct UTC time when updating the contributor. */
    fixUtc(date: _moment.Moment): _moment.Moment;
    /**
     * Adds mat button class to define the material theme variables to uniformize the format of the buttons
     */
    addButtonClass(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerComponent, "arlas-tool-date-picker", never, { "startSelectedDate": { "alias": "startSelectedDate"; "required": false; }; "endSelectedDate": { "alias": "endSelectedDate"; "required": false; }; "timelineComponent": { "alias": "timelineComponent"; "required": false; }; }, {}, never, never, true, never>;
}

declare const DEFAULT_OWL_DATE_TIME_FORMATS_VALUE: {
    parseInput: string;
    fullPickerInput: string;
    datePickerInput: string;
    timePickerInput: string;
    monthYearLabel: string;
    dateA11yLabel: string;
    monthYearA11yLabel: string;
};
declare const ARLAS_DATE_TIME_FORMATS: InjectionToken<OwlDateTimeFormats>;
declare const ARLAS_OWL_MOMENT_ADAPTER_OPTIONS_OVERRIDE: InjectionToken<Partial<OwlMomentDateTimeAdapterOptions>>;

/**
 * This component contains shortcut labels that allow to apply predefined temporal filters on a timeline
 * (Last year, Last month, Today, etc ...).
 * It also displays the start and end values of the current selection on the timeline. And if enabled, a datepicker is allowed on those
 * start and end values.
 * This component is used internally in `TimelineComponent`
 */
declare class TimelineShortcutComponent implements OnInit {
    private arlasCollaborativesearchService;
    private arlasStartupService;
    translate: TranslateService;
    /**
    * @Input : Angular
    * @description In this object, all the necessary inputs of HistogramComponent (ARLAS-web-components)
    * must be set as well as the identifier of the contributor that fetches timeline data. The `HistogramContributor`
    * should be declared before in the `contributorRegistry` of `ArlasStartupService`
    */
    timelineComponent: any;
    /**
     * @Input : Angular
     * @description Optional input. Sets the format of start/end date values of the timeline.
     */
    dateFormat: string;
    /**
     * @Input : Angular
     * @description Whether the date picker is enabled
     */
    activeDatePicker: boolean;
    /**
     * @Input : Angular
     * @description Whether to display the timelines' histogram
     */
    isDisplayHistogram: boolean;
    /**
     * @Output : Angular
     * @description Emits when the value of isDisplayHistogram changes
     */
    isDisplayHistogramChange: EventEmitter<any>;
    /**
     * @Output : Angular
     * @description Emits when the timeline collaboration is removed
     */
    removeCollaboration: EventEmitter<void>;
    timelineContributor: HistogramContributor;
    timeShortcuts: Array<StringifiedTimeShortcut>;
    timeShortcutsMap: Map<string, Array<StringifiedTimeShortcut>>;
    showRemoveIcon: boolean;
    showShortcuts: boolean;
    HIDE_SHOW: string;
    isShortcutSelected: boolean;
    timeZone: string;
    constructor(arlasCollaborativesearchService: ArlasCollaborativesearchService, arlasStartupService: ArlasStartupService, translate: TranslateService);
    ngOnInit(): void;
    /**
     * Applies a temporal filter on timeline according to the chosen shortcut.
     * @param shortCut
     */
    setShortcut(shortCut: StringifiedTimeShortcut): void;
    /**
     * Shows/hides the `div` containing the shortcuts list
     */
    showSortcuts(): void;
    /**
     * Removes all temporal filters of the timeline
     */
    removeTimelineCollaboration(): void;
    toggleTimeline(): void;
    /**
     * Shows or hides the icon that allows to clear all temporal filter. This icon is displayed when there filters on the timeline.
     */
    private setRemoveIconVisibility;
    private groupBy;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineShortcutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineShortcutComponent, "arlas-timeline-shortcut", never, { "timelineComponent": { "alias": "timelineComponent"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "activeDatePicker": { "alias": "activeDatePicker"; "required": false; }; "isDisplayHistogram": { "alias": "isDisplayHistogram"; "required": false; }; }, { "isDisplayHistogramChange": "isDisplayHistogramChange"; "removeCollaboration": "removeCollaboration"; }, never, never, true, never>;
}

interface TimelineConfiguration {
    /**
     * @description Identifier of the contributor that serves data to the graphic component.
     */
    contributorId: string;
    /**
     * @description swimlane | histogram | donut | powerbars | resultlist
     */
    componentType?: string;
    /**
     * @description Set of inputs of a ARLAS-web-component.
     */
    input: any;
    /**
     * @description The date format of the start/end values.
     * Please refer to this [list of specifiers](https://github.com/d3/d3-time-format/blob/master/README.md#locale_format).
     */
    dateFormat?: any;
}
interface CollectionLegend {
    collection: string;
    display_name: string;
    color: string;
    active: boolean;
    main: boolean;
}

/**
 * This component contains
 * - A main timeline histogram that plots the count (or other metric) of data over time
 * - A detailed timeline histogram that plots the current selection on the main timeline (optional)
 * - A datepicker (optional)
 * - Shortcut labels that allow to apply predefined temporal filters (Last year, Last month, Today, etc ...)
 */
declare class TimelineComponent implements OnInit, OnDestroy {
    protected arlasCollaborativesearchService: ArlasCollaborativesearchService;
    private readonly arlasStartupService;
    private readonly arlasOverlayService;
    private readonly arlasColorService;
    protected widgetNotifier: WidgetNotifierService;
    private readonly collectionService;
    /**
     * @Input : Angular
     * @description In this object, all the necessary inputs of HistogramComponent (ARLAS-web-components)
     * must be set as well as the identifier of the contributor that fetches timeline data. The `HistogramContributor`
     * should be declared before in the `contributorRegistry` of `ArlasStartupService`
     */
    timelineComponent: TimelineConfiguration;
    /**
     * @Input : Angular
     * @description Optional input. If not set, the detailed timeline is deactivated.
     * Same as the precedent input, In this object, all the necessary inputs of HistogramComponent (ARLAS-web-components)
     * must be set as well as the identifier of the detailed contributor that fetches data within the current selection.
     * The `DetailedHistogramContributor` should be declared before in the `contributorRegistry` of `ArlasStartupService`
     */
    detailedTimelineComponent: TimelineConfiguration;
    /**
     * @Input : Angular
     * @description Whether the date picker is enabled
     */
    activeDatePicker: boolean;
    /**
     * @Input : Angular
     * @description Whether to display the timelines' histogram
     */
    isDisplayHistogram: boolean;
    /**
     * @Input : Angular
     * @description Whether or not the spinner is displayed when loading data
     */
    showSpinner: boolean;
    /**
     * @Input : Angular
     * @description Color palette of the spinner when loading data
     */
    colorSpinner: string;
    /**
     * @Input : Angular
     * @description Diameter of the spinner when loading data
     */
    diameterSpinner: number;
    /**
     * @Input : Angular
     * @description Stroke of the spinner when loading data
     */
    strokeWidthSpinner: number;
    /**
     * @Output : Angular
     * @description Emits when the value of isDisplayHistogram changes
     */
    isDisplayHistogramChange: EventEmitter<boolean>;
    timelineHistogramComponent: HistogramComponent;
    detailedTimelineHistogramComponent: HistogramComponent;
    showDetailedTimeline: boolean;
    detailedTimelineContributor: DetailedHistogramContributor;
    timelineContributor: HistogramContributor;
    detailedTimelineIntervalSelection: SelectedOutputValues;
    timelineData: any[];
    detailedTimelineData: any[];
    private isDetailedIntervalBrushed;
    private applicationFirstLoad;
    private timelineIsFiltered;
    timelineOverlayRef: ArlasOverlayRef;
    timelineLegend: CollectionLegend[];
    mainCollection: string;
    private readonly _onDestroy$;
    constructor(arlasCollaborativesearchService: ArlasCollaborativesearchService, arlasStartupService: ArlasStartupService, arlasOverlayService: ArlasOverlayService, arlasColorService: ArlasColorService, widgetNotifier: WidgetNotifierService, collectionService: ArlasCollectionService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Recalculates the new data of detailed timeline and resets its own current selection.
     * @param selections List containing only the current selection of detailed timeline
     */
    onDetailedIntervalBrushed(selections: SelectedOutputValues[]): void;
    /**
     * Runs when the selection is brushed on main timeline.
     * @param selections List containing only the current selection of detailed timeline
     */
    onTimelineIntervalBrushed(selections: SelectedOutputValues[]): void;
    /**
     * Runs when the detailed timeline is plotted.
     * Sets current selection of detailed timeline after it is plotted
     * Applies the current selection of detailed timeline on the main timeline
     */
    afterDetailedDataPlotted(e: any): void;
    showHistogramTooltip(tooltip: HistogramTooltip$1, e: HTMLDivElement, xOffset: number, yOffset: number, right: boolean): void;
    hideHistogramTooltip(): void;
    emitTooltip(tooltip: HistogramTooltip$1, e: HTMLDivElement): void;
    hideShowCollection(collectionLegend: CollectionLegend): void;
    /**
     * At the end of the collaboration of the Timeline Contributor, hides the timeline if the collaboration removed the filter.
     * If it added one, then asks the Detailed Timeline Contributor to update its data, to then check if the detailed timeline should display.
     */
    private showDetailedTimelineOnCollaborationEnd;
    /**
     * On the event sent by the timeline-tools, remove the timeline collaboration and hide the detailed timeline
     */
    protected onRemoveCollaboration(): void;
    toggleTimeline(): void;
    private hideShowDetailedTimeline;
    private resetHistogramsInputs;
    private hideDetailedTimeline;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineComponent, "arlas-timeline", never, { "timelineComponent": { "alias": "timelineComponent"; "required": false; }; "detailedTimelineComponent": { "alias": "detailedTimelineComponent"; "required": false; }; "activeDatePicker": { "alias": "activeDatePicker"; "required": false; }; "isDisplayHistogram": { "alias": "isDisplayHistogram"; "required": false; }; "showSpinner": { "alias": "showSpinner"; "required": false; }; "colorSpinner": { "alias": "colorSpinner"; "required": false; }; "diameterSpinner": { "alias": "diameterSpinner"; "required": false; }; "strokeWidthSpinner": { "alias": "strokeWidthSpinner"; "required": false; }; }, { "isDisplayHistogramChange": "isDisplayHistogramChange"; }, never, never, true, never>;
}

declare class AboutComponent {
    private readonly dialog;
    /**
     * @Input : Angular
     * @description Path to the markdown file containing the information to display
     */
    pathToMd: string;
    /**
     * @Input : Angular
     * @description Extra text data displayed before the markdown
     */
    extraTextData: string;
    dialogRef: MatDialogRef<AboutDialogComponent>;
    constructor(dialog: MatDialog);
    openDialog(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AboutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AboutComponent, "arlas-about", never, { "pathToMd": { "alias": "pathToMd"; "required": false; }; "extraTextData": { "alias": "extraTextData"; "required": false; }; }, {}, never, never, true, never>;
}
declare class AboutDialogComponent {
    dialogRef: MatDialogRef<AboutDialogComponent>;
    pathToMd: string;
    extraTextData: string;
    constructor(dialogRef: MatDialogRef<AboutDialogComponent>);
    static ɵfac: i0.ɵɵFactoryDeclaration<AboutDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AboutDialogComponent, "arlas-about-dialog", never, {}, {}, never, never, true, never>;
}

declare class LinkComponent implements OnInit {
    private readonly http;
    private readonly getOptions;
    link: LinkSettings;
    hidden$: EventEmitter<void>;
    onCheck$: EventEmitter<void>;
    onClick$: EventEmitter<void>;
    show: boolean;
    constructor(http: HttpClient, getOptions: any);
    ngOnInit(): void;
    navigateTo(url: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinkComponent, "arlas-link", never, { "link": { "alias": "link"; "required": false; }; }, { "hidden$": "hidden$"; "onCheck$": "onCheck$"; "onClick$": "onClick$"; }, never, never, true, never>;
}

declare class LinksComponent implements OnInit {
    private settingsService;
    clickInside($event: any): void;
    clickOutside(): void;
    close$: EventEmitter<void>;
    links: LinkSettings[];
    nbHidden: number;
    private nbChecked;
    showSpinner: boolean;
    constructor(settingsService: ArlasSettingsService);
    ngOnInit(): void;
    onLinkChecked(): void;
    onLinkHidden(): void;
    onLinkClicked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinksComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinksComponent, "arlas-links", never, {}, { "close$": "close$"; }, never, never, true, never>;
}

declare class TopMenuComponent implements OnInit {
    private readonly authentService;
    private readonly arlasIamService;
    private readonly translate;
    private readonly router;
    private readonly dialog;
    private readonly settingsService;
    private readonly fetchInterceptor;
    private readonly errorService;
    connected: boolean;
    isAuthentActivated: boolean;
    authentMode: 'openid' | 'iam';
    name: string;
    avatar: string;
    initials: string;
    aboutFile: string;
    extraAboutText: string;
    /**
     * @Input : Angular
     * @description Version of the WUI to display as info
     */
    version: string;
    /**
     * @Input : Angular
     * @description Name of the WUI in which the bar is used
     */
    wuiName: string;
    /**
     * @Input : Angular
     * @description Whether to display the "About" button
     */
    showAboutButton: boolean;
    showLinks: boolean;
    linksEnabled: boolean;
    private aboutcomponent;
    constructor(authentService: AuthentificationService, arlasIamService: ArlasIamService, translate: TranslateService, router: Router, dialog: MatDialog, settingsService: ArlasSettingsService, fetchInterceptor: FetchInterceptorService, errorService: ErrorService);
    ngOnInit(): void;
    connect(): void;
    changePassword(): void;
    displayAbout(): void;
    getUserInfos(): void;
    getInitials(name: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<TopMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TopMenuComponent, "arlas-top-menu", never, { "version": { "alias": "version"; "required": false; }; "wuiName": { "alias": "wuiName"; "required": false; }; "showAboutButton": { "alias": "showAboutButton"; "required": false; }; }, {}, never, ["[left-menu]", "[middle-menu]", "[right-menu]"], true, never>;
}

declare class UserInfosComponent implements OnInit {
    private authentService;
    private arlasIamService;
    private settingsService;
    private isAuthentActivated;
    authentMode: any;
    organisations: Array<string>;
    name: string;
    email: string;
    avatar: string;
    constructor(authentService: AuthentificationService, arlasIamService: ArlasIamService, settingsService: ArlasSettingsService);
    ngOnInit(): void;
    computeName: (n: any) => string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserInfosComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserInfosComponent, "arlas-user-infos", never, {}, {}, never, never, true, never>;
}

declare class VerifyComponent implements OnInit {
    private formBuilder;
    private iamService;
    private route;
    private settingsService;
    validateForm: FormGroup;
    validated: boolean;
    displayForm: boolean;
    userId: any;
    token: any;
    constructor(formBuilder: FormBuilder, iamService: ArlasIamService, route: ActivatedRoute, settingsService: ArlasSettingsService);
    ngOnInit(): void;
    onSubmit(formDirective: FormGroupDirective): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VerifyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VerifyComponent, "arlas-verify", never, {}, {}, never, never, true, never>;
}

declare class WidgetTooltipComponent {
    title: i0.InputSignal<string>;
    /** Whether to hide the box-shadow */
    isFlat: i0.InputSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetTooltipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetTooltipComponent, "arlas-widget-tooltip", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "isFlat": { "alias": "isFlat"; "required": false; "isSignal": true; }; }, {}, never, ["[xLabel]", "[xValue]", "[yLabel]", "[yValue]"], true, never>;
}

declare class ArlasExportCsvService {
    private collaborativesearchService;
    private configService;
    private settingsService;
    private translate;
    private arlasCollectionService;
    constructor(collaborativesearchService: ArlasCollaborativesearchService, configService: ArlasConfigService, settingsService: ArlasSettingsService, translate: TranslateService, arlasCollectionService: ArlasCollectionService);
    export(contributor: Contributor, stayAtFirstLevel: boolean, contributorType?: string): Observable<Blob>;
    compute(contributor: Contributor, contributorType?: string): Observable<AggregationResponse>;
    fetchHistogramData$(contributor: any): Observable<AggregationResponse>;
    /**
     * Fetches the resulist data by taking into account the current sort/geosort, columns and details of the resultlist.
     * The number of elements fetched is configured at the applicative level with `resultlist.export_size` in settings.yaml .
     * @param contributor Resultlist contributor
     * @param filter an optional filter to add to the collaboration filters if needed
     * @returns an Observable (rxjs) of arlas Hits.
     */
    fetchResultlistData$(contributor: ResultListContributor, filter?: Filter): Observable<Hits>;
    /**
     * Exports hits as CSV file.
     * The columns of the CSV are retrieved from `contributor.getAllFields()` method.
     * @param contributor Resultlist contributor
     * @param hits arlas Hits to be exported as CSV
     */
    exportResultlist(contributor: ResultListContributor, hits: Hits): void;
    private populateCSV;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasExportCsvService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasExportCsvService>;
}

/**
 * A Widget wraps a component from ARLAS-web-components and bind it to its contributor. The component has thus input data to plot.
 * Note: This component is binded to ARLAS-wui configuration
 */
declare class WidgetComponent implements OnInit {
    private readonly arlasStartupService;
    private readonly arlasCollaborativesearchService;
    private readonly arlasOverlayService;
    private readonly translate;
    private readonly arlasExportCsvService;
    chartType: typeof ChartType;
    contributorType: string;
    contributor: Contributor;
    swimSelected: any;
    swimlanes: any[];
    indeterminatedItems: Set<string>;
    highlightItems: Set<string>;
    showSwimlaneDropDown: boolean;
    graphParam: any;
    metricApproximate: boolean;
    private donutOverlayRef;
    private powerbarOverlayRef;
    private swimlaneOverlayRef;
    componentType: string;
    /**
     * @Input : Angular
     * @description Identifier of the contributor that serves data to the component
     */
    contributorId: string;
    /**
     * @Input : Angular
     * @description Inputs of one of the ARLAS-web-components
     */
    componentParams: any;
    /**
     * @Input : Angular
     * @description Whether we dispylay the export csv button
     */
    showExportCsv: boolean;
    /**
     * @Input : Angular
     * @description Spinner options
     */
    spinnerOptions: SpinnerOptions;
    /**
     * @Input : Angular
     * @description Position of the widget in the group
     */
    position: number;
    /**
     * @Input : Angular
     * @description Number of widgets in the group to whom this widget belongs
     */
    groupLength: number;
    /**
     * @Input : Angular
     * @description Whether the widget has to display a detailed version of itself. Currently only used for histograms
     */
    noDetail: boolean;
    /**
     * @Output : Angular
     * @description Emits an output that comes from the component (ARLAS-web-components). The emitted output has information about
     * the `origin` which is the contributor id of the component; `event` the name of the event; and eventually `data` which contains
     * the emitted data from the component.
     */
    outEvents: Subject<{
        origin: string;
        event: string;
        data?: any;
    }>;
    histogramComponent: HistogramComponent;
    private _onDestroy$;
    constructor(arlasStartupService: ArlasStartupService, arlasCollaborativesearchService: ArlasCollaborativesearchService, arlasOverlayService: ArlasOverlayService, translate: TranslateService, arlasExportCsvService: ArlasExportCsvService);
    showDonutTooltip(tooltip: ARLASDonutTooltip, e: HTMLDivElement): void;
    ngOnInit(): void;
    /**
     * @description Changes swimlane from the pool of swimlanes defined in SwimlaneContributor configuration.
     * @param swimlaneName The name of swimlane.
     */
    changeSwimlane(swimlaneName: any): void;
    /**
     * Emits the components output events.
     * @param source Contributor identifier
     * @param event Name of the event
     * @param data Emitted data
     */
    emitEvent(source: string, event: string, data: any): void;
    exportCsv(contributor: Contributor, stayAtFirstLevel: boolean, componentType: string, contributorType?: string): void;
    changePowerbarsOperator(op: 'Neq' | 'Eq'): void;
    changeMetricsTableOperator(op: 'Neq' | 'Eq'): void;
    showPowerbarTooltip(powerbar: PowerBar, e: HTMLDivElement): void;
    hidePowerbarTooltip(): void;
    showSwimlaneTooltip(tooltip: HistogramTooltip$1, e: HTMLDivElement): void;
    hideSwimlaneTooltip(): void;
    private getContirbutorType;
    private setComponentInput;
    private setFilterOperator;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetComponent, "arlas-tool-widget", never, { "componentType": { "alias": "componentType"; "required": false; }; "contributorId": { "alias": "contributorId"; "required": false; }; "componentParams": { "alias": "componentParams"; "required": false; }; "showExportCsv": { "alias": "showExportCsv"; "required": false; }; "spinnerOptions": { "alias": "spinnerOptions"; "required": false; }; "position": { "alias": "position"; "required": false; }; "groupLength": { "alias": "groupLength"; "required": false; }; "noDetail": { "alias": "noDetail"; "required": false; }; }, { "outEvents": "outEvents"; }, never, never, true, never>;
}

declare class GetTimeLabelPipe implements PipeTransform {
    transform(label: string, format: string, translate: TranslateService, useUtc: boolean): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetTimeLabelPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetTimeLabelPipe, "getTimeLabel", true>;
}

declare class AuthGuardIamService {
    private router;
    private arlasIamService;
    constructor(router: Router, arlasIamService: ArlasIamService);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable$1<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuardIamService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuardIamService>;
}

declare class ArlasConfigurationDescriptor {
    private collaborativesearchService;
    private configService;
    fetchOptions: {
        credentials: string;
    };
    constructor(collaborativesearchService: ArlasCollaborativesearchService, configService: ArlasConfigService);
    /**
     * @description Returns an Observable that contains the list of all collections
     * declared in ARLAS-server (that is configurated in env.js ( serverUrl )
     */
    getAllCollections(): Observable<Array<string>>;
    /**
     *
     * @param types
     * @description Returns an Observable that contains a list of the fields which types are in `types` param.
     * If no `types` are specified, then all the fields are returned.
     */
    getFields(types?: Array<string>): Observable<Array<{
        label: string;
        type: string;
    }>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasConfigurationDescriptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasConfigurationDescriptor>;
}

declare class ArlasMapSettings implements MapSettingsService {
    startUpService: ArlasStartupService;
    mapContributors: MapContributor[];
    constructor(startUpService: ArlasStartupService);
    getGeoQueries(): Map<string, [GeometrySelectModel[], OperationSelectModel[], string]>;
    private getFilterGeometries;
    private getOperations;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasMapSettings, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasMapSettings>;
}

/**
 * This service provides map methods on ARLAS data
 */
declare class ArlasMapService implements MapService {
    private readonly collaborativeSearchService;
    map: AbstractArlasMapGL;
    constructor(collaborativeSearchService: ArlasCollaborativesearchService);
    /**
     * @description zooms to the data extent. If 'map' parameter is not defined, then this function uses the 'map' attribute
     * @param geoPointField geo-point field used to get the bounding box of the data
     * @param map Map instance
     * @param paddingPercentage a percentage of the extent's height and width
     * that is added as a padding to bbox of data (between 0 and 1). It allows to have some context around data
     */
    zoomToData(collection: string, geoPointField: string, map: AbstractArlasMapGL, paddingPercentage?: number): void;
    /**
     *
     * @param map Map instance
     */
    setMap(map: AbstractArlasMapGL): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasMapService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasMapService>;
}

declare class ContributorBuilder {
    static buildContributor(contributorType: string, identifier: string, configService: ArlasConfigService, collaborativesearchService: ArlasCollaborativesearchService, settingsService: ArlasSettingsService, colorService?: ArlasColorService): any;
    /** Returns all the collections that are configured in each type of contributor. */
    static getCollections(contributorsConfig: any[]): Set<string>;
}

interface WalkthroughModuleConfig {
    loader?: Provider;
}
declare class ArlasWalkthroughModule {
    /**
     * Use this method in your root module to provide the ColorGeneratorLoader
     */
    static forRoot(config?: WalkthroughModuleConfig): ModuleWithProviders<ArlasWalkthroughModule>;
    static forChild(config?: WalkthroughModuleConfig): ModuleWithProviders<ArlasWalkthroughModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasWalkthroughModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ArlasWalkthroughModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ArlasWalkthroughModule>;
}

declare abstract class WalkthroughLoader {
    abstract loader(): Promise<any>;
}

declare class ArlasWalkthroughService {
    private readonly walkthrougLoader;
    private readonly translateService;
    hopscotch: any;
    tourData: any;
    isActivable: boolean;
    constructor(walkthrougLoader: WalkthroughLoader, translateService: TranslateService);
    load(): void;
    /**
     *
     * @param tour
     */
    setTour(tour: {
        id: string;
        steps: any[];
    }): void;
    /**
     * Actually starts the tour.
     * @param stepNum Optional : specifies what step to start at
     */
    startTour(stepNum?: number): void;
    /**
     * Skips to a given step in the tour
     * @param index
     */
    showStep(index: any): void;
    /**
     * Goes back one step in the tour
     */
    prevStep(): void;
    /**
     * Goes forward one step in the tour
     */
    nextStep(): void;
    /**
     * Ends the current tour.
     * If clearCookie is set to false, the tour state is preserved.
     * Otherwise, if clearCookie is set to true or is not provided, the tour state is cleared
     * @param clearCookie
     */
    endTour(clearCookie?: boolean): void;
    /**
     * Sets options for running the tour
     * @param options : see https://linkedin.github.io/hopscotch/#setting-tour-options
     */
    configure(options: any): void;
    /**
     * Returns the currently running tour
     */
    getCurrTour(): any;
    /**
     * Returns the current zero-based step number
     */
    getCurrStepNum(): any;
    /**
     * Adds a callback for one of the event types.
     * @param eventName Valid event types are: *start*, *end*, *next*, *prev*, *show*, *close*, *error*
     * @param callback
     */
    listen(eventName: string, callback: () => void): void;
    /**
     * Removes a callback for one of the event types
     */
    unlisten(eventName: string, callback: () => void): void;
    /**
     * Remove all callbacks for hopscotch events
     */
    removeCallbacks(): void;
    /**
     * Clear localStorage for the given tour
     * @param tour
     */
    resetTour(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasWalkthroughService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArlasWalkthroughService>;
}

declare class ArlasToolkitSharedModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasToolkitSharedModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ArlasToolkitSharedModule, never, [typeof i1.CollectionModule, typeof i1.ColorGeneratorModule, typeof ArlasWalkthroughModule, typeof i3.MarkdownModule, typeof AnalyticsBoardComponent, typeof AnalyticsMenuComponent, typeof AoiComponent, typeof BookmarkComponent, typeof BookmarkAddDialogComponent, typeof BookmarkMenuComponent, typeof CalendarTimelineToolComponent, typeof ConfirmModalComponent, typeof DatePickerComponent, typeof DownloadComponent, typeof DownloadDialogComponent, typeof ExtendComponent, typeof FiltersComponent, typeof LanguageSwitcherComponent, typeof LinkComponent, typeof PermissionsCreatorComponent, typeof PermissionsCreatorDialogComponent, typeof SearchComponent, typeof SearchDialogComponent, typeof ShareComponent, typeof ShareDialogComponent, typeof TimelineComponent, typeof TimelineShortcutComponent, typeof HistogramWidgetComponent, typeof ProgressSpinnerComponent, typeof UserInfosComponent, typeof ReconnectDialogComponent, typeof DeniedAccessDialogComponent, typeof CalendarTimelineTooltipOverlayComponent, typeof WidgetComponent, typeof FilterShortcutComponent, typeof FilterShortcutChipComponent, typeof ShortcutFiltersHandlerComponent, typeof TopMenuComponent, typeof AboutComponent, typeof AboutDialogComponent, typeof LinksComponent, typeof LinkComponent, typeof ActionModalComponent], [typeof AnalyticsBoardComponent, typeof AnalyticsMenuComponent, typeof AoiComponent, typeof BookmarkComponent, typeof BookmarkAddDialogComponent, typeof BookmarkMenuComponent, typeof CalendarTimelineToolComponent, typeof ConfirmModalComponent, typeof DatePickerComponent, typeof DownloadComponent, typeof DownloadDialogComponent, typeof ExtendComponent, typeof FiltersComponent, typeof LanguageSwitcherComponent, typeof LinkComponent, typeof PermissionsCreatorComponent, typeof PermissionsCreatorDialogComponent, typeof SearchComponent, typeof SearchDialogComponent, typeof ShareComponent, typeof ShareDialogComponent, typeof TimelineComponent, typeof TimelineShortcutComponent, typeof HistogramWidgetComponent, typeof ProgressSpinnerComponent, typeof UserInfosComponent, typeof ReconnectDialogComponent, typeof DeniedAccessDialogComponent, typeof CalendarTimelineTooltipOverlayComponent, typeof WidgetComponent, typeof FilterShortcutComponent, typeof FilterShortcutChipComponent, typeof ShortcutFiltersHandlerComponent, typeof TopMenuComponent, typeof AboutComponent, typeof AboutDialogComponent, typeof LinksComponent, typeof LinkComponent, typeof ActionModalComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ArlasToolkitSharedModule>;
}

declare class ArlasTaggerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasTaggerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ArlasTaggerModule, never, [typeof i1$1.BrowserAnimationsModule, typeof TagComponent, typeof TagDialogComponent, typeof TagManagementDialogComponent], [typeof TagComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ArlasTaggerModule>;
}

declare class ToolkitRoutingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolkitRoutingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ToolkitRoutingModule, never, [typeof i1$2.RouterModule], [typeof i1$2.RouterModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ToolkitRoutingModule>;
}

declare class ToolkitComponent implements AfterViewInit, OnInit, OnDestroy {
    private readonly configService;
    private readonly arlasStartupService;
    private readonly collaborativeService;
    private readonly activatedRoute;
    private readonly router;
    private readonly location;
    private readonly walkthroughService;
    private readonly errorService;
    analytics: Array<any>;
    languages: string[];
    analyticsOpen: boolean;
    target: string;
    constructor(configService: ArlasConfigService, arlasStartupService: ArlasStartupService, collaborativeService: ArlasCollaborativesearchService, activatedRoute: ActivatedRoute, router: Router, location: Location, walkthroughService: ArlasWalkthroughService, errorService: ErrorService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolkitComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolkitComponent, "arlas-tool-root", never, {}, {}, never, never, true, never>;
}

declare function settingsServiceFactory(settings: ArlasSettingsService): ArlasSettingsService;
declare function configServiceFactory(config: ArlasConfigService): ArlasConfigService;
declare function auhtentServiceFactory(service: AuthentificationService): AuthentificationService;
declare function iamServiceFactory(service: ArlasIamService): ArlasIamService;
declare function localDatePickerFactory(translate: TranslateService): string;
declare function configUpdaterFactory(x: any): any;
declare function getOptionsFactory(settingsService: ArlasSettingsService, arlasAuthService: AuthentificationService, arlasIamService: ArlasIamService): any;
declare const MY_CUSTOM_FORMATS: {
    parseInput: string;
    fullPickerInput: string;
    datePickerInput: string;
    timePickerInput: string;
    monthYearLabel: string;
    dateA11yLabel: string;
    monthYearA11yLabel: string;
};
declare class ArlasToolKitModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ArlasToolKitModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ArlasToolKitModule, never, [typeof ToolkitRoutingModule, typeof ArlasToolkitSharedModule, typeof i3$1.BrowserModule, typeof i1$1.BrowserAnimationsModule, typeof i5.OAuthModule, typeof ToolkitComponent], [typeof ToolkitComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ArlasToolKitModule>;
}

/**
 * This service allows to generate a color for a given term.
 * - colors associated to terms in `keysToColors` are considered first
 * - colors associated to terms from aggregations specified in `colorsAggregations` are considered second
 * - if no color is associated to a term, the color is generated with a determinist method.
 * - for generated colors, the saturation scale is tightened to the highest values with `colorsSaturationWeight`
 * If an external `externalKeysToColors` list is given to the service `getColor` method, it is used insted of `keysToColors`
 * If an external `externalColorsSaturationWeight` list is given to the service `getColor` method,
 * it is used insted of `colorsSaturationWeight`
 */
declare class ArlasColorGeneratorLoader extends ColorGeneratorLoader {
    private configService;
    private collaborativesearchService;
    keysToColors: Array<[string, string]>;
    colorsSaturationWeight: number;
    keysToColorsMap: Map<string, string>;
    colorAggregations: Array<[Aggregation, Aggregation]>;
    private changekeysToColors;
    changekeysToColors$: rxjs.Observable<void>;
    constructor(configService: ArlasConfigService, collaborativesearchService: ArlasCollaborativesearchService);
    getColor(key: string, externalKeysToColors?: Array<[string, string]>, externalColorsSaturationWeight?: number): string;
    getTextColor(color: string): string;
    /**
     * updates the color of the given keyword if the keyword exists already. Otherwise it adds the new keyword and the corresponding color
     * @param keyword
     * @param color
     */
    updateKeywordColor(keyword: string, color: string): void;
    /**
     * Set the keyToColors list. Updates the keysToColorsMap in order to be up to date with the list
     */
    setKeysToColors(keysToColors: Array<[string, string]>): void;
    private getHexColor;
    private setColorsFromAggregations;
}

declare const NO_ORGANISATION = "";

declare class BackendError extends ArlasError {
    private readonly hubUrl;
    service?: string;
    constructor(status: number, message: string, hubUrl: string, service?: string);
    executeAction(): void;
    private goToArlasHub;
}

/** Error sent when failing to access dashboards */
declare class DashboardError extends ArlasError {
    private readonly hubUrl;
    constructor(status: number, hubUrl: string);
    executeAction(): void;
    private goToArlasHub;
}

declare class JwtInterceptor implements HttpInterceptor {
    private readonly authenticationService;
    private readonly iamService;
    private readonly settingsService;
    constructor(authenticationService: AuthentificationService, iamService: ArlasIamService, settingsService: ArlasSettingsService);
    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<JwtInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<JwtInterceptor>;
}

declare class PaginatorI18n implements MatPaginatorIntl {
    private translate;
    changes: Subject<void>;
    itemsPerPageLabel: string;
    nextPageLabel: string;
    previousPageLabel: string;
    firstPageLabel: string;
    lastPageLabel: string;
    constructor(translate: TranslateService);
    initLabels(): void;
    getRangeLabel(page: number, pageSize: number, length: number): string;
}

export { ARLAS_DATE_TIME_FORMATS, ARLAS_ORG_FILTER, ARLAS_OWL_MOMENT_ADAPTER_OPTIONS_OVERRIDE, AboutComponent, AboutDialogComponent, ActionModalComponent, AdmonitionCardComponent, AiasDownloadComponent, AiasEnrichComponent, AiasProcess, AiasResultComponent, AnalyticsBoardComponent, AnalyticsMenuComponent, AnalyticsService, AoiComponent, AoiDatabase, ArlasAoiService, ArlasAuthentificationService, ArlasBookmarkService, ArlasCollaborativesearchService, ArlasCollectionService, ArlasColorGeneratorLoader, ArlasConfigService, ArlasConfigurationDescriptor, ArlasConfigurationUpdaterService, ArlasDataSource, ArlasError, ArlasExploreApi, ArlasExportCsvService, ArlasExtendService, ArlasIamApi, ArlasIamService, ArlasLocalDatabase, ArlasMapService, ArlasMapSettings, ArlasOverlayRef, ArlasOverlayService, ArlasPersistenceDatabase, ArlasSearchField, ArlasSettingsService, ArlasStartupService, ArlasStorageType, ArlasTagService, ArlasTaggerModule, ArlasToolKitModule, ArlasToolkitSharedModule, ArlasTranslateIntl, ArlasWalkthroughModule, ArlasWalkthroughService, AuthGuardIamService, AuthentificationService, AuthorisationError, BackendError, BookMarkType, BookmarkAddDialogComponent, BookmarkComponent, BookmarkDataSource, BookmarkLocalDatabase, BookmarkMenuComponent, BookmarkPersistenceDatabase, CONFIG_ID_QUERY_PARAM, CONFIG_UPDATER, CalendarTimelineToolComponent, CalendarTimelineTooltipOverlayComponent, ChangePasswordComponent, ConfigActionEnum, ConfigMenuComponent, ConfirmModalComponent, ContributorBuilder, DEFAULT_OWL_DATE_TIME_FORMATS_VALUE, DEFAULT_SPINNER_OPTIONS, DONUT_TOOLTIP_DATA, DOWNLOAD_PROCESS_NAME, DashboardError, DatePickerComponent, DeniedAccessDialogComponent, DonutTooltipOverlayComponent, DownloadComponent, DownloadDialogComponent, ENRICH_PROCESS_NAME, ErrorService, ExcludeTypePipe, ExtendComponent, ExtendLocalDatabase, ExtendPersistenceDatabase, FETCH_OPTIONS, FetchInterceptorService, FilterShortcutChipComponent, FilterShortcutComponent, FiltersComponent, ForgotComponent, GET_OPTIONS, GetCollaborationIconPipe, GetColorFilterPipe, GetContributorLabelPipe, GetGlobalColorFilterPipe, GetTimeLabelPipe, HISTOGRAM_TOOLTIP_DATA, HistogramTooltipOverlayComponent, HistogramWidgetComponent, JwtInterceptor, LanguageSwitcherComponent, LinkComponent, LinksComponent, LoginComponent, MY_CUSTOM_FORMATS, NOT_CONFIGURED, NO_ORGANISATION, PaginatorI18n, PermissionService, PermissionsCreatorComponent, PermissionsCreatorDialogComponent, PersistenceService, PowerbarTooltipOverlayComponent, ProcessService, ProcessStatus, ProgressSpinnerComponent, ReconnectDialogComponent, RegisterComponent, ResetComponent, SearchComponent, SearchDialogComponent, ShareComponent, ShareDialogComponent, ShortcutFiltersHandlerComponent, TagComponent, TagDialogComponent, TagManagementDialogComponent, TimelineComponent, TimelineShortcutComponent, ToolkitComponent, ToolkitRoutingModule, TopMenuComponent, UserInfosComponent, VerifyComponent, WalkthroughLoader, WidgetComponent, WidgetNotifierService, WidgetTooltipComponent, ZoomToDataStrategy, auhtentServiceFactory, configServiceFactory, configUpdaterFactory, getFieldProperties, getKeyForColor, getOptionsFactory, getParamValue, hashCode, iamServiceFactory, intToRGB, localDatePickerFactory, settingsServiceFactory, sortOnDate };
export type { ActionType, AiasDownloadDialogData, AiasProcessDialogData, AnalyticGroupConfiguration, AnalyticsTabs, Aoi, ArlasSettings, ArlasStorageObject, AuthentSetting, BookMark, CollectionCount, CollectionLegend, CollectionUnit, Config, ConfigAction, Error, Extend, ExtraConfig, FilterShortcutConfiguration, LinkSettings, MapService, PermissionSetting, PersistenceSetting, ProcessOutput, ShareLayerSourceConfig, SpinnerOptions, TaggerResponse, TimelineConfiguration, ToolTipConfig, WalkthroughModuleConfig, WidgetConfiguration };