import * as i0 from '@angular/core';
import { OnInit, OnChanges, ElementRef, EventEmitter, OnDestroy, QueryList, Renderer2, ModuleWithProviders, TemplateRef, ViewContainerRef, SimpleChanges, InputSignal, OutputEmitterRef, AfterViewInit } from '@angular/core';
import * as i2 from '@angular/forms';
import { FormGroupDirective, ValidatorFn, AbstractControl, UntypedFormGroup, AbstractControlOptions, AsyncValidatorFn } from '@angular/forms';
import * as i3 from '@progress/kendo-angular-buttons';
import * as i4 from '@ngx-translate/core';
import { TranslateService, TranslateLoader } from '@ngx-translate/core';
import * as i2$1 from '@angular/common';
import * as i7 from '@progress/kendo-angular-upload';
import { FileRestrictions, SelectEvent } from '@progress/kendo-angular-upload';
import * as i6 from '@angular/common/http';
import { HttpClient, HttpErrorResponse, HttpContextToken } from '@angular/common/http';
import * as i5 from '@progress/kendo-angular-inputs';
import * as i6$1 from '@progress/kendo-angular-label';
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject, Subscription, Subject } from 'rxjs';
import * as i2$2 from '@angular/router';
import { Router, ActivatedRoute } from '@angular/router';
import * as signalR from '@microsoft/signalr';
import { LogLevel } from '@microsoft/signalr';
import * as i3$4 from 'ngx-toastr';
import { ToastrService } from 'ngx-toastr';
import * as i4$1 from '@azure/msal-angular';
import { MsalService } from '@azure/msal-angular';
import * as i5$3 from 'ngx-clipboard';
import { ClipboardService } from 'ngx-clipboard';
import * as i5$1 from '@progress/kendo-angular-treeview';
import * as i3$2 from '@progress/kendo-angular-popup';
import * as i3$1 from '@progress/kendo-angular-dialog';
import { DialogService } from '@progress/kendo-angular-dialog';
import { IPublicClientApplication } from '@azure/msal-browser';
import { GroupDescriptor, SortDescriptor, State, CompositeFilterDescriptor, FilterDescriptor } from '@progress/kendo-data-query';
import { State as State$1 } from '@progress/kendo-data-query/dist/npm/state';
import * as i5$2 from '@progress/kendo-angular-dateinputs';
import * as i3$3 from '@progress/kendo-angular-dropdowns';
import { PreventableEvent } from '@progress/kendo-angular-dropdowns';
import * as i8 from '@progress/kendo-angular-grid';
import { RemoveEvent, CellClickEvent, DataStateChangeEvent, RowClassArgs, FilterService } from '@progress/kendo-angular-grid';
import * as i7$1 from '@progress/kendo-angular-pager';
import * as i2$3 from '@ngx-loading-bar/http-client';

