import * as i0 from '@angular/core';
import { OnInit, OnChanges, SimpleChanges, EventEmitter, OnDestroy, AfterViewInit, TemplateRef, PipeTransform, ViewContainerRef, ElementRef } from '@angular/core';
import * as i12 from '@angular/material/snack-bar';
import { MatSnackBar } from '@angular/material/snack-bar';
import * as i11 from '@angular/material/dialog';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject, Subject } from 'rxjs';
import * as i1$1 from '@angular/router';
import { Router, ActivatedRoute, CanActivateFn } from '@angular/router';
import * as i80 from '@angular/common/http';
import { HttpClient, HttpErrorResponse } from '@angular/common/http';
import * as i7$1 from '@abacritt/angularx-social-login';
import { SocialUser, SocialAuthService } from '@abacritt/angularx-social-login';
import { BreakpointObserver } from '@angular/cdk/layout';
import * as tin_spa from 'tin-spa';
import * as i3 from '@angular/forms';
import { FormControl, ControlValueAccessor } from '@angular/forms';
import * as _angular_material_paginator from '@angular/material/paginator';
import { MatPaginator } from '@angular/material/paginator';
import * as i5 from '@angular/material/table';
import { MatTableDataSource } from '@angular/material/table';
import * as i26 from '@angular/material/stepper';
import { MatStepper } from '@angular/material/stepper';
import * as i13 from '@angular/material/tabs';
import { MatTabChangeEvent } from '@angular/material/tabs';
import * as i22 from '@angular/material/autocomplete';
import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
import * as i17 from '@angular/material/chips';
import { MatChipInputEvent } from '@angular/material/chips';
import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
import * as i1 from '@angular/common';
import { DecimalPipe, Location } from '@angular/common';
import * as i3$1 from '@angular/material/menu';
import * as i4 from '@angular/material/slider';
import * as i7 from '@angular/material/checkbox';
import * as i8 from '@angular/material/badge';
import * as i9 from '@angular/material/button';
import * as i10 from '@angular/material/icon';
import * as i14 from '@angular/material/form-field';
import * as i15 from '@angular/material/input';
import * as i16 from '@angular/material/card';
import * as i18 from '@angular/material/select';
import * as i19 from '@angular/material/core';
import * as i20 from '@angular/material/progress-spinner';
import * as i21 from '@angular/material/list';
import * as i23 from '@angular/material/tooltip';
import * as i24 from '@angular/material/sort';
import * as i25 from '@angular/material/datepicker';
import * as i27 from '@angular/material/radio';
import * as i28 from '@angular/material/progress-bar';
import * as i29 from '@angular/material/sidenav';
import * as i30 from '@angular/material/toolbar';
import * as i32 from '@angular/material/expansion';
import * as i82 from 'ngx-doc-viewer';
import { MsalService } from '@azure/msal-angular';

declare class TinSpaService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TinSpaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TinSpaService>;
}

