import * as i109 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, 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 i90 from 'lacuna-oauth2-oidc';
import { OAuthStorage, OAuthService } from 'lacuna-oauth2-oidc';
import { CookieService } from 'ngx-cookie-service';
import * as i107 from '@angular/material/snack-bar';
import { MatSnackBarRef, MatSnackBar } from '@angular/material/snack-bar';
import * as i97 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 i114 from '@angular/material/core';
import { ThemePalette } from '@angular/material/core';
import { DomSanitizer, SafeResourceUrl, SafeHtml, SafeStyle, SafeScript, SafeUrl } from '@angular/platform-browser';
import * as i89 from '@angular/forms';
import { FormControl, FormBuilder, UntypedFormGroup, UntypedFormBuilder, UntypedFormArray, AbstractControl, ControlValueAccessor, NgControl, FormGroup, NgForm, FormGroupDirective, ValidatorFn, ValidationErrors } from '@angular/forms';
import * as i115 from '@lacuna/material';
import { ObservableSearchService, PaginatedSearchService, PaginatedSearchParams, PaginatedSearchResult, SearchService, LacunaMatImageViewerConfig } from '@lacuna/material';
import * as i111 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 i116 from 'ngx-lottie';
import { AnimationOptions } from 'ngx-lottie';
import { BooleanInput } from '@angular/cdk/coercion';
import { MatFormFieldControl, MatFormField } from '@angular/material/form-field';
import * as i113 from '@angular/material/datepicker';
import { MatDatepicker } from '@angular/material/datepicker';
import * as i88 from '@angular/common';
import * as i91 from '@angular/material/menu';
import * as i92 from '@angular/material/icon';
import * as i93 from '@angular/material/input';
import * as i94 from '@angular/material/button';
import * as i95 from '@angular/material/toolbar';
import * as i96 from '@angular/material/list';
import * as i98 from '@angular/material/tooltip';
import * as i99 from '@angular/material/card';
import * as i100 from '@angular/material/progress-bar';
import * as i101 from '@angular/material/progress-spinner';
import * as i102 from '@angular/material/sidenav';
import * as i103 from '@angular/material/select';
import * as i104 from '@angular/material/expansion';
import * as i105 from '@angular/material/autocomplete';
import * as i106 from '@angular/material/checkbox';
import * as i108 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 i112 from 'ngx-mask';
import * as i117 from '@angular/material/table';
import * as i118 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 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"
}

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>;
}
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;
}
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;
    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;
    private ensureInitialized;
}
declare const Config: SpaConfiguration;

declare class FaroService {
    private logger;
    private _initialized;
    get initialized(): boolean;
    private _faro;
    get faro(): Faro;
    constructor(logger: Logger);
    init(config: FaroConfigModel): void;
    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;
    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[];
}

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>;
    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;
    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>;
    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 dialogService;
    private agentLookupService;
    private transloco;
    private entityNavigationService;
    private eventViewer;
    dataSource: PaginatedSearchService<EventModel> | SearchService<EventModel>;
    showSubscriptions: boolean;
    hideEntities: boolean;
    hideAgents: boolean;
    disablePagination: boolean;
    get columnsToDisplay(): string[];
    constructor(dialogService: DialogService, agentLookupService: AgentLookupService, transloco: TranslocoService, 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 addFile;
    private addEmptyFile;
    private setCaptchaHeaders;
    fileButtonClick(): void;
    delete(file: any): void;
    viewFile(file: any): void;
    testClick(): 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;
    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;
    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;
    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 {
    trigger: EventEmitter<void>;
    stretch: boolean;
    constructor();
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClickableAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ClickableAreaComponent, "spa-clickable-area", never, { "stretch": { "alias": "stretch"; "required": false; }; }, { "trigger": "trigger"; }, never, ["*"], false, never>;
    static ngAcceptInputType_stretch: any;
}

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>;
}

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<i109.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 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 DndDirective, typeof CaptchaValueAccessorDirective, typeof SpaDateInput, typeof EntityTypePipe], [typeof i88.CommonModule, typeof i89.FormsModule, typeof i89.ReactiveFormsModule, typeof i90.OAuthModule, typeof i91.MatMenuModule, typeof i92.MatIconModule, typeof i93.MatInputModule, typeof i94.MatButtonModule, typeof i95.MatToolbarModule, typeof i96.MatListModule, typeof i97.MatDialogModule, typeof i98.MatTooltipModule, typeof i99.MatCardModule, typeof i100.MatProgressBarModule, typeof i101.MatProgressSpinnerModule, typeof i102.MatSidenavModule, typeof i103.MatSelectModule, typeof i104.MatExpansionModule, typeof i105.MatAutocompleteModule, typeof i106.MatCheckboxModule, typeof i107.MatSnackBarModule, typeof i108.PdfViewerModule, typeof i109.TranslocoModule, typeof TranslocoIntlMessageFormatModule, typeof i111.RouterModule, typeof i112.NgxMaskDirective, typeof i112.NgxMaskPipe, typeof i113.MatDatepickerModule, typeof i114.MatNativeDateModule, typeof i115.LacunaMatModule, typeof i116.LottieComponent], [typeof i89.FormsModule, typeof i89.ReactiveFormsModule, typeof i91.MatMenuModule, typeof i92.MatIconModule, typeof i97.MatDialogModule, typeof i94.MatButtonModule, typeof i93.MatInputModule, typeof i95.MatToolbarModule, typeof i96.MatListModule, typeof i99.MatCardModule, typeof i101.MatProgressSpinnerModule, typeof i102.MatSidenavModule, typeof i104.MatExpansionModule, typeof i105.MatAutocompleteModule, typeof i106.MatCheckboxModule, typeof i117.MatTableModule, typeof i118.MatSortModule, typeof i107.MatSnackBarModule, typeof i108.PdfViewerModule, typeof i109.TranslocoModule, typeof i115.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 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 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 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;
}

declare class StringUtils {
    static removeNonDigits(value: string): string;
    static toUpperCaseFirstLetter(value: string): string;
    static toLowerCaseFirstLetter(value: string): string;
    static htmlEncode(value: string): string;
}

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, 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, 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, Roles, RolesPipe, RootAccessGuard, RootComponent, RootLoginResult, RootRoles, RouteHelperService, SPA_ACCESS_LOCKED_SHOW_RETURN_TO_HOME_BUTTON, SPA_INVISIBLE_CAPTCHA_ENABLED, SafePipe, 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, UserEditComponent, UserEventsComponent, UserInviteComponent, UserListComponent, UserModes, UserProfile, UserService, UsersComponent, defaultSpaLangToLocalesMapping, defaultSpaLocale, initFactoryFunction, initSpaTranslationFactoryFunction, languageCodeMap, localeCodeMap, onApiErrorFactoryFunction, playerFactory };
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, SubShow, SubscriptionAccess, SubscriptionAccessModel, SubscriptionData, SubscriptionModel, SubscriptionPermissionsModel, UpdateAgentLockStatusRequest, UpdateFilesRequest, UploadInspectionModel, UploadInspectionResultModel, UploadModel, UserData, UserModel, UserPermissionsResponse, WebPkiConfig };