declare abstract class FieldComponent<T> implements OnInit, OnChanges {
    parent: FormGroupDirective;
    eref: ElementRef;
    private defaultValue;
    labelKey: string;
    fieldName: string;
    disabled: boolean;
    id: string;
    constructor(parent: FormGroupDirective, eref: ElementRef, defaultValue: T);
    ngOnInit(): void;
    ngOnChanges(): void;
    protected setUp(): void;
    protected setAttribute(name: string, value: string): ValidatorFn;
    updateState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FieldComponent<any>, never, never, { "labelKey": { "alias": "labelKey"; "required": false; }; "fieldName": { "alias": "fieldName"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FieldInputComponent extends FieldComponent<string> {
    parent: FormGroupDirective;
    eref: ElementRef;
    labelKey: string;
    fieldName: string;
    type: string;
    constructor(parent: FormGroupDirective, eref: ElementRef);
    protected setAttribute(name: string, value: string): ValidatorFn;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldInputComponent, "field-input", never, { "labelKey": { "alias": "labelKey"; "required": false; }; "fieldName": { "alias": "fieldName"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class NumberInputComponent extends FieldInputComponent {
    parent: FormGroupDirective;
    eref: ElementRef;
    constructor(parent: FormGroupDirective, eref: ElementRef);
    isPositive: boolean;
    private cachedValue;
    ngAfterContentInit(): void;
    private presetDefaultValue;
    private isNaNValidator;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumberInputComponent, "number-input", never, { "isPositive": { "alias": "isPositive"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class FieldInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldInputModule, [typeof FieldInputComponent, typeof NumberInputComponent], [typeof i3.ButtonsModule, typeof i2.ReactiveFormsModule, typeof i2.FormsModule, typeof i4.TranslateModule, typeof i2$1.CommonModule], [typeof FieldInputComponent, typeof NumberInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldInputModule>;
}

declare class FieldFileUploadComponent extends FieldComponent<File> {
    parent: FormGroupDirective;
    eref: ElementRef;
    private defaultFileRestrictions;
    labelKey: string;
    placeholderKey: string;
    fieldName: string;
    multiple: boolean;
    showFileList: boolean;
    autoUpload: boolean;
    disabled: boolean;
    saveUrl: string;
    removeUrl: string;
    restrictions: FileRestrictions;
    constructor(parent: FormGroupDirective, eref: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldFileUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldFileUploadComponent, "field-file-upload", never, { "labelKey": { "alias": "labelKey"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "fieldName": { "alias": "fieldName"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "showFileList": { "alias": "showFileList"; "required": false; }; "autoUpload": { "alias": "autoUpload"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "saveUrl": { "alias": "saveUrl"; "required": false; }; "removeUrl": { "alias": "removeUrl"; "required": false; }; "restrictions": { "alias": "restrictions"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class FieldFileUploadModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldFileUploadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldFileUploadModule, [typeof FieldFileUploadComponent], [typeof i2.ReactiveFormsModule, typeof i2.FormsModule, typeof i4.TranslateModule, typeof i2$1.CommonModule, typeof FieldInputModule, typeof i6.HttpClientModule, typeof i7.UploadsModule, typeof i5.InputsModule, typeof i3.ButtonsModule], [typeof FieldFileUploadComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldFileUploadModule>;
}

declare class FieldTextAreaComponent extends FieldComponent<string> {
    parent: FormGroupDirective;
    eref: ElementRef;
    labelKey: string;
    placeholderKey: string;
    fieldName: string;
    readonly: boolean;
    height: number;
    rebind: string;
    constructor(parent: FormGroupDirective, eref: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldTextAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldTextAreaComponent, "field-textarea", never, { "labelKey": { "alias": "labelKey"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "fieldName": { "alias": "fieldName"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "height": { "alias": "height"; "required": false; }; "rebind": { "alias": "rebind"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class FieldTextAreaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldTextAreaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldTextAreaModule, [typeof FieldTextAreaComponent], [typeof i2.ReactiveFormsModule, typeof i2.FormsModule, typeof i4.TranslateModule, typeof i2$1.CommonModule, typeof i6.HttpClientModule], [typeof FieldTextAreaComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldTextAreaModule>;
}

declare class FieldFileSelectComponent extends FieldComponent<File> {
    parent: FormGroupDirective;
    eref: ElementRef;
    private defaultFileRestrictions;
    labelKey: string;
    placeholderKey: string;
    fieldName: string;
    multiple: boolean;
    showFileList: boolean;
    disabled: boolean;
    restrictions: FileRestrictions;
    filesSelected: EventEmitter<File[]>;
    onFilesSelected(event: SelectEvent): void;
    constructor(parent: FormGroupDirective, eref: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldFileSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldFileSelectComponent, "field-file-select", never, { "labelKey": { "alias": "labelKey"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "fieldName": { "alias": "fieldName"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "showFileList": { "alias": "showFileList"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "restrictions": { "alias": "restrictions"; "required": false; }; }, { "filesSelected": "filesSelected"; }, never, ["*"], false, never>;
}

declare class FieldFileSelectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldFileSelectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldFileSelectModule, [typeof FieldFileSelectComponent], [typeof i2.ReactiveFormsModule, typeof i2.FormsModule, typeof i4.TranslateModule, typeof i2$1.CommonModule, typeof FieldInputModule, typeof i6.HttpClientModule, typeof i7.UploadsModule], [typeof FieldFileSelectComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldFileSelectModule>;
}

declare class FieldNumericTextBoxInputComponent extends FieldComponent<number> {
    parent: FormGroupDirective;
    eref: ElementRef;
    min: number;
    max: number;
    step: number;
    format: string;
    selectedValue: number;
    placeholder: string;
    selectedChange: EventEmitter<number>;
    get control(): AbstractControl | null;
    constructor(parent: FormGroupDirective, eref: ElementRef);
    ngOnInit(): void;
    ngOnChanges(): void;
    onValueChange(event: number): void;
    private emitSelectedEntity;
    initializeControlValue(): void;
    setControlValue(value: number | string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldNumericTextBoxInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldNumericTextBoxInputComponent, "field-numerictextbox-input", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "format": { "alias": "format"; "required": false; }; "selectedValue": { "alias": "selectedValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, ["*"], false, never>;
}

declare class FieldNumericTextBoxInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldNumericTextBoxInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldNumericTextBoxInputModule, [typeof FieldNumericTextBoxInputComponent], [typeof i2$1.CommonModule, typeof i2.ReactiveFormsModule, typeof i4.TranslateModule, typeof i5.InputsModule, typeof i6$1.LabelModule], [typeof FieldNumericTextBoxInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldNumericTextBoxInputModule>;
}

declare class FieldCheckBoxInputComponent extends FieldComponent<boolean> {
    parent: FormGroupDirective;
    eref: ElementRef;
    selectedValue: boolean;
    selectedChange: EventEmitter<boolean>;
    get control(): AbstractControl | null;
    constructor(parent: FormGroupDirective, eref: ElementRef);
    ngOnInit(): void;
    ngOnChanges(): void;
    onValueChange(event: boolean): void;
    setControlValue(value: boolean | string): void;
    initializeControlValue(): void;
    private emitSelectedEntity;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldCheckBoxInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldCheckBoxInputComponent, "field-checkbox-input", never, { "selectedValue": { "alias": "selectedValue"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, ["*"], false, never>;
}

declare class FieldCheckBoxInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldCheckBoxInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldCheckBoxInputModule, [typeof FieldCheckBoxInputComponent], [typeof i2$1.CommonModule, typeof i2.ReactiveFormsModule, typeof i4.TranslateModule, typeof i5.InputsModule, typeof i6$1.LabelModule], [typeof FieldCheckBoxInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldCheckBoxInputModule>;
}

interface AzureB2CSettings {
    clientId: string;
    authority: string;
    knownAuthorities: string[];
    redirectUri?: string;
    logoutRedirectUri?: string;
}

declare abstract class AppSettings {
    apiUrl: string;
    accountUrl: string;
    toastrTimeOut: number;
    signalRLogLevel?: LogLevel;
    azureB2C: AzureB2CSettings;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppSettings, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppSettings>;
}

interface HttpRequestOptions {
    muteNotFoundError?: boolean;
}

declare class SettingsService {
    putCurrentCallbackPath(): void;
    putCallbackPath(pathUri: string): void;
    getCallbackPath(): string;
    clearCallbackPath(): void;
    setLoginAsUser(id: string): void;
    getLoginAsUser(): string;
    clearLoginAsUser(): void;
    clearToken(): void;
    setToken(token: string): void;
    getToken(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsService>;
}

declare class AppToastrService {
    private toastr;
    private appSettings;
    constructor(toastr: ToastrService, appSettings: AppSettings);
    private timeout;
    showError(message: string, title?: string): void;
    showSuccess(message: string, title?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppToastrService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppToastrService>;
}

declare class HttpService {
    private appToastrService;
    private httpClient;
    private appSettings;
    private translate;
    private router;
    private settingsService;
    constructor(appToastrService: AppToastrService, httpClient: HttpClient, appSettings: AppSettings, translate: TranslateService, router: Router, settingsService: SettingsService);
    get<T>(path: string, options?: HttpRequestOptions): Observable<T>;
    delete(path: string): Observable<object>;
    post<T>(path: string, data: T | FormData, successTranslateMessage?: string, showSuccessMessage?: boolean): Observable<T>;
    put<T>(path: string, data: T | FormData, successTranslateMessage?: string, showSuccessMessage?: boolean): Observable<T>;
    createUrl(path: string): string;
    private handleServerError;
    private showSuccessMessage;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HttpService>;
}

declare abstract class AuthProvider {
    abstract initialize(): Promise<Observable<boolean>>;
    abstract login(): any;
    abstract logout(): any;
    abstract isUserLoggedIn(): boolean;
    abstract getAccessToken(): Observable<string>;
}

declare abstract class IndiginaConfiguration {
    langs?: TranslateLoader;
    appSettings?: AppSettings;
    static ɵfac: i0.ɵɵFactoryDeclaration<IndiginaConfiguration, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IndiginaConfiguration>;
}

declare class AuthProviderResolver {
    private AuthProvider$;
    constructor(msalService: MsalService, settingsService: SettingsService, indiginaConfiguration: IndiginaConfiguration);
    getProvider: () => Observable<AuthProvider>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthProviderResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthProviderResolver>;
}

declare class SignalRService {
    private appSettings;
    protected isConnectionEstablished: boolean;
    protected hubConnection: signalR.HubConnection;
    private eventEmitters;
    constructor(appSettings: AppSettings);
    private createConnection;
    startConnection(token: string): void;
    reconnect(token: string): void;
    on<T>(eventName: string): EventEmitter<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalRService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignalRService>;
}

declare abstract class BaseAccountService<T> {
    resolver: AuthProviderResolver;
    protected httpService: HttpService;
    protected settingsService: SettingsService;
    protected signalRService: SignalRService;
    user: BehaviorSubject<T>;
    constructor(resolver: AuthProviderResolver, httpService: HttpService, settingsService: SettingsService, signalRService: SignalRService);
    login(): void;
    logout(): void;
    private initialize;
    getCurrentUser(): Observable<T>;
    isUserLoggedIn(): Observable<boolean>;
    abstract isAdmin(member: T): boolean;
}

interface ISubscriptionControl {
    connected: boolean;
    resume(): void;
    pause(): void;
}

declare class ReEntrySubscription<T> implements ISubscriptionControl {
    private observable;
    private action;
    private subscription;
    constructor(observable: Observable<T>, action: (event: T) => void);
    get connected(): boolean;
    resume(): void;
    pause(): void;
}

declare class DebounceDirective implements OnInit, OnDestroy {
    debounceTime: number;
    debounceKeyup: EventEmitter<any>;
    private keyUp;
    private subscription;
    ngOnInit(): void;
    ngOnDestroy(): void;
    keyUpEvent(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DebounceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DebounceDirective, "[appDebounce]", never, { "debounceTime": { "alias": "debounceTime"; "required": false; }; }, { "debounceKeyup": "debounceKeyup"; }, never, never, false, never>;
}

declare class DebounceModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DebounceModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DebounceModule, [typeof DebounceDirective], [typeof i2$1.CommonModule], [typeof DebounceDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DebounceModule>;
}

declare class FormGroupWithErrors extends UntypedFormGroup {
    generalErrors: string[];
    constructor(controls: Record<string, AbstractControl>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
    getControl(name: string): AbstractControl;
    applyServerErrors(error: {
        title?: string;
        errors: Record<string, string[]>;
    }, form?: FormGroupWithErrors): void;
}

declare class GeneralErrorsComponent implements OnChanges {
    form: UntypedFormGroup;
    errors: string[];
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeneralErrorsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GeneralErrorsComponent, "app-general-errors", never, { "form": { "alias": "form"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; }, {}, never, never, false, never>;
}

declare class GeneralErrorsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<GeneralErrorsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<GeneralErrorsModule, [typeof GeneralErrorsComponent], [typeof i2$1.CommonModule, typeof i2.ReactiveFormsModule, typeof i2.FormsModule], [typeof GeneralErrorsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<GeneralErrorsModule>;
}

declare class CustomHttpErrorResponse extends HttpErrorResponse {
    title: string;
}

declare enum HttpCodes {
    BadRequest = 400,
    Forbidden = 403,
    InternalServerError = 500,
    NotFound = 404,
    OK = 200,
    Unauthorized = 401
}

interface IdentifiedModel {
    id: string;
}

interface NamedModel extends IdentifiedModel {
    name: string;
}

declare const HttpMethods: NamedModel[];

interface Language {
    name: string;
    code: string;
}

interface Removable {
    suppressDeletion?: boolean;
}

declare class LocaleSettingsService {
    private translate;
    private languages;
    private localeId;
    constructor(translate: TranslateService);
    init(): void;
    getLocales(): Language[];
    getLocale(): string;
    setLocale(locale: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleSettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LocaleSettingsService>;
}

declare class LiveUpdatesControlComponent implements OnInit {
    subscription: ISubscriptionControl;
    ngOnInit(): void;
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LiveUpdatesControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LiveUpdatesControlComponent, "live-updates-control", never, { "subscription": { "alias": "subscription"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LiveUpdatesControlModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LiveUpdatesControlModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LiveUpdatesControlModule, [typeof LiveUpdatesControlComponent], [typeof i2$1.CommonModule, typeof i4.TranslateModule], [typeof LiveUpdatesControlComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LiveUpdatesControlModule>;
}

interface MenuItem {
    text: string;
    url?: string;
    link?: string;
    iconClass?: string;
    expanded?: boolean;
    items?: MenuItem[];
}

interface AccountMenuItem {
    text: string;
    link?: string | Array<string | object>;
    iconClass?: string;
    useRouter?: boolean;
}

declare class MenuItemGroupComponent implements OnChanges, OnInit {
    private router;
    item: MenuItem;
    collapsed: boolean;
    private actualPath;
    constructor(router: Router);
    ngOnInit(): void;
    ngOnChanges(): void;
    collapseChild(activeItem: MenuItem, event: MouseEvent): void;
    private setItemExpand;
    private setActualPath;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemGroupComponent, "[menu-item-group]", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SideMenuComponent {
    items: MenuItem[];
    logoClick: EventEmitter<any>;
    onLogoClick(): void;
    collapse(itemComponent: MenuItemGroupComponent, activeItem: MenuItem, event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SideMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SideMenuComponent, "side-menu", never, { "items": { "alias": "items"; "required": false; }; }, { "logoClick": "logoClick"; }, never, never, false, never>;
}

declare enum ContentTypesFormat {
    Json = "json",
    Xml = "xml",
    Text = "text"
}

interface Brackets {
    inside?: string;
    outside?: string;
}

declare enum TreeViewNodeTypes {
    Object = "object",
    Array = "array",
    String = "string",
    Number = "number",
    Boolean = "boolean"
}

declare class TreeViewNode {
    brackets?: Brackets;
    startTag?: string;
    endTag?: string;
    value?: string | number | boolean | TreeViewNode[] | TreeViewNode;
    nodeType: TreeViewNodeTypes;
    get isPrimitive(): boolean;
    get isArray(): boolean;
    get isObject(): boolean;
    get isComplex(): boolean;
    get children(): TreeViewNode[];
    constructor(init: Partial<TreeViewNode>);
}

interface ResolverResult {
    format: ContentTypesFormat;
    data: TreeViewNode[] | TreeViewNode;
}

declare class TreeViewNodeComponent implements OnInit {
    treeViewProps: QueryList<TreeViewNodeComponent>;
    node: TreeViewNode;
    hasExpand: boolean;
    expanded: boolean;
    ngOnInit(): void;
    toggleExpand(): void;
    expandAll(): void;
    collapseAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeViewNodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeViewNodeComponent, "tree-view-node", never, { "node": { "alias": "node"; "required": false; }; "hasExpand": { "alias": "hasExpand"; "required": false; }; }, {}, never, never, false, never>;
}

interface TreeViewCustomButton {
    id: string;
    icon: string;
    title: string;
    disabled?: boolean;
    visible?: boolean;
    isToggle?: boolean;
    action: () => void;
}

declare class TreeViewComponent implements OnChanges {
    private clipboardService;
    treeViewNodes: QueryList<TreeViewNodeComponent>;
    data: string;
    maxTextLength: number;
    maxRootItems: number;
    customButtons: TreeViewCustomButton[];
    resolved: ResolverResult;
    collapsed: boolean;
    allShow: boolean;
    rawView: boolean;
    activeCustomView: string | null;
    ContentTypesFormat: typeof ContentTypesFormat;
    get IsArray(): boolean;
    get hasCollapse(): boolean;
    get format(): ContentTypesFormat;
    get isShowingCustomContent(): boolean;
    constructor(clipboardService: ClipboardService);
    ngOnChanges(): void;
    expandToggle(): void;
    toggleExpandAll(): void;
    toggleRawView(): void;
    copyToClipboard(): void;
    prettyCopyToClipboard(): void;
    onCustomButtonClick(button: TreeViewCustomButton): void;
    isCustomButtonVisible(button: TreeViewCustomButton): boolean;
    isCustomButtonActive(button: TreeViewCustomButton): boolean;
    getArrayData(): TreeViewNode[];
    getSingleNodeData(): TreeViewNode;
    private hasTextCollapse;
    private hasNodeCollapse;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeViewComponent, "tree-view", never, { "data": { "alias": "data"; "required": false; }; "maxTextLength": { "alias": "maxTextLength"; "required": false; }; "maxRootItems": { "alias": "maxRootItems"; "required": false; }; "customButtons": { "alias": "customButtons"; "required": false; }; }, {}, never, ["[slot=custom-content]"], false, never>;
}

declare class IndiginaTreeViewModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IndiginaTreeViewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IndiginaTreeViewModule, [typeof TreeViewComponent, typeof TreeViewNodeComponent], [typeof i2$1.CommonModule, typeof i4.TranslateModule, typeof i5$1.TreeViewModule], [typeof TreeViewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IndiginaTreeViewModule>;
}

interface MemberBase extends NamedModel {
    userName: string;
    email: string;
    firstName: string;
    lastName: string;
    password: string;
    roles: string[];
}

declare enum MemberTypes {
    Admin = "Admin",
    User = "User"
}

interface Member extends MemberBase {
    type: MemberTypes;
    identityId?: number;
}

declare class AccountService extends BaseAccountService<Member> {
    resolver: AuthProviderResolver;
    constructor(resolver: AuthProviderResolver, httpService: HttpService, settingsService: SettingsService, signalRService: SignalRService);
    isAdmin: (member: Member) => boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService>;
}

declare class AccountMenuComponent {
    private eref;
    private accountService;
    private appSettings;
    accountMenu: ElementRef;
    user: Member;
    menuItems: AccountMenuItem[];
    expand: boolean;
    languageSelectorVisible: boolean;
    constructor(eref: ElementRef, accountService: AccountService, appSettings: AppSettings);
    get fullName(): string;
    get accountUrl(): string;
    toggle(): void;
    logout(): void;
    openLanguageSelector(event: MouseEvent): void;
    clickedOutside(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccountMenuComponent, "account-menu", never, { "user": { "alias": "user"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LanguageSelectorComponent {
    private eref;
    private settings;
    visible: boolean;
    visibleChange: EventEmitter<boolean>;
    currentLanguageCode: string;
    languages: Language[];
    constructor(eref: ElementRef, settings: LocaleSettingsService);
    changeLanguage(code: string): Promise<void>;
    close(): void;
    clickedOutside(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LanguageSelectorComponent, "language-selector", never, { "visible": { "alias": "visible"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, false, never>;
}

declare class LanguageSelectorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageSelectorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LanguageSelectorModule, [typeof LanguageSelectorComponent], [typeof i2$1.CommonModule, typeof i3$1.WindowModule, typeof i4.TranslateModule], [typeof LanguageSelectorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LanguageSelectorModule>;
}

declare class AccountMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AccountMenuModule, [typeof AccountMenuComponent], [typeof i2$1.CommonModule, typeof i3$2.PopupModule, typeof i4.TranslateModule, typeof i2$2.RouterModule, typeof LanguageSelectorModule], [typeof AccountMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AccountMenuModule>;
}

declare class AzureLoginCallbackComponent {
    private readonly msalBroadcastService;
    private readonly router;
    private readonly settingsService;
    private readonly authService;
    ngOnInit(): void;
    logout(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AzureLoginCallbackComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AzureLoginCallbackComponent, "lib-azure-login", never, {}, {}, never, never, true, never>;
}

declare const MSALInstanceFactory: (config: IndiginaConfiguration) => IPublicClientApplication;

declare enum PermissionTypes {
    Create = "Create",
    Delete = "Delete",
    Edit = "Edit",
    View = "View",
    Set = "Set",
    Use = "Use"
}

type Permissions = Record<string, PermissionTypes[]>;

declare class PermissionsService {
    private httpService;
    private accountService;
    private signalRService;
    private loaded;
    mine: BehaviorSubject<Permissions>;
    constructor(httpService: HttpService, accountService: AccountService, signalRService: SignalRService);
    getAll(memberType: MemberTypes): Observable<Permissions>;
    getMine(): Observable<Permissions>;
    private getPermissionsFromServer;
    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionsService>;
}

declare class RequirePermissionDirective implements OnInit {
    private elementRef;
    private route;
    private permissionsService;
    private renderer;
    permissionType: PermissionTypes | PermissionTypes[];
    permissionCategory?: string;
    constructor(elementRef: ElementRef, route: ActivatedRoute, permissionsService: PermissionsService, renderer: Renderer2);
    ngOnInit(): void;
    private hide;
    private show;
    private hasType;
    private getRouteCategory;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequirePermissionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RequirePermissionDirective, "[requirePermission]", never, { "permissionType": { "alias": "permissionType"; "required": false; }; "permissionCategory": { "alias": "permissionCategory"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RequirePermissionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<RequirePermissionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<RequirePermissionModule, [typeof RequirePermissionDirective], never, [typeof RequirePermissionDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<RequirePermissionModule>;
}

declare enum Operators {
    eq = "eq",
    neq = "neq",
    isnull = "isnull",
    isnotnull = "isnotnull",
    lt = "lt",
    lte = "lte",
    gt = "gt",
    gte = "gte",
    startswith = "startswith",
    endswith = "endswith",
    contains = "contains",
    doesnotcontain = "doesnotcontain",
    isempty = "isempty",
    isnotempty = "isnotempty"
}

declare enum FilterTargets {
    Url = 0,
    Grid = 1
}

interface CustomFilter {
    field: string;
    operator: Operators;
    value?: string | boolean | number;
    values?: string[];
    filterTarget: FilterTargets;
}

interface ActivityFilter {
    dateTo?: Date;
    dateFrom?: Date;
    switchToArchive: boolean;
    searchText?: string;
    take?: number;
    skip?: number;
    group?: GroupDescriptor[];
    sort?: SortDescriptor[];
    customFilters?: CustomFilter[];
}

declare enum FieldTypes {
    Text = 0,
    Checkbox = 1,
    Dropdown = 2,
    Multiselect = 3
}

interface CustomFilterElement {
    title: string;
    fieldType: FieldTypes;
    data?: NamedModel[] | Promise<NamedModel[]>;
    filter: CustomFilter;
    valueField?: string;
    placeholder?: string;
    change?(value: string | number | boolean | string[]): void;
}

interface Page<T> {
    data: T[];
    total: number;
}

interface SystemInfo {
    identityProvider: string;
}

interface User extends MemberBase {
    partnerId: string;
    partnerName: string;
}

declare class ActivityFilterService {
    private route;
    private router;
    protected dateFilterParameterName: string;
    currentFilter: ActivityFilter;
    currentGridState: State;
    private readonly defaultFilter;
    protected filterBehavior: BehaviorSubject<ActivityFilter>;
    protected gridStateBehavior: BehaviorSubject<State>;
    filter$: rxjs.Observable<ActivityFilter>;
    gridState$: rxjs.Observable<State>;
    constructor(route: ActivatedRoute, router: Router, dateFilterParameterName: string);
    reset(): void;
    setFilter(filter: ActivityFilter): void;
    applyFilter(filter: ActivityFilter): void;
    setToday(): void;
    clearFilter(): void;
    setGridState(state: State): void;
    setTodayDates(): void;
    private stateNavigation;
    private prepareFilterToSerialize;
    private fillCurrentFilter;
    private fillUrlFilter;
    private fillFromDescriptor;
    private setFieldFilter;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityFilterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActivityFilterService>;
}

interface IEntityEndpoints {
    path: string;
    entityPath(id: string): string;
    query(state: State): string;
}

interface IActivityEndpoints {
    search(state: State, searchTerm: string): string;
    detailedActivity(id: string, partnerId: string): string;
    query(state: State): string;
}

declare const endpoints: {
    signalr: {
        eventsHub: string;
    };
    oidc: {
        config: string;
    };
    members: {
        me: string;
    };
    admins: {
        roles: {
            path: string;
            entityPath(id: string): string;
            query(state: State): string;
        };
        path: string;
        entityPath(id: string): string;
        query(state: State): string;
    };
    system: {
        info: string;
    };
    firstUser: string;
    partners: IEntityEndpoints;
    permissions: {
        all: (type: MemberTypes) => string;
        member: (id: string) => string;
        mine: string;
    };
    users: {
        roles: {
            path: string;
            entityPath(id: string): string;
            query(state: State): string;
        };
        path: string;
        entityPath(id: string): string;
        query(state: State): string;
    };
    apiTokens: IEntityEndpoints;
};
declare function buildEntityEndpoints(name: string): IEntityEndpoints;
declare function buildActivityEndpoints(name?: string): IActivityEndpoints;

type UrlParams = Record<string, string>;

declare const getValueFromFilterByField: (field: string, filter: CompositeFilterDescriptor) => string;

interface IGetPageService<T> {
    getPage(state: State, urlParams?: UrlParams): Observable<Page<T>>;
}

interface IEntityService<T> extends IGetPageService<T> {
    get(id: string, urlParams?: UrlParams): Observable<T>;
    delete(id: string, urlParams?: UrlParams): Observable<object>;
    save(model: T, urlParams?: UrlParams): Observable<T>;
}

declare abstract class EntityService<T extends IdentifiedModel> implements IEntityService<T> {
    protected httpService: HttpService;
    protected endpoints: IEntityEndpoints;
    constructor(httpService: HttpService, endpoints: IEntityEndpoints);
    getPage(state: State$1, urlParams?: UrlParams): Observable<Page<T>>;
    get(id: string, urlParams?: UrlParams, options?: HttpRequestOptions): Observable<T>;
    delete(id: string, urlParams?: UrlParams): Observable<object>;
    save(model: T, urlParams?: UrlParams): Observable<T>;
}

declare enum EventNames {
    UserUpdated = "userUpdated",
    PermissionsUpdated = "permissionsUpdated"
}

declare class ActivityFilterComponent implements OnInit, OnChanges {
    private translate;
    showArchiveSwitcher: boolean;
    showSearhText: boolean;
    customFilterElements: CustomFilterElement[];
    filterService: ActivityFilterService;
    onClearCallback?: () => void;
    filter: ActivityFilter;
    FieldTypes: typeof FieldTypes;
    constructor(translate: TranslateService);
    ngOnInit(): void;
    ngOnChanges(): void;
    defaultNamedModel: NamedModel;
    setTodayFilter(): void;
    clearFilter(): void;
    applyFilter(): void;
    fieldChange(value: string | number | boolean | string[], element: CustomFilterElement): void;
    private fillFilter;
    private setCustomFilters;
    private fixMultiselectFilters;
    private changeFilter;
    private emitChangeEvents;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityFilterComponent, "activity-filter", never, { "showArchiveSwitcher": { "alias": "showArchiveSwitcher"; "required": false; }; "showSearhText": { "alias": "showSearhText"; "required": false; }; "customFilterElements": { "alias": "customFilterElements"; "required": false; }; "filterService": { "alias": "filterService"; "required": false; }; "onClearCallback": { "alias": "onClearCallback"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class CurrentTimezoneComponent implements OnInit {
    timeZoneAndOffset: string;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentTimezoneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrentTimezoneComponent, "current-timezone", never, {}, {}, never, never, false, never>;
}

declare class CurrentTimeZoneModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentTimeZoneModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CurrentTimeZoneModule, [typeof CurrentTimezoneComponent], [typeof i4.TranslateModule], [typeof CurrentTimezoneComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CurrentTimeZoneModule>;
}

declare class ActivityFilterModule {
    static forRoot(startDateFieldName: string): ModuleWithProviders<ActivityFilterModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityFilterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ActivityFilterModule, [typeof ActivityFilterComponent], [typeof i2$1.CommonModule, typeof i2.ReactiveFormsModule, typeof i2.FormsModule, typeof i4.TranslateModule, typeof i5$2.DateInputsModule, typeof i3$3.DropDownsModule, typeof CurrentTimeZoneModule], [typeof ActivityFilterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ActivityFilterModule>;
}

declare class ConfirmDialogComponent {
    private readonly dialogService;
    private readonly viewContainerRef;
    private dialog;
    private callback;
    dialogActions: TemplateRef<any>;
    constructor(dialogService: DialogService, viewContainerRef: ViewContainerRef);
    cancel(): void;
    confirm(): void;
    open(content: string, callback: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialogComponent, "confirm-dialog", never, {}, {}, never, never, false, never>;
}

declare class ConfirmDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfirmDialogModule, [typeof ConfirmDialogComponent], [typeof i4.TranslateModule, typeof i3$1.DialogModule], [typeof ConfirmDialogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ConfirmDialogModule>;
}

declare class EntityEditButtonsBarComponent {
    valid: boolean;
    defaultCreateButtonText: string;
    save: EventEmitter<boolean>;
    permissionTypes: PermissionTypes[];
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityEditButtonsBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EntityEditButtonsBarComponent, "entity-edit-buttons-bar", never, { "valid": { "alias": "valid"; "required": false; }; "defaultCreateButtonText": { "alias": "defaultCreateButtonText"; "required": false; }; }, { "save": "save"; }, never, ["[custom-buttons]"], false, never>;
}

declare class EntityEditButtonsBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityEditButtonsBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EntityEditButtonsBarModule, [typeof EntityEditButtonsBarComponent], [typeof i2$2.RouterModule, typeof RequirePermissionModule, typeof i4.TranslateModule], [typeof EntityEditButtonsBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EntityEditButtonsBarModule>;
}

interface IFormAdapter<T extends IdentifiedModel> {
    getValue(): T;
    getService(): IEntityService<T>;
    getUrlParams(): UrlParams;
    setForm(form: FormGroupWithErrors): void;
    onSaved(value: T): void;
}

declare class EntityEditFormComponent implements OnInit, OnDestroy, OnChanges {
    private route;
    formGroup: BehaviorSubject<FormGroupWithErrors>;
    title: string;
    entityId?: string;
    adapter: IFormAdapter<IdentifiedModel>;
    routeService: Subscription;
    createButtonText: string;
    saveInProgress: boolean;
    constructor(route: ActivatedRoute);
    ngOnChanges(): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
    loadEntity(id?: string): void;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityEditFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EntityEditFormComponent, "entity-edit-form", never, { "title": { "alias": "title"; "required": false; }; "entityId": { "alias": "entityId"; "required": false; }; "adapter": { "alias": "adapter"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class EntityEditFormModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityEditFormModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EntityEditFormModule, [typeof EntityEditFormComponent], [typeof i2$1.CommonModule, typeof i4.TranslateModule, typeof GeneralErrorsModule, typeof EntityEditButtonsBarModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule], [typeof EntityEditFormComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EntityEditFormModule>;
}

declare abstract class EntityEditComponent<T extends IdentifiedModel> implements IFormAdapter<T> {
    service: IEntityService<T>;
    form: FormGroupWithErrors;
    saved: EventEmitter<T>;
    get adapter(): this;
    constructor(service: IEntityService<T>);
    getValue(): T;
    getService(): IEntityService<T>;
    getUrlParams(): UrlParams;
    setForm(form: FormGroupWithErrors): void;
    onSaved(value: T): void;
}

declare class FieldDropdownComponent extends FieldComponent<string> {
    parent: FormGroupDirective;
    eref: ElementRef;
    private translate;
    service: IGetPageService<NamedModel>;
    rebind: string;
    filter?: CompositeFilterDescriptor;
    sort?: SortDescriptor[];
    defaultName?: string;
    selectedItem?: NamedModel;
    data?: NamedModel[];
    textField: string;
    valueField: string;
    selectedChange: EventEmitter<NamedModel | number | string>;
    private kendoDropDown;
    private items;
    defaultItem: NamedModel;
    data$: Observable<NamedModel[]>;
    get control(): AbstractControl;
    constructor(parent: FormGroupDirective, eref: ElementRef, translate: TranslateService);
    ngOnInit(): void;
    ngOnChanges(): void;
    onValueChange(event: string): void;
    setData(): void;
    private setDefaultItem;
    private setDefaultName;
    private handleSelectedItem;
    private handleSelectedEntity;
    private updateControlValue;
    private getEntityByValue;
    private setControlValue;
    private resetControlValue;
    private emitSelectedEntity;
    private writeSelectedEntityValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldDropdownComponent, "field-dropdown", never, { "service": { "alias": "service"; "required": false; }; "rebind": { "alias": "rebind"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "defaultName": { "alias": "defaultName"; "required": false; }; "selectedItem": { "alias": "selectedItem"; "required": false; }; "data": { "alias": "data"; "required": false; }; "textField": { "alias": "textField"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, false, never>;
}

type valueTypes = boolean | string | number;
interface SimpleObject {
    description: string;
    value: valueTypes;
}

declare class ObjectDropdownComponent extends FieldComponent<valueTypes> {
    parent: FormGroupDirective;
    eref: ElementRef;
    private translate;
    fieldName: string;
    labelKey: string;
    data: SimpleObject[];
    selectedItem?: valueTypes;
    defaultName?: string;
    rebind: string;
    selectedChange: EventEmitter<SimpleObject>;
    defaultItem: SimpleObject;
    data$: Observable<SimpleObject[]>;
    get control(): AbstractControl;
    constructor(parent: FormGroupDirective, eref: ElementRef, translate: TranslateService);
    ngOnInit(): void;
    private setDefaultItem;
    ngOnChanges(): void;
    private setInputData;
    onValueChange(event: valueTypes): void;
    private getEntityByValue;
    emitSelectedEntity(entity: SimpleObject): void;
    private writeSelectedItemIfExists;
    private setControlValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectDropdownComponent, "object-dropdown", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "data": { "alias": "data"; "required": false; }; "selectedItem": { "alias": "selectedItem"; "required": false; }; "defaultName": { "alias": "defaultName"; "required": false; }; "rebind": { "alias": "rebind"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, false, never>;
}

declare class FieldMultiSelectComponent<T> extends FieldComponent<string[]> implements OnInit, OnChanges, OnDestroy {
    parent: FormGroupDirective;
    eref: ElementRef;
    service: IEntityService<NamedModel>;
    rebind: string;
    filter?: CompositeFilterDescriptor;
    textField?: string;
    valueField?: string;
    data: NamedModel[];
    singleMode: boolean;
    autoClose: boolean;
    changed: EventEmitter<T>;
    readonly destroy$: Subject<void>;
    data$: Observable<NamedModel[]>;
    private readonly reload$;
    get control(): AbstractControl;
    constructor(parent: FormGroupDirective, eref: ElementRef);
    ngOnInit(): void;
    private loadData;
    private updateControlValue;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    setData(): void;
    onPopupOpen(event: PreventableEvent): void;
    onValueChange(value: T): void;
    private getData;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldMultiSelectComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldMultiSelectComponent<any>, "field-multiselect", never, { "service": { "alias": "service"; "required": false; }; "rebind": { "alias": "rebind"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "textField": { "alias": "textField"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; "data": { "alias": "data"; "required": false; }; "singleMode": { "alias": "singleMode"; "required": false; }; "autoClose": { "alias": "autoClose"; "required": false; }; }, { "changed": "changed"; }, never, never, false, never>;
}

declare class FieldMultiselectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldMultiselectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldMultiselectModule, [typeof FieldMultiSelectComponent], [typeof i2.ReactiveFormsModule, typeof i3$3.MultiSelectModule, typeof i4.TranslateModule, typeof i2$1.CommonModule], [typeof FieldMultiSelectComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldMultiselectModule>;
}

declare class PartnerService extends EntityService<NamedModel> {
    constructor(httpService: HttpService);
    static ɵfac: i0.ɵɵFactoryDeclaration<PartnerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PartnerService>;
}

interface Command {
    name?: string;
    title?: string;
    iconClass?: string;
    handler(data: NamedModel): void;
}

interface Field {
    name: string;
    label: string;
    sortable?: boolean;
    position?: number;
}

declare class EntityListComponent implements OnInit, OnChanges {
    private translate;
    private route;
    private router;
    service: IEntityService<NamedModel>;
    filters: (FilterDescriptor | CompositeFilterDescriptor)[];
    fields?: Field[];
    commands?: Command[];
    rowClass?: (dataItem: NamedModel, index: number) => {};
    defaultSort?: SortDescriptor[];
    mapItemFn?: (item: NamedModel) => NamedModel & Removable;
    pageButtonsCount: number;
    filterChange: EventEmitter<CompositeFilterDescriptor>;
    dialog: ConfirmDialogComponent;
    gridState: State;
    page: BehaviorSubject<Page<NamedModel>>;
    loadings: number;
    searchTerm: string;
    selected: number[];
    gridFields: Field[];
    private defaultFields;
    constructor(translate: TranslateService, route: ActivatedRoute, router: Router);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    generateDateBasedExcelFileName(): string;
    removeHandler(e: RemoveEvent): void;
    selectItem(e: CellClickEvent): void;
    onActivate(child: {
        saved: EventEmitter<NamedModel>;
    }): void;
    onDeactivate(child: {
        saved: EventEmitter<NamedModel>;
    }): void;
    dataStateChange(state: DataStateChangeEvent): void;
    onSearch(value: string): void;
    getAllData(): Observable<Page<NamedModel & Removable>>;
    getRowClass(context: RowClassArgs): Object;
    protected getFilteredData(): void;
    protected updateGrid(data: NamedModel): void;
    protected getData(): rxjs.Subscription;
    private remove;
    private getFilter;
    private onFilterChange;
    private restoreGridState;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EntityListComponent, "entity-list", never, { "service": { "alias": "service"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "commands": { "alias": "commands"; "required": false; }; "rowClass": { "alias": "rowClass"; "required": false; }; "defaultSort": { "alias": "defaultSort"; "required": false; }; "mapItemFn": { "alias": "mapItemFn"; "required": false; }; "pageButtonsCount": { "alias": "pageButtonsCount"; "required": false; }; }, { "filterChange": "filterChange"; }, never, ["*"], false, never>;
}

declare class UserListAdminComponent extends EntityListComponent {
    private partnerService;
    constructor(translate: TranslateService, route: ActivatedRoute, router: Router, partnerService: PartnerService);
    onActivate(child: {
        saved: EventEmitter<NamedModel>;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserListAdminComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserListAdminComponent, "lib-user-list-admin", never, {}, {}, never, ["*"], false, never>;
}

declare class ExcelExportButtonComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ExcelExportButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExcelExportButtonComponent, "excel-export-button", never, {}, {}, never, never, false, never>;
}

declare class ExcelExportButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ExcelExportButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ExcelExportButtonModule, [typeof ExcelExportButtonComponent], [typeof i4.TranslateModule, typeof i8.ExcelModule], [typeof ExcelExportButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ExcelExportButtonModule>;
}

declare class CreateNewComponent {
    private route;
    defaultLabelKey: string;
    permissionTypes: PermissionTypes[];
    constructor(route: ActivatedRoute);
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateNewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CreateNewComponent, "create-new", never, {}, {}, never, never, false, never>;
}

declare class CreateNewModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateNewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CreateNewModule, [typeof CreateNewComponent], [typeof i2$2.RouterModule, typeof RequirePermissionModule, typeof i4.TranslateModule], [typeof CreateNewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CreateNewModule>;
}

declare class EntityListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EntityListModule, [typeof EntityListComponent, typeof UserListAdminComponent], [typeof i2$1.CommonModule, typeof i4.TranslateModule, typeof ConfirmDialogModule, typeof i2$2.RouterModule, typeof i7$1.PagerModule, typeof i8.GridModule, typeof i8.ExcelModule, typeof DebounceModule, typeof ExcelExportButtonModule, typeof i2$2.RouterModule, typeof CreateNewModule, typeof RequirePermissionModule, typeof i2.FormsModule, typeof i5.InputsModule], [typeof EntityListComponent, typeof UserListAdminComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EntityListModule>;
}

declare class FieldDropdownlistComponent implements OnInit {
    private translate;
    service: IEntityService<NamedModel>;
    label: string;
    sort?: SortDescriptor[];
    filter?: CompositeFilterDescriptor;
    initialSelectedId?: string;
    valueChange: EventEmitter<NamedModel>;
    private kendoDropDown;
    defaultItem: NamedModel;
    data: NamedModel[];
    constructor(translate: TranslateService);
    ngOnInit(): Promise<void>;
    private getData;
    onValueChange(event: NamedModel): void;
    initSelectedId(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldDropdownlistComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldDropdownlistComponent, "field-dropdownlist", never, { "service": { "alias": "service"; "required": false; }; "label": { "alias": "label"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "initialSelectedId": { "alias": "initialSelectedId"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class FieldDropdownlistModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldDropdownlistModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldDropdownlistModule, [typeof FieldDropdownlistComponent], [typeof i3$3.DropDownListModule], [typeof FieldDropdownlistComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldDropdownlistModule>;
}

declare const urlSerialize: (object: object) => string;
declare const urlDeserialize: (params: URLSearchParams) => {};

declare class FooterBarComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FooterBarComponent, "footer-bar", never, {}, {}, never, ["*"], false, never>;
}

declare class FooterBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FooterBarModule, [typeof FooterBarComponent], never, [typeof FooterBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FooterBarModule>;
}

declare class ModalWindowComponent {
    protected route: ActivatedRoute;
    private router;
    readonly callbackPath: InputSignal<string | undefined>;
    title?: string;
    readonly closed: OutputEmitterRef<void>;
    constructor(route: ActivatedRoute, router: Router);
    opened: boolean;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalWindowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalWindowComponent, "modal-window", never, { "callbackPath": { "alias": "callbackPath"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; }; }, { "closed": "closed"; }, never, ["*"], false, never>;
}

declare class ModalWindowModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalWindowModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ModalWindowModule, [typeof ModalWindowComponent], [typeof i2$1.CommonModule, typeof i2$2.RouterModule, typeof i3$1.WindowModule, typeof i4.TranslateModule], [typeof ModalWindowComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ModalWindowModule>;
}

declare class MulticheckFilterComponent implements AfterViewInit {
    currentFilter: CompositeFilterDescriptor;
    data: NamedModel[];
    filterService: FilterService;
    field: string;
    valueField: string;
    operator?: string;
    valueChange: EventEmitter<number[]>;
    currentData: NamedModel[];
    showFilter: boolean;
    private value;
    private filters;
    private get ValueKey();
    ngAfterViewInit(): void;
    traverseFilters(filters: CompositeFilterDescriptor | FilterDescriptor): void;
    isItemSelected(item: NamedModel): boolean;
    onSelectionChange(item: NamedModel): void;
    onInput(e: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MulticheckFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MulticheckFilterComponent, "multicheck-filter", never, { "currentFilter": { "alias": "currentFilter"; "required": false; }; "data": { "alias": "data"; "required": false; }; "filterService": { "alias": "filterService"; "required": false; }; "field": { "alias": "field"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; "operator": { "alias": "operator"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class MulticheckFilterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MulticheckFilterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MulticheckFilterModule, [typeof MulticheckFilterComponent], [typeof i2$1.CommonModule], [typeof MulticheckFilterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MulticheckFilterModule>;
}

declare class TopMenuComponent {
    currentUser: Member;
    menuItems: AccountMenuItem[];
    toggleButtonClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TopMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TopMenuComponent, "top-bar", never, { "currentUser": { "alias": "currentUser"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; }, {}, never, ["*", ".pad5left"], false, never>;
}

declare class TopBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TopBarModule, [typeof TopMenuComponent], [typeof i2$1.CommonModule, typeof i2$2.RouterModule, typeof AccountMenuModule], [typeof TopMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TopBarModule>;
}

interface IPrettifier {
    prettify(data: string): string;
}

declare class PrettifierFactory {
    static Create(format: ContentTypesFormat): IPrettifier;
}

declare class FieldDropdownModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldDropdownModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FieldDropdownModule, [typeof FieldDropdownComponent], [typeof i4.TranslateModule, typeof i3$3.DropDownsModule, typeof i2.ReactiveFormsModule, typeof i2$1.CommonModule], [typeof FieldDropdownComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FieldDropdownModule>;
}

declare class ObjectDropdownModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectDropdownModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ObjectDropdownModule, [typeof ObjectDropdownComponent], [typeof i2$1.CommonModule, typeof i4.TranslateModule, typeof i3$3.DropDownsModule, typeof i2.ReactiveFormsModule], [typeof ObjectDropdownComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ObjectDropdownModule>;
}

declare class ForbiddenComponent {
    private accountService;
    constructor(accountService: AccountService);
    logout(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForbiddenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ForbiddenComponent, "app-forbidden", never, {}, {}, never, never, false, never>;
}

declare class SideMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SideMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SideMenuModule, [typeof SideMenuComponent, typeof MenuItemGroupComponent], [typeof i2$1.CommonModule, typeof i4.TranslateModule, typeof i2$2.RouterModule, typeof i2.FormsModule, typeof i2$3.LoadingBarHttpClientModule], [typeof SideMenuComponent, typeof MenuItemGroupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SideMenuModule>;
}

declare class AppCoreModule {
    static forRoot(configuration: IndiginaConfiguration): ModuleWithProviders<AppCoreModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppCoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AppCoreModule, never, [typeof i4.TranslateModule, typeof i2$3.LoadingBarHttpClientModule, typeof i3$4.ToastrModule, typeof i4$1.MsalModule], [typeof i4.TranslateModule, typeof i5$3.ClipboardModule, typeof i2$3.LoadingBarHttpClientModule, typeof i3$4.ToastrModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AppCoreModule>;
}

declare const SKIP_AUTH_TOKEN: HttpContextToken<boolean>;

export { AccountMenuComponent, AccountMenuModule, AccountService, ActivityFilterComponent, ActivityFilterModule, ActivityFilterService, AppCoreModule, AppSettings, AppToastrService, AuthProvider, AuthProviderResolver, AzureLoginCallbackComponent, BaseAccountService, ConfirmDialogComponent, ConfirmDialogModule, ContentTypesFormat, CurrentTimeZoneModule, CurrentTimezoneComponent, CustomHttpErrorResponse, DebounceDirective, DebounceModule, EntityEditButtonsBarComponent, EntityEditButtonsBarModule, EntityEditComponent, EntityEditFormComponent, EntityEditFormModule, EntityListComponent, EntityListModule, EntityService, EventNames, ExcelExportButtonComponent, ExcelExportButtonModule, FieldCheckBoxInputComponent, FieldCheckBoxInputModule, FieldComponent, FieldDropdownComponent, FieldDropdownModule, FieldDropdownlistComponent, FieldDropdownlistModule, FieldFileSelectComponent, FieldFileSelectModule, FieldFileUploadComponent, FieldFileUploadModule, FieldInputComponent, FieldInputModule, FieldMultiSelectComponent, FieldMultiselectModule, FieldNumericTextBoxInputComponent, FieldNumericTextBoxInputModule, FieldTextAreaComponent, FieldTextAreaModule, FieldTypes, FilterTargets, FooterBarComponent, FooterBarModule, ForbiddenComponent, FormGroupWithErrors, GeneralErrorsComponent, GeneralErrorsModule, HttpCodes, HttpMethods, HttpService, IndiginaConfiguration, IndiginaTreeViewModule, LanguageSelectorComponent, LanguageSelectorModule, LiveUpdatesControlComponent, LiveUpdatesControlModule, LocaleSettingsService, MSALInstanceFactory, MemberTypes, MenuItemGroupComponent, ModalWindowComponent, ModalWindowModule, MulticheckFilterComponent, MulticheckFilterModule, NumberInputComponent, ObjectDropdownComponent, ObjectDropdownModule, Operators, PermissionTypes, PermissionsService, PrettifierFactory, ReEntrySubscription, RequirePermissionDirective, RequirePermissionModule, SKIP_AUTH_TOKEN, SettingsService, SideMenuComponent, SideMenuModule, SignalRService, TopBarModule, TopMenuComponent, TreeViewComponent, TreeViewNodeComponent, UserListAdminComponent, buildActivityEndpoints, buildEntityEndpoints, endpoints, getValueFromFilterByField, urlDeserialize, urlSerialize };
export type { AccountMenuItem, ActivityFilter, AzureB2CSettings, Command, CustomFilter, CustomFilterElement, Field, IActivityEndpoints, IEntityEndpoints, IEntityService, IFormAdapter, IGetPageService, IPrettifier, ISubscriptionControl, IdentifiedModel, Language, Member, MemberBase, MenuItem, NamedModel, Page, Permissions, Removable, SimpleObject, SystemInfo, TreeViewCustomButton, UrlParams, User };