declare class StorageService {
    constructor();
    store(storageKey: string, value: any): Promise<void>;
    get(storageKey: string): Promise<any>;
    removeStorageItem(storageKey: string): Promise<void>;
    clear(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
}

declare class MessageService {
    private snackBar;
    dialog: MatDialog;
    constructor(snackBar: MatSnackBar, dialog: MatDialog);
    toast(msg: string): void;
    info(details: string): void;
    infoWithSubject(subject: string, details: string): void;
    error(details: string): void;
    confirm(msg: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
}

declare class ExportService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ExportService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ExportService>;
}

declare class Account {
    user: User;
    profile: Profile;
}
declare class User {
    constructor();
    userName: string;
    password: string;
    tries: string;
    locked: string;
    logged: string;
    disabled: string;
    changepassword: string;
    dateCreated: string;
    dateUpdated: string;
    dateExpire: string;
    token: string;
    tokenExpire: string;
    authType: string;
}
declare class ChangeUserPassword {
    constructor();
    userName: string;
    currentPassword: string;
    newPassword: string;
    confirmPassword: string;
}
declare class Register {
    constructor();
    userName: string;
    roleID: number;
    firstName: string;
    lastName: string;
    email: string;
    authType: string;
    password: string;
}
declare class Profile {
    constructor();
    profileID: string;
    userName: string;
    roleID: number;
    firstName: string;
    lastName: string;
    email: string;
    empID: string;
    arID: string;
    authType: string;
    password: string;
    role: Role;
    code: string;
}
declare class Role {
    constructor();
    roleID: number;
    roleName: string;
    cap1: boolean;
    cap2: boolean;
    cap3: boolean;
    cap4: boolean;
    cap5: boolean;
    cap6: boolean;
    cap7: boolean;
    cap8: boolean;
    cap9: boolean;
    cap10: boolean;
    cap11: boolean;
    cap12: boolean;
    cap13: boolean;
    cap14: boolean;
    cap15: boolean;
    cap16: boolean;
    cap17: boolean;
    cap18: boolean;
    cap19: boolean;
    cap20: boolean;
    cap21: boolean;
    cap22: boolean;
    cap23: boolean;
    cap24: boolean;
    cap25: boolean;
    cap26: boolean;
    cap27: boolean;
    cap28: boolean;
    cap29: boolean;
    cap30: boolean;
    cap31: boolean;
    cap32: boolean;
    cap33: boolean;
    cap34: boolean;
    cap35: boolean;
    cap36: boolean;
    cap37: boolean;
    cap38: boolean;
    cap39: boolean;
    cap40: boolean;
    cap41: boolean;
    cap42: boolean;
    cap43: boolean;
    cap44: boolean;
    cap45: boolean;
    cap46: boolean;
    cap47: boolean;
    cap48: boolean;
    cap49: boolean;
    cap50: boolean;
    cap51: boolean;
    cap52: boolean;
    cap53: boolean;
    cap54: boolean;
    cap55: boolean;
    cap56: boolean;
    cap57: boolean;
    cap58: boolean;
    cap59: boolean;
    cap60: boolean;
    cap61: boolean;
    cap62: boolean;
    cap63: boolean;
    cap64: boolean;
    cap65: boolean;
    cap66: boolean;
    cap67: boolean;
    cap68: boolean;
    cap69: boolean;
    cap70: boolean;
    cap71: boolean;
    cap72: boolean;
    cap73: boolean;
    cap74: boolean;
    cap75: boolean;
    cap76: boolean;
    cap77: boolean;
    cap78: boolean;
    cap79: boolean;
    cap80: boolean;
    cap81: boolean;
    cap82: boolean;
    cap83: boolean;
    cap84: boolean;
    cap85: boolean;
    cap86: boolean;
    cap87: boolean;
    cap88: boolean;
    cap89: boolean;
    cap90: boolean;
    cap91: boolean;
    cap92: boolean;
    cap93: boolean;
    cap94: boolean;
    cap95: boolean;
    cap96: boolean;
    cap97: boolean;
    cap98: boolean;
    cap99: boolean;
    cap100: boolean;
}
declare enum LogLevel {
    All = 0,
    Debug = 1,
    Info = 2,
    Warn = 3,
    Error = 4,
    Fatal = 5,
    Off = 6
}

declare class LogService {
    constructor();
    level: LogLevel;
    logToConsole: boolean;
    logToApi: boolean;
    debug(msg: string, ...optionalParams: any[]): void;
    info(msg: string, ...optionalParams: any[]): void;
    warn(msg: string, ...optionalParams: any[]): void;
    error(msg: string, ...optionalParams: any[]): void;
    fatal(msg: string, ...optionalParams: any[]): void;
    log(msg: string, ...optionalParams: any[]): void;
    private writeToLog;
    private formatParams;
    private shouldLog;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LogService>;
}

declare class HttpService {
    private httpClient;
    private router;
    constructor(httpClient: HttpClient, router: Router);
    apiUrl: string;
    Post(service: string, data: any): Observable<any>;
    Put(service: string, data: any): Observable<any>;
    Post_Raw(url: string, data: any): Observable<any>;
    Post_WithFile(service: string, data: any, file: File): Observable<Object>;
    Post_FormData(service: string, formData: FormData): Observable<Object>;
    Get(service: string): Observable<any>;
    Get_Raw(url: string): Observable<any>;
    Error(error: HttpErrorResponse): "Unauthorized" | "Connection failed";
    private httpOptions_Legacy;
    private httpOptions_Files;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HttpService>;
}

declare class AuthService {
    private _route;
    private socialService;
    private storage;
    router: Router;
    private httpService;
    private messageService;
    private logService;
    private googleAuthInitialized;
    private socialUserSource;
    socialUserObserv: rxjs.Observable<SocialUser>;
    constructor(_route: ActivatedRoute, socialService: SocialAuthService, storage: StorageService, router: Router, httpService: HttpService, messageService: MessageService, logService: LogService);
    private initializeGoogleAuth;
    clearSession(): void;
    sessionExpired(): void;
    logoff(): void;
    private loggedin;
    private loggedinSource;
    loggedinObserv: rxjs.Observable<boolean>;
    Updateloggedin(loggedin: boolean): void;
    private autoLogin;
    private autoLoginSource;
    autoLoginObserv: rxjs.Observable<boolean>;
    UpdateAutoLogin(autoLogin: boolean): void;
    private token;
    tokenSource: BehaviorSubject<string>;
    tokenObserv: rxjs.Observable<string>;
    UpdateToken(newToken: string): void;
    private tokenExpire;
    tokenExpireSource: BehaviorSubject<string>;
    tokenExpireObserv: rxjs.Observable<string>;
    UpdateTokenExpire(newTokenExpire: string): void;
    currentUser: string;
    private currentUserSource;
    currentUserObserv: rxjs.Observable<string>;
    UpdateCurrentUser(newUser: string): void;
    private islineManager;
    private isLineManagerSource;
    isLineManagerObserv: rxjs.Observable<boolean>;
    UpdateIsLineManager(manager: boolean): void;
    private currentRole;
    currentRoleSource: BehaviorSubject<Role>;
    myRoleObserv: rxjs.Observable<Role>;
    UpdateRole(role: any): void;
    private loggedUserSource;
    loggedUserFullName: rxjs.Observable<string>;
    updateLoggedUserFullName(userName: string): void;
    private tenantNameSource;
    tenantNameObserv: rxjs.Observable<string>;
    updateTenantName(tenantName: string): void;
    isAuthorised(capName: string): boolean;
    isValidToken(): boolean;
    checkAuthentication(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
}

interface BitwiseOption {
    name?: string;
    value: number;
    selected: boolean;
    icon?: Icon;
}
declare enum RoleAccess {
    None = 0,
    View = 1,
    Edit = 2,
    Create = 3,
    Full = 4
}
declare enum DetailsSource {
    Row = 0,
    Url = 1
}
declare class dialogOptions {
    width?: string;
    height?: string;
}
interface CloseOptions {
    position?: 'top' | 'bottom';
    text?: string;
}
declare class DetailsDialogConfig {
    stepConfig?: StepConfig;
    statusConfig?: StatusConfig;
    formConfig: FormConfig;
    tableConfig?: TableConfig;
    tableConfigs?: TableConfig[];
    buttons?: Button[];
    details?: any;
    heroField?: any;
    heroValue?: any;
    mode?: 'create' | 'edit' | 'view';
    detailsSource?: DetailsSource;
    options?: dialogOptions;
    autoRefreshConfig?: AutoRefreshConfig;
    refreshOnClose?: boolean;
    causeTableRefresh?: boolean;
    closeOptions?: CloseOptions;
}
declare class Action {
    method?: 'get' | 'post';
    url: string;
    params?: any[];
    successMessage?: string;
    isFormData?: boolean;
    skipCache?: boolean;
    cacheDurationMinutes?: number;
}
interface SearchField extends Field {
    show?: boolean;
}
declare class SearchConfig {
    fields: SearchField[];
    searchAction?: Action;
    emailResults?: boolean;
    tileConfig?: TileConfig;
}
declare class SecurityConfig {
    allow?: CapItem[];
    deny?: CapItem[];
}
interface ChildField {
    childField?: string;
    childValueField?: string;
}
interface AutoRefreshConfig {
    interval?: number;
    stopCondition?: (data: any) => boolean;
    defaultOn?: boolean;
}
interface Field {
    securityConfig?: SecurityConfig;
    name: string;
    type: 'text' | 'multi-text' | 'password' | 'date' | 'datetime' | 'datetimesec' | 'checkbox' | 'select' | 'multi-select' | 'money' | 'number' | 'section' | 'blank' | 'chip' | 'file' | 'file-view' | 'icon' | 'spinner' | 'button' | 'label' | 'email' | 'composite' | 'string' | 'html';
    alias?: string;
    options?: any[];
    optionDisplay?: string;
    optionValue?: string;
    masterOptionValue?: string;
    defaultValue?: any;
    defaultFirstValue?: boolean;
    required?: boolean;
    requiredCondition?: (value: any) => boolean;
    min?: any;
    max?: any;
    rows?: number;
    span?: boolean;
    width?: string;
    size?: string;
    readonly?: boolean;
    hidden?: boolean;
    strict?: boolean;
    path?: string;
    keyField?: string;
    hint?: string;
    masterField?: string;
    children?: ChildField[];
    masterOptions?: any[];
    nullable?: boolean;
    copyContent?: boolean;
    clearContent?: boolean;
    format?: 'text' | 'money' | 'date' | 'datetime' | 'number';
    hideOnCreate?: boolean;
    hideOnExists?: boolean;
    hiddenCondition?: (value: any) => boolean;
    readonlyCondition?: (value: any) => boolean;
    detailsConfig?: DetailsDialogConfig;
    loadAction?: Action;
    loadIDField?: string;
    infoMessage?: string;
    suffix?: string;
    subfields?: Field[];
    optionsSubject?: BehaviorSubject<any[]>;
    section?: string;
    fileOptions?: {
        allowedExtensions?: string[];
        maxSizeMB?: number;
        compressImages?: boolean;
    };
    collapsed?: boolean;
    collapsedCondition?: (value: any) => boolean;
    maxHeight?: string;
    valueCalculation?: (value: any) => any;
    regex?: {
        pattern: string;
        message: string;
    };
    onSelectChange?: (value: any, data: any) => void;
    icon?: Icon;
    color?: string;
    onChange?: (value: any, allValues: any) => void;
}
interface StatusState {
    condition: (data: any) => boolean;
    icon: string;
    color: string;
}
interface StatusItem {
    name: string;
    hiddenCondition?: (data: any) => boolean;
    states: StatusState[];
}
interface StatusConfig {
    items: StatusItem[];
    sticky?: boolean;
    hiddenCondition?: (data: any) => boolean;
}
declare class AlertMessage {
    type?: 'success' | 'info' | 'warn' | 'critical';
    content?: string;
    contentField?: string;
    hiddenCondition?: (value: any) => boolean;
    showCondition?: (value: any) => boolean;
}
declare class AlertConfig {
    subject?: string;
    compact?: boolean;
    sticky?: boolean;
    messages: AlertMessage[];
}
declare class NotesConfig {
    title?: string;
    loadAction?: Action;
    loadIDField?: string;
    notes?: any[];
    nameField?: string;
    dateField?: string;
    commentField?: string;
}
declare class FormConfig {
    title?: string;
    fixedTitle?: boolean;
    alertConfig?: AlertConfig;
    fields: Field[];
    mode?: 'create' | 'edit' | 'view';
    button?: Button;
    multiColumn?: boolean;
    reset?: boolean;
    loadAction?: Action;
    heroField?: any;
    heroValue?: any;
    security?: SecurityConfig;
    includeAudit?: boolean;
    notesConfig?: NotesConfig;
}
interface Confirm {
    message?: string;
    func?: (data: any) => string;
}
interface Button {
    name: string;
    visible?: (value: any) => boolean;
    display?: string;
    icon?: Icon;
    disabled?: (value: any) => boolean;
    color?: string;
    tip?: string;
    dialog?: boolean;
    action?: Action;
    confirm?: Confirm;
    inDialog?: boolean;
    inHeader?: boolean;
    detailsConfig?: DetailsDialogConfig;
    setHeroField?: boolean;
    ignorePendingApproval?: boolean;
    keepOpen?: boolean;
    onSuccess?: (response: ApiResponse, details: any) => void;
    onClick?: (details: any) => void;
    editOnSuccess?: boolean;
    onSuccessButton?: Button;
    skipValidation?: boolean;
}
interface CapsuleConfig {
    displayField: string;
    leftIcons?: Icon[];
    rightIcons?: Icon[];
    loadAction?: Action;
}
interface CardConfig {
    imageField?: string;
    titleField: string;
    subtitleField?: string;
    contentFields: string[];
    columns?: number;
    elevation?: 'low' | 'medium' | 'high';
}
interface Tile {
    name: string;
    alias?: string;
    value?: string;
    color?: string;
    selectedTile?: string;
    hidden?: boolean;
    info?: string;
    prefix?: string;
    suffix?: string;
    action?: Action;
    hiddenCondition?: (value: any) => boolean;
}
declare class TileConfig {
    tiles: Tile[];
    loadAction?: Action;
    loadInit?: boolean;
    clickable?: boolean;
    headerPosition?: 'top' | 'middle';
}
declare class Step {
    name: string;
    value?: any;
    icon?: string;
    hiddenCondition?: (value: any) => boolean;
}
declare class StepConfig {
    steps: Step[];
    valueField?: string;
    loadAction?: Action;
    loadIDField?: string;
    sticky?: boolean;
}
interface Icon {
    name: string;
    color?: string;
    tip?: string;
    tipField?: string;
    bannerField?: string;
    condition?: (value: any) => boolean;
}
interface Color {
    name: string;
    condition?: (value: any) => boolean;
}
interface GroupData {
    groupValue: any;
    displayName: string;
    icon?: string;
    color?: string;
    items: any[];
    order: number;
    firstItem?: any;
}
interface GroupConfig {
    groupByField: string;
    groupDisplayField: string;
    groupIcons?: Icon[];
    groupOrder?: any[];
    itemTextField: string;
    itemIcon?: Icon;
    itemIcons?: Icon[];
    itemAdditionalIcons?: Icon[];
    headerButtons?: Button[];
    showGroupCount?: boolean;
    emptyGroupMessage?: string;
    contextMenuEnabled?: boolean;
    showEmptyGroups?: boolean;
    emptyGroupsSource?: any[];
}
interface Column {
    name: string;
    type?: 'text' | 'date' | 'datetime' | 'datetimesec' | 'checkbox' | 'select' | 'money' | 'number' | 'chip' | 'icon' | 'spinner' | 'button';
    alias?: string;
    maxLength?: number;
    icon?: Icon;
    color?: Color;
    colors?: Color[];
    icons?: Icon[];
    options?: any[];
    optionDisplay?: string;
    optionValue?: string;
    detailsConfig?: DetailsDialogConfig;
    hiddenCondition?: (parentData: any) => boolean;
}
type TableViewType = 'table' | 'capsule' | 'card' | 'grouped';
declare class TableConfig {
    viewType?: TableViewType;
    capsuleConfig?: CapsuleConfig;
    cardConfig?: CardConfig;
    groupConfig?: GroupConfig;
    tabTitle?: string;
    noDataMessage?: string;
    columns?: Column[];
    minColumns?: string[];
    showFilter?: boolean;
    showFilterButton?: boolean;
    holdFilterSpace?: boolean;
    holdHeaderButtonSpace?: boolean;
    elevation?: 'none' | 'low' | 'medium' | 'high';
    formConfig?: FormConfig;
    searchConfig?: SearchConfig;
    tileConfig?: TileConfig;
    stepConfig?: StepConfig;
    buttons?: Button[];
    minButtons?: string[];
    loadAction?: Action;
    countAction?: Action;
    loadIDField?: string;
    loadCriteria?: string;
    lazyLoad?: boolean;
    causeFormRefresh?: boolean;
    logResponse?: boolean;
    flatButtons?: boolean;
    greyOut?: (value: any) => boolean;
    heroField?: any;
    heroValue?: any;
    collapseButtons?: boolean;
    parentData?: any;
    pageSizes?: number[];
    maxButtonsCount?: number;
    hideTabCondition?: (value: any) => boolean;
    download?: {
        columns: string[];
        fileName?: string;
        hiddenCondition?: (value: any) => boolean;
    };
    upload?: {
        action: Action;
        messages?: AlertMessage[];
        hiddenCondition?: (value: any) => boolean;
    };
}
declare class PageConfig {
    title?: string;
    tableConfig?: TableConfig;
    searchTableConfig?: TableConfig;
    titleActions?: Field[];
}
declare class ApiResponse {
    success: boolean;
    message: string;
    data: any;
}
declare class Constants {
    static readonly AUTH_USER = "a";
    static readonly AUTH_NAME = "b";
    static readonly AUTH_ROLES = "c";
    static readonly AUTH_TOKEN = "d";
    static readonly AUTH_TOKEN_EXPIRE = "e";
    static readonly AUTH_TENANT_NAME = "f";
}
declare class ListDialogConfig {
    name: string;
    title: string;
    listName: string;
}
declare class CapItem {
    constructor();
    name: string;
    display: string;
    enabled: boolean;
    showMenu: boolean;
    ignoreSubsDisplay: boolean;
    type: string;
    newLine: boolean;
    link: string;
    icon: string;
    capSubItems: CapItem[];
    color: string;
    isBool: boolean;
}
declare class AppConfig {
    constructor();
    appName: string;
    logo: string;
    logoSize: string;
    ADAuth: boolean;
    localAuth: boolean;
    googleAuth: boolean;
    microsoftAuth: boolean;
    microsoftAuthMessage: string;
    selfService: boolean;
    capItems: CapItem[];
    multitenant: boolean;
    navigation: 'top' | 'side';
    progressLine: boolean;
    docsBaseUrl: string;
    loginStyle: string;
    loginTitle: string;
    loginMessage: string;
    termsUrl: string;
    privacyUrl: string;
    siteUrl: string;
    navWidth: string;
}
declare class Transaction {
    constructor();
    transactionID: number;
    narration: string;
    amount: string;
    type: number;
    date: string;
    accountID: number;
    destinationID: number;
    categoryID: number;
}
declare class FinAccount {
    constructor();
    accountID: number;
    name: string;
    description: string;
    currency: string;
}

declare class DataServiceLib {
    private httpService;
    router: Router;
    private route;
    private authService;
    constructor(httpService: HttpService, router: Router, route: ActivatedRoute, authService: AuthService);
    appConfig: AppConfig;
    private appConfigSource;
    appConfigObserv: Observable<AppConfig>;
    UpdateAppConfig(config: AppConfig): void;
    myRole: any;
    capHome: CapItem;
    capAdmin: CapItem;
    capUsers: CapItem;
    capRoles: CapItem;
    capLogs: CapItem;
    capSettings: CapItem;
    capMultitenant: CapItem;
    capTenants: CapItem;
    capMembership: CapItem;
    capPlans: CapItem;
    capGeneral: CapItem;
    capCustomers: CapItem;
    capInventory: CapItem;
    capAccounts: CapItem;
    capSuppliers: CapItem;
    capTasks: CapItem;
    capHR: CapItem;
    capEmployees: CapItem;
    capDepartments: CapItem;
    capPositions: CapItem;
    capGrades: CapItem;
    capApprovals: CapItem;
    capApprovalsConfig: CapItem;
    capNotifications: CapItem;
    capSelfApproval: CapItem;
    capAppModels: CapItem;
    capNotificationsConfig: CapItem;
    tmpProfileuserName: string;
    isProcessing: boolean;
    departmentFormConfig: FormConfig;
    editDepartmentButton: Button;
    departmentDetailsConfig: DetailsDialogConfig;
    positionFormConfig: FormConfig;
    editPositionButton: Button;
    positionDetailsConfig: DetailsDialogConfig;
    genders: {
        name: string;
        value: number;
    }[];
    employeeFormConfig: FormConfig;
    employeesTableConfig: TableConfig;
    positionsTableConfig: TableConfig;
    departmentTableConfig: TableConfig;
    contactPersonFormConfig: FormConfig;
    contactPersonTableConfig: TableConfig;
    customerFormConfig: FormConfig;
    customerCreateButton: Button;
    customerEditButton: Button;
    customerDetailsConfig: DetailsDialogConfig;
    customersTableConfig: TableConfig;
    supplierFormConfig: FormConfig;
    supplierCreateButton: Button;
    supplierEditButton: Button;
    supplierDetailsConfig: DetailsDialogConfig;
    suppliersTableConfig: TableConfig;
    notificationOptions: {
        name: string;
        value: number;
    }[];
    approvalHistoryFormConfig: FormConfig;
    approvalHistoryTableConfig: TableConfig;
    approvalFormConfig: FormConfig;
    approvalActionFormConfig: FormConfig;
    approveActionDetailsConfig: DetailsDialogConfig;
    declineActionDetailsConfig: DetailsDialogConfig;
    approveButton: Button;
    declineButton: Button;
    cancelButton: Button;
    approvalDetailsConfig: DetailsDialogConfig;
    viewApprovalButton: Button;
    receivedApprovalsTableConfig: TableConfig;
    sentApprovalsTableConfig: TableConfig;
    private listCache;
    private cacheTimestamps;
    private ongoingRequests;
    CallApi(action: Action, data?: any): Observable<any>;
    private handleCachedCall;
    private generateCacheKey;
    private isCacheValid;
    private getCacheDuration;
    ClearCache(): void;
    invalidateListCache(entityUrl: string): void;
    CheckWelcomed(path?: string): void;
    Navigate(path: string): void;
    NavigateWithValue(path: string, value: string): void;
    GetNavigationValue(): any;
    tmpAccountID: any;
    GetUser(): Observable<any>;
    RegisterAccount(u: any): Observable<any>;
    GetUserByID(val: string): Observable<any>;
    UpdateUser(profile: any): Observable<any>;
    UnlockUser(user: any): Observable<any>;
    LockUser(user: any): Observable<any>;
    DeleteUser(user: any): Observable<any>;
    Login(u: User): Observable<any>;
    ChangePassword(u: any): Observable<any>;
    ChangePasswordAdmin(u: any): Observable<any>;
    SelfReset(u: User): Observable<any>;
    PostRole(role: any, action: string): Observable<any>;
    PutRole(role: any): Observable<any>;
    GetRole(by: string, val: string): Observable<any>;
    GetLog(by: string, val: string): Observable<any>;
    GetSetting(by: string, val: string): Observable<any>;
    UpdateSetting(setting: any, action: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataServiceLib, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataServiceLib>;
}

declare class LoaderService {
    isLoading: BehaviorSubject<boolean>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoaderService>;
}

declare class DialogService {
    private dialog;
    private breakpointObserver;
    private smallScreen;
    constructor(dialog: MatDialog, breakpointObserver: BreakpointObserver);
    openDetailsDialog<T>(config: DetailsDialogConfig, dialogComponent: new (...args: any[]) => T): {
        afterClosed: Observable<any>;
        inputChange: Observable<any>;
        dialogRef: MatDialogRef<T>;
    };
    openConfiguredDetailsDialog<T>(button: Button, row: any, dialogComponent: new (...args: any[]) => T): Observable<any>;
    openPrintDialog(htmlContent: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

declare const authGuard: CanActivateFn;

declare class Core {
    static deepClone(obj: any): any;
    static deepClone2(obj: any): any;
    static camelToWords(value: string): string;
    static generateObject(fields: Field[]): {};
    static resetObject(fields: Field[], data: any): void;
    static checkSecurity(security: SecurityConfig, currentRole: any): boolean;
    static hasFormAccess(formConfig: FormConfig, currentRole: any): boolean;
    static getFormAccess(formConfig: FormConfig, currentRole: any): RoleAccess;
    private static getRoleAccess;
    static testVisible(config: FormConfig, data: any, field: Field, currentRole: any): boolean;
    static testReadOnly(config: FormConfig, data: any, field: Field): boolean;
    static testVisibleHeaderButton(data: any, btn: any): boolean;
    static getVisibleSubfields(config: FormConfig, data: any, field: Field, currentRole: any): Field[];
    static validateObject(fields: Field[], data: any): string;
    static testRequired(config: FormConfig, data: any, field: Field): boolean;
    static getInitialValue(field: Field): any;
    static getClone(x: any): any;
    static getNumber(value: string): string | 0;
    static getFirstDayOfMonth(): Date;
    static emailIsValid(email: any): boolean;
    static isValidUNCPath(path: string): boolean;
    static isValidDate(date: any): boolean;
    static isValidEmailList(list: string): boolean;
    static nullDate: string;
    static isNumber(value: string | number): boolean;
    static getDiff(startDate: any, endDate?: string): string;
    static nowDate(NoTime?: boolean): string;
    static getFormatedDate(dateString: string, NoTime?: boolean): string;
    static getFormatedDate2(d: Date, NoTime?: boolean): string;
    static getBusinessDatesCount(startDate: string, endDate: string): number;
}
declare class DetailsDialogProcessor {
    static processDetailsConfig(detailsConfig: DetailsDialogConfig, row: any): DetailsDialogConfig;
    static initializeConfigs(detailsConfig: DetailsDialogConfig): {
        tableConfig: tin_spa.TableConfig;
        tableConfigs: tin_spa.TableConfig[];
        formConfig: FormConfig;
        stepConfig: tin_spa.StepConfig;
        statusConfig: tin_spa.StatusConfig;
        buttons: tin_spa.Button[];
    };
    static setHeroValue(detailsConfig: DetailsDialogConfig, details: any): void;
    static handleFormMode(detailsConfig: DetailsDialogConfig, formConfig: FormConfig): {
        details: any;
        loadByAction: boolean;
        action: any;
    };
    private static loadDetailsData;
    private static loadDetailsFromUrl;
    static setFileField(formConfig: FormConfig): Field;
    static setupButtons(buttons: any): {
        extraButtons: any;
        createButton: any;
        editButton: any;
        deleteButton: any;
    };
}

declare class TinSpaComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<TinSpaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TinSpaComponent, "spa-tin-spa", never, {}, {}, never, never, false, never>;
}

declare class TextComponent implements OnInit, OnChanges {
    private dataService;
    constructor(dataService: DataServiceLib);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    filteredOptions: Observable<string[]>;
    multiDimension: boolean;
    hideRequiredControl: FormControl<boolean>;
    hide: boolean;
    appearance: 'fill' | 'outline';
    readonly: boolean;
    hint: string;
    display: string;
    placeholder: string;
    value: string;
    valueChange: EventEmitter<any>;
    format: string;
    type: string;
    leave: EventEmitter<any>;
    enterPress: EventEmitter<any>;
    rows: number;
    width: string;
    copyContent: boolean;
    clearContent: boolean;
    options: any;
    optionDisplay: string;
    optionValue: string;
    loadAction: Action;
    required: boolean;
    min: number;
    max: number;
    regex?: {
        pattern: string;
        message: string;
    };
    suffix: string;
    infoMessage: string;
    isHovered: boolean;
    onMouseEnter(): void;
    onMouseLeave(): void;
    private initFilter;
    private _filter;
    initControl(control: FormControl): void;
    getDisplayValue(value: any): string;
    changed(): void;
    leaved(): void;
    clear(): void;
    enterPressed(): void;
    refresh(event: MouseEvent): void;
    getData(action: Action): void;
    myControl: FormControl<string>;
    control: FormControl<string>;
    private getValidators;
    validate(control: FormControl): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextComponent, "spa-text", never, { "appearance": { "alias": "appearance"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "display": { "alias": "display"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "format": { "alias": "format"; "required": false; }; "type": { "alias": "type"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "width": { "alias": "width"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionDisplay": { "alias": "optionDisplay"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "loadAction": { "alias": "loadAction"; "required": false; }; "required": { "alias": "required"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "regex": { "alias": "regex"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; }, { "valueChange": "valueChange"; "leave": "leave"; "enterPress": "enterPress"; }, never, never, false, never>;
}

declare class CheckComponent implements OnInit {
    private messageService;
    constructor(messageService: MessageService);
    ngOnInit(): void;
    readonly: boolean;
    display: string;
    value: boolean;
    valueChange: EventEmitter<any>;
    click: EventEmitter<any>;
    check: EventEmitter<any>;
    uncheck: EventEmitter<any>;
    infoMessage: string;
    infoClick: EventEmitter<void>;
    changed(): void;
    clicked(): void;
    checked(): void;
    unchecked(): void;
    onInfoClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckComponent, "spa-check", never, { "readonly": { "alias": "readonly"; "required": false; }; "display": { "alias": "display"; "required": false; }; "value": { "alias": "value"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; }, { "valueChange": "valueChange"; "click": "click"; "check": "check"; "uncheck": "uncheck"; "infoClick": "infoClick"; }, never, never, false, never>;
}

declare class DateComponent implements OnInit, OnChanges {
    required: boolean;
    min: string;
    max: string;
    readonly: boolean;
    hint: string;
    value: string | null;
    display: string;
    placeholder: string;
    width: string;
    valueChange: EventEmitter<string>;
    suffix: string;
    infoMessage: string;
    copyContent: boolean;
    clearContent: boolean;
    isHovered: boolean;
    onMouseEnter(): void;
    onMouseLeave(): void;
    minDate: FormControl;
    maxDate: FormControl;
    control: FormControl;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private initializeDateControls;
    private updateControlState;
    onChangeEvent(): void;
    onInputClick(picker: any): void;
    validate(control: FormControl): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateComponent, "spa-date", never, { "required": { "alias": "required"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "value": { "alias": "value"; "required": false; }; "display": { "alias": "display"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "width": { "alias": "width"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class DatetimeComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    display: string;
    value: string;
    valueChange: EventEmitter<any>;
    readonly: boolean;
    width: string;
    min: string;
    max: string;
    changed(): void;
    suffix: string;
    infoMessage: string;
    copyContent: boolean;
    clearContent: boolean;
    isHovered: boolean;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatetimeComponent, "spa-datetime", never, { "display": { "alias": "display"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "width": { "alias": "width"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class LabelComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    display: string;
    value: string;
    format: string;
    suffix: string;
    size: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LabelComponent, "spa-label", never, { "display": { "alias": "display"; "required": false; }; "value": { "alias": "value"; "required": false; }; "format": { "alias": "format"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SelectCommonComponent implements OnInit, OnDestroy {
    protected messageService: MessageService;
    protected dataService: DataServiceLib;
    constructor(messageService: MessageService, dataService: DataServiceLib);
    ngOnInit(): void;
    ngOnChanges(): void;
    displayValue: any;
    isHovered: boolean;
    selectedOptionHint: string;
    private subscription;
    width: string;
    readonly: boolean;
    required: boolean;
    defaultFirstValue: boolean;
    readonlyMode: string;
    hint: string;
    placeholder: string;
    display: string;
    value: any;
    options: any;
    masterOptions: any;
    masterField: string;
    optionValue: string;
    optionDisplay: string;
    optionDisplayExtra: string;
    nullable: boolean;
    infoMessage: string;
    copyContent: boolean;
    loadAction: Action;
    loadIDField: string;
    field: Field;
    data: any;
    valueChange: EventEmitter<any>;
    hoverChange: EventEmitter<boolean>;
    setDefaultValue(): void;
    changed(): void;
    private updateSelectedOptionHint;
    get computedHint(): string;
    onMouseEnter(): void;
    onMouseLeave(): void;
    refresh(event: MouseEvent): void;
    private transformLoadUrl;
    getData(loadAction: Action): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectCommonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectCommonComponent, "spa-select-common", never, { "width": { "alias": "width"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "defaultFirstValue": { "alias": "defaultFirstValue"; "required": false; }; "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "display": { "alias": "display"; "required": false; }; "value": { "alias": "value"; "required": false; }; "options": { "alias": "options"; "required": false; }; "masterOptions": { "alias": "masterOptions"; "required": false; }; "masterField": { "alias": "masterField"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "optionDisplay": { "alias": "optionDisplay"; "required": false; }; "optionDisplayExtra": { "alias": "optionDisplayExtra"; "required": false; }; "nullable": { "alias": "nullable"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "loadAction": { "alias": "loadAction"; "required": false; }; "loadIDField": { "alias": "loadIDField"; "required": false; }; "field": { "alias": "field"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "valueChange": "valueChange"; "hoverChange": "hoverChange"; }, never, ["[additionalButtons]"], false, never>;
}

declare class ButtonService {
    private authService;
    constructor(authService: AuthService);
    getButton(buttons: Button[], name: string): Button | null;
    getConfirmMessage(button: Button, row: any): string;
    getButtonProperties(button: Button, row: any, config: TableConfig): {
        color: string;
        icon: string;
        disabled: boolean;
        visible: boolean;
        tip: string;
    };
    getButtonColor(button: Button, row: any): string;
    getTitleAction(mode: string, buttons: Button[]): string;
    isTabVisible(tableConfig: TableConfig, details: any): boolean;
    getIcon(button: Button, config: TableConfig | null): string;
    testDisabled(button: Button, row: any, config?: TableConfig): boolean;
    getVisibleButtons(buttons: Button[], row: any, tableConfig?: TableConfig): Button[];
    testVisible(button: Button, row: any, tableConfig?: TableConfig): boolean;
    private hasRequiredAccess;
    private getDefaultColor;
    private getDefaultIcon;
    getCreateButton(buttons: Button[]): Button | undefined;
    isFormButton(button: Button): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ButtonService>;
}

declare class SelectComponent extends SelectCommonComponent implements OnInit {
    protected messageService: MessageService;
    protected dataService: DataServiceLib;
    private dialogService;
    private buttonService;
    constructor(messageService: MessageService, dataService: DataServiceLib, dialogService: DialogService, buttonService: ButtonService);
    ngOnInit(): void;
    detailsConfig: DetailsDialogConfig;
    onHoverChange(isHovered: boolean): void;
    canCreate(): boolean;
    canView(): boolean;
    onPeekClick(event: MouseEvent, mode: 'create' | 'view'): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "spa-select", never, { "detailsConfig": { "alias": "detailsConfig"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ActivityComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    notes: any[];
    notesMessage: string;
    title: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityComponent, "spa-activity", never, { "notes": { "alias": "notes"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FilterComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    flatButtons: boolean;
    showText: boolean;
    showButton: boolean;
    data: MatTableDataSource<unknown, _angular_material_paginator.MatPaginator>;
    refreshClick: EventEmitter<any>;
    _filterText: string;
    keyUp(event: KeyboardEvent): void;
    applyFilter(filterValue: string): void;
    refreshClicked(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent, "spa-filter", never, { "flatButtons": { "alias": "flatButtons"; "required": false; }; "showText": { "alias": "showText"; "required": false; }; "showButton": { "alias": "showButton"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "refreshClick": "refreshClick"; }, never, never, false, never>;
}

declare class messageDialog implements OnInit {
    private dialogRef;
    data: any;
    constructor(dialogRef: MatDialogRef<messageDialog>, data: any);
    ngOnInit(): void;
    messageType: any;
    _messageSubject: any;
    _messageDetails: any;
    response(resp: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<messageDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<messageDialog, "lib-app-message", never, {}, {}, never, never, false, never>;
}

declare class MoneyComponent implements OnInit, OnChanges {
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    initControl(control: FormControl): void;
    readonly: boolean;
    hint: string;
    display: string;
    placeholder: string;
    value: string;
    width: string;
    currency: string;
    valueChange: EventEmitter<any>;
    leave: EventEmitter<any>;
    enterPress: EventEmitter<any>;
    required: boolean;
    min: number;
    max: number;
    infoMessage: string;
    infoClick: EventEmitter<void>;
    copyContent: boolean;
    clearContent: boolean;
    suffix: string;
    isHovered: boolean;
    onMouseEnter(): void;
    onMouseLeave(): void;
    onInfoClick(event: MouseEvent): void;
    clear(): void;
    leaved(): void;
    enterPressed(): void;
    control: FormControl<string>;
    validate(control: FormControl): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MoneyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MoneyComponent, "spa-money", never, { "readonly": { "alias": "readonly"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "display": { "alias": "display"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "width": { "alias": "width"; "required": false; }; "currency": { "alias": "currency"; "required": false; }; "required": { "alias": "required"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; }, { "valueChange": "valueChange"; "leave": "leave"; "enterPress": "enterPress"; "infoClick": "infoClick"; }, never, never, false, never>;
}

declare class OptionComponent implements OnInit {
    private messageService;
    constructor(messageService: MessageService);
    ngOnInit(): void;
    OGValue: any;
    options: any;
    optionValue: string;
    optionDisplay: string;
    readonly: boolean;
    type: string;
    value: string;
    display: string;
    show: boolean;
    required: boolean;
    infoMessage: string;
    copyContent: boolean;
    suffix: string;
    loadAction: Action;
    valueChange: EventEmitter<any>;
    enterPress: EventEmitter<any>;
    changed(): void;
    dateChanged(x: any): void;
    enterPressed(): void;
    resetValue(): void;
    onInfoClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OptionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OptionComponent, "spa-option", never, { "options": { "alias": "options"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "optionDisplay": { "alias": "optionDisplay"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "display": { "alias": "display"; "required": false; }; "show": { "alias": "show"; "required": false; }; "required": { "alias": "required"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "loadAction": { "alias": "loadAction"; "required": false; }; }, { "valueChange": "valueChange"; "enterPress": "enterPress"; }, never, never, false, never>;
}

declare class TilesComponent implements OnInit {
    private dataService;
    private messageService;
    constructor(dataService: DataServiceLib, messageService: MessageService);
    ngOnInit(): void;
    ngOnChanges(): void;
    tiles: Tile[];
    config: TileConfig;
    tileActionSelected: EventEmitter<Action>;
    lastSearch: any;
    data: any;
    reload: Subject<boolean>;
    tileClick: EventEmitter<any>;
    tileUnClick: EventEmitter<any>;
    selectedTile: string;
    loadData(action: Action, data: any): void;
    clicked(clickedTile: Tile): void;
    pop(x: any): void;
    isHidden(tile: Tile): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TilesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TilesComponent, "spa-tiles", never, { "config": { "alias": "config"; "required": false; }; "lastSearch": { "alias": "lastSearch"; "required": false; }; "data": { "alias": "data"; "required": false; }; "reload": { "alias": "reload"; "required": false; }; }, { "tileActionSelected": "tileActionSelected"; "tileClick": "tileClick"; "tileUnClick": "tileUnClick"; }, never, never, false, never>;
}

declare class StepsComponent implements OnInit {
    private breakpointObserver;
    private dataService;
    constructor(breakpointObserver: BreakpointObserver, dataService: DataServiceLib);
    ngOnInit(): void;
    ngOnChanges(): void;
    private observeScreenSize;
    stepper: MatStepper;
    value: string;
    config: StepConfig;
    data: any;
    selectedIndex: number;
    smallScreen: boolean;
    steps: Step[];
    private loadSteps;
    private updateSelectedStep;
    get shouldShowLabels(): boolean;
    getVisibleSteps(): Step[];
    static ɵfac: i0.ɵɵFactoryDeclaration<StepsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepsComponent, "spa-steps", never, { "value": { "alias": "value"; "required": false; }; "config": { "alias": "config"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AttachComponent implements OnInit {
    private messageService;
    constructor(messageService: MessageService);
    ngOnInit(): void;
    fileOptions: {
        allowedExtensions?: string[];
        maxSizeMB?: number;
        compressImages?: boolean;
    };
    private readonly imageExtensions;
    message: string;
    files: any[];
    filesChange: EventEmitter<any>;
    upload: EventEmitter<any>;
    enableUpload: boolean;
    onFileDropped($event: any): void;
    fileBrowseHandler(event: any): void;
    deleteFile(index: number): void;
    prepareFilesList(files: Array<any>): Promise<void>;
    private getFileExtension;
    private isImage;
    formatBytes(bytes: any, decimals: any): string;
    uploaded(): void;
    filesChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttachComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AttachComponent, "spa-attach", never, { "fileOptions": { "alias": "fileOptions"; "required": false; }; "message": { "alias": "message"; "required": false; }; "files": { "alias": "files"; "required": false; }; "enableUpload": { "alias": "enableUpload"; "required": false; }; }, { "filesChange": "filesChange"; "upload": "upload"; }, never, never, false, never>;
}

declare class ChipsComponent implements OnInit {
    private messageService;
    constructor(messageService: MessageService);
    ngOnInit(): void;
    icon: string;
    removable: boolean;
    addable: boolean;
    chips: string[];
    click: EventEmitter<any>;
    remove: EventEmitter<any>;
    clicked(chip: string): void;
    removed(chip: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChipsComponent, "spa-chips", never, { "icon": { "alias": "icon"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "addable": { "alias": "addable"; "required": false; }; "chips": { "alias": "chips"; "required": false; }; }, { "click": "click"; "remove": "remove"; }, never, never, false, never>;
}

declare class LoaderComponent implements OnInit {
    private loaderService;
    constructor(loaderService: LoaderService);
    ngOnInit(): void;
    logo: string;
    loading: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "spa-loader", never, { "logo": { "alias": "logo"; "required": false; }; }, {}, never, never, false, never>;
}

declare class NotificationsService {
    private dataService;
    private notificationCount;
    notificationCount$: rxjs.Observable<number>;
    constructor(dataService: DataServiceLib);
    loadNotifications(): void;
    refreshCount(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationsService>;
}

declare class NavMenuComponent {
    router: Router;
    authService: AuthService;
    private storageService;
    private notificationsService;
    private breakpointObserver;
    dataService: DataServiceLib;
    constructor(router: Router, authService: AuthService, storageService: StorageService, notificationsService: NotificationsService, breakpointObserver: BreakpointObserver, dataService: DataServiceLib);
    ngOnInit(): void;
    notificationCount$: any;
    smallScreen: any;
    myRole: any;
    loggedUserFullName: string;
    tenantName: string;
    loggedin: boolean;
    isExpanded: boolean;
    nowDate: Date;
    appConfig: AppConfig;
    footer: string;
    collapse(): void;
    toggle(): void;
    closeSide(): void;
    logoff(): void;
    redirectTo(link: string): void;
    getSubItems(capItem: CapItem): CapItem[];
    get reversedCapItems(): CapItem[];
    static ɵfac: i0.ɵɵFactoryDeclaration<NavMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavMenuComponent, "spa-nav-menu", never, { "appConfig": { "alias": "appConfig"; "required": false; }; "footer": { "alias": "footer"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TableConfigService {
    private dataService;
    private authService;
    constructor(dataService: DataServiceLib, authService: AuthService);
    setColumns(config: TableConfig, smallScreen: boolean): string[];
    getVisibleColumns(config: TableConfig): Column[];
    getActionsWidth(buttons: Button[], smallScreen: boolean, config: TableConfig): string;
    getDisplayedButtons(buttons: Button[], isSmallScreen: boolean, config: TableConfig): Button[];
    hasTableAccess(config: TableConfig): boolean;
    getVisibleTableConfigs(tableConfigs: TableConfig[]): TableConfig[];
    static ɵfac: i0.ɵɵFactoryDeclaration<TableConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableConfigService>;
}

declare class ConditionService {
    testIconCondition(icon: Icon, row: any): boolean;
    testColorCondition(color: Color, row: any): boolean;
    getColor(value: any, options: any[]): string;
    testCondition(condition: (value: any) => boolean, value: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConditionService>;
}

declare class TableComponent implements OnInit, AfterViewInit {
    private dataService;
    private messageService;
    private breakpointObserver;
    dialog: MatDialog;
    private buttonService;
    private dialogService;
    private tableConfigService;
    private conditionService;
    private authService;
    constructor(dataService: DataServiceLib, messageService: MessageService, breakpointObserver: BreakpointObserver, dialog: MatDialog, buttonService: ButtonService, dialogService: DialogService, tableConfigService: TableConfigService, conditionService: ConditionService, authService: AuthService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    elevation: string;
    actionsWidth: string;
    showFilterButton: boolean;
    tileReload: Subject<boolean>;
    hasBeenActivated: boolean;
    smallScreen: boolean;
    hasFormAccess: boolean;
    tableDataSource: any;
    dataSource: any[];
    displayedColumns: any[];
    displayedButtons: any[];
    originalTableLoadAction: Action;
    emptyGroupsData: any[];
    tablePaginator: MatPaginator;
    data: any;
    tileData: any;
    config: TableConfig;
    reload: Subject<boolean>;
    activeTab: boolean;
    inTab: boolean;
    dataLoad: EventEmitter<any>;
    actionSuccess: EventEmitter<any>;
    refreshClick: EventEmitter<any>;
    searchClick: EventEmitter<any>;
    createClick: EventEmitter<any>;
    actionClick: EventEmitter<any>;
    inputChange: EventEmitter<any>;
    actionResponse: EventEmitter<any>;
    private initializeComponent;
    private updateTableConfiguration;
    private setupDataLoading;
    private loadEmptyGroups;
    loadData(action: Action, data: any): void;
    private setPaginator;
    inputChanged(event: any): void;
    formDefaults(): void;
    setButtons(): void;
    getButton(name: string): Button;
    getIcon(buttonName: string): string;
    getButtonColor(button: Button, row: any): string;
    getOptions(column: any): Column;
    getColor(value: any, options: any[]): string;
    testIconCondition(row: any, icon: Icon): boolean;
    testColorCondition(row: any, color: Color): boolean;
    showBanner(message: string): void;
    testDisabled(row: any, buttonName: string): boolean;
    lastSearch: any;
    searchClicked(x: any): void;
    tileClicked(tile: any): void;
    tileUnClicked(tile: any): void;
    refreshClicked(): void;
    dataLoaded(x: any): void;
    actionClicked(name: string, row: any, group?: any, button?: Button): void;
    columnClicked(column: Column, row: any): void;
    customModel(name: any, row: any, button?: Button): void;
    actionClickedEmit(name: any, row: any): void;
    viewModel(row: any, button?: Button): void;
    newModel(): void;
    editModel(row: any, button?: Button): void;
    private open;
    deleteModel(row: any, button?: Button): void;
    doAction(buttonName: string, row: any): void;
    execAction(button: Button, row: any): void;
    private getElevationClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "spa-table", never, { "data": { "alias": "data"; "required": false; }; "tileData": { "alias": "tileData"; "required": false; }; "config": { "alias": "config"; "required": false; }; "reload": { "alias": "reload"; "required": false; }; "activeTab": { "alias": "activeTab"; "required": false; }; "inTab": { "alias": "inTab"; "required": false; }; }, { "dataLoad": "dataLoad"; "actionSuccess": "actionSuccess"; "refreshClick": "refreshClick"; "searchClick": "searchClick"; "createClick": "createClick"; "actionClick": "actionClick"; "inputChange": "inputChange"; "actionResponse": "actionResponse"; }, never, never, false, never>;
}

declare class TableInternalComponent implements OnInit, AfterViewInit {
    private dataService;
    private messageService;
    private breakpointObserver;
    dialog: MatDialog;
    private buttonService;
    private dialogService;
    private tableConfigService;
    private conditionService;
    private authService;
    constructor(dataService: DataServiceLib, messageService: MessageService, breakpointObserver: BreakpointObserver, dialog: MatDialog, buttonService: ButtonService, dialogService: DialogService, tableConfigService: TableConfigService, conditionService: ConditionService, authService: AuthService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    elevation: string;
    actionsWidth: string;
    showFilterButton: boolean;
    tileReload: Subject<boolean>;
    hasBeenActivated: boolean;
    smallScreen: boolean;
    hasFormAccess: boolean;
    tableDataSource: any;
    dataSource: any[];
    displayedColumns: any[];
    displayedButtons: any[];
    originalTableLoadAction: Action;
    emptyGroupsData: any[];
    tablePaginator: MatPaginator;
    data: any;
    tileData: any;
    config: TableConfig;
    reload: Subject<boolean>;
    activeTab: boolean;
    inTab: boolean;
    dataLoad: EventEmitter<any>;
    actionSuccess: EventEmitter<any>;
    refreshClick: EventEmitter<any>;
    searchClick: EventEmitter<any>;
    createClick: EventEmitter<any>;
    actionClick: EventEmitter<any>;
    inputChange: EventEmitter<any>;
    actionResponse: EventEmitter<any>;
    private initializeComponent;
    private updateTableConfiguration;
    private setupDataLoading;
    private loadEmptyGroups;
    loadData(action: Action, data: any): void;
    private setPaginator;
    inputChanged(event: any): void;
    formDefaults(): void;
    setButtons(): void;
    getButton(name: string): Button;
    getIcon(buttonName: string): string;
    getButtonColor(button: Button, row: any): string;
    getOptions(column: any): Column;
    getColor(value: any, options: any[]): string;
    testIconCondition(row: any, icon: Icon): boolean;
    testColorCondition(row: any, color: Color): boolean;
    showBanner(message: string): void;
    testDisabled(row: any, buttonName: string): boolean;
    lastSearch: any;
    searchClicked(x: any): void;
    tileClicked(tile: any): void;
    tileUnClicked(tile: any): void;
    refreshClicked(): void;
    dataLoaded(x: any): void;
    actionClicked(name: string, row: any, group?: any, button?: Button): void;
    columnClicked(column: Column, row: any): void;
    customModel(name: any, row: any, button?: Button): void;
    actionClickedEmit(name: any, row: any): void;
    viewModel(row: any, button?: Button): void;
    newModel(): void;
    editModel(row: any, button?: Button): void;
    private open;
    deleteModel(row: any, button?: Button): void;
    doAction(buttonName: string, row: any): void;
    execAction(button: Button, row: any): void;
    private getElevationClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableInternalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableInternalComponent, "spa-table-internal", never, { "data": { "alias": "data"; "required": false; }; "tileData": { "alias": "tileData"; "required": false; }; "config": { "alias": "config"; "required": false; }; "reload": { "alias": "reload"; "required": false; }; "activeTab": { "alias": "activeTab"; "required": false; }; "inTab": { "alias": "inTab"; "required": false; }; }, { "dataLoad": "dataLoad"; "actionSuccess": "actionSuccess"; "refreshClick": "refreshClick"; "searchClick": "searchClick"; "createClick": "createClick"; "actionClick": "actionClick"; "inputChange": "inputChange"; "actionResponse": "actionResponse"; }, never, never, false, never>;
}

declare class DetailsDialog implements OnInit, OnDestroy {
    private breakpointObserver;
    private loaderService;
    dataService: DataServiceLib;
    private messageService;
    private dialogRef;
    detailsConfig: DetailsDialogConfig;
    private buttonService;
    private dialogService;
    private authService;
    tableConfigService: TableConfigService;
    constructor(breakpointObserver: BreakpointObserver, loaderService: LoaderService, dataService: DataServiceLib, messageService: MessageService, dialogRef: MatDialogRef<DetailsDialog>, detailsConfig: DetailsDialogConfig, buttonService: ButtonService, dialogService: DialogService, authService: AuthService, tableConfigService: TableConfigService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private refreshSubscription;
    autoRefreshEnabled: boolean;
    titleAction: string;
    loadByAction: boolean;
    extraButtons: Button[];
    buttons: Button[];
    createButton: Button;
    editButton: Button;
    deleteButton: Button;
    fileField: Field;
    files: any[];
    tableReload: Subject<boolean>;
    tableConfig: TableConfig;
    tableConfigs: TableConfig[];
    details: any;
    formConfig: FormConfig;
    stepConfig: StepConfig;
    statusConfig: StatusConfig;
    smallScreen: boolean;
    isLoadComplete: boolean;
    isProcessing: boolean;
    inputChange: EventEmitter<any>;
    selectedTabIndex: number;
    onTabChange(event: MatTabChangeEvent): void;
    private initAutoRefresh;
    private startAutoRefresh;
    private stopAutoRefresh;
    toggleAutoRefresh(): void;
    loadData(action: Action, causeTablesReload: any): void;
    inputChanged(event: any): void;
    setMode(newMode: any): void;
    setTitleAction(): void;
    getButton(name: string): Button;
    testDisabled(row: any, buttonName: string): boolean;
    testVisible(row: any, buttonName: string): boolean;
    testVisibleTab(tblConfig: TableConfig): boolean;
    getButtonColor(button: Button, row: any): string;
    getVisibleFields(): Field[];
    create(): void;
    edit(): void;
    delete(): void;
    custom(button: Button): void;
    private openNestedDetailsDialog;
    private refreshData;
    handleButtonAction(buttonName: string): void;
    processButtonAction(button: Button): void;
    private validateForm;
    private prepareActionData;
    private executeAction;
    private performApiCall;
    getClosePosition(): 'top' | 'bottom';
    getCloseText(): string;
    shouldShowTopClose(): boolean;
    shouldShowBottomClose(): boolean;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsDialog, "spa-detailsDialog", never, {}, { "inputChange": "inputChange"; }, never, never, false, never>;
}

declare class DetailsDialogInternal implements OnInit, OnDestroy {
    private breakpointObserver;
    private loaderService;
    dataService: DataServiceLib;
    private messageService;
    private dialogRef;
    detailsConfig: DetailsDialogConfig;
    private buttonService;
    private dialogService;
    private authService;
    tableConfigService: TableConfigService;
    constructor(breakpointObserver: BreakpointObserver, loaderService: LoaderService, dataService: DataServiceLib, messageService: MessageService, dialogRef: MatDialogRef<DetailsDialogInternal>, detailsConfig: DetailsDialogConfig, buttonService: ButtonService, dialogService: DialogService, authService: AuthService, tableConfigService: TableConfigService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private refreshSubscription;
    autoRefreshEnabled: boolean;
    titleAction: string;
    loadByAction: boolean;
    extraButtons: Button[];
    buttons: Button[];
    createButton: Button;
    editButton: Button;
    deleteButton: Button;
    fileField: Field;
    files: any[];
    tableReload: Subject<boolean>;
    tableConfig: TableConfig;
    tableConfigs: TableConfig[];
    details: any;
    formConfig: FormConfig;
    stepConfig: StepConfig;
    statusConfig: StatusConfig;
    smallScreen: boolean;
    isLoadComplete: boolean;
    isProcessing: boolean;
    inputChange: EventEmitter<any>;
    selectedTabIndex: number;
    onTabChange(event: MatTabChangeEvent): void;
    private initAutoRefresh;
    private startAutoRefresh;
    private stopAutoRefresh;
    toggleAutoRefresh(): void;
    loadData(action: Action, causeTablesReload: any): void;
    inputChanged(event: any): void;
    setMode(newMode: any): void;
    setTitleAction(): void;
    getButton(name: string): Button;
    testDisabled(row: any, buttonName: string): boolean;
    testVisible(row: any, buttonName: string): boolean;
    testVisibleTab(tblConfig: TableConfig): boolean;
    getButtonColor(button: Button, row: any): string;
    getVisibleFields(): Field[];
    create(): void;
    edit(): void;
    delete(): void;
    custom(button: Button): void;
    private openNestedDetailsDialog;
    private refreshData;
    handleButtonAction(buttonName: string): void;
    processButtonAction(button: Button): void;
    private validateForm;
    private prepareActionData;
    private executeAction;
    private performApiCall;
    getClosePosition(): 'top' | 'bottom';
    getCloseText(): string;
    shouldShowTopClose(): boolean;
    shouldShowBottomClose(): boolean;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsDialogInternal, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsDialogInternal, "spa-detailsDialog-internal", never, {}, { "inputChange": "inputChange"; }, never, never, false, never>;
}

declare class FormComponent implements OnInit {
    private messageService;
    private dataService;
    private authService;
    constructor(messageService: MessageService, dataService: DataServiceLib, authService: AuthService);
    ngOnInit(): void;
    dynamicSelectTemplate: TemplateRef<any>;
    hasAccess: boolean;
    fileNames: any;
    fileField: Field;
    fileViewField: Field;
    files: any[];
    fields: Field[];
    buttonDisplay: string;
    isProcessing: boolean;
    multiColumn: boolean;
    childFields: Field[];
    manuallyToggledSections: Set<string>;
    data: any;
    config: FormConfig;
    buttonClick: EventEmitter<any>;
    inputChange: EventEmitter<any>;
    initializeCompositeFields(): void;
    initializeSectionStates(): void;
    private applyValueCalculations;
    getVisibleSubfields(field: Field): Field[];
    getVisibleFields(): Field[];
    testReadOnly(field: Field): boolean;
    testRequired(field: Field): boolean;
    toggleSection(field: Field): void;
    hasSectionFields(sectionName: string): boolean;
    shouldSectionCollapse(field: Field): boolean;
    onInfoClick(event: MouseEvent, infoMessage: string): void;
    selectChanged(field: Field): void;
    inputChanged(field: Field, value: any): void;
    updateChildOptions(masterFieldName: string): void;
    private loadChildMasterOptions;
    buttonClicked(): void;
    processCall(button: Button): void;
    processForm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "spa-form", never, { "files": { "alias": "files"; "required": false; }; "data": { "alias": "data"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "buttonClick": "buttonClick"; "inputChange": "inputChange"; }, ["dynamicSelectTemplate"], never, false, never>;
}

declare class CamelToWordsPipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CamelToWordsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CamelToWordsPipe, "camelToWords", false>;
}

declare class NumberComponent implements OnInit, OnChanges {
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    initControl(control: FormControl): void;
    hideRequiredControl: FormControl<boolean>;
    hide: boolean;
    readonly: boolean;
    hint: string;
    display: string;
    placeholder: string;
    value: number;
    width: string;
    valueChange: EventEmitter<any>;
    leave: EventEmitter<any>;
    enterPress: EventEmitter<any>;
    required: boolean;
    min: number;
    max: number;
    step: number;
    suffix: string;
    infoMessage: string;
    infoClick: EventEmitter<void>;
    copyContent: boolean;
    clearContent: boolean;
    isHovered: boolean;
    onMouseEnter(): void;
    onMouseLeave(): void;
    clear(): void;
    onInfoClick(event: MouseEvent): void;
    leaved(): void;
    enterPressed(): void;
    control: FormControl<number>;
    validate(control: FormControl): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumberComponent, "spa-number", never, { "readonly": { "alias": "readonly"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "display": { "alias": "display"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "width": { "alias": "width"; "required": false; }; "required": { "alias": "required"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; }, { "valueChange": "valueChange"; "leave": "leave"; "enterPress": "enterPress"; "infoClick": "infoClick"; }, never, never, false, never>;
}

declare class SearchComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    data: any;
    config: SearchConfig;
    searchClick: EventEmitter<any>;
    smallScreen: boolean;
    tableDataSource: any;
    search(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchComponent, "spa-search", never, { "config": { "alias": "config"; "required": false; }; "smallScreen": { "alias": "smallScreen"; "required": false; }; "tableDataSource": { "alias": "tableDataSource"; "required": false; }; }, { "searchClick": "searchClick"; }, never, never, false, never>;
}

declare class ViewerComponent implements OnInit {
    private dataService;
    dialog: MatDialog;
    constructor(dataService: DataServiceLib, dialog: MatDialog);
    ngOnInit(): void;
    fileAction: Action;
    path: string;
    folderName: string;
    fileNames: any;
    removable: boolean;
    remove: EventEmitter<any>;
    display: string;
    title: string;
    loadData(): void;
    convert(): void;
    viewDocs(fileName: string): void;
    removed(i: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ViewerComponent, "spa-viewer", never, { "fileAction": { "alias": "fileAction"; "required": false; }; "path": { "alias": "path"; "required": false; }; "folderName": { "alias": "folderName"; "required": false; }; "fileNames": { "alias": "fileNames"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "display": { "alias": "display"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, { "remove": "remove"; }, never, never, false, never>;
}

declare class viewerDialog implements OnInit {
    private httpService;
    private dataServiceLib;
    data: any;
    constructor(httpService: HttpService, dataServiceLib: DataServiceLib, data: any);
    ngOnInit(): void;
    isProcessing: boolean;
    fullPath: string;
    fileNames: any[];
    fileName: string;
    currIndex: number;
    currentFileUrl: string;
    previous(): void;
    next(): void;
    imageDoc: boolean;
    setURL(): void;
    change(fileName: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<viewerDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<viewerDialog, "app-editRequest", never, {}, {}, never, never, false, never>;
}

declare class TenantSettingsComponent implements OnInit {
    dataService: DataServiceLib;
    private messageService;
    authService: AuthService;
    dialog: MatDialog;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService, dialog: MatDialog);
    ngOnInit(): void;
    newName: any;
    myRole: any;
    tenants: any;
    currTenant: any;
    currentTenantID: any;
    plan: any;
    ownTenant: any;
    roles: {
        roleName: string;
        roleID: number;
    }[];
    loadData(): void;
    loadTenants(): void;
    updateTenant(x: any): void;
    refreshOrgsLists(): void;
    switchTenant(): void;
    forceLogin(): void;
    roleField: Field;
    inviteDialogConfig: DetailsDialogConfig;
    membersFormConfig: FormConfig;
    tableReload: Subject<boolean>;
    membersTableConfig: TableConfig;
    orgFormConfig: FormConfig;
    createOrgDialogConfig: DetailsDialogConfig;
    renameOrgDialogConfig: DetailsDialogConfig;
    orgsReload: Subject<boolean>;
    orgsTableConfig: TableConfig;
    mailerFormConfig: FormConfig;
    mailerTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<TenantSettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TenantSettingsComponent, "spa-tenant-settings", never, {}, {}, never, never, false, never>;
}

declare class TenantsComponent implements OnInit {
    private dataService;
    private messageService;
    authService: AuthService;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService);
    ngOnInit(): void;
    tenantFormConfig: FormConfig;
    tenantsTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<TenantsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TenantsComponent, "spa-tenants", never, {}, {}, never, never, false, never>;
}

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

declare class MembershipComponent implements OnInit {
    authService: AuthService;
    constructor(authService: AuthService);
    ngOnInit(): void;
    formConfig: FormConfig;
    membersTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<MembershipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MembershipComponent, "spa-membership", never, {}, {}, never, never, false, never>;
}

declare class PlansComponent implements OnInit {
    authService: AuthService;
    constructor(authService: AuthService);
    ngOnInit(): void;
    formConfig: FormConfig;
    plansTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlansComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlansComponent, "spa-plans", never, {}, {}, never, never, false, never>;
}

declare class CustomersComponent implements OnInit {
    dataService: DataServiceLib;
    authService: AuthService;
    constructor(dataService: DataServiceLib, authService: AuthService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomersComponent, "spa-customers", never, {}, {}, never, never, false, never>;
}

declare class InventoryComponent implements OnInit {
    private dataService;
    private messageService;
    authService: AuthService;
    dialog: MatDialog;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService, dialog: MatDialog);
    ngOnInit(): void;
    loadData(): void;
    reload: Subject<boolean>;
    clicked(x: any): void;
    comment(x: any): void;
    cats(): void;
    formConfig: FormConfig;
    config: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InventoryComponent, "spa-inventory", never, {}, {}, never, never, false, never>;
}

declare class quantityDialog implements OnInit {
    private loaderService;
    private messageService;
    private dataService;
    private dialogRef;
    data: any;
    constructor(loaderService: LoaderService, messageService: MessageService, dataService: DataServiceLib, dialogRef: MatDialogRef<quantityDialog>, data: any);
    ngOnInit(): void;
    quantity: number;
    action: any;
    inv: any;
    isLoadComplete: boolean;
    isProcessing: boolean;
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<quantityDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<quantityDialog, "app-quanityDiag", never, {}, {}, never, never, false, never>;
}

declare class AccountsComponent implements OnInit {
    router: Router;
    private dataService;
    private messageService;
    authService: AuthService;
    dialog: MatDialog;
    constructor(router: Router, dataService: DataServiceLib, messageService: MessageService, authService: AuthService, dialog: MatDialog);
    ngOnInit(): void;
    reload: Subject<boolean>;
    accounts: any;
    loadData(): void;
    view(x: any): void;
    open(x: any): void;
    delete(row: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccountsComponent, "spa-accounts", never, {}, {}, never, never, false, never>;
}

declare class accountDialog implements OnInit {
    private loaderService;
    private messageService;
    private dataService;
    private dialogRef;
    data: any;
    constructor(loaderService: LoaderService, messageService: MessageService, dataService: DataServiceLib, dialogRef: MatDialogRef<accountDialog>, data: any);
    ngOnInit(): void;
    action: any;
    account: FinAccount;
    isLoadComplete: boolean;
    isProcessing: boolean;
    currencies: {
        name: string;
        value: string;
    }[];
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<accountDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<accountDialog, "app-quanityDiag", never, {}, {}, never, never, false, never>;
}

declare class SuppliersComponent implements OnInit {
    dataService: DataServiceLib;
    private messageService;
    authService: AuthService;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SuppliersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SuppliersComponent, "spa-suppliers", never, {}, {}, never, never, false, never>;
}

declare class TransactionsComponent implements OnInit {
    private dataService;
    private messageService;
    private breakpointObserver;
    dialog: MatDialog;
    constructor(dataService: DataServiceLib, messageService: MessageService, breakpointObserver: BreakpointObserver, dialog: MatDialog);
    ngOnInit(): void;
    cats(): void;
    actionClicked(x: any): void;
    loadData(): void;
    transact(x: any, data: any): void;
    transfer(): void;
    smallScreen: any;
    account: any;
    accounts: any[];
    transactions: any[];
    accountID: any;
    categories: any[];
    reload: Subject<boolean>;
    config: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<TransactionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TransactionsComponent, "spa-transactions", never, {}, {}, never, never, false, never>;
}

declare class transactDialog implements OnInit {
    private loaderService;
    private messageService;
    private dataService;
    private dialogRef;
    data: any;
    constructor(loaderService: LoaderService, messageService: MessageService, dataService: DataServiceLib, dialogRef: MatDialogRef<transactDialog>, data: any);
    ngOnInit(): void;
    txn: Transaction;
    action: any;
    account: any;
    accounts: any;
    categories: any;
    isLoadComplete: boolean;
    isProcessing: boolean;
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<transactDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<transactDialog, "app-quanityDiag", never, {}, {}, never, never, false, never>;
}

declare class ListDialogComponent implements OnInit {
    private dataService;
    private dialogRef;
    data: ListDialogConfig;
    constructor(dataService: DataServiceLib, dialogRef: MatDialogRef<ListDialogComponent>, data: ListDialogConfig);
    ngOnInit(): void;
    clicked: boolean;
    actionClicked(): void;
    close(): void;
    item: string;
    tableReload: Subject<boolean>;
    listConfig: ListDialogConfig;
    formConfig: FormConfig;
    config: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListDialogComponent, "spa-list-dialog", never, {}, {}, never, never, false, never>;
}

declare class TasksComponent implements OnInit {
    private dataService;
    private messageService;
    authService: AuthService;
    dialog: MatDialog;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService, dialog: MatDialog);
    ngOnInit(): void;
    loadData(): void;
    cats(): void;
    reload: Subject<boolean>;
    statuses: {
        name: string;
        value: number;
    }[];
    formConfig: FormConfig;
    tasksTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<TasksComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TasksComponent, "spa-tasks", never, {}, {}, never, never, false, never>;
}

declare class DepartmentsComponent implements OnInit {
    dataService: DataServiceLib;
    private messageService;
    authService: AuthService;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DepartmentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DepartmentsComponent, "spa-departments", never, {}, {}, never, never, false, never>;
}

declare class EmployeesComponent implements OnInit {
    dataService: DataServiceLib;
    authService: AuthService;
    constructor(dataService: DataServiceLib, authService: AuthService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmployeesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmployeesComponent, "spa-employees", never, {}, {}, never, never, false, never>;
}

declare class PositionsComponent implements OnInit {
    dataService: DataServiceLib;
    authService: AuthService;
    constructor(dataService: DataServiceLib, authService: AuthService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PositionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PositionsComponent, "spa-positions", never, {}, {}, never, never, false, never>;
}

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

declare class WelcomeComponent implements OnInit {
    dataService: DataServiceLib;
    authService: AuthService;
    constructor(dataService: DataServiceLib, authService: AuthService);
    ngOnInit(): void;
    username: any;
    step: string;
    agree: boolean;
    own: boolean;
    invitations: boolean;
    myTenant: any;
    loadMeta(): void;
    renameTenant(): void;
    next(): void;
    setWelcome(): void;
    home(): void;
    invTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<WelcomeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WelcomeComponent, "spa-welcome", never, {}, {}, never, never, false, never>;
}

declare class NotificationsComponent implements OnInit {
    private dataService;
    private notificationsService;
    constructor(dataService: DataServiceLib, notificationsService: NotificationsService);
    createDialog: DetailsDialogConfig;
    notificationsTableConfig: TableConfig;
    ngOnInit(): void;
    private initializeConfigs;
    actionClicked(x: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationsComponent, "spa-notifications", never, {}, {}, never, never, false, never>;
}

declare class InvitationsTableComponent implements OnInit {
    dataService: DataServiceLib;
    private messageService;
    authService: AuthService;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService);
    ngOnInit(): void;
    invActionClicked(x: any): void;
    tableReload: Subject<boolean>;
    invitationsTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvitationsTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InvitationsTableComponent, "spa-invitations-table", never, {}, {}, never, never, false, never>;
}

declare class CsvService {
    generateCsv(data: any[], columns: string[], filename: string, config: TableConfig): void;
    private convertToCsv;
    private createColumnMap;
    private escapeCommas;
    static ɵfac: i0.ɵɵFactoryDeclaration<CsvService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CsvService>;
}

declare class TableHeaderComponent {
    private buttonService;
    private dialogService;
    private messageService;
    private csvService;
    constructor(buttonService: ButtonService, dialogService: DialogService, messageService: MessageService, csvService: CsvService);
    ngOnInit(): void;
    createButton: Button;
    lastSearch: any;
    config: TableConfig;
    hideTitle: boolean;
    tableDataSource: any;
    tileConfig: TileConfig;
    smallScreen: boolean;
    tileReload: Subject<boolean>;
    showFilterButton: boolean;
    data: any;
    tileData: any;
    createClick: EventEmitter<void>;
    customClick: EventEmitter<any>;
    refreshClick: EventEmitter<void>;
    tileClick: EventEmitter<string>;
    tileUnClick: EventEmitter<string>;
    uploadDetailsDialog: DetailsDialogConfig;
    onButtonClick(button: Button): void;
    onDownloadClick(): void;
    onUploadClick(): void;
    onRefreshClick(): void;
    onTileClick(tile: any): void;
    onTileUnClick(tile: any): void;
    getHeaderButtons(): Button[];
    testVisibleHeaderButton(btn: any): boolean;
    testVisible(button: Button): boolean;
    testDisabled(button: Button): boolean;
    getButtonColor(button: Button, row: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeaderComponent, "app-table-header", never, { "lastSearch": { "alias": "lastSearch"; "required": false; }; "config": { "alias": "config"; "required": false; }; "hideTitle": { "alias": "hideTitle"; "required": false; }; "tableDataSource": { "alias": "tableDataSource"; "required": false; }; "tileConfig": { "alias": "tileConfig"; "required": false; }; "smallScreen": { "alias": "smallScreen"; "required": false; }; "tileReload": { "alias": "tileReload"; "required": false; }; "showFilterButton": { "alias": "showFilterButton"; "required": false; }; "data": { "alias": "data"; "required": false; }; "tileData": { "alias": "tileData"; "required": false; }; }, { "createClick": "createClick"; "customClick": "customClick"; "refreshClick": "refreshClick"; "tileClick": "tileClick"; "tileUnClick": "tileUnClick"; }, never, never, false, never>;
}

declare class TableRowComponent {
    private buttonService;
    column: Column;
    row: any;
    config: TableConfig;
    smallScreen: boolean;
    actionClick: EventEmitter<{
        name: string;
        row: any;
    }>;
    columnClick: EventEmitter<{
        column: Column;
        row: any;
    }>;
    showBannerEvent: EventEmitter<string>;
    constructor(buttonService: ButtonService);
    testIconCondition(row: any, icon: Icon): boolean;
    getColorOnCondition(row: any, column: Column): string;
    getColor(value: any, options: any[]): string;
    onActionClick(name: string, row: any): void;
    onColumnClick(column: Column, row: any): void;
    showBanner(message: string): void;
    textDisplayed(row: any, column: Column): any;
    textTruncated(row: any, column: Column): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableRowComponent, "app-table-row", never, { "column": { "alias": "column"; "required": false; }; "row": { "alias": "row"; "required": false; }; "config": { "alias": "config"; "required": false; }; "smallScreen": { "alias": "smallScreen"; "required": false; }; }, { "actionClick": "actionClick"; "columnClick": "columnClick"; "showBannerEvent": "showBannerEvent"; }, never, never, false, never>;
}

declare class TableActionComponent {
    private buttonService;
    constructor(buttonService: ButtonService);
    displayedButtons: Button[];
    config: TableConfig;
    row: any;
    smallScreen: boolean;
    actionClick: EventEmitter<{
        name: string;
        row: any;
    }>;
    testVisible(row: any, buttonName: string): boolean;
    testDisabled(row: any, buttonName: string): boolean;
    getButtonColor(button: Button, row: any): string;
    getIcon(buttonName: string): string;
    onActionClick(buttonName: string, row: any): void;
    get visibleButtons(): Button[];
    get overflowButtons(): Button[];
    static ɵfac: i0.ɵɵFactoryDeclaration<TableActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableActionComponent, "app-table-action", never, { "displayedButtons": { "alias": "displayedButtons"; "required": false; }; "config": { "alias": "config"; "required": false; }; "row": { "alias": "row"; "required": false; }; "smallScreen": { "alias": "smallScreen"; "required": false; }; }, { "actionClick": "actionClick"; }, never, never, false, never>;
}

declare class AlertComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    config: AlertConfig;
    data: any;
    getAlertMessages(type?: any): AlertMessage[];
    hasAlertMessages(type?: any): boolean;
    hasAnyAlertMessages(): boolean;
    testVisible(msg: AlertMessage): boolean;
    getMessageContent(msg: AlertMessage): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "spa-alert", never, { "config": { "alias": "config"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class EmailComponent implements OnInit {
    private messageService;
    constructor(messageService: MessageService);
    display: string;
    value: string;
    valueChange: EventEmitter<string>;
    readonly: boolean;
    required: boolean;
    hint: string;
    suffix: string;
    infoMessage: string;
    copyContent: boolean;
    clearContent: boolean;
    options: any[];
    optionValue: string;
    emails: string[];
    emailControl: FormControl;
    filteredOptions: Observable<string[]>;
    ngOnInit(): void;
    private _filter;
    addEmail(event: MatChipInputEvent): void;
    addMultipleEmails(value: string): void;
    isValidEmail(email: string): boolean;
    handlePaste(event: ClipboardEvent): void;
    extractEmails(text: string): string[];
    removeEmail(email: string): void;
    clearEmails(): void;
    updateValue(): void;
    optionSelected(event: MatAutocompleteSelectedEvent): void;
    copyEmails(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmailComponent, "spa-email", never, { "display": { "alias": "display"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class PageComponent implements OnInit {
    dataServiceLib: DataServiceLib;
    private messageService;
    constructor(dataServiceLib: DataServiceLib, messageService: MessageService);
    ngOnInit(): void;
    config: PageConfig;
    searchModeActivated: EventEmitter<any>;
    searchModeDeactivated: EventEmitter<any>;
    refreshClick: EventEmitter<any>;
    actionClick: EventEmitter<any>;
    actionResponse: EventEmitter<any>;
    inputChange: EventEmitter<any>;
    createClick: EventEmitter<any>;
    searchClick: EventEmitter<any>;
    dataLoad: EventEmitter<any>;
    titleActionChange: EventEmitter<{
        name: string;
        value: any;
    }>;
    tableReload: Subject<boolean>;
    searchMode: boolean;
    normalTableConfig: TableConfig;
    searchTableConfig: TableConfig;
    toggleSearch(): void;
    titleActionChanged(event: {
        name: string;
        value: any;
    }): void;
    getNormalTableConfig(): TableConfig;
    getSearchTableConfig(): TableConfig;
    refreshClicked(): void;
    actionClicked(x: any): void;
    actionResponded(x: any): void;
    inputChanged(x: any): void;
    createClicked(x: any): void;
    searchClicked(x: any): void;
    dataLoaded(x: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageComponent, "spa-page", never, { "config": { "alias": "config"; "required": false; }; }, { "searchModeActivated": "searchModeActivated"; "searchModeDeactivated": "searchModeDeactivated"; "refreshClick": "refreshClick"; "actionClick": "actionClick"; "actionResponse": "actionResponse"; "inputChange": "inputChange"; "createClick": "createClick"; "searchClick": "searchClick"; "dataLoad": "dataLoad"; "titleActionChange": "titleActionChange"; }, never, never, false, never>;
}

declare class SelectInternalComponent extends SelectCommonComponent implements OnInit {
    protected messageService: MessageService;
    protected dataService: DataServiceLib;
    private dialogService;
    private buttonService;
    constructor(messageService: MessageService, dataService: DataServiceLib, dialogService: DialogService, buttonService: ButtonService);
    ngOnInit(): void;
    detailsConfig: DetailsDialogConfig;
    onHoverChange(isHovered: boolean): void;
    canCreate(): boolean;
    canView(): boolean;
    onPeekClick(event: MouseEvent, mode: 'create' | 'view'): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectInternalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectInternalComponent, "spa-select-internal", never, { "detailsConfig": { "alias": "detailsConfig"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SuffixComponent implements OnInit {
    private messageService;
    constructor(messageService: MessageService);
    ngOnInit(): void;
    label: string;
    infoMessage: string;
    copyContent: boolean;
    isHovered: boolean;
    clearContent: boolean;
    value: any;
    infoClick: EventEmitter<void>;
    copyClick: EventEmitter<string>;
    clearClick: EventEmitter<void>;
    valueChange: EventEmitter<any>;
    onInfoClick(event: MouseEvent): void;
    onCopyClick(event: MouseEvent): void;
    onClearClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SuffixComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SuffixComponent, "spa-suffix", never, { "label": { "alias": "label"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "isHovered": { "alias": "isHovered"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "infoClick": "infoClick"; "copyClick": "copyClick"; "clearClick": "clearClick"; "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class SelectContextDirective {
    private templateRef;
    private viewContainer;
    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
    set selectContext(context: any);
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectContextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectContextDirective, "[selectContext]", never, { "selectContext": { "alias": "selectContext"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SelectLiteComponent extends SelectCommonComponent implements OnInit {
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectLiteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectLiteComponent, "spa-select-lite", never, {}, {}, never, never, false, never>;
}

declare class TableLiteComponent implements OnInit, AfterViewInit {
    private dataService;
    private messageService;
    private breakpointObserver;
    dialog: MatDialog;
    private buttonService;
    private dialogService;
    private tableConfigService;
    private conditionService;
    private authService;
    constructor(dataService: DataServiceLib, messageService: MessageService, breakpointObserver: BreakpointObserver, dialog: MatDialog, buttonService: ButtonService, dialogService: DialogService, tableConfigService: TableConfigService, conditionService: ConditionService, authService: AuthService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    elevation: string;
    actionsWidth: string;
    showFilterButton: boolean;
    tileReload: Subject<boolean>;
    hasBeenActivated: boolean;
    smallScreen: boolean;
    hasFormAccess: boolean;
    tableDataSource: any;
    dataSource: any[];
    displayedColumns: any[];
    displayedButtons: any[];
    originalTableLoadAction: Action;
    emptyGroupsData: any[];
    tablePaginator: MatPaginator;
    data: any;
    tileData: any;
    config: TableConfig;
    reload: Subject<boolean>;
    activeTab: boolean;
    inTab: boolean;
    dataLoad: EventEmitter<any>;
    actionSuccess: EventEmitter<any>;
    refreshClick: EventEmitter<any>;
    searchClick: EventEmitter<any>;
    createClick: EventEmitter<any>;
    actionClick: EventEmitter<any>;
    inputChange: EventEmitter<any>;
    actionResponse: EventEmitter<any>;
    private initializeComponent;
    private updateTableConfiguration;
    private setupDataLoading;
    private loadEmptyGroups;
    loadData(action: Action, data: any): void;
    private setPaginator;
    inputChanged(event: any): void;
    formDefaults(): void;
    setButtons(): void;
    getButton(name: string): Button;
    getIcon(buttonName: string): string;
    getButtonColor(button: Button, row: any): string;
    getOptions(column: any): Column;
    getColor(value: any, options: any[]): string;
    testIconCondition(row: any, icon: Icon): boolean;
    testColorCondition(row: any, color: Color): boolean;
    showBanner(message: string): void;
    testDisabled(row: any, buttonName: string): boolean;
    lastSearch: any;
    searchClicked(x: any): void;
    tileClicked(tile: any): void;
    tileUnClicked(tile: any): void;
    refreshClicked(): void;
    dataLoaded(x: any): void;
    actionClicked(name: string, row: any, group?: any, button?: Button): void;
    columnClicked(column: Column, row: any): void;
    customModel(name: any, row: any, button?: Button): void;
    actionClickedEmit(name: any, row: any): void;
    viewModel(row: any, button?: Button): void;
    newModel(): void;
    editModel(row: any, button?: Button): void;
    private open;
    deleteModel(row: any, button?: Button): void;
    doAction(buttonName: string, row: any): void;
    execAction(button: Button, row: any): void;
    private getElevationClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableLiteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableLiteComponent, "spa-table-lite", never, { "data": { "alias": "data"; "required": false; }; "tileData": { "alias": "tileData"; "required": false; }; "config": { "alias": "config"; "required": false; }; "reload": { "alias": "reload"; "required": false; }; "activeTab": { "alias": "activeTab"; "required": false; }; "inTab": { "alias": "inTab"; "required": false; }; }, { "dataLoad": "dataLoad"; "actionSuccess": "actionSuccess"; "refreshClick": "refreshClick"; "searchClick": "searchClick"; "createClick": "createClick"; "actionClick": "actionClick"; "inputChange": "inputChange"; "actionResponse": "actionResponse"; }, never, never, false, never>;
}

declare class DetailsDialogLite implements OnInit, OnDestroy {
    private breakpointObserver;
    private loaderService;
    dataService: DataServiceLib;
    private messageService;
    private dialogRef;
    detailsConfig: DetailsDialogConfig;
    private buttonService;
    private dialogService;
    private authService;
    tableConfigService: TableConfigService;
    constructor(breakpointObserver: BreakpointObserver, loaderService: LoaderService, dataService: DataServiceLib, messageService: MessageService, dialogRef: MatDialogRef<DetailsDialogLite>, detailsConfig: DetailsDialogConfig, buttonService: ButtonService, dialogService: DialogService, authService: AuthService, tableConfigService: TableConfigService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private refreshSubscription;
    autoRefreshEnabled: boolean;
    titleAction: string;
    loadByAction: boolean;
    extraButtons: Button[];
    buttons: Button[];
    createButton: Button;
    editButton: Button;
    deleteButton: Button;
    fileField: Field;
    files: any[];
    tableReload: Subject<boolean>;
    tableConfig: TableConfig;
    tableConfigs: TableConfig[];
    details: any;
    formConfig: FormConfig;
    stepConfig: StepConfig;
    statusConfig: StatusConfig;
    smallScreen: boolean;
    isLoadComplete: boolean;
    isProcessing: boolean;
    inputChange: EventEmitter<any>;
    selectedTabIndex: number;
    onTabChange(event: MatTabChangeEvent): void;
    private initAutoRefresh;
    private startAutoRefresh;
    private stopAutoRefresh;
    toggleAutoRefresh(): void;
    loadData(action: Action, causeTablesReload: any): void;
    inputChanged(event: any): void;
    setMode(newMode: any): void;
    setTitleAction(): void;
    getButton(name: string): Button;
    testDisabled(row: any, buttonName: string): boolean;
    testVisible(row: any, buttonName: string): boolean;
    testVisibleTab(tblConfig: TableConfig): boolean;
    getButtonColor(button: Button, row: any): string;
    getVisibleFields(): Field[];
    create(): void;
    edit(): void;
    delete(): void;
    custom(button: Button): void;
    private openNestedDetailsDialog;
    private refreshData;
    handleButtonAction(buttonName: string): void;
    processButtonAction(button: Button): void;
    private validateForm;
    private prepareActionData;
    private executeAction;
    private performApiCall;
    getClosePosition(): 'top' | 'bottom';
    getCloseText(): string;
    shouldShowTopClose(): boolean;
    shouldShowBottomClose(): boolean;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsDialogLite, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsDialogLite, "spa-detailsDialog-lite", never, {}, { "inputChange": "inputChange"; }, never, never, false, never>;
}

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

declare class ApprovalsConfigComponent implements OnInit {
    private dataService;
    constructor(dataService: DataServiceLib);
    approvalRoleFormConfig: FormConfig;
    approvalRolesTableConfig: TableConfig;
    approvalLevelOptions: any[];
    approvalLevelFormConfig: FormConfig;
    approvalLevelDetailsConfig: DetailsDialogConfig;
    approvalLevelsTableConfig: TableConfig;
    approvalConfigFormConfig: FormConfig;
    approvalConfigDetailsConfig: DetailsDialogConfig;
    approvalConfigTable: TableConfig;
    pageConfig: PageConfig;
    ngOnInit(): void;
    private initializeConfigs;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApprovalsConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApprovalsConfigComponent, "spa-approvals-config", never, {}, {}, never, never, false, never>;
}

declare class MultiTextComponent implements OnInit {
    private messageService;
    private dataService;
    constructor(messageService: MessageService, dataService: DataServiceLib);
    textInput: ElementRef<HTMLInputElement>;
    display: string;
    value: string;
    valueChange: EventEmitter<string>;
    readonly: boolean;
    required: boolean;
    hint: string;
    strict: boolean;
    suffix: string;
    infoMessage: string;
    copyContent: boolean;
    clearContent: boolean;
    options: any[];
    optionDisplay: string;
    optionValue: string;
    loadAction: Action;
    values: string[];
    control: FormControl<string>;
    filteredOptions: Observable<any[]>;
    errorState: boolean;
    private selectedFromAutocomplete;
    ngOnInit(): void;
    ngOnChanges(): void;
    private setupAutoComplete;
    private filterOptions;
    add(event: MatChipInputEvent): void;
    private addValue;
    remove(value: string): void;
    optionSelected(event: MatAutocompleteSelectedEvent): void;
    private resetInput;
    updateValue(): void;
    clear(): void;
    getDisplayValue(value: string): string;
    copyValues(): void;
    isHovered: boolean;
    hoverChange: EventEmitter<boolean>;
    onMouseEnter(): void;
    onMouseLeave(): void;
    refresh(event: MouseEvent): void;
    getData(action: Action): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiTextComponent, "spa-multi-text", never, { "display": { "alias": "display"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "strict": { "alias": "strict"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionDisplay": { "alias": "optionDisplay"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "loadAction": { "alias": "loadAction"; "required": false; }; }, { "valueChange": "valueChange"; "hoverChange": "hoverChange"; }, never, never, false, never>;
}

declare class MultiSelectComponent implements OnInit {
    private messageService;
    private dataService;
    constructor(messageService: MessageService, dataService: DataServiceLib);
    display: string;
    value: string;
    valueChange: EventEmitter<string>;
    readonly: boolean;
    required: boolean;
    hint: string;
    options: any[];
    optionDisplay: string;
    optionValue: string;
    infoMessage: string;
    copyContent: boolean;
    clearContent: boolean;
    nullable: boolean;
    placeholder: string;
    width: string;
    suffix: string;
    loadAction: Action;
    control: FormControl<any[]>;
    selectedValues: any[];
    ngOnInit(): void;
    ngOnChanges(): void;
    private initializeValues;
    selectionChange(event: any): void;
    private updateValue;
    getOptionDisplay(value: any): string;
    compareWith(v1: any, v2: any): boolean;
    clear(): void;
    copyValues(): void;
    isHovered: boolean;
    hoverChange: EventEmitter<boolean>;
    onMouseEnter(): void;
    onMouseLeave(): void;
    refresh(event: MouseEvent): void;
    getData(action: Action): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSelectComponent, "spa-multi-select", never, { "display": { "alias": "display"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionDisplay": { "alias": "optionDisplay"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "required": false; }; "nullable": { "alias": "nullable"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "width": { "alias": "width"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "loadAction": { "alias": "loadAction"; "required": false; }; }, { "valueChange": "valueChange"; "hoverChange": "hoverChange"; }, never, never, false, never>;
}

declare class SelectBitwiseComponent implements OnInit {
    display: string;
    hint: string;
    required: boolean;
    readonly: boolean;
    width: string;
    infoMessage: string;
    options: {
        name?: string;
        value: number;
        icon?: Icon;
    }[];
    set value(val: number);
    get value(): number;
    valueChange: EventEmitter<number>;
    infoClick: EventEmitter<void>;
    private _value;
    bitwiseOptions: BitwiseOption[];
    selectedValues: number[];
    hasNames: boolean;
    get selectedOptions(): BitwiseOption[];
    ngOnInit(): void;
    onSelectionChange(event: any): void;
    private updateSelectedValues;
    onInfoClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectBitwiseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectBitwiseComponent, "spa-select-bitwise", never, { "display": { "alias": "display"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "width": { "alias": "width"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "options": { "alias": "options"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "infoClick": "infoClick"; }, never, never, false, never>;
}

declare class AppModelsComponent implements OnInit {
    private dataService;
    constructor(dataService: DataServiceLib);
    ngOnInit(): void;
    appModelFormConfig: FormConfig;
    appModelDetailsConfig: DetailsDialogConfig;
    appModelTableConfig: TableConfig;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppModelsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppModelsComponent, "spa-app-models", never, {}, {}, never, never, false, never>;
}

declare class NotificationsConfigComponent implements OnInit {
    private dataService;
    constructor(dataService: DataServiceLib);
    notificationOperationFormConfig: FormConfig;
    notificationOperationsTableConfig: TableConfig;
    notificationConfigFormConfig: FormConfig;
    notificationConfigDetailsConfig: DetailsDialogConfig;
    notificationConfigTable: TableConfig;
    pageConfig: PageConfig;
    ngOnInit(): void;
    private initializeConfigs;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationsConfigComponent, "spa-notifications-config", never, {}, {}, never, never, false, never>;
}

declare class HtmlComponent implements OnInit {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    ngOnInit(): void;
    ngOnChanges(): void;
    value: string;
    maxHeight: string;
    display: string;
    sanitizedHtml: SafeHtml;
    private sanitizeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlComponent, "spa-html", never, { "value": { "alias": "value"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "display": { "alias": "display"; "required": false; }; }, {}, never, never, false, never>;
}

declare class NotesComponent implements OnInit {
    private dataService;
    constructor(dataService: DataServiceLib);
    ngOnInit(): void;
    title: string;
    notes: any[];
    loadAction: any;
    loadIDField: string;
    data: any;
    nameField: string;
    dateField: string;
    commentField: string;
    private loadNotes;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotesComponent, "spa-notes", never, { "title": { "alias": "title"; "required": false; }; "notes": { "alias": "notes"; "required": false; }; "loadAction": { "alias": "loadAction"; "required": false; }; "loadIDField": { "alias": "loadIDField"; "required": false; }; "data": { "alias": "data"; "required": false; }; "nameField": { "alias": "nameField"; "required": false; }; "dateField": { "alias": "dateField"; "required": false; }; "commentField": { "alias": "commentField"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CapsulesComponent {
    buttonService: ButtonService;
    private conditionService;
    constructor(buttonService: ButtonService, conditionService: ConditionService);
    config: TableConfig;
    dataSource: any[];
    displayedButtons: Button[];
    actionClick: EventEmitter<{
        name: string;
        row: any;
    }>;
    getDisplayValue(row: any): string;
    testIconCondition(row: any, icon: any): boolean;
    onActionClick(buttonName: string, row: any): void;
    getButtonColor(button: Button, row: any): string;
    getIcon(buttonName: string): string;
    testDisabled(row: any, buttonName: string): boolean;
    private getButton;
    static ɵfac: i0.ɵɵFactoryDeclaration<CapsulesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CapsulesComponent, "spa-capsules", never, { "config": { "alias": "config"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "displayedButtons": { "alias": "displayedButtons"; "required": false; }; }, { "actionClick": "actionClick"; }, never, never, false, never>;
}

declare class CardsComponent {
    buttonService: ButtonService;
    private conditionService;
    constructor(buttonService: ButtonService, conditionService: ConditionService);
    config: TableConfig;
    dataSource: any[];
    displayedButtons: Button[];
    smallScreen: boolean;
    actionClick: EventEmitter<{
        name: string;
        row: any;
    }>;
    columnClick: EventEmitter<{
        column: any;
        row: any;
    }>;
    showBannerEvent: EventEmitter<string>;
    getTitleValue(row: any): string;
    getSubtitleValue(row: any): string;
    getContentValues(row: any): {
        label: string;
        value: any;
    }[];
    onActionClick(buttonName: string, row: any): void;
    getButtonColor(button: Button, row: any): string;
    getIcon(buttonName: string): string;
    testDisabled(row: any, buttonName: string): boolean;
    testVisible(row: any, buttonName: string): boolean;
    getElevationClass(): string;
    getColumnCount(): number;
    private getButton;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardsComponent, "spa-cards", never, { "config": { "alias": "config"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "displayedButtons": { "alias": "displayedButtons"; "required": false; }; "smallScreen": { "alias": "smallScreen"; "required": false; }; }, { "actionClick": "actionClick"; "columnClick": "columnClick"; "showBannerEvent": "showBannerEvent"; }, never, never, false, never>;
}

declare class TabsComponent implements OnInit {
    private dataService;
    constructor(dataService: DataServiceLib);
    ngOnInit(): void;
    tableConfigs: TableConfig[];
    tabCounts: {
        [index: number]: number;
    };
    activeTabsLoaded: {
        [index: number]: boolean;
    };
    selectedTabIndex: number;
    tableReloads: {
        [index: number]: Subject<boolean>;
    };
    private loadAllCounts;
    private loadTabCount;
    onTabChange(event: any): void;
    getTabCount(index: number): number | undefined;
    shouldShowBadge(index: number): boolean;
    getTabTitle(config: TableConfig): string;
    shouldLoadTabData(index: number): boolean;
    refreshTabCount(index: number): void;
    onTableActionResponse(tabIndex: number, event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "spa-tabs", never, { "tableConfigs": { "alias": "tableConfigs"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StatusesComponent {
    config: StatusConfig;
    data: any;
    isComponentVisible(): boolean;
    isItemVisible(item: StatusItem): boolean;
    getIcon(item: StatusItem): string;
    getIconColor(item: StatusItem): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatusesComponent, "spa-statuses", never, { "config": { "alias": "config"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class GroupsComponent implements OnInit {
    private conditionService;
    private buttonService;
    constructor(conditionService: ConditionService, buttonService: ButtonService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    config: TableConfig;
    dataSource: any[];
    displayedButtons: Button[];
    actionClick: EventEmitter<{
        name: string;
        row: any;
        group?: GroupData;
        button?: Button;
    }>;
    groupedData: GroupData[];
    private processData;
    private getGroupIcon;
    private getGroupIconColor;
    private getGroupOrder;
    getItemText(item: any): string;
    getItemIcon(item: any): string | null;
    getItemIconColor(item: any): string | null;
    getVisibleAdditionalIcons(item: any): Icon[];
    getIconTooltip(icon: Icon, item: any): string;
    getVisibleHeaderButtons(group: GroupData): Button[];
    getHeaderButtonIcon(button: Button): string;
    getHeaderButtonColor(button: Button, group: GroupData): string;
    getHeaderButtonTooltip(button: Button): string;
    isHeaderButtonDisabled(button: Button, group: GroupData): boolean;
    getVisibleButtons(item: any): Button[];
    getButtonIcon(button: Button): string;
    getButtonIconColor(button: Button, item: any): string;
    isButtonDisabled(button: Button, item: any): boolean;
    itemActionClicked(buttonName: string, item: any, group: GroupData): void;
    headerButtonClicked(button: Button, group: GroupData): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GroupsComponent, "spa-groups", never, { "config": { "alias": "config"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "displayedButtons": { "alias": "displayedButtons"; "required": false; }; }, { "actionClick": "actionClick"; }, never, never, false, never>;
}

declare class TitleActionsComponent implements OnInit {
    private dataService;
    private messageService;
    constructor(dataService: DataServiceLib, messageService: MessageService);
    ngOnInit(): void;
    titleActions: Field[];
    actionChange: EventEmitter<{
        name: string;
        value: any;
    }>;
    actionValues: {
        [key: string]: any;
    };
    private loadActionOptions;
    onActionChange(action: Field, value: any): void;
    onButtonClick(action: Field): void;
    getOptionDisplay(action: Field): string;
    getOptionValue(action: Field): string;
    isHidden(action: Field): boolean;
    isReadonly(action: Field): boolean;
    getValue(action: Field): any;
    setValue(action: Field, value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TitleActionsComponent, "spa-title-actions", never, { "titleActions": { "alias": "titleActions"; "required": false; }; }, { "actionChange": "actionChange"; }, never, never, false, never>;
}

declare class SpaMatModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaMatModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SpaMatModule, never, never, [typeof i1.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i3$1.MatMenuModule, typeof i4.MatSliderModule, typeof i5.MatTableModule, typeof _angular_material_paginator.MatPaginatorModule, typeof i7.MatCheckboxModule, typeof i8.MatBadgeModule, typeof i9.MatButtonModule, typeof i10.MatIconModule, typeof i11.MatDialogModule, typeof i12.MatSnackBarModule, typeof i13.MatTabsModule, typeof i14.MatFormFieldModule, typeof i15.MatInputModule, typeof i16.MatCardModule, typeof i17.MatChipsModule, typeof i18.MatSelectModule, typeof i19.MatNativeDateModule, typeof i20.MatProgressSpinnerModule, typeof i21.MatListModule, typeof i22.MatAutocompleteModule, typeof i23.MatTooltipModule, typeof i24.MatSortModule, typeof i25.MatDatepickerModule, typeof i26.MatStepperModule, typeof i27.MatRadioModule, typeof i28.MatProgressBarModule, typeof i29.MatSidenavModule, typeof i30.MatToolbarModule, typeof i1$1.RouterModule, typeof i32.MatExpansionModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpaMatModule>;
}

declare class CurrencyInputMaskDirective implements ControlValueAccessor, OnInit {
    private elementRef;
    private decimalPipe;
    private el;
    private onModelChange;
    private onModelTouched;
    private lastNumVal;
    private DECIMAL_MARK;
    constructor(elementRef: ElementRef, decimalPipe: DecimalPipe);
    ngOnInit(): void;
    handleFocus(event: any): void;
    handleCut(event: any): void;
    handleKeypress(event: any): void;
    handleInput(event: any): void;
    handlePaste(event: any): void;
    handleBlur(event: any): void;
    registerOnChange(callbackFunction: Function): void;
    registerOnTouched(callbackFunction: Function): void;
    setDisabledState(value: boolean): void;
    writeValue(numValue: number): void;
    private maskInput;
    private inputUpdated;
    private restrictDecimalValue;
    private transformWithPipe;
    private getUnmaskedValue;
    private updateInputValue;
    private getInputValue;
    private convertStrToDecimal;
    private convertDecimalToStr;
    private isNumeric;
    private saveCursorPosition;
    private setCursorPosition;
    private isIdxBetweenSelection;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyInputMaskDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CurrencyInputMaskDirective, "[appCurrencyInputMask]", never, {}, {}, never, never, false, never>;
}

declare class CurrencyInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CurrencyInputModule, [typeof CurrencyInputMaskDirective], [typeof i1.CommonModule, typeof i3.FormsModule], [typeof CurrencyInputMaskDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CurrencyInputModule>;
}

declare class TinSpaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TinSpaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TinSpaModule, [typeof TinSpaComponent, typeof TextComponent, typeof CheckComponent, typeof DateComponent, typeof DatetimeComponent, typeof LabelComponent, typeof SelectComponent, typeof ActivityComponent, typeof FilterComponent, typeof messageDialog, typeof MoneyComponent, typeof OptionComponent, typeof TilesComponent, typeof StepsComponent, typeof AttachComponent, typeof ChipsComponent, typeof LoaderComponent, typeof NavMenuComponent, typeof TableComponent, typeof TableInternalComponent, typeof DetailsDialog, typeof DetailsDialogInternal, typeof FormComponent, typeof CamelToWordsPipe, typeof NumberComponent, typeof SearchComponent, typeof ViewerComponent, typeof viewerDialog, typeof TenantSettingsComponent, typeof TenantsComponent, typeof BugComponent, typeof MembershipComponent, typeof PlansComponent, typeof CustomersComponent, typeof InventoryComponent, typeof quantityDialog, typeof AccountsComponent, typeof accountDialog, typeof SuppliersComponent, typeof TransactionsComponent, typeof transactDialog, typeof ListDialogComponent, typeof TasksComponent, typeof DepartmentsComponent, typeof EmployeesComponent, typeof PositionsComponent, typeof GradesComponent, typeof WelcomeComponent, typeof NotificationsComponent, typeof InvitationsTableComponent, typeof TableHeaderComponent, typeof TableRowComponent, typeof TableActionComponent, typeof AlertComponent, typeof EmailComponent, typeof PageComponent, typeof SelectCommonComponent, typeof SelectInternalComponent, typeof SuffixComponent, typeof SelectContextDirective, typeof SelectLiteComponent, typeof TableLiteComponent, typeof DetailsDialogLite, typeof ApprovalsComponent, typeof ApprovalsConfigComponent, typeof MultiTextComponent, typeof MultiSelectComponent, typeof SelectBitwiseComponent, typeof AppModelsComponent, typeof NotificationsConfigComponent, typeof HtmlComponent, typeof NotesComponent, typeof CapsulesComponent, typeof CardsComponent, typeof TabsComponent, typeof StatusesComponent, typeof GroupsComponent, typeof TitleActionsComponent], [typeof SpaMatModule, typeof i80.HttpClientModule, typeof CurrencyInputModule, typeof i82.NgxDocViewerModule], [typeof TinSpaComponent, typeof SpaMatModule, typeof AlertComponent, typeof TextComponent, typeof MultiTextComponent, typeof messageDialog, typeof NavMenuComponent, typeof LoaderComponent, typeof TilesComponent, typeof DateComponent, typeof SelectComponent, typeof SelectBitwiseComponent, typeof MultiSelectComponent, typeof DatetimeComponent, typeof CheckComponent, typeof AttachComponent, typeof MoneyComponent, typeof ChipsComponent, typeof ActivityComponent, typeof OptionComponent, typeof LabelComponent, typeof StepsComponent, typeof FilterComponent, typeof TableComponent, typeof DetailsDialog, typeof FormComponent, typeof NumberComponent, typeof SearchComponent, typeof ViewerComponent, typeof viewerDialog, typeof ListDialogComponent, typeof CustomersComponent, typeof AccountsComponent, typeof InventoryComponent, typeof SuppliersComponent, typeof TransactionsComponent, typeof ListDialogComponent, typeof TasksComponent, typeof DepartmentsComponent, typeof EmployeesComponent, typeof PositionsComponent, typeof GradesComponent, typeof WelcomeComponent, typeof EmailComponent, typeof PageComponent, typeof HtmlComponent, typeof NotesComponent, typeof CapsulesComponent, typeof TabsComponent, typeof StatusesComponent, typeof GroupsComponent, typeof TitleActionsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TinSpaModule>;
}

declare class LoginComponent implements OnInit {
    private httpService;
    private storageService;
    router: Router;
    private messageService;
    dataService: DataServiceLib;
    authService: AuthService;
    private logService;
    private route;
    private notificationsService;
    private msalService;
    constructor(httpService: HttpService, storageService: StorageService, router: Router, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, logService: LogService, route: ActivatedRoute, notificationsService: NotificationsService, msalService: MsalService);
    ngOnInit(): void;
    loginWithMS(): void;
    autoLogin: boolean;
    socialUser: SocialUser | null;
    style: string;
    email: string;
    password: string;
    redirectPath: any;
    user: User;
    hide: boolean;
    isProcessing: boolean;
    appConfig: AppConfig;
    signup(): void;
    recoverAccount(): void;
    login(): void;
    notifications(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoginComponent, "spa-login", never, {}, {}, never, never, false, never>;
}

declare class SignupComponent implements OnInit {
    private httpService;
    private messageService;
    private dataService;
    private authService;
    constructor(httpService: HttpService, messageService: MessageService, dataService: DataServiceLib, authService: AuthService);
    ngOnInit(): void;
    isProcessing: boolean;
    user: User;
    profile: Profile;
    account: Account;
    confirmPassword: string;
    create(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SignupComponent, "spa-signup", never, {}, {}, never, never, false, never>;
}

declare class RecoverAccountComponent implements OnInit {
    private location;
    private dataService;
    authService: AuthService;
    private messageService;
    constructor(location: Location, dataService: DataServiceLib, authService: AuthService, messageService: MessageService);
    ngOnInit(): void;
    userName: string;
    recover(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecoverAccountComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RecoverAccountComponent, "spa-recover-account", never, {}, {}, never, never, false, never>;
}

declare class SpaIndexModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaIndexModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SpaIndexModule, [typeof LoginComponent, typeof SignupComponent, typeof RecoverAccountComponent], [typeof i3.ReactiveFormsModule, typeof i1.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof TinSpaModule, typeof i7$1.SocialLoginModule], [typeof i1.CommonModule, typeof i3.FormsModule, typeof TinSpaModule, typeof LoginComponent, typeof SignupComponent, typeof RecoverAccountComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpaIndexModule>;
}

declare class ChangePasswordComponent implements OnInit {
    router: Router;
    private location;
    private httpService;
    private messageService;
    dataService: DataServiceLib;
    private authService;
    private route;
    constructor(router: Router, location: Location, httpService: HttpService, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, route: ActivatedRoute);
    ngOnInit(): void;
    myRole: any;
    redirectPath: any;
    isProcessing: boolean;
    changePassword: ChangeUserPassword;
    change(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChangePasswordComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChangePasswordComponent, "spa-change-password", never, {}, {}, never, never, false, never>;
}

declare class ProfileComponent implements OnInit {
    dataService: DataServiceLib;
    private messageService;
    private httpService;
    private router;
    private authService;
    constructor(dataService: DataServiceLib, messageService: MessageService, httpService: HttpService, router: Router, authService: AuthService);
    ngOnInit(): void;
    isProcessing: boolean;
    myRole: any;
    initials: string;
    appConfig: AppConfig;
    selfProfile: boolean;
    profile: Profile;
    roles: any;
    approvalRoles: any;
    employees: any;
    loadProfile(userName: string): void;
    loadRoles(): void;
    changePassword(): void;
    gotoUsers(): void;
    update(): void;
    updateProfile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProfileComponent, "spa-profile", never, { "appConfig": { "alias": "appConfig"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SpaUserModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaUserModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SpaUserModule, [typeof ChangePasswordComponent, typeof ProfileComponent], [typeof i3.ReactiveFormsModule, typeof i1.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof TinSpaModule], [typeof i1.CommonModule, typeof i3.FormsModule, typeof TinSpaModule, typeof ChangePasswordComponent, typeof ProfileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpaUserModule>;
}

declare class UsersComponent implements OnInit {
    private httpService;
    router: Router;
    private authService;
    private dataService;
    dialog: MatDialog;
    private messageService;
    constructor(httpService: HttpService, router: Router, authService: AuthService, dataService: DataServiceLib, dialog: MatDialog, messageService: MessageService);
    userBaseFormConfig: FormConfig;
    createDialog: DetailsDialogConfig;
    editDialog: DetailsDialogConfig;
    passwordDialog: DetailsDialogConfig;
    usersTableConfig: TableConfig;
    ngOnInit(): void;
    inputChanged(x: any): void;
    loadMeta(): void;
    private initializeConfigs;
    static ɵfac: i0.ɵɵFactoryDeclaration<UsersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UsersComponent, "spa-users", never, {}, {}, never, never, false, never>;
}

declare class RolesComponent implements OnInit {
    private httpService;
    private router;
    private authService;
    private dataService;
    private dialogService;
    dialog: MatDialog;
    private messageService;
    constructor(httpService: HttpService, router: Router, authService: AuthService, dataService: DataServiceLib, dialogService: DialogService, dialog: MatDialog, messageService: MessageService);
    ngOnInit(): void;
    isProcessing: boolean;
    roles: Role[];
    RoleAccess: typeof RoleAccess;
    appConfig: AppConfig;
    roleAccessOptions: {
        value: RoleAccess;
        name: string;
    }[];
    loadRoles(): void;
    refresh(): void;
    onCapItemChange(capItem: CapItem, checked: boolean, role: any): void;
    hasSubItemsAccess(capItem: CapItem, role: any): boolean;
    addRole(): void;
    updateRole(role: Role): void;
    deleteRole(role: Role): void;
    renameDialogConfig: DetailsDialogConfig;
    renameButton: Button;
    renameRole(role: Role): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RolesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RolesComponent, "spa-roles", never, {}, {}, never, never, false, never>;
}

declare class addRoleDialog implements OnInit {
    private loaderService;
    private messageService;
    private dataService;
    private authService;
    private dialogRef;
    data: any;
    constructor(loaderService: LoaderService, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, dialogRef: MatDialogRef<addRoleDialog>, data: any);
    ngOnInit(): void;
    capItems: any;
    isProcessing: boolean;
    role: Role;
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<addRoleDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<addRoleDialog, "app-addRole", never, {}, {}, never, never, false, never>;
}

declare class CreateAccountComponent implements OnInit {
    private httpService;
    private messageService;
    private dataService;
    private authService;
    router: Router;
    constructor(httpService: HttpService, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, router: Router);
    ngOnInit(): void;
    appConfig: AppConfig;
    isProcessing: boolean;
    register: Register;
    confirmPassword: string;
    openProfile: boolean;
    authTypes: {
        name: string;
        value: string;
    }[];
    roles: any;
    check(): void;
    loadRoles(): void;
    create(): void;
    viewProfile(userName: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateAccountComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CreateAccountComponent, "spa-create-account", never, { "appConfig": { "alias": "appConfig"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LogsComponent implements OnInit {
    private authService;
    private dataService;
    constructor(authService: AuthService, dataService: DataServiceLib);
    logsPageConfig: PageConfig;
    ngOnInit(): void;
    private initializeConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<LogsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LogsComponent, "spa-logs", never, {}, {}, never, never, false, never>;
}

declare class SettingsComponent implements OnInit {
    private dataService;
    private messageService;
    constructor(dataService: DataServiceLib, messageService: MessageService);
    ngOnInit(): void;
    _filterText: string;
    settings: any;
    isProcessing: boolean;
    applyFilter(filterValue: string): void;
    loadSettings(): void;
    updateSetting(setting: any): void;
    addSetting(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsComponent, "spa-settings", never, {}, {}, never, never, false, never>;
}

declare class SpaAdminModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaAdminModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SpaAdminModule, [typeof UsersComponent, typeof RolesComponent, typeof addRoleDialog, typeof CreateAccountComponent, typeof LogsComponent, typeof SettingsComponent], [typeof i3.ReactiveFormsModule, typeof i1.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof TinSpaModule], [typeof i1.CommonModule, typeof i3.FormsModule, typeof TinSpaModule, typeof UsersComponent, typeof RolesComponent, typeof addRoleDialog, typeof CreateAccountComponent, typeof LogsComponent, typeof SettingsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpaAdminModule>;
}

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

declare class IndexModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IndexModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IndexModule, never, [typeof i1.CommonModule, typeof IndexRoutingModule, typeof SpaIndexModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IndexModule>;
}

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

declare class AdminModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AdminModule, never, [typeof i1.CommonModule, typeof AdminRoutingModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AdminModule>;
}

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

declare class UserModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UserModule, never, [typeof i1.CommonModule, typeof UserRoutingModule, typeof SpaUserModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UserModule>;
}

export { AccountsComponent, Action, ActivityComponent, AdminModule, AlertComponent, AlertConfig, AlertMessage, ApiResponse, AppConfig, AttachComponent, AuthService, CapItem, CapsulesComponent, ChangePasswordComponent, CheckComponent, ChipsComponent, Constants, Core, CreateAccountComponent, CustomersComponent, DataServiceLib, DateComponent, DatetimeComponent, DepartmentsComponent, DetailsDialog, DetailsDialogConfig, DetailsDialogProcessor, DetailsSource, DialogService, EmailComponent, EmployeesComponent, ExportService, FilterComponent, FinAccount, FormComponent, FormConfig, GradesComponent, GroupsComponent, HtmlComponent, HttpService, IndexModule, InventoryComponent, LabelComponent, ListDialogComponent, ListDialogConfig, LoaderComponent, LoaderService, LogService, LoginComponent, LogsComponent, MessageService, MoneyComponent, MultiSelectComponent, MultiTextComponent, NavMenuComponent, NotesComponent, NotesConfig, NumberComponent, OptionComponent, PageComponent, PageConfig, PositionsComponent, ProfileComponent, RecoverAccountComponent, RoleAccess, RolesComponent, SearchComponent, SearchConfig, SecurityConfig, SelectBitwiseComponent, SelectComponent, SettingsComponent, SignupComponent, SpaAdminModule, SpaIndexModule, SpaMatModule, SpaUserModule, StatusesComponent, Step, StepConfig, StepsComponent, StorageService, SuppliersComponent, TableComponent, TableConfig, TabsComponent, TasksComponent, TextComponent, TileConfig, TilesComponent, TinSpaComponent, TinSpaModule, TinSpaService, TitleActionsComponent, Transaction, TransactionsComponent, UserModule, UsersComponent, ViewerComponent, WelcomeComponent, addRoleDialog, authGuard, dialogOptions, messageDialog, viewerDialog };
export type { AutoRefreshConfig, BitwiseOption, Button, CapsuleConfig, CardConfig, ChildField, CloseOptions, Color, Column, Confirm, Field, GroupConfig, GroupData, Icon, SearchField, StatusConfig, StatusItem, StatusState, TableViewType, Tile };