import * as i0 from '@angular/core';
import { EventEmitter, ChangeDetectorRef, Type, ElementRef, NgZone, Injector, TemplateRef, SimpleChanges } from '@angular/core';
import * as i2 from '@angular/router';
import { Router, ActivatedRoute, UrlTree, UrlSegment, Data } from '@angular/router';
import { Title, DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
import { AppEmbeddingExtensions, MessageService, UtilityService, ExportService } from '@esfaenza/extensions';
import { AppState, TokenService, CompletedJobRedirectionService, GlobalSearchService, UserPreferencesService, MenuFilteringService } from '@esfaenza/core/services';
import { HTTPService } from '@esfaenza/httpservice';
import * as i1 from '@angular/common';
import { Location } from '@angular/common';
import { AccessControlService } from '@esfaenza/access-control';
import { BaseMessageService, NotificationsService } from '@esfaenza/signalr-notifications';
import { PreferencesService, CacheService } from '@esfaenza/preferences';
import * as i5 from '@esfaenza/localizations';
import { LocalizationService } from '@esfaenza/localizations';
import { JaceIdentity, ApplicationJob, ApplicationMenu, SearchResult, SearchResultContainer, ActiveModuleView, EntityFeedsWidgetConfiguration, Feed, CreateUpdateFeedDto, UserAccount, UpdatePasswordDto } from '@esfaenza/core/domain';
import { Subscription, ReplaySubject, Subject } from 'rxjs';
import * as i3 from '@angular/forms';
import { NgForm, NgModel } from '@angular/forms';
import * as i4 from '@esfaenza/core/directives';
import * as i6 from 'ngx-bootstrap/progressbar';
import * as i7 from 'ngx-bootstrap/dropdown';
import * as i8 from 'ngx-bootstrap/modal';
import { ModalDirective } from 'ngx-bootstrap/modal';
import * as i9 from '@esfaenza/es-table';
import { ThTdProvider, AppSearch } from '@esfaenza/es-table';
import { ImageTransform, ImageCroppedEvent } from 'ngx-image-cropper';
import { AppFile } from '@esfaenza/forms-and-validations';
import { DropdownOption } from '@esfaenza/utility-components';
import { HttpParams } from '@angular/common/http';

declare class BackTop {
    position: number;
    showSpeed: number;
    moveSpeed: number;
    private _selector;
    ngAfterViewInit(): void;
    _onClick(): boolean;
    _onWindowScroll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BackTop, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BackTop, "back-top", never, { "position": { "alias": "position"; "required": false; }; "showSpeed": { "alias": "showSpeed"; "required": false; }; "moveSpeed": { "alias": "moveSpeed"; "required": false; }; }, {}, never, never, true, never>;
}

declare class Breadcrumb {
    _state: AppState;
    private router;
    private _activatedRoute;
    private _titleService;
    private emb;
    MainLink: BreadcrumbItem;
    SubLinks: BreadcrumbItem[];
    constructor(_state: AppState, router: Router, _activatedRoute: ActivatedRoute, _titleService: Title, emb: AppEmbeddingExtensions);
    handleNavigation(title: string, internal: boolean, tree?: UrlTree): void;
    ngOnInit(): void;
    onSubNavigation(tree: UrlTree, title: string): void;
    onMainNavigation(tree: UrlTree, title: string): void;
    private getRouterLink;
    static ɵfac: i0.ɵɵFactoryDeclaration<Breadcrumb, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Breadcrumb, "breadcrumb", never, {}, {}, never, never, true, never>;
}
declare class BreadcrumbItem {
    title: string;
    routerLink: any[];
}

declare class EsModalComponent {
    _state: AppState;
    Size: string;
    IgnoreBackdrop: boolean;
    Backdrop: boolean;
    HasOverlap: boolean;
    onShow: EventEmitter<void>;
    onHide: EventEmitter<void>;
    constructor(_state: AppState);
    private Modal;
    show(): void;
    hide(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EsModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EsModalComponent, "es-modal", never, { "Size": { "alias": "Size"; "required": false; }; "IgnoreBackdrop": { "alias": "IgnoreBackdrop"; "required": false; }; "Backdrop": { "alias": "Backdrop"; "required": false; }; "HasOverlap": { "alias": "HasOverlap"; "required": false; }; }, { "onShow": "onShow"; "onHide": "onHide"; }, never, ["*"], true, never>;
}

declare class ErrorPageComponent {
    private router;
    private route;
    private msgService;
    private http;
    private bts;
    private emb;
    ANONYMOUS_MODE: boolean;
    statusCode: string;
    statusText: string;
    errorMessage: string;
    errorFrom: string;
    errorLastCalls: string;
    previousUrl: string;
    identityInfos: string;
    errorLastRequests: string;
    errorLastResponses: string;
    debugging: boolean;
    constructor(router: Router, route: ActivatedRoute, msgService: MessageService, http: HTTPService, bts: TokenService, emb: AppEmbeddingExtensions, ANONYMOUS_MODE: boolean);
    ngOnInit(): void;
    b64DecodeUnicode(str: any): string;
    goPreviousPage(): void;
    goDashboard(): void;
    dlgCreateTicket: EsModalComponent;
    CreateTicketDTO: any;
    canReport: boolean;
    onCreateTicket(): void;
    doCreateTicket(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorPageComponent, "errorpage", never, {}, {}, never, never, true, never>;
}

declare class PagesComponent {
    sanitizer: DomSanitizer;
    _state: AppState;
    private _location;
    router: Router;
    isMenuCollapsed: boolean;
    maxHeight: number;
    dynamicCSSUrl: SafeResourceUrl;
    loadedModuleCss: string;
    constructor(sanitizer: DomSanitizer, _state: AppState, _location: Location, router: Router);
    ngOnInit(): void;
    getCurrentPageName(): void;
    hideMenu(): void;
    getHeight(): void;
    onResize(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PagesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PagesComponent, "pages", never, {}, {}, never, never, true, never>;
}

declare class ExternalPagesComponent {
    emb: AppEmbeddingExtensions;
    private route;
    anonymousMode: boolean;
    constructor(emb: AppEmbeddingExtensions, _state: AppState, route: ActivatedRoute, bts: TokenService, aac: AccessControlService, anonymousMode: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalPagesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExternalPagesComponent, "external-pages", never, {}, {}, never, never, true, never>;
}

declare class JaceLoginComponent {
    loginUrlLegacy: boolean;
    constructor(loginUrlLegacy: boolean);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JaceLoginComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JaceLoginComponent, "login", never, {}, {}, never, never, true, never>;
}

declare abstract class ReactiveComponent {
    protected Subscriptions: Subscription[];
    protected destroyed$: ReplaySubject<boolean>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReactiveComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReactiveComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class Navbar extends ReactiveComponent {
    private prefsService;
    private cacheService;
    private MessageDef;
    private notifications;
    private msgExts;
    lc: LocalizationService;
    private http;
    cdr: ChangeDetectorRef;
    _state: AppState;
    sr: TokenService;
    private router;
    private cjrService;
    extensionComponents: Type<any>[];
    loginUrlLegacy: boolean;
    ANONYMOUS_MODE: boolean;
    applicationVersion: string;
    applicationEnvironment: string;
    isMenuCollapsed: boolean;
    anomaliesProcessing: boolean;
    CurrentIdentity: JaceIdentity;
    private newVersionWarned;
    navbar: ElementRef;
    constructor(prefsService: PreferencesService, cacheService: CacheService, MessageDef: BaseMessageService, notifications: NotificationsService, msgExts: MessageService, lc: LocalizationService, http: HTTPService, cdr: ChangeDetectorRef, _state: AppState, sr: TokenService, router: Router, cjrService: CompletedJobRedirectionService, extensionComponents: Type<any>[], loginUrlLegacy: boolean, ANONYMOUS_MODE: boolean);
    ngOnDestroy(): void;
    private handleBaseNotifications;
    private checkIdentity;
    private checkSessionTimeout;
    ngAfterViewInit(): void;
    goToDashboard(): void;
    toggleMenu(): void;
    logout(): void;
    changeModule(): void;
    changeTenant(): void;
    clearUserPreferences(warn?: boolean): void;
    clearCacheClient(warn?: boolean): void;
    clearCacheServer(): void;
    clearAll(): void;
    forceClearConnectedClientAssets(muo: 'cache' | 'preferences'): void;
    clearMessages(): void;
    completedJobClicked(job: ApplicationJob): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Navbar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Navbar, "navbar", never, {}, {}, never, ["*"], true, never>;
}

declare class RedirecterComponent {
    _state: AppState;
    private route;
    router: Router;
    private redirectMap;
    private emb;
    Error: string;
    tenant: string;
    private wrongTenant;
    constructor(_state: AppState, route: ActivatedRoute, router: Router, redirectMap: {
        [index: string]: {
            url: string;
            params: string[];
        };
    }, emb: AppEmbeddingExtensions);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RedirecterComponent, [null, null, null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RedirecterComponent, "redirecter", never, {}, {}, never, never, true, never>;
}

declare class Sidebar {
    lc: LocalizationService;
    private cdr;
    private _elementRef;
    private _router;
    _state: AppState;
    private zone;
    private utiExts;
    private aac;
    private menuItemsRaw;
    private menuFilteringService;
    sr: TokenService;
    globalSearchService: GlobalSearchService;
    profile: UserPreferencesService;
    private msgExts;
    menuItems: Array<any>;
    menuHeight: number;
    isMenuCollapsed: boolean;
    isMenuShouldCollapsed: boolean;
    showHoverElem: boolean;
    hoverElemHeight: number;
    hoverElemTop: number;
    applicationVersion: string;
    applicationName: string;
    user: string;
    tenant: string;
    sidebar: ElementRef;
    constructor(lc: LocalizationService, lcMenu: Type<LocalizationService>, cdr: ChangeDetectorRef, _elementRef: ElementRef, _router: Router, _state: AppState, zone: NgZone, utiExts: UtilityService, aac: AccessControlService, menuItemsRaw: ApplicationMenu[], menuFilteringService: MenuFilteringService, sr: TokenService, globalSearchService: GlobalSearchService, profile: UserPreferencesService, msgExts: MessageService);
    ngOnInit(): Promise<void>;
    private getMenuItems;
    private checkSubMenuOverClaims;
    onWindowResize(): void;
    private _shouldMenuCollapse;
    menuCollapse(): void;
    menuCollapseStateChange(isCollapsed: boolean): void;
    menuExpand(): void;
    hoverItem(jQueryevent: any): void;
    sendAwayHoverElement(): void;
    updateSidebarHeight(): void;
    collapseMenu(jQueryevent: any, item: any): boolean;
    private outsideAngularClickHandler;
    onChangeTenant(): void;
    onLogout(): void;
    private getUserProfileData;
    SelectedResult: SearchResult;
    ShowSingleTable: boolean;
    searchTerm: string;
    searchingTerm: boolean;
    searchResult: SearchResultContainer;
    onSearchRequest(): void;
    onSearchModelChanged(): void;
    closeSearch(): void;
    FilterSearchResults(item?: SearchResult): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Sidebar, [null, { optional: true; }, null, null, null, null, null, null, null, null, null, null, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Sidebar, "sidebar", never, {}, {}, never, never, true, never>;
}

declare abstract class BaseComponent extends ReactiveComponent {
    protected CompletePath: string;
    protected ComponentPath: string;
    protected BasePath: string;
    protected Parameters: {
        [name: string]: string;
    };
    protected QueryParameters: {
        [name: string]: string;
    };
    protected InternalNavigation: boolean;
    protected NavigationTitle: string;
    private _router;
    private _emb;
    constructor(injector: Injector);
    gatherRouteInformations(segs: UrlSegment[], data: Data): void;
    protected navigate(command: any[], extras?: any): void;
    back(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class JaceResourceComponent {
    private cdr;
    private _state;
    private sanitizer;
    Module: string;
    ModuleKeyType: 'altid' | 'id';
    Page: string;
    Localhost: string;
    Params: {
        [id: string]: string;
    };
    Height: number;
    sanitizedSourceResource: SafeResourceUrl;
    constructor(cdr: ChangeDetectorRef, _state: AppState, sanitizer: DomSanitizer);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    afterModulesRetrieve(modules: ActiveModuleView[]): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<JaceResourceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JaceResourceComponent, "jace-resource", never, { "Module": { "alias": "Module"; "required": false; }; "ModuleKeyType": { "alias": "ModuleKeyType"; "required": false; }; "Page": { "alias": "Page"; "required": false; }; "Localhost": { "alias": "Localhost"; "required": false; }; "Params": { "alias": "Params"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EsModalHeadComponent {
    _state: AppState;
    AllowClose: boolean;
    Close: EventEmitter<void>;
    constructor(_state: AppState);
    CloseFunction(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EsModalHeadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EsModalHeadComponent, "es-modal-head", never, { "AllowClose": { "alias": "AllowClose"; "required": false; }; }, { "Close": "Close"; }, never, ["*"], true, never>;
}

declare class LabeledSpanComponent {
    H_MODE: string;
    V_MODE: string;
    First: boolean;
    Label: string;
    Display: "Horizontal" | "Vertical";
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LabeledSpanComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LabeledSpanComponent, "labeled-span", never, { "First": { "alias": "First"; "required": false; }; "Label": { "alias": "Label"; "required": false; }; "Display": { "alias": "Display"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class EsImageCropperComponent {
    Height: number;
    Width: number;
    constructor();
    ProfileImage: AppFile;
    private _OutputImage;
    get OutputImage(): any;
    canvasRotation: number;
    scale: number;
    transform: ImageTransform;
    onResetImage(): void;
    onImageCropped(event: ImageCroppedEvent): void;
    onRotateLeft(): void;
    onRotateRight(): void;
    onFlipHorizontal(): void;
    onFlipVertical(): void;
    private doFlipAfterRotate;
    onZoomOut(): void;
    onZoomIn(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EsImageCropperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EsImageCropperComponent, "es-image-cropper", never, { "Height": { "alias": "Height"; "required": false; }; "Width": { "alias": "Width"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormSelectorComponent {
    SetValidationSubject: Subject<{
        fieldName: string;
        error: string;
    }>;
    ModalOnly: i0.InputSignal<boolean>;
    Valid: i0.InputSignal<boolean>;
    SelectedLabel: i0.ModelSignal<any>;
    Validation: i0.InputSignal<boolean>;
    Readonly: i0.InputSignal<boolean>;
    Form: i0.InputSignal<NgForm>;
    Name: i0.InputSignal<string>;
    ngModelOptions: any;
    Required: i0.InputSignal<boolean>;
    Placeholder: i0.InputSignal<string>;
    HasExternalLink: i0.InputSignal<boolean>;
    onChange: EventEmitter<void>;
    onSearch: EventEmitter<void>;
    onNavigation: EventEmitter<void>;
    onClipboardCopy: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormSelectorComponent, "form-selector", never, { "SetValidationSubject": { "alias": "SetValidationSubject"; "required": false; }; "ModalOnly": { "alias": "ModalOnly"; "required": false; "isSignal": true; }; "Valid": { "alias": "Valid"; "required": false; "isSignal": true; }; "SelectedLabel": { "alias": "SelectedLabel"; "required": false; "isSignal": true; }; "Validation": { "alias": "Validation"; "required": false; "isSignal": true; }; "Readonly": { "alias": "Readonly"; "required": false; "isSignal": true; }; "Form": { "alias": "Form"; "required": false; "isSignal": true; }; "Name": { "alias": "Name"; "required": false; "isSignal": true; }; "ngModelOptions": { "alias": "ngModelOptions"; "required": false; "isSignal": true; }; "Required": { "alias": "Required"; "required": false; "isSignal": true; }; "Placeholder": { "alias": "Placeholder"; "required": false; "isSignal": true; }; "HasExternalLink": { "alias": "HasExternalLink"; "required": false; "isSignal": true; }; }, { "SelectedLabel": "SelectedLabelChange"; "onChange": "onChange"; "onSearch": "onSearch"; "onNavigation": "onNavigation"; "onClipboardCopy": "onClipboardCopy"; }, never, never, true, never>;
}

declare class FormSelectorDialogComponent {
    Subject: string;
    EsTableTemplate: ThTdProvider;
    TableClasses: string;
    SingleSelection: boolean;
    searchView: any;
    onClearValue: EventEmitter<void>;
    onCloseDialog: EventEmitter<void>;
    onConfirmSelection: EventEmitter<void>;
    onSearchRequest: EventEmitter<boolean>;
    onDialogVisibilityChange: EventEmitter<boolean>;
    itemSearch: EsModalComponent;
    show(): void;
    hide(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormSelectorDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormSelectorDialogComponent, "form-selector-dialog", never, { "Subject": { "alias": "Subject"; "required": false; }; "EsTableTemplate": { "alias": "EsTableTemplate"; "required": false; }; "TableClasses": { "alias": "TableClasses"; "required": false; }; "SingleSelection": { "alias": "SingleSelection"; "required": false; }; "searchView": { "alias": "searchView"; "required": false; }; }, { "onClearValue": "onClearValue"; "onCloseDialog": "onCloseDialog"; "onConfirmSelection": "onConfirmSelection"; "onSearchRequest": "onSearchRequest"; "onDialogVisibilityChange": "onDialogVisibilityChange"; }, never, ["[filters]"], true, never>;
}

declare class EntityFeedsWidgetComponent {
    private http;
    private utiExts;
    private msgs;
    private tks;
    EntityType: string;
    EntityId: string;
    RefreshSubject: Subject<void>;
    GetFeedsAPI: string;
    CreateFeedAPI: string;
    UpdateFeedAPI: string;
    DeleteFeedAPI: string;
    ReactToFeedAPI: string;
    GetUserTagsAPI: string;
    GetFeedAttachmentAPI: string;
    WidgetTitle: string;
    MaxHeight: string;
    Readonly: boolean;
    AllowUserTags: boolean;
    AllowReactions: boolean;
    AllowAttachments: boolean;
    AllowComments: boolean;
    AllowReplies: boolean;
    DebugMode: boolean;
    ModuleConfig: EntityFeedsWidgetConfiguration;
    FLAG_RefreshingFeeds: boolean;
    Feeds: Feed[];
    LoggedUser: string;
    FeedContentFilter: string;
    UserTags: string[];
    private refreshSub;
    constructor(http: HTTPService, utiExts: UtilityService, msgs: MessageService, tks: TokenService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    doRefreshFeeds(): void;
    onDownloadFeedAttachment(item: Feed): void;
    dlgCreateUpdateFeed: EsModalComponent;
    CreateUpdateFeedDTO: CreateUpdateFeedDto;
    AllegatoFile: AppFile;
    EditMode: boolean;
    onCreateFeed(isReply?: boolean): void;
    onUpdateFeed(): void;
    doCreateUpdateFeed(): void;
    onDeleteFeed(): void;
    private doDeleteFeed;
    onReactToFeed(item: Feed, idReaction: string): void;
    private doReactToFeed;
    dlgFeedContentDetails: EsModalComponent;
    FeedContentDetails: string;
    onShowFeedContent(item: string): void;
    SelectedFeed: Feed;
    FeedsOperations: DropdownOption[];
    onSelectFeed(item: Feed): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityFeedsWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EntityFeedsWidgetComponent, "entity-feeds-widget", never, { "EntityType": { "alias": "EntityType"; "required": false; }; "EntityId": { "alias": "EntityId"; "required": false; }; "RefreshSubject": { "alias": "RefreshSubject"; "required": false; }; "GetFeedsAPI": { "alias": "GetFeedsAPI"; "required": false; }; "CreateFeedAPI": { "alias": "CreateFeedAPI"; "required": false; }; "UpdateFeedAPI": { "alias": "UpdateFeedAPI"; "required": false; }; "DeleteFeedAPI": { "alias": "DeleteFeedAPI"; "required": false; }; "ReactToFeedAPI": { "alias": "ReactToFeedAPI"; "required": false; }; "GetUserTagsAPI": { "alias": "GetUserTagsAPI"; "required": false; }; "GetFeedAttachmentAPI": { "alias": "GetFeedAttachmentAPI"; "required": false; }; "WidgetTitle": { "alias": "WidgetTitle"; "required": false; }; "MaxHeight": { "alias": "MaxHeight"; "required": false; }; "Readonly": { "alias": "Readonly"; "required": false; }; "AllowUserTags": { "alias": "AllowUserTags"; "required": false; }; "AllowReactions": { "alias": "AllowReactions"; "required": false; }; "AllowAttachments": { "alias": "AllowAttachments"; "required": false; }; "AllowComments": { "alias": "AllowComments"; "required": false; }; "AllowReplies": { "alias": "AllowReplies"; "required": false; }; "DebugMode": { "alias": "DebugMode"; "required": false; }; "ModuleConfig": { "alias": "ModuleConfig"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ComponentsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ComponentsModule, never, [typeof i1.CommonModule, typeof i2.RouterModule, typeof i3.FormsModule, typeof i4.DirectivesModule, typeof i5.LocalizationModule, typeof i6.ProgressbarModule, typeof i7.BsDropdownModule, typeof i8.ModalModule, typeof i9.EsTableModule, typeof BackTop, typeof Breadcrumb, typeof ErrorPageComponent, typeof PagesComponent, typeof ExternalPagesComponent, typeof JaceLoginComponent, typeof Navbar, typeof RedirecterComponent, typeof Sidebar, typeof JaceResourceComponent, typeof EsModalComponent, typeof EsModalHeadComponent, typeof LabeledSpanComponent, typeof EsImageCropperComponent, typeof FormSelectorComponent, typeof FormSelectorDialogComponent, typeof EntityFeedsWidgetComponent], [typeof BackTop, typeof Breadcrumb, typeof ErrorPageComponent, typeof PagesComponent, typeof ExternalPagesComponent, typeof JaceLoginComponent, typeof Navbar, typeof RedirecterComponent, typeof Sidebar, typeof JaceResourceComponent, typeof EsModalComponent, typeof EsModalHeadComponent, typeof LabeledSpanComponent, typeof EsImageCropperComponent, typeof FormSelectorComponent, typeof FormSelectorDialogComponent, typeof EntityFeedsWidgetComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ComponentsModule>;
}

declare class EmbeddingComponent extends BaseComponent {
    private injector;
    private emb;
    Module: string;
    Localhost: string;
    Page: string;
    Pars: string;
    QueryPars: string;
    EmbeddingSuccesfull: boolean;
    constructor(injector: Injector, emb: AppEmbeddingExtensions);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmbeddingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmbeddingComponent, "embedding", never, {}, {}, never, never, true, never>;
}

declare class UserInfosComponent extends BaseComponent {
    private tks;
    msgExts: MessageService;
    expExts: ExportService;
    utiExts: UtilityService;
    lc: LocalizationService;
    _state: AppState;
    profile: UserPreferencesService;
    private prefs;
    private PREFS_DISABLE_EFFECTS;
    AccountDetails: UserAccount;
    AccountRoles: string[];
    AccountPermissions: string[];
    GraphicEffectsDeactivated: boolean;
    constructor(inj: Injector, tks: TokenService, msgExts: MessageService, expExts: ExportService, utiExts: UtilityService, lc: LocalizationService, _state: AppState, profile: UserPreferencesService, prefs: PreferencesService);
    ngOnInit(): Promise<void>;
    effectsActiveChanged(): Promise<void>;
    getAccountDetails(): Promise<void>;
    dlgShowAccountRoles: EsModalComponent;
    onShowAccountRoles(): void;
    dlgUpdateProfilePicture: EsModalComponent;
    imageCropper: EsImageCropperComponent;
    UpdateProfilePictureDTO: {
        image: AppFile;
    };
    onUpdateProfilePicture(): void;
    doUpdateProfilePicture(): Promise<void>;
    onDeleteProfilePicture(): void;
    doDeleteProfilePicture(): Promise<void>;
    dlgUpdateRecoverySettings: EsModalComponent;
    UpdateRecoverySettingsDTO: {
        email: string;
    };
    onUpdateRecoverySettings(): void;
    doUpdateRecoverySettings(): Promise<void>;
    dlgUpdatePassword: EsModalComponent;
    UpdatePasswordDTO: UpdatePasswordDto;
    CustomError: string;
    onUpdatePassword(): void;
    doUpdatePassword(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserInfosComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserInfosComponent, "user-infos", never, {}, {}, never, never, true, never>;
}

declare class BaseSelectorInitialization<TSearch> {
    subject: string;
    searchType: new () => TSearch;
    searchApi: string;
    navigationEntity?: string;
    searchIndependantProperties?: string[];
    idProperty?: string;
    constructor(subject: string, searchType: new () => TSearch, searchApi: string, navigationEntity?: string, searchIndependantProperties?: string[], idProperty?: string);
}

declare class BaseSelectorComponent<TSearch extends AppSearch<TItem>, TItem> {
    private injector;
    Initialized: ReplaySubject<boolean>;
    itemSearch: i0.Signal<ModalDirective>;
    EsTableTemplate: i0.Signal<ThTdProvider>;
    EsTableTemplateComponent: i0.Signal<ThTdProvider>;
    FiltersTemplate: i0.Signal<TemplateRef<any>>;
    ModalOnly: boolean;
    EntityName: string;
    searchModal: ModalDirective;
    inputChange: EventEmitter<TItem[] | TItem>;
    firstValueLoaded: EventEmitter<void>;
    protected SelectedItems: string[];
    SelectedObjects: TItem[];
    SelectedLabel: string;
    propagateChange: (_: any) => void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    DisplayMode: boolean;
    Readonly: boolean;
    Form: NgForm;
    Placeholder: string;
    ngModelOptions: any;
    SingleSelection: boolean;
    Required: boolean;
    Validation: boolean;
    PageSize: number;
    Navigation: boolean;
    EmitStartingValue: boolean;
    dialogVisible: EventEmitter<boolean>;
    dialogHidden: EventEmitter<boolean>;
    inputFinalized: EventEmitter<string>;
    name: string;
    searchView: TSearch;
    protected nameof: <T>(name: Extract<keyof T, string>) => string;
    subject: string;
    private searchType;
    private searchApi;
    private itemIdProperty;
    private searchIndependantProperties;
    navigationEntity: string;
    protected applyFilters(view: TSearch, firstApplication?: boolean, onlyEssentials?: boolean): void;
    protected applyIdFilter(view: TSearch, itemid?: string): void;
    protected evaluateLabel(item: TItem[]): string;
    protected loadSearchDictionaries(): Promise<void>;
    protected Initialize(): BaseSelectorInitialization<TSearch>;
    private firstApplication;
    ngControl: NgModel;
    Pristine: boolean;
    private CurrentValue;
    ac: AccessControlService;
    ValidationSubject: Subject<{
        fieldName: string;
        error: string;
    }>;
    destroyed$: Subject<void>;
    private router;
    lc: LocalizationService;
    http: HTTPService;
    state: AppState;
    private msgExts;
    private clipboardService;
    private hashingService;
    private redirectMap;
    private routesMap;
    constructor(injector: Injector);
    _outer: BaseSelectorComponent<any, any>;
    bridge(outer: BaseSelectorComponent<any, any>): void;
    ngOnInit(): Promise<void>;
    ngOnDestroy(): Promise<void>;
    ngOnChanges(changes: SimpleChanges): Promise<void>;
    resetSearch(applyFilters?: boolean): boolean;
    initStartValue(valueId: string): void;
    ensureClosed(): void;
    confirmSelection(): Promise<void>;
    sendSearch(resetPage?: boolean, selectResults?: boolean, applyOtherFilters?: boolean): boolean;
    private afterSearch;
    writeValue(obj: any): Promise<void>;
    changed(emit?: boolean): void;
    cleanSelection(): void;
    modalVisible(visible: boolean): void;
    copyToClipboard(subjectOverride?: string): boolean;
    navigate(): void;
    private SelectAll;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSelectorComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseSelectorComponent<any, any>, "base-selector", never, { "ModalOnly": { "alias": "ModalOnly"; "required": false; }; "EntityName": { "alias": "EntityName"; "required": false; }; "DisplayMode": { "alias": "DisplayMode"; "required": false; }; "Readonly": { "alias": "Readonly"; "required": false; }; "Form": { "alias": "Form"; "required": false; }; "Placeholder": { "alias": "Placeholder"; "required": false; }; "ngModelOptions": { "alias": "ngModelOptions"; "required": false; }; "SingleSelection": { "alias": "SingleSelection"; "required": false; }; "Required": { "alias": "Required"; "required": false; }; "Validation": { "alias": "Validation"; "required": false; }; "PageSize": { "alias": "PageSize"; "required": false; }; "Navigation": { "alias": "Navigation"; "required": false; }; "EmitStartingValue": { "alias": "EmitStartingValue"; "required": false; }; "name": { "alias": "name"; "required": false; }; "ValidationSubject": { "alias": "ValidationSubject"; "required": false; }; }, { "inputChange": "inputChange"; "firstValueLoaded": "firstValueLoaded"; "dialogVisible": "dialogVisible"; "dialogHidden": "dialogHidden"; "inputFinalized": "inputFinalized"; }, ["EsTableTemplate", "FiltersTemplate"], never, true, never>;
}

declare abstract class BaseSearchComponent<TSearch extends AppSearch<TItem>, TItem> extends BaseComponent {
    searchView: TSearch;
    protected HotView: string;
    protected SearchURL: string;
    protected SearchType: new () => TSearch;
    protected ItemType: new () => TItem;
    protected http: HTTPService;
    protected utiExts: UtilityService;
    protected msgExts: MessageService;
    private location;
    private localStorage;
    private route;
    lc: LocalizationService;
    constructor(injector: Injector);
    ngOnInit(): void;
    private init;
    private createOrLoadView;
    sendSearch(): void;
    onSearchRequest(resetPage?: boolean): void;
    private RetrieveProto;
    prepareExport(callback: any, limit?: number, pars?: HttpParams): void;
    abstract initialize(): [string, string, new () => TSearch, new () => TItem] | any;
    protected getDictionaries(): Promise<void>;
    protected afterLoadView(_: TSearch): void;
    protected afterCreateView(_: TSearch): void;
    protected reviewBindings(): void;
    protected canPerformSearch(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSearchComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseSearchComponent<any, any>, "ng-component", never, {}, {}, never, never, true, never>;
}

export { BackTop, BaseComponent, BaseSearchComponent, BaseSelectorComponent, BaseSelectorInitialization, Breadcrumb, BreadcrumbItem, ComponentsModule, EmbeddingComponent, EntityFeedsWidgetComponent, ErrorPageComponent, EsImageCropperComponent, EsModalComponent, EsModalHeadComponent, ExternalPagesComponent, FormSelectorComponent, FormSelectorDialogComponent, JaceLoginComponent, JaceResourceComponent, LabeledSpanComponent, Navbar, PagesComponent, ReactiveComponent, RedirecterComponent, Sidebar, UserInfosComponent };
