import * as i114 from '@ngneat/transloco';
import { TranslocoConfig, HashMap, TranslocoService, TranslocoLoader, Translation } from '@ngneat/transloco';
import * as lottie_web from 'lottie-web';
import * as i0 from '@angular/core';
import { Type, OnInit, NgZone, ErrorHandler, OnDestroy, EventEmitter, PipeTransform, ElementRef, QueryList, TemplateRef, AfterViewInit, AfterContentInit, AfterContentChecked, DoCheck, ModuleWithProviders, InjectionToken } from '@angular/core';
import { HttpErrorResponse, HttpRequest, HttpHandler, HttpEvent, HttpClient, HttpParams, HttpHeaders, HttpInterceptor } from '@angular/common/http';
import * as rxjs from 'rxjs';
import { Observable, Subject, Subscription } from 'rxjs';
import * as i95 from 'lacuna-oauth2-oidc';
import { OAuthStorage, OAuthService } from 'lacuna-oauth2-oidc';
import { CookieService } from 'ngx-cookie-service';
import * as i112 from '@angular/material/snack-bar';
import { MatSnackBarRef, MatSnackBar } from '@angular/material/snack-bar';
import * as i102 from '@angular/material/dialog';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import { ApplicationInsights } from '@microsoft/applicationinsights-web';
import { Faro } from '@grafana/faro-web-sdk';
import * as i119 from '@angular/material/core';
import { ThemePalette } from '@angular/material/core';
import { DomSanitizer, SafeResourceUrl, SafeHtml, SafeStyle, SafeScript, SafeUrl } from '@angular/platform-browser';
import * as i94 from '@angular/forms';
import { FormControl, FormBuilder, UntypedFormGroup, UntypedFormBuilder, UntypedFormArray, AbstractControl, ControlValueAccessor, NgControl, FormGroup, NgForm, FormGroupDirective, ValidatorFn, ValidationErrors } from '@angular/forms';
import * as i120 from '@lacuna/material';
import { ObservableSearchService, PaginatedSearchService, PaginatedSearchParams, PaginatedSearchResult, SearchService, LacunaMatImageViewerConfig } from '@lacuna/material';
import * as i116 from '@angular/router';
import { ActivatedRoute, Router, Routes, CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
import { Platform } from '@angular/cdk/platform';
import * as momentJs from 'moment';
import * as i121 from 'ngx-lottie';
import { AnimationOptions } from 'ngx-lottie';
import * as i1 from '@angular/cdk/coercion';
import { BooleanInput } from '@angular/cdk/coercion';
import { FocusableOption } from '@angular/cdk/a11y';
import { MatFormFieldControl, MatFormField } from '@angular/material/form-field';
import * as i118 from '@angular/material/datepicker';
import { MatDatepicker } from '@angular/material/datepicker';
import * as i93 from '@angular/common';
import * as i96 from '@angular/material/menu';
import * as i97 from '@angular/material/icon';
import * as i98 from '@angular/material/input';
import * as i99 from '@angular/material/button';
import * as i100 from '@angular/material/toolbar';
import * as i101 from '@angular/material/list';
import * as i103 from '@angular/material/tooltip';
import * as i104 from '@angular/material/card';
import * as i105 from '@angular/material/progress-bar';
import * as i106 from '@angular/material/progress-spinner';
import * as i107 from '@angular/material/sidenav';
import * as i108 from '@angular/material/select';
import * as i109 from '@angular/material/expansion';
import * as i110 from '@angular/material/autocomplete';
import * as i111 from '@angular/material/checkbox';
import * as i113 from 'ng2-pdf-viewer';
import IntlMessageFormat from 'intl-messageformat';
import { Formats } from 'intl-messageformat/src/formatters';
import { Options } from 'intl-messageformat/src/core';
import * as i117 from 'ngx-mask';
import * as i122 from '@angular/material/table';
import * as i123 from '@angular/material/sort';

declare enum LogLevels {
    Trace = 0,
    Debug = 1,
    Information = 2,
    Warning = 3,
    Error = 4,
    Critical = 5
}
declare class Logger {
    private minLevel;
    constructor();
    logTrace(...args: any[]): void;
    logDebug(...args: any[]): void;
    logInformation(...args: any[]): void;
    logWarning(...args: any[]): void;
    logError(...args: any[]): void;
    logCritical(...args: any[]): void;
    private log;
    private writeLog;
    private stringifyArg;
    private getLevelLabel;
    private getLevelName;
    private parseLogLevel;
    private tryGetMinLevelFrom;
    static ɵfac: i0.ɵɵFactoryDeclaration<Logger, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Logger>;
}

interface SubscriptionModel {
    id: string;
    name: string;
    alias?: string;
    parentSubscriptionId?: string;
}
interface SubscriptionData {
    name: string;
    alias: string;
}
interface CheckSubscriptionNameAvailabilityResponse {
    available: boolean;
}

declare const enum ErrorCodes {
    Unknown = "Unknown",
    BadAlgorithm = "BadAlgorithm",
    SubscriptionNotFound = "SubscriptionNotFound",
    SubscriptionRequired = "SubscriptionRequired",
    ApplicationNotFound = "ApplicationNotFound",
    BadSubscription = "BadSubscription",
    NormalSubscriptionRequired = "NormalSubscriptionRequired",
    NotRegistered = "NotRegistered",
    AgentNotFound = "AgentNotFound",
    AgentIsNotUser = "AgentIsNotUser",
    InviteNotFound = "InviteNotFound",
    ApplicationKeyNotFound = "ApplicationKeyNotFound",
    ApplicationDeleted = "ApplicationDeleted",
    ApplicationNameExists = "ApplicationNameExists",
    UserNotFound = "UserNotFound",
    InvalidClaimCode = "InvalidClaimCode",
    SearchNotSupported = "SearchNotSupported",
    EmailDisabled = "EmailDisabled",
    HttpsRequired = "HttpsRequired",
    RoleMissing = "RoleMissing",
    UploadNotFound = "UploadNotFound",
    PublicKeyAuthenticationExpired = "PublicKeyAuthenticationExpired",
    NonceReused = "NonceReused",
    InvalidNonceSignature = "InvalidNonceSignature",
    PublicKeyAuthenticationSessionMissing = "PublicKeyAuthenticationSessionMissing",
    InvalidPublicKeyAuthenticationSession = "InvalidPublicKeyAuthenticationSession",
    ChildNamespaceNotFound = "ChildNamespaceNotFound",
    OidcDisabled = "OidcDisabled",
    RootPasswordHashNotFound = "RootPasswordHashNotFound",
    GrantIdError = "GrantIdError"
}
declare const enum Roles {
    Dummy = "Dummy"
}
declare const enum RootRoles {
    Dummy = "Dummy"
}
declare const enum Permissions {
    Read = "Read",
    Write = "Write",
    ManageAgents = "ManageAgents",
    HangfireAccess = "HangfireAccess",
    Lookup = "Lookup",
    ViewChildRoles = "ViewChildRoles",
    ContactWebhooks = "ContactWebhooks",
    EditUsers = "EditUsers",
    ViewAgentEvents = "ViewAgentEvents",
    ViewAgentActions = "ViewAgentActions",
    ViewSubscriptionEvents = "ViewSubscriptionEvents",
    ViewInvites = "ViewInvites",
    ViewUsers = "ViewUsers",
    ViewApplications = "ViewApplications"
}
declare const enum EntityTypes {
    Subscription = "Subscription",
    User = "User",
    Application = "Application",
    Invite = "Invite"
}
declare const enum AgentTypes {
    User = "User",
    Application = "Application"
}
declare const enum EventTypes {
    SubscriptionCreated = "SubscriptionCreated",
    SubscriptionUpdated = "SubscriptionUpdated",
    SubscriptionDeleted = "SubscriptionDeleted",
    ApplicationKeyCreated = "ApplicationKeyCreated",
    ApplicationKeyDeleted = "ApplicationKeyDeleted",
    ApplicationCreated = "ApplicationCreated",
    ApplicationDeleted = "ApplicationDeleted",
    SubscriptionAccessUpdated = "SubscriptionAccessUpdated",
    UserRegistered = "UserRegistered",
    InviteCreated = "InviteCreated",
    InviteUpdated = "InviteUpdated",
    InviteDeleted = "InviteDeleted",
    InviteFulfilled = "InviteFulfilled",
    UserLocked = "UserLocked",
    ApplicationLocked = "ApplicationLocked",
    UserUnlocked = "UserUnlocked",
    ApplicationUnlocked = "ApplicationUnlocked"
}
declare const enum NamedRoutes {
    Home = "Home",
    Private = "Private",
    Sub = "Sub",
    SysAdmin = "SysAdmin",
    AccessLocked = "AccessLocked",
    Subscriptions = "Subscriptions",
    SubscriptionCreate = "SubscriptionCreate",
    SubscriptionDetail = "SubscriptionDetail",
    SubscriptionEdit = "SubscriptionEdit",
    Users = "Users",
    UserDetail = "UserDetail",
    UserEvents = "UserEvents",
    UserActions = "UserActions",
    UserEdit = "UserEdit",
    UserAccessEdit = "UserAccessEdit",
    Invite = "Invite",
    InviteDetail = "InviteDetail",
    InviteEdit = "InviteEdit",
    Applications = "Applications",
    ApplicationCreate = "ApplicationCreate",
    ApplicationDetail = "ApplicationDetail",
    ApplicationEdit = "ApplicationEdit",
    ApplicationActions = "ApplicationActions",
    ApplicationEvents = "ApplicationEvents",
    ApplicationKeys = "ApplicationKeys",
    ApplicationKeyCreate = "ApplicationKeyCreate",
    Events = "Events",
    ServersList = "ServersList"
}
declare enum UserModes {
    Parent = "parent",
    App = "app"
}
declare enum ChildRedirectTypes {
    Invite = "invite",
    UserDetails = "user-detail",
    UserEditAccess = "user-edit-access"
}
declare enum GrammaticalGender {
    Feminine = "Feminine",
    Masculine = "Masculine"
}
declare enum RootLoginResult {
    Success = "Success",
    InvalidPassword = "InvalidPassword"
}
declare enum CaptchaProviders {
    Recaptcha = "Recaptcha",
    Turnstile = "Turnstile",
    HCaptcha = "HCaptcha"
}
declare enum UserDiscoveryPolicies {
    None = "None",
    RestrictSubscription = "RestrictSubscription"
}

interface SubscriptionAccessModel {
    subscriptionId: string;
    roles: Roles[];
    parentRoles?: string[];
}
interface SubscriptionAccess {
    subscription: SubscriptionModel;
    roles: Roles[];
    parentRoles?: string[];
}
interface AuthorizationData {
    roles: Roles[];
}
interface RootAuthorizationData {
    roles: RootRoles[];
    grantAppId?: string;
}

interface Profile {
    id: string;
    adminRoles: RootRoles[];
    permissionsOnRoot: Permissions[];
    subscriptions: SubscriptionAccess[];
    isLocked: boolean;
}

interface EventModel {
    id: number;
    subscriptionId: string;
    agentId?: string;
    date: Date;
    type: EventTypes;
    entityType: EntityTypes;
    entityId: string;
    details: string;
    remoteIPAddress?: string;
    remotePort?: number;
}

interface RequiredIdClaims {
    name: boolean;
    cpf: boolean;
    emailAddress: boolean;
    customClaims?: string[];
}
interface EntityNavigator {
    navigate(entityType: EntityTypes, id: string): void;
}
interface EventViewer {
    show(event: EventModel): Promise<void>;
}
/** Selection semantics of a spa-selectable-area: 'checkbox' for independent options, 'radio' for a single choice out of many. */
type SpaSelectableMode = 'checkbox' | 'radio';
interface LacunaSpaModuleParams {
    listOfRoles: string[];
    listOfRootRoles: string[];
    translocoConfig?: Partial<TranslocoConfig>;
    languageToLocalesMapping?: HashMap<string[]>;
    requiredIdClaims?: RequiredIdClaims;
    asyncInit?: boolean;
    entityNavigator?: Type<EntityNavigator>;
    eventViewer?: Type<EventViewer>;
    getEntityIcon?: GetEntityIconFunction;
    getEventTypeName?: GetEventTypeNameFunction;
    listOfUnassignableRoles?: string[];
    getRoleName?: GetRoleNameFunction;
    getBreadcrumbDisplayName?: GetBreadcrumbDisplayNameFunction;
    enableLanguageRoute?: boolean;
    oidcRedirectPath?: string;
    showReturnToHomeButton?: boolean;
    enableInvisibleCaptcha?: boolean;
}
interface GetEntityIconFunction {
    (entityType: EntityTypes): string | null;
}
interface GetEventTypeNameFunction {
    (eventType: EventTypes): string | null;
}
interface GetRoleNameFunction {
    (role: Roles | RootRoles): string | null;
}
interface GetBreadcrumbDisplayNameFunction {
    (namedRoute: NamedRoutes): string | null;
}
interface OnApiErrorFunction {
    (err: HttpErrorResponse, request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
}

declare class CookieStorageService extends OAuthStorage {
    private cookieService;
    constructor(cookieService: CookieService);
    getItem(key: string): string;
    removeItem(key: string, path?: string, domain?: string): void;
    setItem(key: string, data: string, expires?: number | Date, path?: string, domain?: string, secure?: boolean, sameSite?: "Lax" | "Strict"): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CookieStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CookieStorageService>;
}

declare class SpaApiHeadersService {
    apiHeaders: ApiHeaders;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaApiHeadersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SpaApiHeadersService>;
}
type ApiHeaders = {
    [name: string]: string | string[];
};

interface RootAuthenticationRequest {
    rootPassword: string;
}
interface RootAuthenticationResponse {
    result: RootLoginResult;
    rootToken: string;
    expiresOn: string;
    rootProfile: Profile;
}

declare class MessageComponent implements OnInit {
    data: any;
    ref: MatSnackBarRef<MessageComponent>;
    private logger;
    message: string;
    isClickable: boolean;
    icon: string;
    constructor(data: any, ref: MatSnackBarRef<MessageComponent>, logger: Logger);
    ngOnInit(): void;
    details(): void;
    dismiss(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MessageComponent, "spa-message", never, {}, {}, never, never, false, never>;
}

declare class MessageService {
    private snackBar;
    private dialog;
    errorMessages: string[];
    lastSnackBar: MatSnackBarRef<MessageComponent>;
    constructor(snackBar: MatSnackBar, dialog: MatDialog);
    showSuccess(message: string, args?: {
        duration?: number;
    }): MatSnackBarRef<MessageComponent>;
    showInfo(message: string, args?: {
        duration?: number;
    }): MatSnackBarRef<MessageComponent>;
    showWarning(message: string, args?: {
        duration?: number;
    }): MatSnackBarRef<MessageComponent>;
    showError(message: string, args?: {
        duration?: number;
    }): MatSnackBarRef<MessageComponent>;
    dismiss(): void;
    private showAllErrors;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
}

declare class UserProfile {
    id: string;
    name: string;
    emailAddress: string;
    cpf: string;
    customClaims: object;
    subscriptions: SubscriptionAccess[];
    adminRoles: RootRoles[];
    permissionsOnRoot: Permissions[];
    isLocked: boolean;
    constructor(id: string, name: string, emailAddress: string, cpf: string, customClaims: object, subscriptions: SubscriptionAccess[], adminRoles: RootRoles[], permissionsOnRoot: Permissions[], isLocked: boolean);
}
interface SubscriptionPermissionsModel extends SubscriptionAccess {
    sub: string;
    permissions: Permissions[];
}
declare class SpaControlService {
    private http;
    private oauthService;
    private spaApiHeadersService;
    private logger;
    private cookieStorage;
    private ngZone;
    private messageService;
    private transloco;
    private listOfRoles;
    private listOfRootRoles;
    private requiredIdClaims;
    private listOfUnassignableRoles;
    private oidcRedirectPath;
    _initialized: boolean;
    initError: any;
    signInError: any;
    private initializedSubject;
    initialized: Observable<any>;
    private subscriptionSubject;
    selectedSubscription: Observable<SubscriptionPermissionsModel>;
    get selectedSubscriptionSnapshot(): SubscriptionPermissionsModel;
    allSubscriptionsSelected: Observable<boolean>;
    private sessionCheckEventListener;
    private sessionCheckStartupTimeout;
    get userProfile(): UserProfile;
    private _userProfile;
    private pendingReturnUrl;
    private userPermissionsOnSubs;
    private _rootToken;
    private _rootTokenExpiresOn;
    constructor(http: HttpClient, oauthService: OAuthService, spaApiHeadersService: SpaApiHeadersService, logger: Logger, cookieStorage: CookieStorageService, ngZone: NgZone, messageService: MessageService, transloco: TranslocoService, listOfRoles: string[], listOfRootRoles: string[], requiredIdClaims: RequiredIdClaims, listOfUnassignableRoles: string[], oidcRedirectPath: string);
    init(): Promise<any>;
    private initRootAuth;
    private checkSession;
    protected handleSessionChanged(): void;
    protected startCheckSession(): void;
    protected getSessionState(): string;
    private removeSessionCheckEventListener;
    private initOidcAuth;
    private registerAndFetchProfile;
    private refreshUserSubscriptions;
    startLogin(returnUrl?: string, params?: any): void;
    private getOAuthState;
    shouldAttemptLogin(): boolean;
    private get lastLoginAttempt();
    private set lastLoginAttempt(value);
    private getAuthParams;
    private onOAuthEvent;
    private getHeaders;
    private setApiHeaders;
    private ensureInitialized;
    private isHttpUnauthorizedError;
    private isApiError;
    getHangfireAccessTicket(): Observable<string>;
    getUserPermissionsOnSubscription(sub: string): Observable<Permissions[]>;
    userHasPermissionOnSubscription(sub: string, permission?: Permissions): Observable<boolean>;
    userHasPermissionOnSelectedSubscription(permission?: Permissions): Observable<boolean>;
    userHasAnyRootRole(): boolean;
    userHasAnyRoleOnSubscription(sub: string): boolean;
    userHasAnyRole(): boolean;
    trySetSubscription(sub: string): Observable<boolean>;
    getSubscriptionRoles(sub: string, dontFilterUnassignableRoles?: boolean): string[];
    guessSubscription(): string;
    saveSubInLocalStorage(sub: string): void;
    get lastSubscription(): string;
    signOut(noRedirectToLogoutUrl?: boolean): string;
    claimAccess(claimCode: string): Promise<any>;
    tryPopReturnUrl(): string;
    rootLogin(rootPassword: string): Observable<RootAuthenticationResponse>;
    rootLogout(): void;
    instantiateRootUserProfile(rootProfile: Profile): UserProfile;
    getRootToken(): string;
    hasRootToken(): boolean;
    hasValidOidcToken(): boolean;
    getOidcToken(): string;
    getUserAgent(): any;
    isSafari13(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaControlService, [null, null, null, null, null, null, null, null, null, null, { optional: true; }, null, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SpaControlService>;
}

declare class ApplicationInsightsService {
    private logger;
    private _initialized;
    get initialized(): boolean;
    private _appInsights;
    get appInsights(): ApplicationInsights;
    constructor(logger: Logger);
    init(connectionString: string): void;
    private ensureInitialized;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationInsightsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationInsightsService>;
}

declare class GoogleAnalyticsService {
    private logger;
    private _initialized;
    get initialized(): boolean;
    get ga(): any;
    constructor(logger: Logger);
    emitEvent(eventCategory: string, eventAction: string, eventLabel?: string, eventValue?: number): void;
    init(googleAnalyticsTrackingId: string): void;
    private ensureInitialized;
    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleAnalyticsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GoogleAnalyticsService>;
}

interface SpaConfigurationModel {
    oidc: OidcConfigModel;
    rootAuthenticationEnabled: boolean;
    publicUploadEnabled: boolean;
    subscriptionHeader: string;
    subscriptionRoot: string;
    subscriptionNoFilter: string;
    emailEnabled: boolean;
    siteName: string;
    webPki: WebPkiConfig;
    maxFileSize: number;
    maxFilenameSize: number;
    maxShowingSubscriptions: number;
    labels: LabelsConfigModel;
    hasParentIntegration: boolean;
    parentUrl: string;
    parentName: string;
    appInsightsConnectionString: string;
    googleAnalyticsTrackingId: string;
    theme: string;
    segmentedUploadThreshold: number;
    uploadSegmentLength: number;
    captcha: CaptchaConfigModel;
    cdnUrl: string;
    faro: FaroConfigModel;
    userDiscoveryPolicy?: UserDiscoveryPolicies;
}
interface OidcConfigModel {
    enabled: boolean;
    authority: string;
    clientId: string;
    apiName: string;
    customScopes: string;
    nameClaim: string;
    emailAddressClaim: string;
    cpfClaim: string;
    audienceParamName: string;
    skipIssuerCheck: boolean;
    strictDiscoveryDocumentValidation: boolean;
    jwks: JwkModel[];
    requireHttps: boolean;
    redirectUri: string;
    postLogoutRedirectUri: string;
    sessionCheckEnabled: boolean;
    culture: string;
}
interface JwkModel {
    kty: string;
    use: string;
    kid: string;
    x5t: string;
    n: string;
    e: string;
    x5c: string[];
}
interface WebPkiConfig {
    license: string;
    brand: string;
}
interface LabelsConfigModel {
    subscription: string;
    theSubscription: string;
    subscriptions: string;
    allSubscriptions: string;
    subscriptionGender: GrammaticalGender;
}
interface CaptchaConfigModel {
    enabled: true;
    provider: CaptchaProviders;
    siteKey: string;
}
interface FaroConfigModel {
    enabled: boolean;
    url: string;
    apiKey: string;
    app: FaroAppIdentificationModel;
    samplingRate: number;
    propagateTraceHeadersCorsUrls: string[];
    ignoreUrls: string[];
}
interface FaroAppIdentificationModel {
    name: string;
    version: string;
    environment: string;
}
declare class SpaConfiguration {
    private initialized;
    private _oidc;
    private _rootAuthenticationEnabled;
    private _publicUploadEnabled;
    private _subscriptionHeader;
    private _subscriptionRoot;
    private _subscriptionNoFilter;
    private _emailEnabled;
    private _siteName;
    private _webPki;
    private _maxFileSize;
    private _maxFilenameSize;
    private _maxShowingSubscriptions;
    private _labels;
    private _hasParentIntegration;
    private _parentUrl;
    private _parentName;
    private _appInsightsConnectionString;
    private _googleAnalyticsTrackingId;
    private _theme;
    private _segmentedUploadThreshold;
    private _uploadSegmentLength;
    private _captcha;
    private _cdnUrl;
    private _userDiscoveryPolicy;
    initialize(model: SpaConfigurationModel): void;
    get oidc(): OidcConfigModel;
    get rootAuthenticationEnabled(): boolean;
    get publicUploadEnabled(): boolean;
    get subscriptionHeader(): string;
    get subscriptionRoot(): string;
    get subscriptionNoFilter(): string;
    get emailEnabled(): boolean;
    get siteName(): string;
    get webPki(): WebPkiConfig;
    get maxFileSize(): number;
    get maxFilenameSize(): number;
    get maxShowingSubscriptions(): number;
    get labels(): LabelsConfigModel;
    get hasParentIntegration(): boolean;
    get parentUrl(): string;
    get parentName(): string;
    get appInsightsConnectionString(): string;
    get googleAnalyticsTrackingId(): string;
    get theme(): string;
    get segmentedUploadThreshold(): number;
    get uploadSegmentLength(): number;
    get captcha(): CaptchaConfigModel;
    get cdnUrl(): string;
    get userDiscoveryPolicy(): UserDiscoveryPolicies;
    private ensureInitialized;
}
declare const Config: SpaConfiguration;

declare class FaroService {
    private logger;
    private static readonly regexPrefix;
    private static readonly defaultIgnoreUrls;
    private static readonly defaultMaxSessionPersistenceTime;
    private _initialized;
    get initialized(): boolean;
    private _faro;
    get faro(): Faro;
    constructor(logger: Logger);
    init(config: FaroConfigModel): void;
    private ignoreUrls;
    /** Faro URL matchers may be plain strings (literal match) or RegExp. A config value prefixed with "regex:" is compiled into a RegExp. */
    private toUrlMatcher;
    /** Renames the span to "<METHOD> <target>" when both are known. */
    private renameHttpSpan;
    private ensureInitialized;
    static ɵfac: i0.ɵɵFactoryDeclaration<FaroService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FaroService>;
}

declare class StartupService {
    private logger;
    private http;
    private spaControl;
    private appInsightsService;
    private googleAnalyticsService;
    private faroService;
    private asyncSpaInit;
    initError: any;
    constructor(logger: Logger, http: HttpClient, spaControl: SpaControlService, appInsightsService: ApplicationInsightsService, googleAnalyticsService: GoogleAnalyticsService, faroService: FaroService, asyncSpaInit: boolean);
    init(): Promise<any>;
    private getConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<StartupService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StartupService>;
}

declare class DialogConfirmWithCheckboxComponent implements OnInit {
    data: any;
    private domSanitizer;
    private transloco;
    title: string;
    message: string;
    confirmButtonText: string;
    confirmButtonColor: ThemePalette;
    confirmButtonMatIcon: string;
    cancelButtonText: string;
    cancelButtonColor: ThemePalette;
    cancelButtonMatIcon: string;
    checkboxMessage: string;
    checkboxResult: boolean;
    useMessageAsHtml: boolean;
    requireCheckToConfirm: boolean;
    constructor(data: any, domSanitizer: DomSanitizer, transloco: TranslocoService);
    ngOnInit(): void;
    submit(dialogResult: boolean): DialogConfirmWithCheckboxResult;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogConfirmWithCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogConfirmWithCheckboxComponent, "spa-dialog-confirm-with-checkbox", never, {}, {}, never, never, false, never>;
}
interface DialogConfirmWithCheckboxResult {
    dialogResult: boolean;
    checkboxResult: boolean;
}

declare class DialogMobileAuthorizationRequiredComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogMobileAuthorizationRequiredComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogMobileAuthorizationRequiredComponent, "spa-dialog-mobile-authorization-required", never, {}, {}, never, never, false, never>;
}

interface UploadModel {
    id: string;
    name: string;
    contentType: string;
    percentDone?: number;
}
interface FileModel extends UploadModel {
    location: string;
}
interface UpdateFilesRequest {
    add: UploadModel[];
    delete: string[];
}
declare enum FileUploadError {
    MaxSize = "MaxSize",
    Type = "Type",
    ZeroByteFile = "ZeroByteFile",
    InvalidContentType = "InvalidContentType",
    InvalidExtensionForType = "InvalidExtensionForType",
    MaxFilenameSize = "MaxFilenameSize"
}
declare class FileUploadErrorInfo {
    file: string;
    type: FileUploadError;
}
interface UploadInspectionModel {
    name: string;
    contentType: string;
}
interface UploadInspectionResultModel {
    isContentTypeValid: boolean;
    isExtensionValid: boolean;
}
interface CaptchaTicketRequest {
    captcha: string;
}
interface CaptchaTicketModel {
    ticket: string;
    expirationDate: string;
    secondsToExpire: number;
}

interface DialogConfirmWithReasonData {
    message: string;
    title?: string;
    confirmButtonText?: string;
    confirmButtonColor?: ThemePalette;
    confirmButtonMatIcon?: string;
    cancelButtonText?: string;
    cancelButtonColor?: ThemePalette;
    cancelButtonMatIcon?: string;
    useMessageAsHtml?: boolean;
    reasonLabel?: string;
    reasonMaxLength?: number;
    disableClose?: boolean;
}
interface DialogConfirmWithReasonResult {
    dialogResult: boolean;
    reason: string;
}
declare class DialogConfirmWithReasonComponent implements OnInit {
    data: DialogConfirmWithReasonData;
    private dialogRef;
    private domSanitizer;
    private transloco;
    reasonForm: FormControl;
    title: string;
    message: string;
    confirmButtonText: string;
    confirmButtonColor: ThemePalette;
    confirmButtonMatIcon: string;
    cancelButtonText: string;
    cancelButtonColor: ThemePalette;
    cancelButtonMatIcon: string;
    useMessageAsHtml: boolean;
    reasonLabel: string;
    reasonMaxLength: number;
    constructor(data: DialogConfirmWithReasonData, dialogRef: MatDialogRef<DialogConfirmWithReasonData>, domSanitizer: DomSanitizer, transloco: TranslocoService, fb: FormBuilder);
    ngOnInit(): void;
    submit(dialogResult: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogConfirmWithReasonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogConfirmWithReasonComponent, "spa-dialog-confirm-with-reason", never, {}, {}, never, never, false, never>;
}

/**
 * Async modal dialog service
 * DialogService makes this app easier to test by faking this service.
 * TODO: better modal implementation that doesn't use window.confirm
 */
declare class DialogService {
    private dialog;
    private transloco;
    constructor(dialog: MatDialog, transloco: TranslocoService);
    /**
     * Ask user to confirm an action. `message` explains the action and choices. `title` is optional, default value: 'Confirm'.
     * Returns observable resolving to `true`=confirm or `false`=cancel
     */
    confirm(messageOrOpts?: string | {
        message?: string;
        title?: string;
        confirmButtonText?: string;
        confirmButtonColor?: ThemePalette;
        confirmButtonMatIcon?: string;
        cancelButtonText?: string;
        cancelButtonColor?: ThemePalette;
        cancelButtonMatIcon?: string;
        useMessageAsHtml?: boolean;
        disableClose?: boolean;
    }, title?: string): Promise<boolean>;
    /**
     * Ask user to confirm a discard action. `message` explains the action and choices. `title` is optional, default value: 'Discard changes?'.
     * Returns observable resolving to `true`=confirm or `false`=cancel
     */
    confirmDiscard: (message?: string, title?: string, useMessageAsHtml?: boolean, disableClose?: boolean) => Promise<boolean>;
    /**
     * Notifies the user that the current operation will continue in the background, allowing him to cancel his action (and therefore continue
     * "watching" the operation be performed).
     */
    confirmContinueBackground: (message?: string, title?: string, useMessageAsHtml?: boolean, disableClose?: boolean) => Promise<boolean>;
    /**
     * Ask user to confirm a delete action. `message` explains the action and choices. `title` is optional, default value: 'Delete?'.
     * Returns observable resolving to `true`=confirm or `false`=cancel
     */
    confirmDelete: (message: string, title?: string, useMessageAsHtml?: boolean, disableClose?: boolean) => Promise<boolean>;
    confirmWithCheckbox(messageOrOpts: string | {
        message?: string;
        title?: string;
        confirmButtonText?: string;
        confirmButtonColor?: ThemePalette;
        confirmButtonMatIcon?: string;
        cancelButtonText?: string;
        cancelButtonColor?: ThemePalette;
        cancelButtonMatIcon?: string;
        checkboxMessage: string;
        checkboxInitalState?: boolean;
        useMessageAsHtml?: boolean;
        disableClose?: boolean;
        requireCheckToConfirm?: boolean;
    }, checkboxMessage?: string, checkboxInitalState?: boolean, title?: string): Promise<DialogConfirmWithCheckboxResult>;
    alert(message: string, title?: string, useMessageAsHtml?: boolean, disableClose?: boolean): Promise<any>;
    showValue(value: string, opts?: {
        title?: string;
        message?: string;
        footer?: string;
        disableClose?: boolean;
    }): Promise<any>;
    subSelector(subs: SubscriptionAccess[], includeRoot?: boolean, disableClose?: boolean): Promise<any>;
    showValidation(vr: any, disableClose?: boolean): Promise<any>;
    showMobileAuthorizationRequired(): MatDialogRef<DialogMobileAuthorizationRequiredComponent>;
    openFile(files: FileModel[], index: number, disableClose?: boolean): Promise<any>;
    showAllErrors(errorMessages: string[], title?: string, disableClose?: boolean): Promise<any>;
    rootLogin(opts?: {
        message?: string;
        title?: string;
        useMessageAsHtml?: boolean;
        disableClose?: boolean;
        navigateHomeIfCancelled?: boolean;
        reloadOnSuccess?: boolean;
    }): Observable<RootAuthenticationResponse>;
    openLanguageSelector(opts?: {
        message?: string;
        title?: string;
        useMessageAsHtml?: boolean;
        disableClose?: boolean;
    }): Observable<void>;
    showEvent(event: EventModel): Promise<void>;
    confirmWithReason(messageOrOpts: string | DialogConfirmWithReasonData, title?: string): Promise<DialogConfirmWithReasonResult>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

declare class SpaErrorHandlingService extends ErrorHandler {
    private spaControl;
    private appInsightsService;
    private faroService;
    private logger;
    private transloco;
    dialogService: DialogService;
    private messageService;
    refreshRootTokenSubject: Subject<RootAuthenticationResponse>;
    constructor(spaControl: SpaControlService, appInsightsService: ApplicationInsightsService, faroService: FaroService, logger: Logger, transloco: TranslocoService, dialogService: DialogService, messageService: MessageService);
    handleError(error: any): void;
    private refreshRootTokenAndRetry;
    onApiError: (err: HttpErrorResponse, request: HttpRequest<any>, next: HttpHandler) => Observable<HttpEvent<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaErrorHandlingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SpaErrorHandlingService>;
}

interface LanguageParseResultFromUrl {
    found: boolean;
    language?: string;
    urlWithoutLanguageSegment?: string;
}
declare const defaultSpaLangToLocalesMapping: HashMap<string[]>;
declare const defaultSpaLocale = "en-US";
declare class SpaLanguageService implements OnDestroy {
    private logger;
    private translocoService;
    private cookieStorage;
    private languageToLocalesMapping;
    private $toUnsubscribe;
    private readonly languageFromUrlRegex;
    private temporaryLanguageFromNavigation;
    lastLanguageParsedOrGuessed: string;
    private currentLocaleSubject;
    currentLocale: Observable<string>;
    get currentLocaleSnapshot(): string;
    constructor(logger: Logger, translocoService: TranslocoService, cookieStorage: CookieStorageService, languageToLocalesMapping: HashMap<string[]>);
    init(): Promise<HashMap<any>>;
    setTemporarilyLanguageFromNavigation(language: string, navigationId: number): void;
    commitLanguageFromNavigation(language: string, navigationId: number): void;
    rollbackLanguageFromNavigation(navigationId: number): void;
    setActiveLanguageIfDifferent(lang: string): void;
    getLanguagePreferenceFromCookie(): string;
    setLanguagePreferenceInCookie(lang: string): void;
    getApplicationAvailableLangs(): string[];
    isLanguageAvailable(lang: string): boolean;
    parseLanguageFromUrl(url: string): LanguageParseResultFromUrl;
    generateUrlWithLangSegment(originalUrl: string, lang: string): string;
    replaceOrInsertLangInUrl(originalUrl: string, lang: string): string;
    guessLanguage(ignoreLastLanguageGuessedOrParsed?: boolean): string;
    getLocaleBasedOnLanguage(lang: string): string;
    setLocale(locale: string): void;
    getLocale(): string;
    setLocaleAndStoreInCookie(locale: string): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaLanguageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SpaLanguageService>;
}

declare class AuthManagementService {
    private logger;
    private http;
    private changedSubject;
    changed: Observable<any>;
    constructor(logger: Logger, http: HttpClient);
    getUserSubscriptionRoles(userId: string, sub: string): Observable<SubscriptionAccessModel | RootRoles[]>;
    updateSubscriptionRoles(sub: string, agentId: string, data: AuthorizationData | RootAuthorizationData): Observable<any>;
    getUserPermissionsOnSubscription(sub: string): Observable<Permissions[]>;
    notifyChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthManagementService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthManagementService>;
}

declare class EventService implements OnDestroy, ObservableSearchService, PaginatedSearchService<EventModel> {
    private logger;
    private http;
    private spaControl;
    private authManager;
    private $subscriptions;
    private changedSubject;
    private cache;
    changed: Observable<string>;
    constructor(logger: Logger, http: HttpClient, spaControl: SpaControlService, authManager: AuthManagementService);
    listPaginated(params: PaginatedSearchParams): Observable<PaginatedSearchResult<EventModel>>;
    ngOnDestroy(): void;
    getServiceForApplicationEvents(appId: string): SearchService<EventModel>;
    getServiceForApplicationActions(appId: string): PaginatedSearchService<EventModel>;
    getServiceForUserEvents(userId: string): SearchService<EventModel>;
    getServiceForUserActions(userId: string): PaginatedSearchService<EventModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<EventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EventService>;
}
declare class EntityEventService implements SearchService<EventModel> {
    private apiRoute;
    private http;
    constructor(apiRoute: string, http: HttpClient);
    list(): Observable<EventModel[]>;
}
declare class PaginatedEntityEventService implements PaginatedSearchService<EventModel> {
    private apiRoute;
    private http;
    constructor(apiRoute: string, http: HttpClient);
    listPaginated(params: PaginatedSearchParams): Observable<PaginatedSearchResult<EventModel>>;
}

declare class ApplicationActionsComponent implements OnInit {
    route: ActivatedRoute;
    private router;
    private eventService;
    private logger;
    dataSource: PaginatedSearchService<EventModel>;
    constructor(route: ActivatedRoute, router: Router, eventService: EventService, logger: Logger);
    ngOnInit(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationActionsComponent, "spa-application-actions", never, {}, {}, never, never, false, never>;
}

interface ApplicationModel {
    id: string;
    subscriptionId: string;
    name: string;
    rootRoles: RootRoles[];
    subscriptions: SubscriptionAccessModel[];
    grantAppId: string;
    isLocked: boolean;
}
interface ApplicationData {
    name: string;
    authorizationData: AuthorizationData;
    rootAuthorizationData: RootAuthorizationData;
}

declare class ApplicationService implements OnDestroy, ObservableSearchService, PaginatedSearchService<ApplicationModel> {
    private logger;
    private http;
    private spaControl;
    private authManager;
    private $subscriptions;
    private changedSubject;
    changed: Observable<string>;
    constructor(logger: Logger, http: HttpClient, spaControl: SpaControlService, authManager: AuthManagementService);
    listPaginated(params: PaginatedSearchParams): Observable<PaginatedSearchResult<ApplicationModel>>;
    list(query?: string): Observable<ApplicationModel[]>;
    get(id: string): Observable<ApplicationModel>;
    create(sub: string, data: ApplicationData): Observable<ApplicationModel>;
    checkNameAvailable(sub: string, name: string, id?: string): Observable<boolean>;
    updateSubscriptionAccess(sub: string, id: string, data: AuthorizationData | RootAuthorizationData): Observable<any>;
    delete(id: string): Observable<any>;
    notifyChanged(id?: string): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationService>;
}

declare class ApplicationCreateComponent implements OnInit {
    route: ActivatedRoute;
    private router;
    private logger;
    private fb;
    private dialogService;
    private appService;
    private messageService;
    private spaControl;
    private transloco;
    private $toUnsubscribe;
    private $nameChangesSubscription;
    form: UntypedFormGroup;
    saving: boolean;
    saved: boolean;
    subscriptions: SubscriptionModel[];
    rootSubSelected: boolean;
    selectedSubscription: string;
    maxSubs: number;
    subscriptionGender: GrammaticalGender;
    private readonly rootSub;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, fb: UntypedFormBuilder, dialogService: DialogService, appService: ApplicationService, messageService: MessageService, spaControl: SpaControlService, transloco: TranslocoService);
    get roles(): UntypedFormArray;
    clearRoles(): void;
    /** Fills the role controls with the given roles, leaving all of them unchecked. See RoleFormUtils.setRoleOptions. */
    setRoleOptions(roleNames: string[]): void;
    createForm(): void;
    getSubAccess(subId: string): SubscriptionAccess;
    ngOnInit(): void;
    onSubmit(): void;
    displaySubscription(): string;
    selectSubscription(): void;
    canDeactivate(): true | Promise<boolean>;
    close(): void;
    getErrorMessage(formControlName: string): string;
    private checkNameAvailable;
    private validateRoles;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationCreateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationCreateComponent, "spa-application-create", never, {}, {}, never, never, false, never>;
}

interface AgentModel {
    id: string;
    name: string;
    type: AgentTypes;
}
interface AgentBulkLookupResponse {
    agents: {
        [id: string]: AgentModel;
    };
}
interface UpdateAgentLockStatusRequest {
    lock: boolean;
    description: string;
}

interface UserModel {
    id: string;
    parentId?: string;
    subject: string;
    name: string;
    emailAddress: string;
    rootRoles: RootRoles[];
    parentRootRoles?: string[];
    subscriptions: SubscriptionAccessModel[];
    isLocked: boolean;
}
interface UserData {
    subject: string;
    name: string;
    emailAddress: string;
    authorizationData: AuthorizationData;
    rootAuthorizationData: RootAuthorizationData;
}
interface UserPermissionsResponse {
    roles: Roles[];
    rootRoles: RootRoles[];
}
interface UserDiscoveryResponse {
    canBeFound: boolean;
}

declare class UserService implements OnDestroy, ObservableSearchService, PaginatedSearchService<UserModel> {
    private logger;
    private http;
    private spaControl;
    private authManagementService;
    private $subscriptions;
    private changedSubject;
    changed: Observable<string>;
    constructor(logger: Logger, http: HttpClient, spaControl: SpaControlService, authManagementService: AuthManagementService);
    create(sub: string, data: UserData): Observable<UserModel>;
    list(q: string, global: boolean): Observable<UserModel[]>;
    listPaginated(params: PaginatedSearchParams): Observable<PaginatedSearchResult<UserModel>>;
    listTopGlobalUsers(q: string, limit?: number): Observable<UserModel[]>;
    get(id: string): Observable<UserModel>;
    getFromParent(subject: string): Observable<UserModel>;
    discover(id: string): Observable<UserDiscoveryResponse>;
    notifyChanged(id?: string): void;
    update(subject: string, data: UserData, subId?: string): Observable<UserModel>;
    getUserPermissionsOnSubscription(userId: string, sub: string): Observable<UserPermissionsResponse>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
}

declare class AgentService {
    private http;
    private userService;
    private applicationService;
    private dialogService;
    private messageService;
    private readonly authManagementService;
    private readonly transloco;
    constructor(http: HttpClient, userService: UserService, applicationService: ApplicationService, dialogService: DialogService, messageService: MessageService);
    confirmAndUpdateLockStatus(args: {
        id: string;
        lock: boolean;
        type: AgentTypes;
        dialogMessage: string;
        dialogConfirmButtonText: string;
        successMessage: string;
    }): Promise<void>;
    /**
     * Asks the user to confirm the revocation of an agent's access to a subscription and, if confirmed, revokes it.
     * Access is revoked by clearing every role the agent has on the subscription.
     * Returns whether the access was revoked (false if the user cancelled).
     */
    confirmAndRevokeSubscriptionAccess(sub: string, agentId: string): Promise<boolean>;
    updateLockStatus(id: string, request: UpdateAgentLockStatusRequest, type: AgentTypes): rxjs.Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AgentService>;
}

declare class ApplicationDetailComponent implements OnInit, OnDestroy {
    route: ActivatedRoute;
    private router;
    private logger;
    private appService;
    private dialogService;
    private messageService;
    private spaControl;
    private transloco;
    private agentService;
    private $toUnsubscribe;
    loading: boolean;
    saving: boolean;
    model: ApplicationModel;
    canManage$: Observable<boolean>;
    canViewEvents$: Observable<boolean>;
    canViewActions$: Observable<boolean>;
    deletionRequested: boolean;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, appService: ApplicationService, dialogService: DialogService, messageService: MessageService, spaControl: SpaControlService, transloco: TranslocoService, agentService: AgentService);
    ngOnInit(): void;
    isRootSubscription(sub: string): boolean;
    load(): void;
    delete(): void;
    close(): void;
    lock(): Promise<void>;
    unlock(): Promise<void>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationDetailComponent, "spa-application-detail", never, {}, {}, never, never, false, never>;
}

interface CanComponentDeactivate {
    canDeactivate: () => Observable<boolean> | Promise<boolean> | boolean;
}
declare class CanDeactivateGuard {
    canDeactivate(component: CanComponentDeactivate): Observable<boolean> | Promise<boolean> | boolean;
    private canDeactivateAsync;
    static ɵfac: i0.ɵɵFactoryDeclaration<CanDeactivateGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CanDeactivateGuard>;
}

declare class ApplicationEditComponent implements OnInit, OnDestroy, CanComponentDeactivate {
    route: ActivatedRoute;
    private router;
    private logger;
    private fb;
    private dialogService;
    private appService;
    private messageService;
    private spaControl;
    private transloco;
    private listOfRoles;
    private $toUnsubscribe;
    form: UntypedFormGroup;
    model: ApplicationModel;
    saving: boolean;
    loading: boolean;
    closing: boolean;
    rootSubSelected: boolean;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, fb: UntypedFormBuilder, dialogService: DialogService, appService: ApplicationService, messageService: MessageService, spaControl: SpaControlService, transloco: TranslocoService, listOfRoles: string[]);
    get roles(): UntypedFormArray;
    getModelRoles(): string[];
    clearRoles(): void;
    private validateRoles;
    createForm(): void;
    rebuildForm(): void;
    ngOnInit(): void;
    getErrorMessage(formControlName: string): string;
    onSubmit(): void;
    canDeactivate(): true | Promise<boolean>;
    discard(): void;
    close(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationEditComponent, "spa-application-edit", never, {}, {}, never, never, false, never>;
}

declare class ApplicationEventsComponent implements OnInit {
    route: ActivatedRoute;
    private router;
    private eventService;
    private logger;
    dataSource: SearchService<EventModel>;
    constructor(route: ActivatedRoute, router: Router, eventService: EventService, logger: Logger);
    ngOnInit(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationEventsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationEventsComponent, "spa-application-events", never, {}, {}, never, never, false, never>;
}

interface ApplicationKeyModel {
    id: string;
    applicationId: string;
    description: string;
    expiresOn: Date;
}
interface CreateApplicationApiKeyRequest {
    description: string;
    expiresOn: Date;
}
interface CreateApplicationApiKeyResponse {
    key: string;
    info: ApplicationKeyModel;
}

declare class ApplicationKeyServiceFactory {
    private http;
    private services;
    constructor(http: HttpClient);
    getService(appId: string): ApplicationKeyService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationKeyServiceFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationKeyServiceFactory>;
}
declare class ApplicationKeyService implements SearchService<ApplicationKeyModel>, ObservableSearchService {
    private appId;
    private http;
    private changedSubject;
    changed: Observable<string>;
    constructor(appId: string, http: HttpClient);
    list(): Observable<ApplicationKeyModel[]>;
    createApiKey(request: CreateApplicationApiKeyRequest): Observable<CreateApplicationApiKeyResponse>;
    delete(id: string): Observable<any>;
}

declare class ApplicationKeyCreateComponent implements OnInit {
    route: ActivatedRoute;
    private logger;
    private fb;
    private spaControl;
    private appKeyServiceFactory;
    private router;
    private messageService;
    private dialogService;
    private transloco;
    form: UntypedFormGroup;
    saving: boolean;
    closing: boolean;
    constructor(route: ActivatedRoute, logger: Logger, fb: UntypedFormBuilder, spaControl: SpaControlService, appKeyServiceFactory: ApplicationKeyServiceFactory, router: Router, messageService: MessageService, dialogService: DialogService, transloco: TranslocoService);
    createForm(): void;
    ngOnInit(): void;
    onSubmit(): void;
    canDeactivate(): true | Promise<boolean>;
    close(): void;
    getErrorMessage(formControlName: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationKeyCreateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationKeyCreateComponent, "spa-application-key-create", never, {}, {}, never, never, false, never>;
}

declare class ApplicationKeysComponent implements OnInit {
    route: ActivatedRoute;
    private router;
    private logger;
    private dialogService;
    private appKeyServiceFactory;
    private messageService;
    private spaControl;
    private transloco;
    appKeyService: ApplicationKeyService;
    saving: boolean;
    columnsToDisplay: string[];
    canManage$: Observable<boolean>;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, dialogService: DialogService, appKeyServiceFactory: ApplicationKeyServiceFactory, messageService: MessageService, spaControl: SpaControlService, transloco: TranslocoService);
    ngOnInit(): void;
    delete(key: ApplicationKeyModel): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationKeysComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationKeysComponent, "spa-application-keys", never, {}, {}, never, never, false, never>;
}

declare class ApplicationListComponent {
    appService: ApplicationService;
    private spaControl;
    private transloco;
    columnsToDisplay$: Observable<string[]>;
    constructor(appService: ApplicationService, spaControl: SpaControlService, transloco: TranslocoService);
    isRootSubscription(sub: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationListComponent, "spa-application-list", never, {}, {}, never, never, false, never>;
}

declare class ApplicationsComponent implements OnInit {
    route: ActivatedRoute;
    private logger;
    private spaControl;
    canManage$: Observable<boolean>;
    constructor(route: ActivatedRoute, logger: Logger, spaControl: SpaControlService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationsComponent, "spa-applications", never, {}, {}, never, never, false, never>;
}

declare class BoxComponent implements OnInit {
    loading: boolean;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BoxComponent, "spa-box", never, { "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["[box-title]", "[box-subtitle]", "[box-commands]", "*"], false, never>;
}

interface NamedRoute {
    name: NamedRoutes;
    branchRoot: boolean;
    displayName: string;
    url: string;
    pathToMatch: string;
    activatedRoute: ActivatedRoute;
}

declare class RouteHelperService implements OnDestroy {
    private logger;
    private router;
    private $toUnsubscribe;
    private activatedNamedRoutesSubject;
    activatedNamedRoutes: Observable<ActivatedNamedRouteCollection>;
    get activatedNamedRoutesSnapshot(): ActivatedNamedRouteCollection;
    private currentUrlSubject;
    currentUrl: Observable<string>;
    get currentUrlSnapshot(): string;
    private currentPathToMatchSubject;
    currentPathToMatch: Observable<string>;
    get currentPathToMatchSnapshot(): string;
    constructor(logger: Logger, router: Router);
    setUpNamedRoutesAndUpdateCurrentUrls(route: ActivatedRoute, initialUrl?: string, namedRoutes?: NamedRoute[], initialPath?: string): NamedRoute[];
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RouteHelperService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RouteHelperService>;
}
declare class ActivatedNamedRouteCollection {
    activatedRoutes: NamedRoute[];
    constructor(activatedRoutes: NamedRoute[]);
    isInRoute(routeName: NamedRoutes): boolean;
    findNamedRoute(routeName: NamedRoutes): NamedRoute;
    getSubManagementRouteUrl(): string;
    private isManagementRoute;
}

declare class BreadcrumbComponent implements OnInit, OnDestroy {
    private logger;
    private routeHelperService;
    private router;
    private getOverriddenBreadcrumbDisplayName;
    private $toUnsubscribe;
    breadcrumbsArray: NamedRoute[];
    get isBreadcrumbsArrayEmpty(): boolean;
    get canNavigateUp(): boolean;
    breadcrumbsUpdate: EventEmitter<NamedRoute[]>;
    constructor(logger: Logger, routeHelperService: RouteHelperService, router: Router, getOverriddenBreadcrumbDisplayName: GetBreadcrumbDisplayNameFunction);
    ngOnInit(): void;
    buildBreadcrumbsArray: () => void;
    navigateUp(): void;
    removeBreadcrumb(routeName: NamedRoutes): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, [null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "spa-breadcrumb", never, {}, { "breadcrumbsUpdate": "breadcrumbsUpdate"; }, never, never, false, never>;
}

declare class BreadcrumbNameComponent implements OnInit, OnDestroy {
    private transloco;
    private getOverriddenBreadcrumbDisplayName;
    private $toUnsubscribe;
    namedRoute: NamedRoute;
    currentLang: string;
    lastTranslationLoaded: HashMap<any>;
    static translationMap: any;
    static langOfTranslationMap: string;
    static fallbackTranslationMap: any;
    static fallbackLanguage: string;
    latestTransformedValue: string | null;
    latestValue: NamedRoutes;
    latestLanguageUsed: string;
    constructor(transloco: TranslocoService, getOverriddenBreadcrumbDisplayName: GetBreadcrumbDisplayNameFunction);
    ngOnInit(): void;
    getBreadcrumbDisplayName(): string;
    fetchFallbackTranslationInfo(): {
        fallbackTranslationMap: any;
        fallbackLanguage: string;
    };
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbNameComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbNameComponent, "spa-breadcrumb-name", never, { "namedRoute": { "alias": "namedRoute"; "required": false; }; "currentLang": { "alias": "currentLang"; "required": false; }; "lastTranslationLoaded": { "alias": "lastTranslationLoaded"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CloseButtonComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CloseButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CloseButtonComponent, "spa-close-button", never, {}, {}, never, never, false, never>;
}

declare class PrivateAreaUnavailableComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    tryAgain(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrivateAreaUnavailableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PrivateAreaUnavailableComponent, "spa-private-area-unavailable", never, {}, {}, never, never, false, never>;
}

declare class DialogShowValueComponent implements OnInit {
    data: any;
    private transloco;
    value: string;
    title: string;
    message: string;
    footer: string;
    constructor(data: any, transloco: TranslocoService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogShowValueComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogShowValueComponent, "spa-dialog-show-value", never, {}, {}, never, never, false, never>;
}

declare class DialogAlertComponent implements OnInit {
    data: any;
    private domSanitizer;
    private transloco;
    title: string;
    message: string;
    useMessageAsHtml: boolean;
    constructor(data: any, domSanitizer: DomSanitizer, transloco: TranslocoService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogAlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogAlertComponent, "spa-dialog-alert", never, {}, {}, never, never, false, never>;
}

declare class DialogFancyConfirmComponent implements OnInit {
    data: any;
    private domSanitizer;
    private transloco;
    title: string;
    message: string;
    confirmButtonText: string;
    confirmButtonColor: ThemePalette;
    confirmButtonMatIcon: string;
    cancelButtonText: string;
    cancelButtonColor: ThemePalette;
    cancelButtonMatIcon: string;
    useMessageAsHtml: boolean;
    constructor(data: any, domSanitizer: DomSanitizer, transloco: TranslocoService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFancyConfirmComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogFancyConfirmComponent, "spa-dialog-fancy-confirm", never, {}, {}, never, never, false, never>;
}

type LanguageName = {
    english: string;
    native: string;
};
declare const localeCodeMap: HashMap<LanguageName>;
declare const languageCodeMap: HashMap<LanguageName>;

declare class DialogLanguageSelectorComponent implements OnInit {
    private dialogRef;
    router: Router;
    spaLanguage: SpaLanguageService;
    private logger;
    private fb;
    private transloco;
    data: any;
    private languageRouteEnabled;
    private languageToLocalesMapping;
    private $toUnsubscribe;
    form: UntypedFormGroup;
    availableLanguages: string[];
    availableLocales: string[];
    localeCodeMap: HashMap<LanguageName>;
    languageCodeMap: HashMap<LanguageName>;
    title: string;
    message: string;
    useMessageAsHtml: boolean;
    get languageControl(): AbstractControl;
    get localeControl(): AbstractControl;
    constructor(dialogRef: MatDialogRef<DialogLanguageSelectorComponent>, router: Router, spaLanguage: SpaLanguageService, logger: Logger, fb: UntypedFormBuilder, transloco: TranslocoService, data: any, languageRouteEnabled: boolean, languageToLocalesMapping: HashMap<string[]>);
    ngOnInit(): void;
    createForm(): void;
    getAvailableLocales(): string[];
    onSubmit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogLanguageSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogLanguageSelectorComponent, "spa-dialog-language-selector", never, {}, {}, never, never, false, never>;
}

declare class DialogRootLoginComponent implements OnInit, OnDestroy {
    data: any;
    private dialogRef;
    private spaControl;
    private fb;
    private transloco;
    private router;
    private logger;
    private $toUnsubscribe;
    form: UntypedFormGroup;
    loginSucceeded: RootLoginResult;
    submitting: boolean;
    title: string;
    message: string;
    useMessageAsHtml: boolean;
    disableClose: boolean;
    navigateHomeIfCancelled: boolean;
    reloadOnSuccess: boolean;
    get isPasswordInvalid(): boolean;
    constructor(data: any, dialogRef: MatDialogRef<DialogRootLoginComponent>, spaControl: SpaControlService, fb: UntypedFormBuilder, transloco: TranslocoService, router: Router, logger: Logger);
    ngOnInit(): void;
    createForm(): void;
    onSubmit(): void;
    getErrorMessage(formControlName: string): string;
    close(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogRootLoginComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogRootLoginComponent, "spa-dialog-root-login", never, {}, {}, never, never, false, never>;
}

interface SubShow {
    name: string;
    sub: SubscriptionAccess;
}
declare class DialogSubscriptionSelectorComponent implements OnInit {
    data: any;
    dialogRef: MatDialogRef<DialogSubscriptionSelectorComponent>;
    subscriptions: SubShow[];
    subscriptionGender: GrammaticalGender;
    disableClose: boolean;
    constructor(data: any, dialogRef: MatDialogRef<DialogSubscriptionSelectorComponent>);
    ngOnInit(): void;
    select(s: SubShow): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogSubscriptionSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogSubscriptionSelectorComponent, "spa-dialog-subscription-selector", never, {}, {}, never, never, false, never>;
}

declare class DialogUploadErrorComponent implements OnInit {
    data: any;
    private transloco;
    title: string;
    errors: FileUploadErrorInfo[];
    acceptedTypes: string[];
    maxFileSize: number;
    maxFilenameSize: number;
    constructor(data: any, transloco: TranslocoService);
    ngOnInit(): void;
    getError(type: FileUploadError): string;
    private formatListOfAcceptedTypes;
    private formatFileSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogUploadErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogUploadErrorComponent, "spa-dialog-upload-error", never, {}, {}, never, never, false, never>;
}

declare class DialogValidationResultsComponent implements OnInit {
    dialogRef: MatDialogRef<DialogValidationResultsComponent>;
    data: any;
    private transloco;
    private logger;
    model: any;
    private pki;
    itemStack: any;
    constructor(dialogRef: MatDialogRef<DialogValidationResultsComponent>, data: any, transloco: TranslocoService, logger: Logger);
    ngOnInit(): void;
    showDetails(item: any): void;
    showParent(item: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogValidationResultsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogValidationResultsComponent, "spa-dialog-validation-results", never, {}, {}, never, never, false, never>;
}

declare class DialogViewFileComponent implements OnInit {
    data: any;
    private sanitizer;
    private http;
    platform: Platform;
    files: FileModel[];
    filesAsDataUrl: SafeResourceUrl[];
    index: number;
    fileSrc: any;
    fileLocation: string;
    name: string;
    contentType: string;
    imageViewerCfg: LacunaMatImageViewerConfig;
    constructor(data: any, sanitizer: DomSanitizer, http: HttpClient, platform: Platform);
    ngOnInit(): void;
    getDocument(index: any): void;
    isMobile(): boolean;
    next(): void;
    back(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogViewFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogViewFileComponent, "spa-dialog-view-file", never, {}, {}, never, never, false, never>;
}

declare class DialogErrorMessagesComponent implements OnInit {
    data: any;
    private transloco;
    title: string;
    errorMessages: string[];
    constructor(data: any, transloco: TranslocoService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogErrorMessagesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogErrorMessagesComponent, "spa-dialog-error-messages", never, {}, {}, never, never, false, never>;
}

declare class DialogEventDetailsComponent implements OnInit {
    event: EventModel;
    constructor(event: EventModel);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogEventDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogEventDetailsComponent, "spa-dialog-event-details", never, {}, {}, never, ["*"], false, never>;
}

declare class DummyComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DummyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DummyComponent, "spa-dummy", never, {}, {}, never, never, false, never>;
}

declare class EntityTypePipe implements PipeTransform {
    private transloco;
    constructor(transloco: TranslocoService);
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityTypePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EntityTypePipe, "entityType", false>;
}

declare class EventEntityCellComponent implements OnInit {
    private entityTypePipe;
    ENTITY_NOT_FOUND: number;
    event: EventModel;
    name: string | number;
    show: EventEmitter<any>;
    entityWithId: string;
    constructor(entityTypePipe: EntityTypePipe);
    ngOnInit(): void;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EventEntityCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EventEntityCellComponent, "spa-event-entity-cell", never, { "event": { "alias": "event"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "show": "show"; }, never, never, false, never>;
}

declare class AgentLookupService {
    private http;
    private lookupTasks;
    private lookupQueue;
    private lookupQueueChanged;
    constructor(http: HttpClient);
    get(id: string): Observable<AgentModel>;
    private enqueueLookup;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgentLookupService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AgentLookupService>;
}

declare class EventListComponent implements OnInit {
    private logger;
    private dialogService;
    private transloco;
    private agentLookupService;
    private userService;
    private entityNavigationService;
    private eventViewer;
    dataSource: PaginatedSearchService<EventModel> | SearchService<EventModel>;
    showSubscriptions: boolean;
    hideEntities: boolean;
    hideAgents: boolean;
    disablePagination: boolean;
    loading: boolean;
    get columnsToDisplay(): string[];
    constructor(logger: Logger, dialogService: DialogService, transloco: TranslocoService, agentLookupService: AgentLookupService, userService: UserService, entityNavigationService: EntityNavigator, eventViewer: EventViewer);
    ngOnInit(): void;
    showDetails(e: EventModel): void;
    navigateToAgent(e: EventModel): void;
    navigateToEntity(e: EventModel): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EventListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EventListComponent, "spa-event-list", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "showSubscriptions": { "alias": "showSubscriptions"; "required": false; }; "hideEntities": { "alias": "hideEntities"; "required": false; }; "hideAgents": { "alias": "hideAgents"; "required": false; }; "disablePagination": { "alias": "disablePagination"; "required": false; }; }, {}, never, never, false, never>;
    static ngAcceptInputType_showSubscriptions: any;
    static ngAcceptInputType_hideEntities: any;
    static ngAcceptInputType_hideAgents: any;
    static ngAcceptInputType_disablePagination: any;
}

declare class EventsComponent implements OnInit {
    route: ActivatedRoute;
    eventService: EventService;
    private spaControl;
    showSubs$: Observable<boolean>;
    constructor(route: ActivatedRoute, eventService: EventService, spaControl: SpaControlService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EventsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EventsComponent, "spa-events", never, {}, {}, never, never, false, never>;
}

declare const enum UploadEventTypes {
    Progress = "Progress",
    Completed = "Completed"
}
declare class UploadEvent {
    type: UploadEventTypes;
    model?: FileModel;
    progress?: number;
    constructor(type: UploadEventTypes, model?: FileModel, progress?: number);
}
declare class UploadService {
    private http;
    private spaControl;
    get defaultApiRoute(): string;
    constructor(http: HttpClient, spaControl: SpaControlService);
    uploadFile(formData: FormData, uploadUrl?: string, params?: HttpParams, headers?: HttpHeaders): Observable<HttpEvent<any>>;
    startSegmentedUpload(): Observable<string>;
    uploadFile2(file: File, uploadUrl?: string, params?: HttpParams, headers?: HttpHeaders): Observable<UploadEvent>;
    validate(uploads: UploadInspectionModel[]): Observable<UploadInspectionResultModel[]>;
    generateCaptchaTicket(captcha: string): Observable<CaptchaTicketModel>;
    private uploadFileSingleSegment;
    private uploadFileSegmentedly;
    private sendUploadRequest;
    private sendStartSegmentedUploadRequest;
    private makeHot;
    static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UploadService>;
}

declare class FileSizePipe implements PipeTransform {
    transform(bytes: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "fileSize", false>;
}

type widgetId = number | string;
interface CaptchaRenderOptions {
    sitekey: string;
    callback?: (response: string) => void;
    "expired-callback"?: () => void;
    "error-callback"?: (e: any) => void;
    invisible?: boolean;
    [key: string]: any;
}

declare global {
    interface Window {
        captchaloadedcallback?: () => void;
    }
}
declare abstract class BaseCaptchaProvider {
    readonly translocoService: TranslocoService;
    abstract readonly name: string;
    abstract readonly url: string;
    private static loadPromise;
    private static loaded;
    abstract render(element: HTMLElement, options: CaptchaRenderOptions): widgetId;
    abstract execute(widgetId: widgetId): void;
    abstract reset(widgetId: widgetId): void;
    abstract getResponse(widgetId: widgetId): string | null;
    loadScript(): Promise<void>;
}

declare class CaptchaComponent implements OnInit, OnDestroy {
    private readonly zone;
    private readonly logger;
    private readonly injector;
    private readonly captchaService;
    private readonly elementRef;
    private readonly invisibleEnabled;
    private readonly config;
    id: string;
    provider: BaseCaptchaProvider;
    resolved: i0.OutputEmitterRef<string>;
    errored: i0.OutputEmitterRef<any>;
    expired: i0.OutputEmitterRef<void>;
    private widgetId;
    private executeRequested;
    ngOnInit(): void;
    execute(): void;
    reset(): void;
    private renderCaptcha;
    private resolvedCallback;
    private expiredCallback;
    private errorCallback;
    private captchaReset;
    private getCaptchaProvider;
    private randomId;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaptchaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CaptchaComponent, "spa-captcha", never, {}, { "resolved": "resolved"; "errored": "errored"; "expired": "expired"; }, never, never, false, never>;
}

declare class CaptchaService {
    private readonly logger;
    private component;
    private lastPromise;
    private lastTimeout;
    registerComponent(component: CaptchaComponent): void;
    private runTest;
    private showCaptcha;
    unregisterComponent(component: CaptchaComponent): void;
    notifyResolved(code: string): void;
    executeAsync(onManual: () => void): Promise<string>;
    execute(): Observable<string>;
    private clearLastRequest;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaptchaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CaptchaService>;
}

declare class FilesActionDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<FilesActionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FilesActionDirective, "[filesAction]", never, {}, {}, never, never, false, never>;
}
declare class FilesComponent implements OnInit {
    private fb;
    private dialogService;
    private uploadService;
    private logger;
    private dialog;
    private fileSizePipe;
    private spaControl;
    private captchaService;
    filesToAdd: UntypedFormArray;
    filesToDelete: UntypedFormArray;
    existingFiles: FileModel[];
    acceptedTypes: string[];
    accept: string;
    onFileClick: (file: FileModel) => any;
    uploadUrl: string;
    httpParams?: HttpParams;
    httpHeaders?: HttpHeaders;
    readOnly: boolean;
    single: boolean;
    get maxFileSize(): number;
    set maxFileSize(maxSize: number);
    private _maxFileSize;
    hideViewButton: boolean;
    hideDeleteButton: boolean;
    get maxFilenameSize(): number;
    set maxFilenameSize(maxFilenameSize: number);
    private _maxFilenameSize;
    fileButton: ElementRef;
    filesActions: QueryList<TemplateRef<any>>;
    highlightContainer: boolean;
    touched: boolean;
    filesLoading: EventEmitter<boolean>;
    private numberOfFilesLoading;
    private _loadingFiles;
    get loadingFiles(): boolean;
    get changesPending(): boolean;
    get filesToShow(): FileModel[];
    get willSwapFile(): boolean;
    loading: boolean;
    useCaptcha: boolean;
    captchaTicketExpiration: momentJs.Moment;
    constructor(fb: UntypedFormBuilder, dialogService: DialogService, uploadService: UploadService, logger: Logger, dialog: MatDialog, fileSizePipe: FileSizePipe, spaControl: SpaControlService, captchaService: CaptchaService);
    ngOnInit(): void;
    transferDataSuccess($event: any): Promise<void>;
    private convertFilesToInspectionModel;
    private uploadFile;
    private openErrorDetailsDialog;
    private fileStartedLoading;
    private fileFinishedLoading;
    private fileModelToFormGroup;
    private addEmptyFile;
    private setCaptchaHeaders;
    fileButtonClick(): void;
    delete(file: any): void;
    viewFile(file: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilesComponent, "spa-files", never, { "filesToAdd": { "alias": "filesToAdd"; "required": false; }; "filesToDelete": { "alias": "filesToDelete"; "required": false; }; "existingFiles": { "alias": "existingFiles"; "required": false; }; "acceptedTypes": { "alias": "acceptedTypes"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "onFileClick": { "alias": "onFileClick"; "required": false; }; "uploadUrl": { "alias": "uploadUrl"; "required": false; }; "httpParams": { "alias": "httpParams"; "required": false; }; "httpHeaders": { "alias": "httpHeaders"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "single": { "alias": "single"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; "hideViewButton": { "alias": "hideViewButton"; "required": false; }; "hideDeleteButton": { "alias": "hideDeleteButton"; "required": false; }; "maxFilenameSize": { "alias": "maxFilenameSize"; "required": false; }; }, { "filesLoading": "filesLoading"; }, ["filesActions"], never, false, never>;
    static ngAcceptInputType_readOnly: any;
    static ngAcceptInputType_single: any;
    static ngAcceptInputType_hideViewButton: any;
    static ngAcceptInputType_hideDeleteButton: any;
}

interface InviteModel {
    id: string;
    subscriptionId: string;
    emailAddress: string;
    inviteAuthorizationData: InviteAuthorizationData;
}
interface InviteAuthorizationData {
    authorizationData: AuthorizationData;
    rootAuthorizationData: RootAuthorizationData;
}
interface InviteData {
    inviteAuthorizationData: InviteAuthorizationData;
}
interface CreateInviteResponse {
    invite: InviteModel;
    claimCode: string;
    emailSent: boolean;
    sendFailReason: InviteSendFailResons;
}
declare enum InviteSendFailResons {
    InternalServerError = "InternalServerError",
    EmailDisabled = "EmailDisabled"
}

declare class InviteService implements OnDestroy, ObservableSearchService, SearchService<InviteModel> {
    private logger;
    private http;
    private spaControl;
    private $subscriptions;
    private changedSubject;
    private cache;
    changed: Observable<string>;
    constructor(logger: Logger, http: HttpClient, spaControl: SpaControlService);
    list(): Observable<InviteModel[]>;
    get(id: string): Observable<InviteModel>;
    getClaimCode(id: string): Observable<string>;
    create(sub: string, emailAddress: string, inviteData: InviteAuthorizationData): Observable<CreateInviteResponse>;
    resend(id: string): Observable<any>;
    update(id: string, data: InviteData): Observable<InviteModel>;
    delete(id: string): Observable<any>;
    notifyChanged(id?: string): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InviteService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InviteService>;
}

declare class InviteDetailComponent implements OnInit, OnDestroy {
    route: ActivatedRoute;
    private router;
    private logger;
    private inviteService;
    private dialogService;
    private messageService;
    private spaControl;
    private transloco;
    private $subscriptions;
    loading: boolean;
    loadingClaimCode: boolean;
    resending: boolean;
    emailEnabled: boolean;
    saving: boolean;
    model: InviteModel;
    canManage$: Observable<boolean>;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, inviteService: InviteService, dialogService: DialogService, messageService: MessageService, spaControl: SpaControlService, transloco: TranslocoService);
    ngOnInit(): void;
    load(): void;
    resend(): void;
    getClaimCode(): void;
    getAccessLink(): void;
    delete(): void;
    isRootSubscription(sub: string): boolean;
    close(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InviteDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InviteDetailComponent, "spa-invite-detail", never, {}, {}, never, never, false, never>;
}

declare class InviteEditComponent implements OnInit, OnDestroy, CanComponentDeactivate {
    private route;
    private router;
    private logger;
    private fb;
    private dialogService;
    private inviteService;
    private messageService;
    private spaControl;
    private transloco;
    private listOfRoles;
    private $toUnsubscribe;
    form: UntypedFormGroup;
    model: InviteModel;
    saving: boolean;
    loading: boolean;
    private closing;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, fb: UntypedFormBuilder, dialogService: DialogService, inviteService: InviteService, messageService: MessageService, spaControl: SpaControlService, transloco: TranslocoService, listOfRoles: string[]);
    get roles(): UntypedFormArray;
    createForm(): void;
    private getRolesFromModel;
    resetForm(): void;
    ngOnInit(): void;
    private validateRoles;
    getErrorMessage(formControlName: string): string;
    onSubmit(): void;
    canDeactivate(): true | Promise<boolean>;
    discard(): void;
    close(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InviteEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InviteEditComponent, "spa-invite-edit", never, {}, {}, never, never, false, never>;
}

declare class InviteListComponent implements OnInit {
    private logger;
    inviteService: InviteService;
    private spaControl;
    columnsToDisplay$: Observable<string[]>;
    constructor(logger: Logger, inviteService: InviteService, spaControl: SpaControlService);
    ngOnInit(): void;
    isRootSubscription(sub: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<InviteListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InviteListComponent, "spa-invite-list", never, {}, {}, never, never, false, never>;
}

declare class LacunaFooterComponent implements OnInit {
    loading: boolean;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LacunaFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LacunaFooterComponent, "spa-lacuna-footer", never, { "loading": { "alias": "loading"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LanguageButtonComponent implements OnInit, OnDestroy {
    private logger;
    private translocoService;
    private dialogService;
    private $toUnsubscribe;
    btnClass: string;
    currentLang: string;
    constructor(logger: Logger, translocoService: TranslocoService, dialogService: DialogService);
    ngOnInit(): void;
    openLangSelector(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LanguageButtonComponent, "spa-language-button", never, { "btnClass": { "alias": "btnClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LanguageSelectorComponent implements OnInit {
    router: Router;
    spaLanguage: SpaLanguageService;
    private languageRouteEnabled;
    availableLanguages: string[];
    constructor(router: Router, spaLanguage: SpaLanguageService, languageRouteEnabled: boolean);
    ngOnInit(): void;
    changeLanguage(newLang: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LanguageSelectorComponent, "spa-language-selector", never, {}, {}, never, never, false, never>;
}

declare class NoAccessComponent implements OnInit {
    private spaControl;
    private http;
    private dialogService;
    private transloco;
    siteName: any;
    userName: string;
    loading: boolean;
    constructor(spaControl: SpaControlService, http: HttpClient, dialogService: DialogService, transloco: TranslocoService);
    ngOnInit(): void;
    claimAccess(claimCode: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NoAccessComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NoAccessComponent, "spa-no-access", never, {}, {}, never, never, false, never>;
}

declare class PrivateAreaComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrivateAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PrivateAreaComponent, "spa-private-area", never, {}, {}, never, never, false, never>;
}

declare class PropComponent implements OnInit {
    label: string;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PropComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PropComponent, "spa-prop", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class RootComponent implements OnInit {
    private router;
    private logger;
    private spaControl;
    private routeHelper;
    private googleAnalyticsService;
    private spaLanguage;
    private languageRouteEnabled;
    private asyncInit;
    readonly useInvisibleCaptcha: boolean;
    loading: boolean;
    constructor(router: Router, logger: Logger, spaControl: SpaControlService, routeHelper: RouteHelperService, googleAnalyticsService: GoogleAnalyticsService, spaLanguage: SpaLanguageService, languageRouteEnabled: boolean, asyncInit: boolean);
    ngOnInit(): void;
    trackSpaPagesOnAnalytics(): void;
    watchLanguageOnRoutes(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RootComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RootComponent, "spa-root", never, {}, {}, never, never, false, never>;
}

declare class ServiceUnavailableComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    tryAgain(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceUnavailableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceUnavailableComponent, "spa-service-unavailable", never, {}, {}, never, never, false, never>;
}

declare class SignInComponent implements OnInit {
    private spaControl;
    siteName: string;
    constructor(spaControl: SpaControlService);
    ngOnInit(): void;
    signIn(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignInComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SignInComponent, "spa-sign-in", never, {}, {}, never, never, false, never>;
}

declare class SignOutComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignOutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SignOutComponent, "spa-sign-out", never, {}, {}, never, never, false, never>;
}

declare class SubmitButtonComponent implements OnInit {
    form: UntypedFormGroup;
    disabled: boolean;
    submit: EventEmitter<any>;
    constructor();
    ngOnInit(): void;
    onButtonClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubmitButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubmitButtonComponent, "spa-submit-button", never, { "form": { "alias": "form"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "submit": "submit"; }, never, ["*"], false, never>;
}

declare class SubscriptionService implements SearchService<SubscriptionModel> {
    protected http: HttpClient;
    changed: Observable<string>;
    protected cache: SubscriptionModel[];
    protected changedSubject: Subject<string>;
    constructor(http: HttpClient);
    list(): Observable<SubscriptionModel[]>;
    create(data: SubscriptionData): Observable<SubscriptionModel>;
    get(id: string): Observable<SubscriptionModel>;
    update(id: string, data: SubscriptionData): Observable<SubscriptionModel>;
    checkNameAvailable(name: string, id?: string): Observable<boolean>;
    protected updateCache(m: SubscriptionModel, notifyChanged: boolean): void;
    protected notifyChanged(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SubscriptionService>;
}

declare class SubscriptionCreateComponent implements OnInit, CanComponentDeactivate {
    route: ActivatedRoute;
    private router;
    private logger;
    private dialogService;
    private subscriptionService;
    private messageService;
    private transloco;
    saving: boolean;
    closing: boolean;
    subscriptionGender: GrammaticalGender;
    private formComponent;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, dialogService: DialogService, subscriptionService: SubscriptionService, messageService: MessageService, transloco: TranslocoService);
    ngOnInit(): void;
    onSubmit(data: SubscriptionData): void;
    canDeactivate(): true | Promise<boolean>;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionCreateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionCreateComponent, "spa-subscription-create", never, {}, {}, never, never, false, never>;
}

declare class SubscriptionDetailComponent implements OnInit, OnDestroy {
    route: ActivatedRoute;
    private router;
    private logger;
    private subscriptionService;
    model: SubscriptionModel;
    loading: boolean;
    hasParentIntegration: boolean;
    private $toUnsubscribe;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, subscriptionService: SubscriptionService);
    ngOnInit(): void;
    load(): void;
    close(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionDetailComponent, "spa-subscription-detail", never, {}, {}, never, never, false, never>;
}

declare class SubscriptionListComponent {
    subService: SubscriptionService;
    constructor(subService: SubscriptionService);
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionListComponent, "spa-subscription-list", never, {}, {}, never, never, false, never>;
}

declare class SubscriptionFormComponent implements OnInit {
    private fb;
    private logger;
    private subscriptionService;
    private transloco;
    form: UntypedFormGroup;
    private _model;
    get model(): SubscriptionModel;
    set model(value: SubscriptionModel);
    submitted: EventEmitter<SubscriptionData>;
    get submitAction(): string;
    private hasParentIntegration;
    constructor(fb: UntypedFormBuilder, logger: Logger, subscriptionService: SubscriptionService, transloco: TranslocoService);
    createForm(): void;
    resetForm(): void;
    ngOnInit(): void;
    onSubmit(): void;
    getErrorMessage(formControlName: string): string;
    private checkNameAvailable;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionFormComponent, "spa-subscription-form", never, { "model": { "alias": "model"; "required": false; }; }, { "submitted": "submitted"; }, never, never, false, never>;
}

declare class SubscriptionEditComponent implements OnInit, CanComponentDeactivate {
    route: ActivatedRoute;
    private router;
    private logger;
    private dialogService;
    private subscriptionService;
    private messageService;
    private transloco;
    loading: boolean;
    saving: boolean;
    closing: boolean;
    model: SubscriptionModel;
    subscriptionGender: GrammaticalGender;
    private formComponent;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, dialogService: DialogService, subscriptionService: SubscriptionService, messageService: MessageService, transloco: TranslocoService);
    ngOnInit(): void;
    onSubmit(data: SubscriptionData): void;
    canDeactivate(): true | Promise<boolean>;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionEditComponent, "spa-subscription-edit", never, {}, {}, never, never, false, never>;
}

declare class SubscriptionsComponent implements OnInit, OnDestroy {
    route: ActivatedRoute;
    private logger;
    private subService;
    private dialogService;
    private transloco;
    private $serviceChangeSubscription;
    hasParentIntegration: boolean;
    constructor(route: ActivatedRoute, logger: Logger, subService: SubscriptionService, dialogService: DialogService, transloco: TranslocoService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionsComponent, "spa-subscriptions", never, {}, {}, never, never, false, never>;
}

declare class SuccessPanelComponent implements OnInit {
    lottieConfig: AnimationOptions;
    private anim;
    private animationSpeed;
    constructor();
    handleAnimation(anim: any): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SuccessPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SuccessPanelComponent, "spa-success-panel", never, {}, {}, never, ["[success-title]", "[success-actions]"], false, never>;
}

declare class UserAccessEditComponent implements OnInit, OnDestroy, CanComponentDeactivate {
    route: ActivatedRoute;
    private router;
    private logger;
    private fb;
    private dialogService;
    private messageService;
    private spaControl;
    private authManagementService;
    private transloco;
    private listOfRoles;
    private listOfUnassignableRoles;
    private userService;
    private $toUnsubscribe;
    form: UntypedFormGroup;
    saving: boolean;
    private closing;
    subscription: SubscriptionModel;
    loadingAccess: boolean;
    /** Whether the logged user is editing his own access. */
    isSelf: boolean;
    /** Whether the user had any role on this subscription when the screen was loaded. */
    private hadRoles;
    private readonly agentService;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, fb: UntypedFormBuilder, dialogService: DialogService, messageService: MessageService, spaControl: SpaControlService, authManagementService: AuthManagementService, transloco: TranslocoService, listOfRoles: string[], listOfUnassignableRoles: string[], userService: UserService);
    get roles(): UntypedFormArray;
    clearRoles(): void;
    createForm(): void;
    private validateRoles;
    /**
     * Whether the form may be saved with no roles selected, which revokes the user's access to the subscription (the same outcome as the "revoke access" command on the user details screen).
     * Defaults to true, except when the logged user is editing his own access (since he would lock himself out) or when the parent integration is enabled (the "revoke access" command is not
     * available in that case either). Override to prevent access from being revoked through this screen.
     */
    protected allowEmptyRoles(): boolean;
    /**
     * The roles that are currently checked, including the unassignable ones the user already had (their controls are disabled, so they are only reachable through getRawValue()).
     * The back-end replaces the whole role list on save, so leaving them out would strip the unassignable roles from the user despite their checkbox being marked.
     */
    private getSelectedRoles;
    /** Whether saving now would revoke the user's access to the subscription. */
    get willRevokeAccess(): boolean;
    ngOnInit(): void;
    toggleCheckbox(r: AbstractControl<any, any, any>): void;
    onSubmit(): void;
    canDeactivate(): true | Promise<boolean>;
    close(): void;
    getErrorMessage(formControlName: string): string;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserAccessEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserAccessEditComponent, "spa-user-access-edit", never, {}, {}, never, never, false, never>;
}

declare class UserActionsComponent implements OnInit {
    route: ActivatedRoute;
    private router;
    private eventService;
    private logger;
    dataSource: PaginatedSearchService<EventModel>;
    constructor(route: ActivatedRoute, router: Router, eventService: EventService, logger: Logger);
    ngOnInit(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserActionsComponent, "spa-user-actions", never, {}, {}, never, never, false, never>;
}

declare class ParentRedirectService {
    private routeHelper;
    private router;
    private spaControl;
    route: ActivatedRoute;
    private dialogService;
    constructor(routeHelper: RouteHelperService, router: Router, spaControl: SpaControlService, route: ActivatedRoute, dialogService: DialogService);
    redirectToParent(redirectType: ChildRedirectTypes, userId?: string, subscriptions?: SubscriptionAccess[]): Observable<ActivatedNamedRouteCollection>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParentRedirectService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ParentRedirectService>;
}

declare class UserDetailComponent implements OnInit, OnDestroy {
    route: ActivatedRoute;
    private logger;
    private userService;
    private router;
    private spaControl;
    private messageService;
    private dialogService;
    private authManagementService;
    private parentRedirectService;
    private transloco;
    private agentService;
    private $toUnsubscribe;
    agentId: string;
    parentName: string;
    mode: UserModes;
    model: UserModel;
    loading: boolean;
    showSubs$: Observable<boolean>;
    canManage$: Observable<boolean>;
    canEdit$: Observable<boolean>;
    canViewEvents$: Observable<boolean>;
    canViewActions$: Observable<boolean>;
    rootSubSelected$: Observable<boolean>;
    cannotRevoke: boolean;
    revoking: boolean;
    parentIntegrationEnabled: boolean;
    subscriptionGender: GrammaticalGender;
    constructor(route: ActivatedRoute, logger: Logger, userService: UserService, router: Router, spaControl: SpaControlService, messageService: MessageService, dialogService: DialogService, authManagementService: AuthManagementService, parentRedirectService: ParentRedirectService, transloco: TranslocoService, agentService: AgentService);
    ngOnInit(): void;
    isParentUser(): boolean;
    load(): void;
    confirmRevoke(subId: string): void;
    navigateToUserDetail(): void;
    navigateToParentEditAccess(): void;
    revoke(): void;
    navigateToEditAccess(): void;
    editAccess(): void;
    close(): void;
    displayRootRoles(u: UserModel): string[];
    displayRoles(sa: SubscriptionAccessModel): string[];
    lock(): Promise<void>;
    unlock(): Promise<void>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserDetailComponent, "spa-user-detail", never, {}, {}, never, never, false, never>;
}

declare class UserEditComponent implements OnInit, OnDestroy, CanComponentDeactivate {
    route: ActivatedRoute;
    private router;
    private logger;
    private fb;
    private dialogService;
    private messageService;
    private userService;
    private transloco;
    private $toUnsubscribe;
    form: UntypedFormGroup;
    model: UserModel;
    private closing;
    saving: boolean;
    loading: boolean;
    subscriptionGender: GrammaticalGender;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, fb: UntypedFormBuilder, dialogService: DialogService, messageService: MessageService, userService: UserService, transloco: TranslocoService);
    createForm(): void;
    rebuildForm(): void;
    ngOnInit(): void;
    onSubmit(): void;
    canDeactivate(): true | Promise<boolean>;
    close(): void;
    getErrorMessage(formControlName: string): string;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserEditComponent, "spa-user-edit", never, {}, {}, never, never, false, never>;
}

declare class UserEventsComponent implements OnInit {
    route: ActivatedRoute;
    private router;
    private eventService;
    private logger;
    dataSource: SearchService<EventModel>;
    constructor(route: ActivatedRoute, router: Router, eventService: EventService, logger: Logger);
    ngOnInit(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventsComponent, "spa-user-events", never, {}, {}, never, never, false, never>;
}

declare class UserInviteComponent implements OnInit, OnDestroy, CanComponentDeactivate {
    route: ActivatedRoute;
    private router;
    private logger;
    private fb;
    private dialogService;
    private messageService;
    private spaControl;
    private userService;
    private authManagementService;
    private inviteService;
    private transloco;
    private $toUnsubscribe;
    private $userChangesSubscription;
    form: UntypedFormGroup;
    saving: boolean;
    subscriptions: SubscriptionModel[];
    filteredUsers: Observable<UserModel[]>;
    private closing;
    submitAction$: Observable<string>;
    selectedSubscription: string;
    maxSubs: number;
    loadingUsers: boolean;
    waitingInput: boolean;
    subscriptionGender: GrammaticalGender;
    private readonly rootSub;
    constructor(route: ActivatedRoute, router: Router, logger: Logger, fb: UntypedFormBuilder, dialogService: DialogService, messageService: MessageService, spaControl: SpaControlService, userService: UserService, authManagementService: AuthManagementService, inviteService: InviteService, transloco: TranslocoService);
    get roles(): UntypedFormArray;
    clearRoles(): void;
    /** Fills the role controls with the given roles, leaving all of them unchecked. See RoleFormUtils.setRoleOptions. */
    setRoleOptions(roleNames: string[]): void;
    createForm(): void;
    private validateRoles;
    private validateUserControl;
    private validateUserNotInSub;
    getSubAccess(subId: string): SubscriptionAccess;
    ngOnInit(): void;
    displayFn(user?: UserModel): string | undefined;
    onSubmit(): void;
    canDeactivate(): true | Promise<boolean>;
    close(): void;
    displaySubscription(): string;
    selectSubscription(): void;
    getErrorMessage(formControlName: string): string;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserInviteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserInviteComponent, "spa-user-invite", never, {}, {}, never, never, false, never>;
}

declare class UserListComponent {
    private logger;
    userService: UserService;
    private route;
    private router;
    private spaControl;
    columnsToDisplay: string[];
    showSubs$: Observable<boolean>;
    rootSubSelected$: Observable<boolean>;
    constructor(logger: Logger, userService: UserService, route: ActivatedRoute, router: Router, spaControl: SpaControlService);
    displayRootRoles(u: UserModel): string[];
    displayRoles(sa: SubscriptionAccessModel): string[];
    navigateToUser(e: UserModel): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserListComponent, "spa-user-list", never, {}, {}, never, never, false, never>;
}

declare class UsersComponent implements OnInit, OnDestroy {
    private router;
    route: ActivatedRoute;
    private logger;
    private spaControl;
    private parentRedirectService;
    private $toUnsubscribe;
    canManage$: Observable<boolean>;
    canViewInvites$: Observable<boolean>;
    parentIntegrationEnabled: boolean;
    constructor(router: Router, route: ActivatedRoute, logger: Logger, spaControl: SpaControlService, parentRedirectService: ParentRedirectService);
    ngOnInit(): void;
    navigateToInvite(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UsersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UsersComponent, "spa-users", never, {}, {}, never, never, false, never>;
}

declare class AccessLockedComponent {
    showReturnToHomeButton: boolean;
    constructor(showReturnToHomeButton: boolean);
    goToHome(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccessLockedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccessLockedComponent, "spa-access-locked", never, {}, {}, never, never, false, never>;
}

interface ServerSummary {
    id: string;
    name: string;
    startDate: string;
    lastHeartbeat: string;
    isHealthy: boolean;
    failedHealthCheck: string;
}

declare class ServerService {
    protected http: HttpClient;
    constructor(http: HttpClient);
    list(): rxjs.Observable<ServerSummary[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServerService>;
}

declare class ServersListComponent implements OnInit {
    route: ActivatedRoute;
    private serverService;
    serversDataSource: ServerSummary[];
    isLoading: boolean;
    constructor(route: ActivatedRoute, serverService: ServerService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServersListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServersListComponent, "spa-servers-list", never, {}, {}, never, never, false, never>;
}

declare class SpaDialogTitleComponent {
    disableClose: boolean;
    customClose: boolean;
    closeClicked: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaDialogTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpaDialogTitleComponent, "spa-dialog-title", never, { "disableClose": { "alias": "disableClose"; "required": false; }; "customClose": { "alias": "customClose"; "required": false; }; }, { "closeClicked": "closeClicked"; }, never, ["*"], false, never>;
    static ngAcceptInputType_disableClose: any;
    static ngAcceptInputType_customClose: any;
}

declare class ClickableAreaComponent implements AfterViewInit {
    /** The template button, not the host: scanning the host would match this component's own button and warn every time. */
    private area;
    trigger: EventEmitter<void>;
    /** Defaults to 'button'.
     *
     * Old versions kept this unspecified and therefore defaulted to 'submit', causing unexpected form submission side-effects.
     *
     * A clickable area reports itself through (trigger), opt into 'submit' if it should also submit its form. */
    type: 'button' | 'submit' | 'reset';
    stretch: boolean;
    ariaLabel: string | null;
    ariaLabelledby: string | null;
    ariaDisabled: boolean | undefined;
    constructor();
    ngAfterViewInit(): void;
    onClick(event?: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClickableAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ClickableAreaComponent, "spa-clickable-area", never, { "type": { "alias": "type"; "required": false; }; "stretch": { "alias": "stretch"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; }; "ariaDisabled": { "alias": "ariaDisabled"; "required": false; }; }, { "trigger": "trigger"; }, never, ["*"], false, never>;
    static ngAcceptInputType_stretch: any;
    static ngAcceptInputType_ariaDisabled: i1.BooleanInput;
}

declare class SelectableAreaComponent implements FocusableOption, AfterViewInit {
    private control;
    checked: boolean | 'mixed' | undefined;
    disabled: boolean | undefined;
    stretch: boolean;
    ariaLabel: string | null;
    ariaLabelledby: string | null;
    checkedChange: EventEmitter<boolean>;
    private isTabStop;
    /** The enclosing group, when the area is inside one. The group is authoritative on the mode: a checkbox doesn't make sense inside a radiogroup. */
    private readonly group;
    /** A lone area is always a checkbox, since role="radio" is only valid inside a radiogroup. Put the area in a spa-selectable-group to make it a radio. */
    get effectiveMode(): SpaSelectableMode;
    get ariaChecked(): boolean | 'mixed';
    /** @docs-private the enclosing group's handlers match focus and key events against it */
    get controlElement(): HTMLElement;
    get indicatorIcon(): string;
    ngAfterViewInit(): void;
    focus(): void;
    /** @docs-private the enclosing group owns the roving tabindex */
    setTabStop(isTabStop: boolean): void;
    onClick(event?: Event): void;
    /** @docs-private requests the selection this area stands for. Also called by the group as the arrow keys move onto it. */
    activate(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectableAreaComponent, "spa-selectable-area", never, { "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "stretch": { "alias": "stretch"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, ["*", "[selectable-actions]"], false, never>;
    static ngAcceptInputType_checked: i1.BooleanInput;
    static ngAcceptInputType_disabled: i1.BooleanInput;
    static ngAcceptInputType_stretch: any;
}

declare class SelectableGroupComponent implements AfterContentInit, AfterContentChecked, OnDestroy {
    private readonly elementRef;
    private areas;
    mode: SpaSelectableMode;
    ariaLabel: string | null;
    ariaLabelledby: string | null;
    /** Only radio mode has a roving tabindex to manage, so this stays undefined in checkbox mode and every use of it is a mode check as well. */
    private keyManager;
    private hasWarnedOfMultipleChecked;
    get role(): string;
    get hostAriaLabel(): string | null;
    get hostAriaLabelledby(): string | null;
    ngAfterContentInit(): void;
    ngAfterContentChecked(): void;
    ngOnDestroy(): void;
    onKeydown(event: KeyboardEvent): void;
    onFocusIn(event: FocusEvent): void;
    private updateTabStops;
    private warnOfMultipleChecked;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectableGroupComponent, "spa-selectable-group", never, { "mode": { "alias": "mode"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; }; }, {}, ["areas"], ["*"], false, never>;
}

declare class LinkButtonComponent {
    trigger: EventEmitter<void>;
    constructor();
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinkButtonComponent, "spa-link-button", never, {}, { "trigger": "trigger"; }, never, ["*"], false, never>;
}

declare class AgentPipe implements PipeTransform {
    private agentLookupService;
    constructor(agentLookupService: AgentLookupService);
    transform(value: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgentPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AgentPipe, "agent", false>;
}

declare class BreadcrumbPipe implements PipeTransform {
    private transloco;
    private getOverriddenBreadcrumbDisplayName;
    static translationMap: any;
    static langOfTranslationMap: string;
    static fallbackTranslationMap: any;
    static fallbackLanguage: string;
    latestTransformedValue: string | null;
    latestValue: NamedRoutes;
    latestLanguageUsed: string;
    constructor(transloco: TranslocoService, getOverriddenBreadcrumbDisplayName: GetBreadcrumbDisplayNameFunction);
    transform(value: NamedRoute): any;
    fetchFallbackTranslationInfo(): {
        fallbackTranslationMap: any;
        fallbackLanguage: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbPipe, [null, { optional: true; }]>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BreadcrumbPipe, "breadcrumb", false>;
}

declare class CpfPipe implements PipeTransform {
    transform(value: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CpfPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CpfPipe, "cpf", false>;
}

declare class EntityIconPipe implements PipeTransform {
    private getEntityIcon;
    constructor(getEntityIcon: GetEntityIconFunction);
    transform(value: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityIconPipe, [{ optional: true; }]>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EntityIconPipe, "entityIcon", false>;
}

declare const ENTITY_NOT_FOUND = -1;
declare class EntityLookupService {
    private http;
    private logger;
    private lookupTasks;
    private lookupQueue;
    private lookupQueueChanged;
    constructor(http: HttpClient, logger: Logger);
    get(type: EntityTypes, id: string): Observable<string | number>;
    private enqueueLookup;
    private getIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityLookupService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EntityLookupService>;
}

declare class EntityNamePipe implements PipeTransform {
    private entityLookupService;
    constructor(entityLookupService: EntityLookupService);
    transform(value: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityNamePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EntityNamePipe, "entityName", false>;
}

declare class EventTypePipe implements PipeTransform {
    private getEventTypeName;
    private transloco;
    constructor(getEventTypeName: GetEventTypeNameFunction, transloco: TranslocoService);
    transform(value: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<EventTypePipe, [{ optional: true; }, null]>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EventTypePipe, "eventType", false>;
}

declare class RolesPipe implements PipeTransform {
    private getRoleName;
    private transloco;
    constructor(getRoleName: GetRoleNameFunction, transloco: TranslocoService);
    getRoleFullName(role: any, rolesTranslationObj: any): any;
    transform(value: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<RolesPipe, [{ optional: true; }, null]>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RolesPipe, "roles", false>;
}

declare class SubscriptionPipe implements PipeTransform {
    private spaControl;
    private entityLookupService;
    private logger;
    constructor(spaControl: SpaControlService, entityLookupService: EntityLookupService, logger: Logger);
    transform(value: any, args?: any): Observable<string>;
    getAliasOrName(subId: string): Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SubscriptionPipe, "sub", false>;
}

declare class SafePipe implements PipeTransform {
    protected sanitizer: DomSanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(value: any, type?: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", false>;
}

interface LocaleSensitivePipeArgs {
    value: any;
    locale: string;
    [otherArgs: string]: any;
}
declare abstract class LocaleSensitivePipe {
    protected spaLanguageService: SpaLanguageService;
    latestTransformedValue: string | null;
    latestArgsUsed: LocaleSensitivePipeArgs;
    get currentLocale(): string;
    constructor(spaLanguageService: SpaLanguageService);
    abstract transformFunction(args: LocaleSensitivePipeArgs): string | null;
    transformUsingCache(transformFunctionArgs: LocaleSensitivePipeArgs): string;
    checkIfArgsChanged(args: LocaleSensitivePipeArgs): boolean;
}

declare class SpaDatePipe extends LocaleSensitivePipe implements PipeTransform {
    private spaLanguage;
    private datePipe;
    constructor(spaLanguage: SpaLanguageService);
    transform(value: any, format?: string, timezone?: string, locale?: string): string | null;
    transformFunction(args: LocaleSensitivePipeArgs): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SpaDatePipe, "spaDate", false>;
}

declare class SpaCurrencyPipe extends LocaleSensitivePipe implements PipeTransform {
    private spaLanguage;
    private currencyPipe;
    constructor(spaLanguage: SpaLanguageService);
    transform(value: any, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): string | null;
    transformFunction(args: LocaleSensitivePipeArgs): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaCurrencyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SpaCurrencyPipe, "spaCurrency", false>;
}

declare class SpaDecimalPipe extends LocaleSensitivePipe implements PipeTransform {
    private spaLanguage;
    private decimalPipe;
    constructor(spaLanguage: SpaLanguageService);
    transform(value: any, digitsInfo?: string, locale?: string): string | null;
    transformFunction(args: LocaleSensitivePipeArgs): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaDecimalPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SpaDecimalPipe, "spaNumber", false>;
}

declare class SpaPercentPipe extends LocaleSensitivePipe implements PipeTransform {
    private spaLanguage;
    private percentPipe;
    constructor(spaLanguage: SpaLanguageService);
    transform(value: any, digitsInfo?: string, locale?: string): string | null;
    transformFunction(args: LocaleSensitivePipeArgs): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaPercentPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SpaPercentPipe, "spaPercent", false>;
}

/** Key used for null/undefined values, when the pipes are told to distinguish them from false */
declare const undefinedBooleanTranslationKey = "common.undefined";
/** Base class of the pipes that display a boolean value as a translated text (see BooleanPipe, YesNoPipe and EnabledDisabledPipe).
 * It can also be used by the final application to create its own aliases, with its own pair of translation keys.
 *
 * These pipes are impure, so that their results are updated when the language is changed without reloading the application (see SpaLanguageService).
 * Since impure pipes are executed on every change detection cycle, the translated text is cached, and only recalculated when the translation key or the active language change. */
declare abstract class BaseBooleanPipe {
    protected transloco: TranslocoService;
    private cache;
    constructor(transloco: TranslocoService);
    protected translateBoolean(value: boolean | null | undefined, trueKey: string, falseKey: string, showUndefined: boolean): string;
}
/** Displays a boolean value as a translated text. By default it uses the translation keys "common.true" and "common.false", but any other pair of keys can be given, e.g. {{ model.hasExpired | bool:'app.expired':'app.valid' }}.
 *
 * Null and undefined values are treated as false, unless the argument showUndefined is true, in which case they are displayed as "common.undefined". */
declare class BooleanPipe extends BaseBooleanPipe implements PipeTransform {
    constructor(transloco: TranslocoService);
    transform(value: boolean | null | undefined, trueKey?: string, falseKey?: string, showUndefined?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BooleanPipe, "bool", false>;
}

/** Displays a boolean value as "Enabled" or "Disabled", translated to the active language. It is an alias for {{ value | bool:'common.enabled':'common.disabled' }}.
 *
 * Null and undefined values are treated as false, unless the argument showUndefined is true, in which case they are displayed as "common.undefined". */
declare class EnabledDisabledPipe extends BaseBooleanPipe implements PipeTransform {
    constructor(transloco: TranslocoService);
    transform(value: boolean | null | undefined, showUndefined?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EnabledDisabledPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EnabledDisabledPipe, "enabledDisabled", false>;
}

/** Displays a boolean value as "Yes" or "No", translated to the active language. It is an alias for {{ value | bool:'common.yes':'common.no' }}.
 *
 * Null and undefined values are treated as false, unless the argument showUndefined is true, in which case they are displayed as "common.undefined". */
declare class YesNoPipe extends BaseBooleanPipe implements PipeTransform {
    constructor(transloco: TranslocoService);
    transform(value: boolean | null | undefined, showUndefined?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<YesNoPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<YesNoPipe, "yesNo", false>;
}

declare class DndDirective {
    filesDropped: EventEmitter<any>;
    filesOver: EventEmitter<boolean>;
    constructor();
    onDragOver(evt: any): void;
    onDragLeave(evt: any): void;
    onDrop(evt: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DndDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DndDirective, "[spaDnd]", never, {}, { "filesDropped": "filesDropped"; "filesOver": "filesOver"; }, never, never, false, never>;
}

declare class CaptchaValueAccessorDirective implements ControlValueAccessor, OnInit {
    private readonly captchaComponent;
    private onChange;
    private onTouched;
    private resolved;
    ngOnInit(): void;
    writeValue(_: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CaptchaValueAccessorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CaptchaValueAccessorDirective, "spa-captcha[formControl], spa-captcha[formControlName], spa-captcha[ngModel]", never, {}, {}, never, never, false, never>;
}

declare class SpaDateInput implements MatFormFieldControl<string>, ControlValueAccessor, OnDestroy, DoCheck {
    ngControl: NgControl;
    private parentForm;
    private parentFormGroup;
    parentFormField: MatFormField;
    private elementRef;
    private spaLanguage;
    private transloco;
    static nextId: number;
    $toUnsubscribe: Subscription[];
    datePicker: MatDatepicker<Date>;
    dateInput: HTMLInputElement | ElementRef<HTMLInputElement>;
    hourInput: HTMLInputElement | ElementRef<HTMLInputElement>;
    minuteInput: HTMLInputElement | ElementRef<HTMLInputElement>;
    secondInput: HTMLInputElement | ElementRef<HTMLInputElement>;
    form: FormGroup;
    get value(): string;
    set value(date: string | Date);
    stateChanges: Subject<void>;
    id: string;
    get placeholder(): string;
    set placeholder(plh: string);
    private _placeholder;
    focused: boolean;
    touched: boolean;
    get empty(): boolean;
    get shouldLabelFloat(): boolean;
    get required(): boolean;
    set required(req: BooleanInput);
    private _required;
    get disabled(): boolean;
    set disabled(value: BooleanInput);
    private _disabled;
    errorState: boolean;
    controlType: string;
    userAriaDescribedBy: string;
    describedBy: string;
    get dayStart(): boolean;
    set dayStart(value: BooleanInput);
    private _dayStart;
    get dayEnd(): boolean;
    set dayEnd(value: BooleanInput);
    private _dayEnd;
    get readonly(): boolean;
    set readonly(value: BooleanInput);
    private _readonly;
    get withTime(): boolean;
    set withTime(value: BooleanInput);
    private _withTime;
    get showSeconds(): boolean;
    set showSeconds(value: BooleanInput);
    private _showSeconds;
    get noTimeZone(): boolean;
    set noTimeZone(value: BooleanInput);
    private _noTimeZone;
    get hideClear(): boolean;
    set hideClear(value: BooleanInput);
    private _hideClear;
    get hidePicker(): boolean;
    set hidePicker(value: BooleanInput);
    private _hidePicker;
    private get hours();
    private get minutes();
    private get seconds();
    stepHours: number;
    stepMinutes: number;
    stepSeconds: number;
    private currentLocale;
    constructor(fb: FormBuilder, ngControl: NgControl, parentForm: NgForm, parentFormGroup: FormGroupDirective, parentFormField: MatFormField, elementRef: ElementRef<HTMLElement>, spaLanguage: SpaLanguageService, transloco: TranslocoService);
    private getValueFromForm;
    onFocusIn(event: FocusEvent): void;
    onFocusOut(event: FocusEvent): void;
    onChange: (_: any) => void;
    onTouched: () => void;
    ngOnDestroy(): void;
    ngDoCheck(): void;
    private updateErrorState;
    setDescribedByIds(ids: string[]): void;
    onContainerClick(event: MouseEvent): void;
    writeValue(s: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    handleInput(): void;
    private setValueFromDate;
    private setDateValue;
    openPicker(): void;
    clear(): void;
    change(prop: string, up?: boolean): void;
    private getNextValueByProp;
    private formatTwoDigitTimeValue;
    selectInputIfCursorStart(e: KeyboardEvent, el: HTMLInputElement | ElementRef<HTMLInputElement>): void;
    selectInputIfCursorEnd(e: KeyboardEvent, el: HTMLInputElement | ElementRef<HTMLInputElement>, end: number): void;
    private getSelectedDate;
    onPaste(e: ClipboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaDateInput, [null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpaDateInput, "spa-date-input", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "userAriaDescribedBy": { "alias": "aria-describedby"; "required": false; }; "dayStart": { "alias": "dayStart"; "required": false; }; "dayEnd": { "alias": "dayEnd"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "withTime": { "alias": "withTime"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "noTimeZone": { "alias": "noTimeZone"; "required": false; }; "hideClear": { "alias": "hideClear"; "required": false; }; "hidePicker": { "alias": "hidePicker"; "required": false; }; "stepHours": { "alias": "stepHours"; "required": false; }; "stepMinutes": { "alias": "stepMinutes"; "required": false; }; "stepSeconds": { "alias": "stepSeconds"; "required": false; }; }, {}, never, never, false, never>;
}

type MFLocale = ConstructorParameters<typeof IntlMessageFormat>[1];
interface IntlMessageFormatConfig {
    locales?: MFLocale;
    formats?: Partial<Formats>;
    opts?: Options;
    enableCache?: boolean;
}

declare class TranslocoIntlMessageFormatModule {
    static forRoot(config?: IntlMessageFormatConfig): ModuleWithProviders<TranslocoIntlMessageFormatModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TranslocoIntlMessageFormatModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TranslocoIntlMessageFormatModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TranslocoIntlMessageFormatModule>;
}

declare function playerFactory(): lottie_web.LottiePlayer;
declare function initFactoryFunction(startup: StartupService): () => Promise<any>;
declare function initSpaTranslationFactoryFunction(spaLanguage: SpaLanguageService): () => Promise<i114.HashMap<any>>;
declare function onApiErrorFactoryFunction(errorHandlingService: SpaErrorHandlingService): OnApiErrorFunction;
declare const DEFAULT_SPA_TRANSLOCO_CONFIG: TranslocoConfig;
declare class LacunaSpaModule {
    static forRoot(params: LacunaSpaModuleParams): ModuleWithProviders<LacunaSpaModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LacunaSpaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LacunaSpaModule, [typeof ApplicationActionsComponent, typeof ApplicationCreateComponent, typeof ApplicationDetailComponent, typeof ApplicationEditComponent, typeof ApplicationEventsComponent, typeof ApplicationKeyCreateComponent, typeof ApplicationKeysComponent, typeof ApplicationListComponent, typeof ApplicationsComponent, typeof BoxComponent, typeof BreadcrumbComponent, typeof BreadcrumbNameComponent, typeof CloseButtonComponent, typeof PrivateAreaUnavailableComponent, typeof DialogMobileAuthorizationRequiredComponent, typeof DialogShowValueComponent, typeof DialogAlertComponent, typeof DialogFancyConfirmComponent, typeof DialogLanguageSelectorComponent, typeof DialogRootLoginComponent, typeof DialogSubscriptionSelectorComponent, typeof DialogConfirmWithCheckboxComponent, typeof DialogUploadErrorComponent, typeof DialogValidationResultsComponent, typeof DialogViewFileComponent, typeof DialogErrorMessagesComponent, typeof DialogEventDetailsComponent, typeof DummyComponent, typeof EventEntityCellComponent, typeof EventListComponent, typeof EventsComponent, typeof FilesActionDirective, typeof FilesComponent, typeof InviteDetailComponent, typeof InviteEditComponent, typeof InviteListComponent, typeof LacunaFooterComponent, typeof LanguageButtonComponent, typeof LanguageSelectorComponent, typeof MessageComponent, typeof NoAccessComponent, typeof PrivateAreaComponent, typeof PropComponent, typeof RootComponent, typeof ServiceUnavailableComponent, typeof SignInComponent, typeof SignOutComponent, typeof SubmitButtonComponent, typeof SubscriptionCreateComponent, typeof SubscriptionDetailComponent, typeof SubscriptionListComponent, typeof SubscriptionFormComponent, typeof SubscriptionEditComponent, typeof SubscriptionsComponent, typeof SuccessPanelComponent, typeof UserAccessEditComponent, typeof UserActionsComponent, typeof UserDetailComponent, typeof UserEditComponent, typeof UserEventsComponent, typeof UserInviteComponent, typeof UserListComponent, typeof UsersComponent, typeof AccessLockedComponent, typeof DialogConfirmWithReasonComponent, typeof ServersListComponent, typeof SpaDialogTitleComponent, typeof ClickableAreaComponent, typeof SelectableAreaComponent, typeof SelectableGroupComponent, typeof LinkButtonComponent, typeof CaptchaComponent, typeof AgentPipe, typeof BreadcrumbPipe, typeof CpfPipe, typeof EntityIconPipe, typeof EntityNamePipe, typeof EventTypePipe, typeof RolesPipe, typeof SubscriptionPipe, typeof FileSizePipe, typeof SafePipe, typeof SpaDatePipe, typeof SpaCurrencyPipe, typeof SpaDecimalPipe, typeof SpaPercentPipe, typeof BooleanPipe, typeof EnabledDisabledPipe, typeof YesNoPipe, typeof DndDirective, typeof CaptchaValueAccessorDirective, typeof SpaDateInput, typeof EntityTypePipe], [typeof i93.CommonModule, typeof i94.FormsModule, typeof i94.ReactiveFormsModule, typeof i95.OAuthModule, typeof i96.MatMenuModule, typeof i97.MatIconModule, typeof i98.MatInputModule, typeof i99.MatButtonModule, typeof i100.MatToolbarModule, typeof i101.MatListModule, typeof i102.MatDialogModule, typeof i103.MatTooltipModule, typeof i104.MatCardModule, typeof i105.MatProgressBarModule, typeof i106.MatProgressSpinnerModule, typeof i107.MatSidenavModule, typeof i108.MatSelectModule, typeof i109.MatExpansionModule, typeof i110.MatAutocompleteModule, typeof i111.MatCheckboxModule, typeof i112.MatSnackBarModule, typeof i113.PdfViewerModule, typeof i114.TranslocoModule, typeof TranslocoIntlMessageFormatModule, typeof i116.RouterModule, typeof i117.NgxMaskDirective, typeof i117.NgxMaskPipe, typeof i118.MatDatepickerModule, typeof i119.MatNativeDateModule, typeof i120.LacunaMatModule, typeof i121.LottieComponent], [typeof i94.FormsModule, typeof i94.ReactiveFormsModule, typeof i96.MatMenuModule, typeof i97.MatIconModule, typeof i102.MatDialogModule, typeof i99.MatButtonModule, typeof i98.MatInputModule, typeof i100.MatToolbarModule, typeof i101.MatListModule, typeof i104.MatCardModule, typeof i106.MatProgressSpinnerModule, typeof i107.MatSidenavModule, typeof i109.MatExpansionModule, typeof i110.MatAutocompleteModule, typeof i111.MatCheckboxModule, typeof i122.MatTableModule, typeof i123.MatSortModule, typeof i112.MatSnackBarModule, typeof i113.PdfViewerModule, typeof i114.TranslocoModule, typeof i120.LacunaMatModule, typeof ApplicationActionsComponent, typeof ApplicationCreateComponent, typeof ApplicationDetailComponent, typeof ApplicationEditComponent, typeof ApplicationEventsComponent, typeof ApplicationKeyCreateComponent, typeof ApplicationKeysComponent, typeof ApplicationListComponent, typeof ApplicationsComponent, typeof BoxComponent, typeof BreadcrumbComponent, typeof BreadcrumbNameComponent, typeof CloseButtonComponent, typeof PrivateAreaUnavailableComponent, typeof DialogMobileAuthorizationRequiredComponent, typeof DialogShowValueComponent, typeof DialogAlertComponent, typeof DialogFancyConfirmComponent, typeof DialogLanguageSelectorComponent, typeof DialogRootLoginComponent, typeof DialogSubscriptionSelectorComponent, typeof DialogConfirmWithCheckboxComponent, typeof DialogUploadErrorComponent, typeof DialogValidationResultsComponent, typeof DialogViewFileComponent, typeof DialogErrorMessagesComponent, typeof DialogEventDetailsComponent, typeof DummyComponent, typeof EventEntityCellComponent, typeof EventListComponent, typeof EventsComponent, typeof FilesActionDirective, typeof FilesComponent, typeof InviteDetailComponent, typeof InviteEditComponent, typeof InviteListComponent, typeof LacunaFooterComponent, typeof LanguageButtonComponent, typeof LanguageSelectorComponent, typeof MessageComponent, typeof NoAccessComponent, typeof PrivateAreaComponent, typeof PropComponent, typeof RootComponent, typeof ServiceUnavailableComponent, typeof SignInComponent, typeof SignOutComponent, typeof SubmitButtonComponent, typeof SubscriptionCreateComponent, typeof SubscriptionDetailComponent, typeof SubscriptionListComponent, typeof SubscriptionFormComponent, typeof SubscriptionEditComponent, typeof SubscriptionsComponent, typeof SuccessPanelComponent, typeof UserAccessEditComponent, typeof UserActionsComponent, typeof UserDetailComponent, typeof UserEditComponent, typeof UserEventsComponent, typeof UserInviteComponent, typeof UserListComponent, typeof UsersComponent, typeof AccessLockedComponent, typeof DialogConfirmWithReasonComponent, typeof ServersListComponent, typeof SpaDialogTitleComponent, typeof ClickableAreaComponent, typeof SelectableAreaComponent, typeof SelectableGroupComponent, typeof LinkButtonComponent, typeof CaptchaComponent, typeof AgentPipe, typeof BreadcrumbPipe, typeof CpfPipe, typeof EntityIconPipe, typeof EntityNamePipe, typeof EventTypePipe, typeof RolesPipe, typeof SubscriptionPipe, typeof FileSizePipe, typeof SafePipe, typeof SpaDatePipe, typeof SpaCurrencyPipe, typeof SpaDecimalPipe, typeof SpaPercentPipe, typeof BooleanPipe, typeof EnabledDisabledPipe, typeof YesNoPipe, typeof DndDirective, typeof CaptchaValueAccessorDirective, typeof SpaDateInput]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LacunaSpaModule>;
}

interface RouteComponents {
    homeComponent: Type<any>;
    layoutComponent: Type<any>;
    privateAreaComponent?: Type<any>;
    signInComponent?: Type<any>;
    signOutComponent?: Type<any>;
    noAccessComponent?: Type<any>;
    privateAreaUnavailableComponent?: Type<any>;
    serviceUnavailableComponent?: Type<any>;
    privateHomeComponent?: Type<any>;
    eventsComponent?: Type<any>;
    accessLockedComponent?: Type<any>;
    subscriptionsComponent?: Type<any>;
    subscriptionCreateComponent?: Type<any>;
    subscriptionDetailComponent?: Type<any>;
    subscriptionEditComponent?: Type<any>;
    usersComponent?: Type<any>;
    userInviteComponent?: Type<any>;
    userDetailComponent?: Type<any>;
    userEventsComponent?: Type<any>;
    userActionsComponent?: Type<any>;
    userEditComponent?: Type<any>;
    userAccessEditComponent?: Type<any>;
    inviteDetailComponent?: Type<any>;
    inviteEditComponent?: Type<any>;
    applicationsComponent?: Type<any>;
    applicationCreateComponent?: Type<any>;
    applicationDetailComponent?: Type<any>;
    applicationEditComponent?: Type<any>;
    applicationEventsComponent?: Type<any>;
    applicationActionsComponent?: Type<any>;
    applicationKeysComponent?: Type<any>;
    applicationKeyCreateComponent?: Type<any>;
}
interface IncrementalRouteTree {
    publicRoutes?: Routes;
    privateRoutes?: Routes;
    subscriptionRoutes?: Routes;
    sysAdminRoutes?: Routes;
}
declare function LacunaSpaRouteTree(routedComponents: RouteComponents, routesLevelsToIncrement: IncrementalRouteTree, homeGuard?: Type<any>, childRedirectGuard?: Type<any>, enableLanguageRoute?: boolean): Routes;
declare function ManagementRoutes(routedComponents: RouteComponents): Routes;

interface LookupRequestItem {
    type: EntityTypes;
    id: string;
}
interface LookupResponseItem {
    type: EntityTypes;
    id: string;
    name: string;
}

declare const LIST_OF_ROLES: InjectionToken<string[]>;
declare const LIST_OF_ROOT_ROLES: InjectionToken<string[]>;
declare const REQUIRED_ID_CLAIMS: InjectionToken<RequiredIdClaims>;
declare const ASYNC_INIT: InjectionToken<boolean>;
declare const ENTITY_NAVIGATOR: InjectionToken<EntityNavigator>;
declare const EVENT_VIEWER: InjectionToken<EventViewer>;
declare const GET_ENTITY_ICON: InjectionToken<GetEntityIconFunction>;
declare const GET_EVENT_TYPE_NAME: InjectionToken<GetEventTypeNameFunction>;
declare const GET_ROLE_NAME: InjectionToken<GetRoleNameFunction>;
declare const LIST_OF_UNASSIGNABLE_ROLES: InjectionToken<string[]>;
declare const GET_BREADCRUMB_DISPLAY_NAME: InjectionToken<GetBreadcrumbDisplayNameFunction>;
declare const ON_API_ERROR: InjectionToken<OnApiErrorFunction>;
declare const LANGUAGE_ROUTE_ENABLED: InjectionToken<boolean>;
declare const LANGUAGE_TO_LOCALES_MAPPING: InjectionToken<HashMap<string[]>>;
declare const OIDC_REDIRECT_PATH: InjectionToken<HashMap<string[]>>;
declare const SPA_ACCESS_LOCKED_SHOW_RETURN_TO_HOME_BUTTON: InjectionToken<HashMap<string[]>>;
declare const SPA_INVISIBLE_CAPTCHA_ENABLED: InjectionToken<boolean>;
declare const SPA_SELECTABLE_GROUP: InjectionToken<{
    readonly mode: SpaSelectableMode;
}>;

declare class SpaValidators {
    static arrayMin(val: number): ValidatorFn;
    static optionalEmail(control: AbstractControl): ValidationErrors | null;
    static requiredEmail(control: AbstractControl): ValidationErrors | null;
    static cpf(control: AbstractControl): ValidationErrors | null;
    static cnpj(control: AbstractControl): ValidationErrors | null;
}

/** Coerces to a boolean like coerceBooleanProperty, but keeps undefined when the input was never set, so that an attribute bound to it is omitted instead of being rendered as "false". */
declare function coerceOptionalBooleanProperty(value: BooleanInput): boolean | undefined;
/** Coerces to an aria-checked value, preserving the "mixed" state used by indeterminate (tri-state) controls. Like coerceOptionalBooleanProperty, keeps undefined when the input was never set. */
declare function coerceAriaCheckedProperty(value: BooleanInput): boolean | 'mixed' | undefined;
declare class StringUtils {
    static removeNonDigits(value: string): string;
    static toUpperCaseFirstLetter(value: string): string;
    static toLowerCaseFirstLetter(value: string): string;
    static htmlEncode(value: string): string;
}
/** Helpers for the arrays of role checkbox controls (one group of { role, enabled } per role) used by the screens that grant access to a subscription. */
declare class RoleFormUtils {
    /** Removes every role control from the given array. */
    static clearRoles(roles: UntypedFormArray): void;
    /**
     * Fills the given array with one control per role, leaving all of them unchecked.
     * The controls are only re-created when the roles themselves change (subscriptions usually offer the same roles), since re-creating them
     * destroys and rebuilds every checkbox, along with the form directives bound to it.
     */
    static setRoleOptions(roles: UntypedFormArray, fb: UntypedFormBuilder, roleNames: string[]): void;
}

declare class AccessLockedGuard implements CanActivate {
    private spaControl;
    private router;
    constructor(spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccessLockedGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccessLockedGuard>;
}

declare class AccessNotLockedGuard implements CanActivate {
    private spaControl;
    private router;
    constructor(spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccessNotLockedGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccessNotLockedGuard>;
}

declare class AuthenticatedGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticatedGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticatedGuard>;
}

declare class ChildRedirectGuard {
    private logger;
    private router;
    constructor(logger: Logger, router: Router);
    canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | Promise<boolean> | boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChildRedirectGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChildRedirectGuard>;
}

declare class ClaimAccessGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClaimAccessGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClaimAccessGuard>;
}

declare class FillSubscriptionGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FillSubscriptionGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FillSubscriptionGuard>;
}

declare class InitSuccessGuard {
    private logger;
    private startup;
    private router;
    constructor(logger: Logger, startup: StartupService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InitSuccessGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InitSuccessGuard>;
}
declare class InitErrorGuard {
    private logger;
    private startup;
    private router;
    constructor(logger: Logger, startup: StartupService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InitErrorGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InitErrorGuard>;
}

declare class NoAccessGuard {
    private logger;
    private spaControl;
    private router;
    private messageService;
    private transloco;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router, messageService: MessageService, transloco: TranslocoService);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NoAccessGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NoAccessGuard>;
}

declare class NotAuthenticatedGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotAuthenticatedGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotAuthenticatedGuard>;
}

declare class ParentIntegrationDisabledGuard {
    private logger;
    private router;
    constructor(logger: Logger, router: Router);
    canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | Promise<boolean> | boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParentIntegrationDisabledGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ParentIntegrationDisabledGuard>;
}
declare class ParentIntegrationEnabledGuard {
    private logger;
    private router;
    constructor(logger: Logger, router: Router);
    canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | Promise<boolean> | boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParentIntegrationEnabledGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ParentIntegrationEnabledGuard>;
}

declare class PrivateAccessGuard {
    private logger;
    private spaControl;
    private router;
    private authenticatedGuard;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router, authenticatedGuard: AuthenticatedGuard);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrivateAccessGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PrivateAccessGuard>;
}

declare class RootAccessGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RootAccessGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RootAccessGuard>;
}

declare class SignOutGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignOutGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignOutGuard>;
}

declare class SpaInitSuccessGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaInitSuccessGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SpaInitSuccessGuard>;
}
declare class SpaInitErrorGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaInitErrorGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SpaInitErrorGuard>;
}

declare class SubscriptionAccessGuard {
    private logger;
    private spaControl;
    private router;
    private messageService;
    private transloco;
    subscriptionGender: GrammaticalGender;
    theSubscription: string;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router, messageService: MessageService, transloco: TranslocoService);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionAccessGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SubscriptionAccessGuard>;
}

declare class SubscriptionSelectedGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionSelectedGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SubscriptionSelectedGuard>;
}

declare class TranslationLoadedGuard {
    private logger;
    private transloco;
    private languageRouteEnabled;
    constructor(logger: Logger, transloco: TranslocoService, languageRouteEnabled: boolean);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationLoadedGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationLoadedGuard>;
}

declare class UserAccessEditGuard {
    private logger;
    private spaControl;
    private router;
    constructor(logger: Logger, spaControl: SpaControlService, router: Router);
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserAccessEditGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserAccessEditGuard>;
}

declare class GlobalSearchService {
    private logger;
    private subscriptionService;
    private userService;
    private appService;
    constructor(logger: Logger, subscriptionService: SubscriptionService, userService: UserService, appService: ApplicationService);
    search(query: string): Observable<GlobalSearchResult[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalSearchService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalSearchService>;
}
declare class GlobalSearchResult {
    type: EntityTypes;
    id: string;
    name: string;
    subscriptionId: string;
    constructor(type: EntityTypes, id: string, name: string, subscriptionId: string);
}

declare class HttpInterceptService {
    private logger;
    private spaApiHeadersService;
    private transloco;
    private onApiError;
    constructor(logger: Logger, spaApiHeadersService: SpaApiHeadersService, transloco: TranslocoService, onApiError: OnApiErrorFunction);
    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpInterceptService, [null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HttpInterceptService>;
}
declare class AppHttpInterceptor implements HttpInterceptor {
    private interceptService;
    constructor(interceptService: HttpInterceptService);
    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppHttpInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppHttpInterceptor>;
}

declare class HttpTranslocoLoader implements TranslocoLoader {
    private http;
    private logger;
    private loadedSubject;
    loaded$: Observable<HashMap<any>>;
    constructor(http: HttpClient, logger: Logger);
    getTranslation(langPath: string): Observable<Translation>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpTranslocoLoader, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HttpTranslocoLoader>;
}

declare class LatestEventsService implements OnDestroy, ObservableSearchService, SearchService<EventModel> {
    private logger;
    private http;
    private spaControl;
    private authManager;
    private $subscriptions;
    private changedSubject;
    changed: Observable<string>;
    constructor(logger: Logger, http: HttpClient, spaControl: SpaControlService, authManager: AuthManagementService);
    list(): Observable<EventModel[]>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LatestEventsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LatestEventsService>;
}

declare class SpaEntityNavigationService implements EntityNavigator {
    private router;
    private logger;
    private routeHelper;
    subManagementRouteUrl: string;
    inSysAdmin: boolean;
    constructor(router: Router, logger: Logger, routeHelper: RouteHelperService);
    navigate(entityType: EntityTypes, id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaEntityNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SpaEntityNavigationService>;
}

export { ASYNC_INIT, AccessLockedComponent, AccessLockedGuard, AccessNotLockedGuard, ActivatedNamedRouteCollection, AgentLookupService, AgentPipe, AgentService, AgentTypes, AppHttpInterceptor, ApplicationActionsComponent, ApplicationCreateComponent, ApplicationDetailComponent, ApplicationEditComponent, ApplicationEventsComponent, ApplicationKeyCreateComponent, ApplicationKeyService, ApplicationKeyServiceFactory, ApplicationKeysComponent, ApplicationListComponent, ApplicationService, ApplicationsComponent, AuthManagementService, AuthenticatedGuard, BaseBooleanPipe, BooleanPipe, BoxComponent, BreadcrumbComponent, BreadcrumbNameComponent, BreadcrumbPipe, CanDeactivateGuard, CaptchaComponent, CaptchaProviders, CaptchaService, CaptchaValueAccessorDirective, ChildRedirectGuard, ChildRedirectTypes, ClaimAccessGuard, ClickableAreaComponent, CloseButtonComponent, Config, CookieStorageService, CpfPipe, DEFAULT_SPA_TRANSLOCO_CONFIG, DialogAlertComponent, DialogConfirmWithCheckboxComponent, DialogConfirmWithReasonComponent, DialogErrorMessagesComponent, DialogEventDetailsComponent, DialogFancyConfirmComponent, DialogLanguageSelectorComponent, DialogMobileAuthorizationRequiredComponent, DialogRootLoginComponent, DialogService, DialogShowValueComponent, DialogSubscriptionSelectorComponent, DialogUploadErrorComponent, DialogValidationResultsComponent, DialogViewFileComponent, DndDirective, DummyComponent, ENTITY_NAVIGATOR, ENTITY_NOT_FOUND, EVENT_VIEWER, EnabledDisabledPipe, EntityEventService, EntityIconPipe, EntityLookupService, EntityNamePipe, EntityTypes, ErrorCodes, EventEntityCellComponent, EventListComponent, EventService, EventTypePipe, EventTypes, EventsComponent, FileSizePipe, FileUploadError, FileUploadErrorInfo, FilesActionDirective, FilesComponent, FillSubscriptionGuard, GET_BREADCRUMB_DISPLAY_NAME, GET_ENTITY_ICON, GET_EVENT_TYPE_NAME, GET_ROLE_NAME, GlobalSearchResult, GlobalSearchService, GrammaticalGender, HttpInterceptService, HttpTranslocoLoader, InitErrorGuard, InitSuccessGuard, InviteDetailComponent, InviteEditComponent, InviteListComponent, InviteSendFailResons, InviteService, LANGUAGE_ROUTE_ENABLED, LANGUAGE_TO_LOCALES_MAPPING, LIST_OF_ROLES, LIST_OF_ROOT_ROLES, LIST_OF_UNASSIGNABLE_ROLES, LacunaFooterComponent, LacunaSpaModule, LacunaSpaRouteTree, LanguageButtonComponent, LanguageSelectorComponent, LatestEventsService, LinkButtonComponent, LocaleSensitivePipe, LogLevels, Logger, ManagementRoutes, MessageComponent, MessageService, NamedRoutes, NoAccessComponent, NoAccessGuard, NotAuthenticatedGuard, OIDC_REDIRECT_PATH, ON_API_ERROR, PaginatedEntityEventService, ParentIntegrationDisabledGuard, ParentIntegrationEnabledGuard, ParentRedirectService, Permissions, PrivateAccessGuard, PrivateAreaComponent, PrivateAreaUnavailableComponent, PropComponent, REQUIRED_ID_CLAIMS, RoleFormUtils, Roles, RolesPipe, RootAccessGuard, RootComponent, RootLoginResult, RootRoles, RouteHelperService, SPA_ACCESS_LOCKED_SHOW_RETURN_TO_HOME_BUTTON, SPA_INVISIBLE_CAPTCHA_ENABLED, SPA_SELECTABLE_GROUP, SafePipe, SelectableAreaComponent, SelectableGroupComponent, ServerService, ServersListComponent, ServiceUnavailableComponent, SignInComponent, SignOutComponent, SignOutGuard, SpaApiHeadersService, SpaConfiguration, SpaControlService, SpaCurrencyPipe, SpaDateInput, SpaDatePipe, SpaDecimalPipe, SpaDialogTitleComponent, SpaEntityNavigationService, SpaErrorHandlingService, SpaInitErrorGuard, SpaInitSuccessGuard, SpaLanguageService, SpaPercentPipe, SpaValidators, StartupService, StringUtils, SubmitButtonComponent, SubscriptionAccessGuard, SubscriptionCreateComponent, SubscriptionDetailComponent, SubscriptionEditComponent, SubscriptionFormComponent, SubscriptionListComponent, SubscriptionPipe, SubscriptionSelectedGuard, SubscriptionService, SubscriptionsComponent, SuccessPanelComponent, TranslationLoadedGuard, UploadEvent, UploadEventTypes, UploadService, UserAccessEditComponent, UserAccessEditGuard, UserActionsComponent, UserDetailComponent, UserDiscoveryPolicies, UserEditComponent, UserEventsComponent, UserInviteComponent, UserListComponent, UserModes, UserProfile, UserService, UsersComponent, YesNoPipe, coerceAriaCheckedProperty, coerceOptionalBooleanProperty, defaultSpaLangToLocalesMapping, defaultSpaLocale, initFactoryFunction, initSpaTranslationFactoryFunction, languageCodeMap, localeCodeMap, onApiErrorFactoryFunction, playerFactory, undefinedBooleanTranslationKey };
export type { AgentBulkLookupResponse, AgentModel, ApiHeaders, ApplicationData, ApplicationKeyModel, ApplicationModel, AuthorizationData, CanComponentDeactivate, CaptchaConfigModel, CaptchaTicketModel, CaptchaTicketRequest, CheckSubscriptionNameAvailabilityResponse, CreateApplicationApiKeyRequest, CreateApplicationApiKeyResponse, CreateInviteResponse, DialogConfirmWithCheckboxResult, DialogConfirmWithReasonData, DialogConfirmWithReasonResult, EntityNavigator, EventModel, EventViewer, FaroAppIdentificationModel, FaroConfigModel, FileModel, GetBreadcrumbDisplayNameFunction, GetEntityIconFunction, GetEventTypeNameFunction, GetRoleNameFunction, IncrementalRouteTree, InviteAuthorizationData, InviteData, InviteModel, JwkModel, LabelsConfigModel, LacunaSpaModuleParams, LanguageName, LanguageParseResultFromUrl, LocaleSensitivePipeArgs, LookupRequestItem, LookupResponseItem, NamedRoute, OidcConfigModel, OnApiErrorFunction, Profile, RequiredIdClaims, RootAuthenticationRequest, RootAuthenticationResponse, RootAuthorizationData, RouteComponents, SpaConfigurationModel, SpaSelectableMode, SubShow, SubscriptionAccess, SubscriptionAccessModel, SubscriptionData, SubscriptionModel, SubscriptionPermissionsModel, UpdateAgentLockStatusRequest, UpdateFilesRequest, UploadInspectionModel, UploadInspectionResultModel, UploadModel, UserData, UserDiscoveryResponse, UserModel, UserPermissionsResponse, WebPkiConfig };