import * as i0 from '@angular/core';
import { OnInit, OnDestroy, TemplateRef, ViewContainerRef, OnChanges, SimpleChanges, EventEmitter, AfterViewInit, PipeTransform, ElementRef, AfterViewChecked, ChangeDetectorRef } 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 from '@angular/router';
import { Router, ActivatedRoute, CanActivateFn } from '@angular/router';
import * as i62 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 { SwUpdate } from '@angular/service-worker';
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 { ChartData, ChartOptions, Plugin } from 'chart.js';
import * as i26 from '@angular/material/stepper';
import { MatStepper } from '@angular/material/stepper';
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 i66 from '@angular/cdk/drag-drop';
import { CdkDragEnter, CdkDragExit, CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i4 from '@angular/common';
import { DecimalPipe, Location } from '@angular/common';
import * as i3$1 from '@angular/material/menu';
import * as i4$1 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 i13 from '@angular/material/tabs';
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 i64 from 'ngx-doc-viewer';
import * as i65 from 'ng2-charts';
import { MsalService } from '@azure/msal-angular';

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

declare class StorageService {
    private useSession;
    constructor();
    setSessionMode(useSession: boolean): void;
    private getStorage;
    store(storageKey: string, value: any): Promise<void>;
    get(storageKey: string): Promise<any>;
    removeStorageItem(storageKey: string): Promise<void>;
    clear(): Promise<void>;
    storePersistent(storageKey: string, value: any): void;
    getPersistent(storageKey: string): any;
    removePersistent(storageKey: string): void;
    clearAll(): void;
    clearSessionData(): void;
    hasKey(storageKey: string): boolean;
    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 enum InvoiceStatus {
    Draft = 0,
    Submitted = 1,
    Paid = 2,
    Discarded = 3,
    Paying = 4
}
declare enum InvoiceItemType {
    General = 0,
    Product = 1,
    Service = 2
}
declare enum AssetStatus {
    Draft = 0,
    Active = 1,
    FullyDepreciated = 2,
    Disposed = 3
}
declare enum TransactionTiming {
    Immediate = 0,// Payment occurs now - no AR/AP created
    Deferred = 1
}
declare enum PurchaseStatus {
    Draft = 0,
    Confirmed = 1,// Changed: Receiving → Confirmed (same int=1)
    Completed = 2
}
declare enum ReceiptStatus {
    Draft = 0,
    Completed = 1
}
declare enum UnitOfMeasure {
    Piece = 0,
    Box = 1,
    Case = 2,
    Carton = 3,
    Pallet = 4,
    Kilogram = 5,
    Gram = 6,
    Litre = 7,
    Millilitre = 8,
    Meter = 9,
    Pack = 10,
    Set = 11,
    Dozen = 12
}
declare class loginConfig {
    constructor();
    appName: string;
    selfService: boolean;
    logo: string;
    logoSize: string;
}
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;
    rememberMe: boolean;
}
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;
    cap101: boolean;
    cap102: boolean;
    cap103: boolean;
    cap104: boolean;
    cap105: boolean;
    cap106: boolean;
    cap107: boolean;
    cap108: boolean;
    cap109: boolean;
    cap110: boolean;
    cap111: boolean;
    cap112: boolean;
    cap113: boolean;
    cap114: boolean;
    cap115: boolean;
    cap116: boolean;
    cap117: boolean;
    cap118: boolean;
    cap119: boolean;
    cap120: boolean;
    cap121: boolean;
    cap122: boolean;
    cap123: boolean;
    cap124: boolean;
    cap125: boolean;
    cap126: boolean;
    cap127: boolean;
    cap128: boolean;
    cap129: boolean;
    cap130: boolean;
    cap131: boolean;
    cap132: boolean;
    cap133: boolean;
    cap134: boolean;
    cap135: boolean;
    cap136: boolean;
    cap137: boolean;
    cap138: boolean;
    cap139: boolean;
    cap140: boolean;
    cap141: boolean;
    cap142: boolean;
    cap143: boolean;
    cap144: boolean;
    cap145: boolean;
    cap146: boolean;
    cap147: boolean;
    cap148: boolean;
    cap149: boolean;
    cap150: boolean;
    cap151: boolean;
    cap152: boolean;
    cap153: boolean;
    cap154: boolean;
    cap155: boolean;
    cap156: boolean;
    cap157: boolean;
    cap158: boolean;
    cap159: boolean;
    cap160: boolean;
    cap161: boolean;
    cap162: boolean;
    cap163: boolean;
    cap164: boolean;
    cap165: boolean;
    cap166: boolean;
    cap167: boolean;
    cap168: boolean;
    cap169: boolean;
    cap170: boolean;
    cap171: boolean;
    cap172: boolean;
    cap173: boolean;
    cap174: boolean;
    cap175: boolean;
    cap176: boolean;
    cap177: boolean;
    cap178: boolean;
    cap179: boolean;
    cap180: boolean;
    cap181: boolean;
    cap182: boolean;
    cap183: boolean;
    cap184: boolean;
    cap185: boolean;
    cap186: boolean;
    cap187: boolean;
    cap188: boolean;
    cap189: boolean;
    cap190: boolean;
    cap191: boolean;
    cap192: boolean;
    cap193: boolean;
    cap194: boolean;
    cap195: boolean;
    cap196: boolean;
    cap197: boolean;
    cap198: boolean;
    cap199: boolean;
    cap200: boolean;
}
declare class SignupData {
    token: string;
    authType: string;
    firstName: string;
    lastName: string;
    email: string;
    orgName: string;
    termsAccepted: boolean;
    invitations: any[];
    acceptedInvitationIds: number[];
}
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>;
}

interface EntityChangeEvent {
    entityName: string;
    data: any;
}
interface NotificationEvent {
    message: string;
    category: string;
    type: string;
    sender: string;
}
declare class SignalRService {
    private hubConnection;
    private notificationCount;
    notificationCount$: rxjs.Observable<number>;
    private entityCreated;
    private entityUpdated;
    private entityDeleted;
    entityCreated$: rxjs.Observable<EntityChangeEvent>;
    entityUpdated$: rxjs.Observable<EntityChangeEvent>;
    entityDeleted$: rxjs.Observable<EntityChangeEvent>;
    private notificationReceived;
    notificationReceived$: rxjs.Observable<NotificationEvent>;
    private agentMessage;
    private agentTyping;
    agentMessage$: rxjs.Observable<any>;
    agentTyping$: rxjs.Observable<boolean>;
    onReconnected: (() => void) | null;
    onDataReconnected: (() => void) | null;
    private dataHubConnected;
    dataHubConnected$: rxjs.Observable<boolean>;
    private currentToken;
    startConnection(hubUrl: string, token: string): void;
    updateToken(token: string): void;
    stopConnection(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalRService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignalRService>;
}

declare class AuthService {
    private _route;
    private socialService;
    private storage;
    router: Router;
    private httpService;
    private messageService;
    private logService;
    private signalRService;
    private googleAuthInitialized;
    private isRefreshing;
    private refreshTimer;
    private socialUserSource;
    socialUserObserv: rxjs.Observable<SocialUser>;
    constructor(_route: ActivatedRoute, socialService: SocialAuthService, storage: StorageService, router: Router, httpService: HttpService, messageService: MessageService, logService: LogService, signalRService: SignalRService);
    private initializeGoogleAuth;
    clearSession(revokeOnServer?: boolean): 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;
    applyLoginResponse(data: any, rememberMe: boolean): void;
    private scheduleTokenRefresh;
    private initVisibilityRefresh;
    hasValidSession(): boolean;
    hasRefreshToken(): boolean;
    tryRestoreSession(): Promise<boolean>;
    silentRefresh(): Promise<boolean>;
    checkAuthentication(): Promise<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 MovementType {
    In = 0,
    Out = 1
}
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;
    initAction?: Action;
    hideTablesInCreateMode?: boolean;
    allowUserKeepOpen?: boolean;
    keepOpenBehavior?: 'reset' | 'edit';
    nestingLevel?: number;
}
declare class Action {
    method?: 'get' | 'post';
    url: string;
    params?: any[];
    successMessage?: string;
    isFormData?: boolean;
    skipCache?: boolean;
    cacheDurationMinutes?: number;
}
interface CacheRule {
    pattern: string;
    durationMinutes: number;
}
declare class CacheConfig {
    rules: CacheRule[];
    addRule(pattern: string, durationMinutes: number): void;
    getDuration(url: string): number | null;
    private matchesPattern;
}
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' | 'text-area' | 'text-single' | 'text-multi' | 'text-mask' | 'date' | 'date-short' | 'datetime' | 'datetimesec' | 'checkbox' | 'select' | 'select-multi' | '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;
    masterValueField?: string;
    masterDefaultValueField?: string;
    children?: ChildField[];
    masterOptions?: any[];
    nullable?: boolean;
    copyContent?: boolean;
    clearContent?: boolean;
    selectAll?: 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, option?: 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';
    message?: string;
    messageField?: 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;
    resetMode?: 'create' | 'edit';
    rowDataMap?: Record<string, string | ((data: any) => any)>;
}
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';
}
type TileStyle = 'basic' | 'icon' | 'chart';
type TileChartType = 'line' | 'bar' | 'pie' | 'doughnut';
interface TileChartConfig {
    type: TileChartType;
    dataField?: string;
    data?: any;
    color?: string;
    colors?: string[];
    height?: number;
    gaugeValue?: number;
    gaugeColor?: string;
}
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;
    style?: TileStyle;
    icon?: string;
    footer?: string;
    footerIcon?: string;
    badge?: string;
    badgeColor?: string;
    chart?: TileChartConfig;
}
declare class TileConfig {
    tiles: Tile[];
    loadAction?: Action;
    loadInit?: boolean;
    clickable?: boolean;
    headerPosition?: 'top' | 'middle';
}
type SpaChartType = 'line' | 'bar' | 'pie' | 'doughnut';
interface ChartItem {
    name: string;
    title?: string;
    subtitle?: string;
    footer?: string;
    footerIcon?: string;
    type: SpaChartType;
    loadAction?: Action;
    data?: any;
    colors?: string[];
    height?: string;
    showLegend?: boolean;
    showPoints?: boolean;
    tension?: number;
    gaugeValue?: number;
    gaugeColor?: string;
    hidden?: boolean;
    hiddenCondition?: (value: any) => boolean;
    options?: any;
}
declare class ChartConfig {
    charts: ChartItem[];
    loadAction?: Action;
    loadInit?: boolean;
    columns?: number;
}
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;
}
interface GroupConfig {
    groupValueField?: string;
    displayNameField?: string;
    iconField?: string;
    colorField?: string;
    orderField?: string;
    itemsField?: string;
    itemTextField: string;
    itemIcon?: Icon;
    itemIcons?: Icon[];
    itemAdditionalIcons?: Icon[];
    groupIcons?: Icon[];
    showGroupCount?: boolean;
    emptyGroupMessage?: string;
    showEmptyGroups?: boolean;
    headerButtons?: Button[];
    contextMenuEnabled?: boolean;
    filterEnabled?: boolean;
    dragEnabled?: boolean;
    dropAction?: Action;
}
interface Column {
    name: string;
    type?: 'text' | 'date' | 'date-short' | '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;
    };
    realTime?: boolean;
    entityName?: string;
    allowUserKeepOpen?: boolean;
    keepOpenBehavior?: 'reset' | 'edit';
}
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";
    static readonly AUTH_REFRESH_TOKEN = "g";
    static readonly AUTH_REFRESH_TOKEN_EXPIRE = "h";
    static readonly AUTH_REMEMBER_ME = "r";
}
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;
    featureKey: string;
}
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' | 'side-modern';
    progressLine: boolean;
    docsBaseUrl: string;
    loginStyle: string;
    loginTitle: string;
    loginMessage: string;
    termsUrl: string;
    privacyUrl: string;
    siteUrl: string;
    navWidth: string;
    navColor: string;
    navImage: 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;
    cacheConfig: CacheConfig;
    myRole: any;
    capHome: CapItem;
    capAdmin: CapItem;
    capUsers: CapItem;
    capRoles: CapItem;
    capLogs: CapItem;
    capSettings: CapItem;
    capMultitenant: CapItem;
    capTenants: CapItem;
    capMembership: CapItem;
    capPlans: CapItem;
    capFeatures: CapItem;
    capPlanFeatures: CapItem;
    capSubscription: CapItem;
    capBilling: CapItem;
    capGeneral: CapItem;
    capCustomers: CapItem;
    capCategories: CapItem;
    capSubCategories: CapItem;
    capBrands: CapItem;
    capGPTCaches: CapItem;
    capPreferences: CapItem;
    capSuppliers: CapItem;
    capTasks: CapItem;
    capHR: CapItem;
    capEmployees: CapItem;
    capDepartments: CapItem;
    capPositions: CapItem;
    capGrades: CapItem;
    capPayroll: CapItem;
    capSalaryStructures: CapItem;
    capStatutoryDeductions: CapItem;
    capPayrollRuns: CapItem;
    capCommissionConfigs: CapItem;
    capCommissionEntries: CapItem;
    capSalaryAdvances: CapItem;
    capOvertimeEntries: CapItem;
    capApprovals: CapItem;
    capApprovalsConfig: CapItem;
    capNotifications: CapItem;
    capSelfApproval: CapItem;
    capAppModels: CapItem;
    capNotificationsConfig: CapItem;
    capAccountingOutstandingInvoices: CapItem;
    capAccounting: CapItem;
    capAccounts: CapItem;
    capAggregates: CapItem;
    capReports: CapItem;
    capAging: CapItem;
    capTaxRates: CapItem;
    capStandingOrders: CapItem;
    capFixedAssetsModule: CapItem;
    capFixedAssetsDashboard: CapItem;
    capFixedAssets: CapItem;
    capFixedAssetCategories: CapItem;
    capCurrencies: CapItem;
    capTransactionTypes: CapItem;
    capTransactions: CapItem;
    capAccountingInvoices: CapItem;
    capInvoicing: CapItem;
    capLoans: CapItem;
    capLoanProducts: CapItem;
    capLoansMain: CapItem;
    capLoanPayments: CapItem;
    capInventory: CapItem;
    capInventoryDashboard: CapItem;
    capInventoryStock: CapItem;
    capProducts: CapItem;
    capServiceItems: CapItem;
    capBundleProducts: CapItem;
    capInventoryItems: CapItem;
    capPurchaseOrders: CapItem;
    capInventoryReceipts: CapItem;
    capSalesOrders: CapItem;
    capSales: CapItem;
    capRequisitions: CapItem;
    capInventoryAdjustments: CapItem;
    capInventoryReturns: CapItem;
    capInventoryTransactions: CapItem;
    capProductionRecipes: CapItem;
    capProductionOrders: CapItem;
    capManufacturing: CapItem;
    capSalesModule: CapItem;
    capPurchasingModule: CapItem;
    capAccountingDashboard: CapItem;
    capSalesDashboard: CapItem;
    capPurchasingDashboard: CapItem;
    capSupplierAging: CapItem;
    capInvoiceDashboard: CapItem;
    capPayrollDashboard: CapItem;
    tmpProfileuserName: string;
    isProcessing: boolean;
    departmentFormConfig: FormConfig;
    editDepartmentButton: Button;
    departmentDetailsConfig: DetailsDialogConfig;
    positionFormConfig: FormConfig;
    editPositionButton: Button;
    positionDetailsConfig: DetailsDialogConfig;
    genders: {
        name: string;
        value: number;
    }[];
    employeeFormConfig: FormConfig;
    editEmployeeButton: Button;
    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;
    gptCachesFormConfig: FormConfig;
    gptCachesTableConfig: 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 isCrudAction;
    private extractEntityName;
    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>;
    private pendingSignupSource;
    pendingSignup$: Observable<SignupData>;
    SetPendingSignup(data: SignupData): void;
    ClearPendingSignup(): void;
    Signup(data: SignupData): 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 defaultDialogComponent;
    private smallScreen;
    constructor(dialog: MatDialog, breakpointObserver: BreakpointObserver, defaultDialogComponent: any);
    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>;
    openDefaultDetailsDialog(button: Button, row: any, nestingLevel?: number): Observable<any>;
    openDefaultDialog(config: DetailsDialogConfig): {
        afterClosed: Observable<any>;
        inputChange: Observable<any>;
        dialogRef: MatDialogRef<any>;
    };
    openPrintDialog(htmlContent: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

declare class AccountingService {
    private dataService;
    accountFormConfig: FormConfig;
    accountCreateButton: Button;
    finAccounEditButton: Button;
    accountBaseDetailsConfig: DetailsDialogConfig;
    invoicePaymentFormConfig: FormConfig;
    invoicePaymentCreateButton: Button;
    invoicePaymentsCreateDetailsDialogConfig: DetailsDialogConfig;
    invoicePaymentsTableConfig: TableConfig;
    invoiceFormConfig: FormConfig;
    invoiceItemsFormConfig: FormConfig;
    invoiceItemEditButton: Button;
    invoiceItemDetailsConfig: DetailsDialogConfig;
    invoiceMoveItemFormConfig: FormConfig;
    invoiceMoveItemDetailsConfig: DetailsDialogConfig;
    invoiceItemsTableConfig: TableConfig;
    invoiceRecordPaymentButton: Button;
    invoiceDiscardButton: Button;
    invoiceReturnButton: Button;
    invoiceSubmitButton: Button;
    invoiceEditButton: Button;
    invoiceDownloadButton: Button;
    invoiceDetailsDialogConfig: DetailsDialogConfig;
    invoiceViewButton: Button;
    invoicesTileConfig: TileConfig;
    invoicesTableConfig: TableConfig;
    agingTileConfig: TileConfig;
    agingBaseTableConfig: TableConfig;
    customerInvoiceFormConfig: FormConfig;
    customerInvoiceItemsTableConfig: TableConfig;
    customerInvoicePaymentsTableConfig: TableConfig;
    customerInvoiceDetailsDialogConfig: DetailsDialogConfig;
    customerInvoicesTableConfig: TableConfig;
    statementFormConfig: FormConfig;
    statementTableConfig: TableConfig;
    statementSearchTableConfig: TableConfig;
    taxRateFormConfig: FormConfig;
    taxRateCreateButton: Button;
    taxRateEditButton: Button;
    taxRateDeleteButton: Button;
    taxRateDetailsConfig: DetailsDialogConfig;
    taxRatesTableConfig: TableConfig;
    currencyFormConfig: FormConfig;
    currencyCreateButton: Button;
    currencyEditButton: Button;
    currencyDeleteButton: Button;
    currencyDetailsConfig: DetailsDialogConfig;
    currenciesTableConfig: TableConfig;
    transactionTypeFormConfig: FormConfig;
    transactionTypeCreateButton: Button;
    transactionTypeEditButton: Button;
    transactionTypeDetailsConfig: DetailsDialogConfig;
    transactionTypesTableConfig: TableConfig;
    transactionImportItemFormConfig: FormConfig;
    transactionImportItemsTableConfig: TableConfig;
    transactionImportUploadFormConfig: FormConfig;
    transactionImportDetailsDialogConfig: DetailsDialogConfig;
    transactionImportButton: Button;
    transactionFormConfig: FormConfig;
    transactionEditButton: Button;
    transactionVoidButton: Button;
    transactionDetailsConfig: DetailsDialogConfig;
    transactionsTableConfig: TableConfig;
    transactionSearchTableConfig: TableConfig;
    accountTransactionsTableConfig: TableConfig;
    transactionTemplateFormConfig: FormConfig;
    transactionTemplateProcessFormConfig: FormConfig;
    transactionTemplateCreateButton: Button;
    transactionTemplateEditButton: Button;
    transactionTemplateDetailsConfig: DetailsDialogConfig;
    transactionTemplateProcessDetailsConfig: DetailsDialogConfig;
    transactionTemplatesTableConfig: TableConfig;
    standingOrderFormConfig: FormConfig;
    standingOrderExecutionsTableConfig: TableConfig;
    standingOrderCreateButton: Button;
    standingOrderEditButton: Button;
    standingOrderDeleteButton: Button;
    standingOrderExecuteButton: Button;
    standingOrderPauseButton: Button;
    standingOrderResumeButton: Button;
    standingOrderDetailsConfig: DetailsDialogConfig;
    standingOrdersTableConfig: TableConfig;
    accountDetailsConfig: DetailsDialogConfig;
    accountsTableConfig: TableConfig;
    trialBalanceTableConfig: TableConfig;
    pnlTableConfig: TableConfig;
    balanceSheetReportTableConfig: TableConfig;
    aggregatesTableConfig: TableConfig;
    cumulativeAggregatesTableConfig: TableConfig;
    cashFlowAggregatesTableConfig: TableConfig;
    balanceSheetAggregatesTableConfig: TableConfig;
    budgetFormConfig: FormConfig;
    budgetLineFormConfig: FormConfig;
    budgetLinesTableConfig: TableConfig;
    budgetPublishButton: Button;
    budgetSetActiveButton: Button;
    budgetCopyButton: Button;
    budgetEditButton: Button;
    budgetDetailsConfig: DetailsDialogConfig;
    budgetsTableConfig: TableConfig;
    budgetVsActualByPeriodTableConfig: TableConfig;
    budgetVsActualByAccountTableConfig: TableConfig;
    budgetSummaryTileConfig: TileConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccountingService>;
}

declare class AssetsService {
    categoryFormConfig: FormConfig;
    categoryCreateButton: Button;
    categoryEditButton: Button;
    categoryDetailsConfig: DetailsDialogConfig;
    categoryTableConfig: TableConfig;
    assetFormConfig: FormConfig;
    depreciationEntriesTableConfig: TableConfig;
    assetCreateButton: Button;
    assetEditButton: Button;
    assetActivateButton: Button;
    assetDepreciateButton: Button;
    disposeFormConfig: FormConfig;
    assetDisposeButton: Button;
    assetDetailsConfig: DetailsDialogConfig;
    assetTileConfig: TileConfig;
    assetsTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<AssetsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AssetsService>;
}

declare class LoansService {
    loanProductCreateButton: Button;
    loanProductEditButton: Button;
    loanProductDeleteButton: Button;
    loanProductFormConfig: FormConfig;
    loanProductTableConfig: TableConfig;
    loanCreateButton: Button;
    loanEditButton: Button;
    loanDisburseButton: Button;
    loanFormConfig: FormConfig;
    loanScheduleTableConfig: TableConfig;
    loanDetailsConfig: DetailsDialogConfig;
    loanViewButton: Button;
    loanTableConfig: TableConfig;
    loanPaymentCreateButton: Button;
    loanPaymentFormConfig: FormConfig;
    loanPaymentTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoansService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoansService>;
}

declare class InventoryService {
    private dataService;
    private generalService;
    productDetailsConfig: DetailsDialogConfig;
    constructor();
    productFormConfig: FormConfig;
    productViewButton: Button;
    productCreateButton: Button;
    productEditButton: Button;
    productDeleteButton: Button;
    productsTableConfig: TableConfig;
    productComponentFormConfig: FormConfig;
    productComponentsTableConfig: TableConfig;
    bundleProductFormConfig: FormConfig;
    bundleProductDetailsConfig: DetailsDialogConfig;
    bundleProductViewButton: Button;
    bundleProductCreateButton: Button;
    bundleProductsTableConfig: TableConfig;
    serviceItemFormConfig: FormConfig;
    serviceItemCreateButton: Button;
    serviceItemEditButton: Button;
    serviceItemDeleteButton: Button;
    serviceItemDetailsConfig: DetailsDialogConfig;
    serviceItemsTableConfig: TableConfig;
    requisitionItemFormConfig: FormConfig;
    requisitionItemsTableConfig: TableConfig;
    requisitionFormConfig: FormConfig;
    requisitionEditButton: Button;
    requisitionSubmitButton: Button;
    requisitionIssueButton: Button;
    requisitionCancelButton: Button;
    requisitionDetailsConfig: DetailsDialogConfig;
    requisitionViewButton: Button;
    requisitionsTableConfig: TableConfig;
    inventoryItemFormConfig: FormConfig;
    inventoryItemDetailsConfig: DetailsDialogConfig;
    inventoryItemsTableConfig: TableConfig;
    inventoryAdjustmentFormConfig: FormConfig;
    inventoryAdjustmentCreateButton: Button;
    inventoryAdjustmentEditButton: Button;
    inventoryAdjustmentDeleteButton: Button;
    inventoryAdjustmentDetailsConfig: DetailsDialogConfig;
    inventoryAdjustmentsTableConfig: TableConfig;
    inventoryReturnItemFormConfig: FormConfig;
    inventoryReturnItemsTableConfig: TableConfig;
    inventoryReturnFormConfig: FormConfig;
    inventoryReturnCreateButton: Button;
    inventoryReturnEditButton: Button;
    inventoryReturnDeleteButton: Button;
    inventoryReturnRejectButton: Button;
    inventoryReturnDetailsConfig: DetailsDialogConfig;
    inventoryReturnViewButton: Button;
    inventoryReturnsTableConfig: TableConfig;
    inventoryTransactionFormConfig: FormConfig;
    inventoryTransactionDetailsConfig: DetailsDialogConfig;
    inventoryTransactionsTableConfig: TableConfig;
    inventoryStockItemsTableConfig: TableConfig;
    inventoryStockProductFormConfig: FormConfig;
    inventoryStockDetailsConfig: DetailsDialogConfig;
    inventoryStockTileConfig: TileConfig;
    inventoryStockTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InventoryService>;
}

declare class GeneralService {
    private dataService;
    categoryFormConfig: FormConfig;
    categoryCreateButton: Button;
    categoryEditButton: Button;
    categoryDeleteButton: Button;
    categoryDetailsConfig: DetailsDialogConfig;
    categoriesTableConfig: TableConfig;
    subCategoryFormConfig: FormConfig;
    subCategoryCreateButton: Button;
    subCategoryEditButton: Button;
    subCategoryDeleteButton: Button;
    subCategoryDetailsConfig: DetailsDialogConfig;
    subCategoriesTableConfig: TableConfig;
    brandFormConfig: FormConfig;
    brandCreateButton: Button;
    brandEditButton: Button;
    brandDeleteButton: Button;
    brandDetailsConfig: DetailsDialogConfig;
    brandsTableConfig: TableConfig;
    listItemFormConfig: FormConfig;
    listItemCreateButton: Button;
    listItemEditButton: Button;
    listItemDeleteButton: Button;
    listItemDetailsConfig: DetailsDialogConfig;
    listItemsTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeneralService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GeneralService>;
}

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

interface VisibleTab {
    config: TableConfig;
    originalIndex: number;
}
declare class TabService {
    private dataService;
    private buttonService;
    private tableConfigService;
    constructor(dataService: DataServiceLib, buttonService: ButtonService, tableConfigService: TableConfigService);
    private transformCountUrl;
    initializeTabs(tableConfigs: TableConfig[], parentData?: any): {
        tabCounts: {
            [index: number]: number;
        };
        tableReloads: {
            [index: number]: Subject<boolean>;
        };
    };
    loadTabCount(tabIndex: number, countAction: any, tabCounts: {
        [index: number]: number;
    }, parentData?: any): void;
    refreshTabCount(index: number, tableConfigs: TableConfig[], tabCounts: {
        [index: number]: number;
    }, parentData?: any): void;
    handleTabChange(selectedIndex: number, activeTabsLoaded: {
        [index: number]: boolean;
    }): void;
    shouldLoadTabData(index: number, activeTabsLoaded: {
        [index: number]: boolean;
    }): boolean;
    shouldShowBadge(index: number, tableConfigs: TableConfig[], tabCounts: {
        [index: number]: number;
    }): boolean;
    getTabCount(index: number, tabCounts: {
        [index: number]: number;
    }): number | undefined;
    getTabTitle(config: TableConfig): string;
    isTabVisible(tblConfig: TableConfig, parentData?: any): boolean;
    getVisibleTabs(tableConfigs: TableConfig[], parentData?: any): VisibleTab[];
    static ɵfac: i0.ɵɵFactoryDeclaration<TabService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TabService>;
}

declare class SubscriptionService {
    private httpService;
    private enabledFeaturesSource;
    enabledFeatures$: rxjs.Observable<string[]>;
    private featuresLoaded;
    constructor(httpService: HttpService);
    loadFeatures(): void;
    isFeatureEnabled(featureKey: string): boolean;
    isModuleEnabled(featureKey: string): boolean;
    clearFeatures(): void;
    get loaded(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SubscriptionService>;
}

declare class UpdateService {
    private swUpdate;
    private snackBar;
    constructor(swUpdate: SwUpdate, snackBar: MatSnackBar);
    private listenForUpdates;
    checkForUpdate(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateService>;
}

declare class PushNotificationService {
    private httpService;
    private vapidPublicKey;
    constructor(httpService: HttpService);
    init(): void;
    private fetchVapidKeyAndSubscribe;
    private requestPermissionAndSubscribe;
    private subscribe;
    private saveSubscription;
    private urlBase64ToUint8Array;
    static ɵfac: i0.ɵɵFactoryDeclaration<PushNotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PushNotificationService>;
}

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

interface AgentMessage {
    conversationId?: number;
    role: 'user' | 'assistant';
    content: string;
    intent?: string;
    createdDate: Date;
}
interface ConversationSummary {
    conversationID: number;
    title: string;
    appName: string;
    createdDate: Date;
}
declare class AgentService {
    private dataService;
    private signalRService;
    private messages;
    private conversations;
    private typing;
    private isOpen;
    private currentConversationId;
    private greeting;
    private suggestedQuestions;
    messages$: rxjs.Observable<AgentMessage[]>;
    conversations$: rxjs.Observable<ConversationSummary[]>;
    typing$: rxjs.Observable<boolean>;
    isOpen$: rxjs.Observable<boolean>;
    currentConversationId$: rxjs.Observable<number>;
    greeting$: rxjs.Observable<string>;
    suggestedQuestions$: rxjs.Observable<string[]>;
    constructor(dataService: DataServiceLib, signalRService: SignalRService);
    get appName(): string;
    get agentName(): string;
    private initListeners;
    loadConfig(): void;
    loadConversations(): void;
    loadMessages(conversationId: number): void;
    sendMessage(text: string): void;
    newConversation(): void;
    deleteConversation(id: number): void;
    private hasLoadedInitial;
    toggle(): void;
    open(): void;
    close(): void;
    private restoreLastConversation;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AgentService>;
}

declare class AnalyticsService {
    private router;
    private initialized;
    constructor(router: Router);
    init(production: boolean, measurementId: string): void;
    private loadGtagScript;
    private sendPageView;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsService>;
}

declare const authGuard: CanActivateFn;

declare const featureGuard: (featureKey: string) => CanActivateFn;

declare class FeatureDirective implements OnInit, OnDestroy {
    private templateRef;
    private viewContainer;
    private subscriptionService;
    spaFeature: string;
    private hasView;
    private subscription;
    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, subscriptionService: SubscriptionService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private updateView;
    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FeatureDirective, "[spaFeature]", never, { "spaFeature": { "alias": "spaFeature"; "required": false; }; }, {}, never, never, false, never>;
}

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 {
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    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>;
    width: string;
    copyContent: boolean;
    clearContent: boolean;
    required: boolean;
    min: number;
    max: number;
    regex?: {
        pattern: string;
        message: string;
    };
    suffix: string;
    infoMessage: string;
    isHovered: boolean;
    onMouseEnter(): void;
    onMouseLeave(): void;
    initControl(): void;
    leaved(): void;
    clear(): void;
    enterPressed(): void;
    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; }; "width": { "alias": "width"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "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 TextMaskComponent implements OnInit, OnChanges {
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    hide: boolean;
    appearance: 'fill' | 'outline';
    readonly: boolean;
    hint: string;
    display: string;
    placeholder: string;
    value: string;
    valueChange: EventEmitter<any>;
    leave: EventEmitter<any>;
    enterPress: EventEmitter<any>;
    width: string;
    required: boolean;
    min: number;
    max: number;
    regex?: {
        pattern: string;
        message: string;
    };
    infoMessage: string;
    initControl(): void;
    leaved(): void;
    enterPressed(): void;
    control: FormControl<string>;
    private getValidators;
    validate(control: FormControl): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextMaskComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextMaskComponent, "spa-text-mask", 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; }; "width": { "alias": "width"; "required": false; }; "required": { "alias": "required"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "regex": { "alias": "regex"; "required": false; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; }, { "valueChange": "valueChange"; "leave": "leave"; "enterPress": "enterPress"; }, never, never, false, never>;
}

declare class TextAreaComponent implements OnInit, OnChanges {
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    appearance: 'fill' | 'outline';
    readonly: boolean;
    hint: string;
    display: string;
    placeholder: string;
    value: string;
    valueChange: EventEmitter<any>;
    leave: EventEmitter<any>;
    enterPress: EventEmitter<any>;
    rows: number;
    width: string;
    copyContent: boolean;
    clearContent: boolean;
    required: boolean;
    min: number;
    max: number;
    regex?: {
        pattern: string;
        message: string;
    };
    suffix: string;
    infoMessage: string;
    isHovered: boolean;
    onMouseEnter(): void;
    onMouseLeave(): void;
    initControl(): void;
    leaved(): void;
    clear(): void;
    enterPressed(): void;
    control: FormControl<string>;
    private getValidators;
    validate(control: FormControl): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextAreaComponent, "spa-text-area", 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; }; "rows": { "alias": "rows"; "required": false; }; "width": { "alias": "width"; "required": false; }; "copyContent": { "alias": "copyContent"; "required": false; }; "clearContent": { "alias": "clearContent"; "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 TextSingleComponent implements OnInit, OnChanges, OnDestroy {
    private dataService;
    private dialogService;
    private buttonService;
    private messageService;
    constructor(dataService: DataServiceLib, dialogService: DialogService, // Changed: Added DialogService injection
    buttonService: ButtonService, // Changed: Added ButtonService injection
    messageService: MessageService);
    ngOnChanges(changes: SimpleChanges): void;
    private subscription;
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    filteredOptions: Observable<string[]>;
    multiDimension: boolean;
    appearance: 'fill' | 'outline';
    readonly: boolean;
    hint: string;
    display: string;
    placeholder: string;
    value: string;
    valueChange: EventEmitter<any>;
    leave: EventEmitter<any>;
    enterPress: EventEmitter<any>;
    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;
    field: Field;
    data: any;
    detailsConfig: DetailsDialogConfig;
    masterField: string;
    isHovered: boolean;
    onMouseEnter(): void;
    onMouseLeave(): void;
    private initFilter;
    private _filter;
    initControl(): void;
    getDisplayValue(value: any): string;
    changed(): void;
    leaved(): void;
    isValidSelection(inputValue: string): boolean;
    clear(): void;
    enterPressed(): void;
    refresh(event: MouseEvent): void;
    getData(action: Action): void;
    myControl: FormControl<string>;
    private getValidators;
    validate(control: FormControl): string;
    canCreate(): boolean;
    canView(): boolean;
    onPeekClick(event: MouseEvent, mode: 'create' | 'view'): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextSingleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextSingleComponent, "spa-text-single", 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; }; "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; }; "field": { "alias": "field"; "required": false; }; "data": { "alias": "data"; "required": false; }; "detailsConfig": { "alias": "detailsConfig"; "required": false; }; "masterField": { "alias": "masterField"; "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;
    private compareValues;
    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 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;
    smallScreen: 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; }; "smallScreen": { "alias": "smallScreen"; "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;
    isTileValuePrimitive(tile: Tile): boolean;
    hasTileChartData(tile: Tile): boolean;
    getTileMiniChartData(tile: Tile): ChartData;
    getMiniChartOptions(tile: Tile): ChartOptions;
    getTileChartPlugins(tile: Tile): Plugin[];
    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 NavMenuComponent {
    router: Router;
    authService: AuthService;
    private storageService;
    private notificationsService;
    private breakpointObserver;
    dataService: DataServiceLib;
    private dialog;
    subscriptionService: SubscriptionService;
    constructor(router: Router, authService: AuthService, storageService: StorageService, notificationsService: NotificationsService, breakpointObserver: BreakpointObserver, dataService: DataServiceLib, dialog: MatDialog, subscriptionService: SubscriptionService);
    ngOnInit(): void;
    notificationCount$: any;
    smallScreen: any;
    myRole: any;
    loggedUserFullName: string;
    tenantName: string;
    loggedin: boolean;
    isExpanded: boolean;
    nowDate: Date;
    isMiniSidebar: boolean;
    isMiniHovered: boolean;
    openMenus: Set<string>;
    currentUrl: string;
    topbarScrolled: boolean;
    onWindowScroll(): void;
    appConfig: AppConfig;
    footer: string;
    collapse(): void;
    toggle(): void;
    closeSide(): void;
    logoff(): void;
    redirectTo(link: string): void;
    getSubItems(capItem: CapItem): CapItem[];
    isFeatureAllowed(cap: CapItem): boolean;
    get reversedCapItems(): CapItem[];
    openTerms(): void;
    openPrivacy(): void;
    toggleMiniSidebar(): void;
    onMiniMouseEnter(): void;
    onMiniMouseLeave(): void;
    toggleModernMenu(capName: string): void;
    isMenuOpen(capName: string): boolean;
    isActiveRoute(link: string): boolean;
    isParentActive(cap: CapItem): boolean;
    getInitials(display: string): string;
    modernNavigate(link: string): void;
    get isModernExpanded(): boolean;
    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 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, OnDestroy {
    private dataService;
    private messageService;
    private breakpointObserver;
    dialog: MatDialog;
    private buttonService;
    private dialogService;
    private tableConfigService;
    private conditionService;
    private authService;
    private signalRService;
    constructor(dataService: DataServiceLib, messageService: MessageService, breakpointObserver: BreakpointObserver, dialog: MatDialog, buttonService: ButtonService, dialogService: DialogService, tableConfigService: TableConfigService, conditionService: ConditionService, authService: AuthService, signalRService: SignalRService);
    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;
    tablePaginator: MatPaginator;
    data: any;
    tileData: any;
    config: TableConfig;
    reload: Subject<boolean>;
    activeTab: boolean;
    inTab: boolean;
    nestingLevel: number;
    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 realTimeSubs;
    private realTimeEntityName;
    isSignalRConnected: boolean;
    private initializeComponent;
    private updateTableConfiguration;
    private setupDataLoading;
    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;
    private realTimeRefreshOrFallback;
    private setupRealTimeSubscriptions;
    private deriveEntityName;
    private findIdKey;
    ngOnDestroy(): void;
    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; }; "nestingLevel": { "alias": "nestingLevel"; "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;
    userKeepOpen: 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;
    nestingLevel: number;
    showTabs: boolean;
    isLoadComplete: boolean;
    isProcessing: boolean;
    inputChange: EventEmitter<any>;
    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;
    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;
    private effectiveKeepOpen;
    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 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>;
    resolveLoadAction(field: Field): 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 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 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;
    isRealTime: boolean;
    isConnected: boolean;
    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; }; "isRealTime": { "alias": "isRealTime"; "required": false; }; "isConnected": { "alias": "isConnected"; "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 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 TextMultiComponent 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<TextMultiComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextMultiComponent, "spa-text-multi", 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 SelectMultiComponent 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;
    selectAll: boolean;
    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<SelectMultiComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectMultiComponent, "spa-select-multi", 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; }; "selectAll": { "alias": "selectAll"; "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 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, OnChanges {
    private tabService;
    constructor(tabService: TabService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    tableConfigs: TableConfig[];
    reload: Subject<boolean>;
    parentDetails: any;
    nestingLevel: number;
    formRefresh: EventEmitter<void>;
    tabCounts: {
        [index: number]: number;
    };
    activeTabsLoaded: {
        [index: number]: boolean;
    };
    selectedTabIndex: number;
    tableReloads: {
        [index: number]: Subject<boolean>;
    };
    visibleTabs: VisibleTab[];
    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;
    onTableActionSuccess(tabIndex: number, event: any): void;
    isTabVisible(config: TableConfig): boolean;
    updateVisibleTabs(): void;
    getReloadSubject(index: number): Subject<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "spa-tabs", never, { "tableConfigs": { "alias": "tableConfigs"; "required": false; }; "reload": { "alias": "reload"; "required": false; }; "parentDetails": { "alias": "parentDetails"; "required": false; }; "nestingLevel": { "alias": "nestingLevel"; "required": false; }; }, { "formRefresh": "formRefresh"; }, 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;
    private dataService;
    private snackBar;
    constructor(conditionService: ConditionService, buttonService: ButtonService, dataService: DataServiceLib, // Changed: Injected for drop action API calls
    snackBar: MatSnackBar);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    config: TableConfig;
    dataSource: any[];
    displayedButtons: Button[];
    actionClick: EventEmitter<{
        name: string;
        row: any;
        group?: GroupData;
        button?: Button;
    }>;
    groupedData: GroupData[];
    allGroupedData: GroupData[];
    filterText: string;
    highlightedGroup: GroupData | null;
    private mapServerData;
    applyFilter(): void;
    private getGroupIconFromConfig;
    private getGroupColorFromConfig;
    onDropListEntered(event: CdkDragEnter<any[]>): void;
    onDropListExited(event: CdkDragExit<any[]>): void;
    onDrop(event: CdkDragDrop<any[]>): void;
    getItemText(item: any): string;
    getItemIcon(item: any): string | null;
    getItemIconTip(item: any): string;
    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 WelcomeComponent implements OnInit {
    private router;
    dataService: DataServiceLib;
    constructor(router: Router, dataService: DataServiceLib);
    ngOnInit(): void;
    businessModules: {
        name: string;
        icon: string;
        description: string;
        features: string[];
        components: number;
        demoUrl: string;
        color: string;
    }[];
    advancedFeatures: {
        name: string;
        modules: string;
        description: string;
    }[];
    supportingModules: {
        name: string;
        icon: string;
        link: string;
        description: string;
    }[];
    componentFeatures: {
        category: string;
        count: number;
        items: string;
    }[];
    moduleStats: {
        totalModules: number;
        totalComponents: number;
        totalFeatures: number;
    };
    navigateTo(url: string): void;
    private calculateModuleStats;
    static ɵfac: i0.ɵɵFactoryDeclaration<WelcomeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WelcomeComponent, "spa-welcome", never, {}, {}, never, never, false, never>;
}

declare class TermsDialogComponent {
    private dialogRef;
    constructor(dialogRef: MatDialogRef<TermsDialogComponent>);
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TermsDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TermsDialogComponent, "spa-terms-dialog", never, {}, {}, never, never, false, never>;
}

declare class PrivacyDialogComponent {
    private dialogRef;
    constructor(dialogRef: MatDialogRef<PrivacyDialogComponent>);
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrivacyDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PrivacyDialogComponent, "spa-privacy-dialog", never, {}, {}, never, never, false, never>;
}

declare class ChartsComponent implements OnInit {
    private dataService;
    private messageService;
    constructor(dataService: DataServiceLib, messageService: MessageService);
    config: ChartConfig;
    data: any;
    reload: Subject<boolean>;
    ngOnInit(): void;
    loadData(action: Action, data: any): void;
    getChartData(chart: ChartItem): ChartData;
    getChartOptions(chart: ChartItem): ChartOptions;
    getPlugins(chart: ChartItem): Plugin[];
    isHidden(chart: ChartItem): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChartsComponent, "spa-charts", never, { "config": { "alias": "config"; "required": false; }; "data": { "alias": "data"; "required": false; }; "reload": { "alias": "reload"; "required": false; }; }, {}, never, never, false, never>;
}

interface LandingColors {
    primary: string;
    primaryDark: string;
    primaryLight: string;
    secondary: string;
    secondaryLight: string;
}
interface LandingBrandOverride {
    svgMarkup: string;
    wordmarkLine1?: string;
    wordmarkLine2?: string;
}
interface LandingNavLink {
    label: string;
    target: string;
}
interface LandingFeature {
    title: string;
    description: string;
    icon: string;
    color: string;
}
interface LandingStep {
    number: string;
    title: string;
    description: string;
    icon: string;
}
interface LandingModuleTile {
    name: string;
    icon: string;
}
interface LandingModuleGroup {
    category: string;
    tiles: LandingModuleTile[];
}
interface LandingMetric {
    value: string;
    label: string;
}
interface LandingSecurityItem {
    icon: string;
    title: string;
    description: string;
}
interface LandingTestimonial {
    quote: string;
    authorName: string;
    authorRole: string;
    authorInitials: string;
}
interface LandingPricingPlan {
    name: string;
    price: string;
    period?: string;
    description: string;
    features: string[];
    ctaLabel: string;
    ctaRoute?: string;
    ctaSection?: string;
    popular?: boolean;
    outline?: boolean;
}
interface LandingFooterLink {
    label: string;
    section?: string;
    route?: string;
}
interface LandingFooterColumn {
    title: string;
    links: LandingFooterLink[];
}
interface LandingConfig {
    appName: string;
    logoSrc: string;
    colors: LandingColors;
    navBrand?: LandingBrandOverride;
    navLinks: LandingNavLink[];
    hero: {
        badge?: string;
        headline: string;
        gradientText: string;
        subtitle: string;
        primaryCTA: string;
        primaryCTARoute?: string;
        secondaryCTA: string;
        secondaryCTASection: string;
        trustSignals: string[];
        layout?: 'centered' | 'split';
        watermarkSvg?: string;
    };
    features: {
        title: string;
        subtitle: string;
        items: LandingFeature[];
    };
    workflow?: {
        title: string;
        subtitle?: string;
        style?: 'steps' | 'road';
        steps: LandingStep[];
    };
    modules?: {
        title: string;
        subtitle: string;
        groups: LandingModuleGroup[];
    };
    metrics?: LandingMetric[];
    security?: {
        title: string;
        subtitle: string;
        items: LandingSecurityItem[];
    };
    testimonials?: {
        title: string;
        subtitle?: string;
        items: LandingTestimonial[];
    };
    pricing?: {
        title: string;
        subtitle?: string;
        plans: LandingPricingPlan[];
    };
    finalCta?: {
        headline: string;
        subtitle: string;
        primaryCTA: string;
        primaryCTARoute?: string;
        secondaryCTA?: string;
        secondaryCTASection?: string;
    };
    footerCompany?: string;
    footerTagline?: string;
    footerBrand?: LandingBrandOverride;
    footerColumns?: LandingFooterColumn[];
}
declare const ALSQUARE_SVG_DARK = "<svg viewBox=\"0 0 80 80\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n  <path d=\"M32 62C17.6 62 6 50.4 6 36S17.6 10 32 10c9.2 0 17.3 4.9 21.8 12.2\" stroke=\"#1a3a7a\" stroke-width=\"9\" stroke-linecap=\"round\" fill=\"none\"/>\n  <circle cx=\"32\" cy=\"36\" r=\"10\" fill=\"white\" stroke=\"#1a3a7a\" stroke-width=\"7\"/>\n  <circle cx=\"32\" cy=\"36\" r=\"5.5\" fill=\"#e8a020\"/>\n  <line x1=\"48\" y1=\"22\" x2=\"48\" y2=\"62\" stroke=\"#1a3a7a\" stroke-width=\"9\" stroke-linecap=\"round\"/>\n  <rect x=\"56\" y=\"6\" width=\"7\" height=\"56\" rx=\"3.5\" fill=\"#e8a020\"/>\n  <rect x=\"67\" y=\"0\" width=\"6\" height=\"6\" rx=\"1\" fill=\"#1a3a7a\"/>\n  <rect x=\"67\" y=\"9\" width=\"6\" height=\"6\" rx=\"1\" fill=\"#1a3a7a\"/>\n  <rect x=\"75\" y=\"0\" width=\"5\" height=\"5\" rx=\"1\" fill=\"#1a3a7a\" opacity=\"0.7\"/>\n  <rect x=\"75\" y=\"8\" width=\"5\" height=\"5\" rx=\"1\" fill=\"#1a3a7a\" opacity=\"0.5\"/>\n</svg>";
declare const ALSQUARE_SVG_WHITE = "<svg viewBox=\"0 0 80 80\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n  <path d=\"M32 62C17.6 62 6 50.4 6 36S17.6 10 32 10c9.2 0 17.3 4.9 21.8 12.2\" stroke=\"#ffffff\" stroke-width=\"9\" stroke-linecap=\"round\" fill=\"none\"/>\n  <circle cx=\"32\" cy=\"36\" r=\"10\" fill=\"#0f172a\" stroke=\"#ffffff\" stroke-width=\"7\"/>\n  <circle cx=\"32\" cy=\"36\" r=\"5.5\" fill=\"#e8a020\"/>\n  <line x1=\"48\" y1=\"22\" x2=\"48\" y2=\"62\" stroke=\"#ffffff\" stroke-width=\"9\" stroke-linecap=\"round\"/>\n  <rect x=\"56\" y=\"6\" width=\"7\" height=\"56\" rx=\"3.5\" fill=\"#e8a020\"/>\n  <rect x=\"67\" y=\"0\" width=\"6\" height=\"6\" rx=\"1\" fill=\"#ffffff\"/>\n  <rect x=\"67\" y=\"9\" width=\"6\" height=\"6\" rx=\"1\" fill=\"#ffffff\"/>\n  <rect x=\"75\" y=\"0\" width=\"5\" height=\"5\" rx=\"1\" fill=\"#ffffff\" opacity=\"0.7\"/>\n  <rect x=\"75\" y=\"8\" width=\"5\" height=\"5\" rx=\"1\" fill=\"#ffffff\" opacity=\"0.5\"/>\n</svg>";

declare class SpaLandingComponent implements OnInit, AfterViewInit, OnDestroy {
    private router;
    private authService;
    private el;
    private sanitizer;
    config: LandingConfig;
    mobileMenuOpen: boolean;
    navScrolled: boolean;
    currentYear: number;
    private observer;
    constructor(router: Router, authService: AuthService, el: ElementRef, sanitizer: DomSanitizer);
    get safeNavBrandSvg(): SafeHtml | null;
    get safeHeroWatermarkSvg(): SafeHtml | null;
    get safeFooterBrandSvg(): SafeHtml | null;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onWindowScroll(): void;
    scrollToSection(target: string): void;
    toggleMobileMenu(): void;
    navigateTo(path: string): void;
    iconBg(hex: string): string;
    private applyColors;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaLandingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpaLandingComponent, "spa-landing", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, ["[lpHeroVisual]", "[lpCustomSection]"], false, never>;
}

interface ToastItem {
    id: number;
    message: string;
    icon: string;
    color: string;
    category: string;
    timestamp: Date;
}
declare class ToastComponent implements OnInit, OnDestroy {
    private signalRService;
    toasts: ToastItem[];
    private subs;
    private nextId;
    private maxToasts;
    private autoDismissMs;
    constructor(signalRService: SignalRService);
    ngOnInit(): void;
    private show;
    dismiss(id: number): void;
    trackToast(index: number, toast: ToastItem): number;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "spa-toast", never, {}, {}, never, never, false, never>;
}

declare class AgentComponent implements OnInit, OnDestroy, AfterViewChecked {
    agentService: AgentService;
    private signalRService;
    messageContainer: ElementRef;
    messageInput: ElementRef;
    messages: AgentMessage[];
    isOpen: boolean;
    isTyping: boolean;
    inputText: string;
    greeting: string;
    suggestedQuestions: string[];
    isOnline: boolean;
    private subs;
    private shouldScroll;
    private viewportHandler;
    constructor(agentService: AgentService, signalRService: SignalRService);
    get agentName(): string;
    ngOnInit(): void;
    ngAfterViewChecked(): void;
    toggleChat(): void;
    onDocumentClick(event: MouseEvent): void;
    sendMessage(): void;
    sendSuggested(question: string): void;
    onKeydown(event: KeyboardEvent): void;
    newConversation(): void;
    private scrollToBottom;
    private focusInput;
    trackMessage(index: number, msg: AgentMessage): string;
    private initMobileViewport;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgentComponent, "spa-agent", never, {}, {}, never, never, false, never>;
}

declare class SpaMatModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaMatModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SpaMatModule, never, never, [typeof i4.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i3$1.MatMenuModule, typeof i4$1.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.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 i4.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 TextMaskComponent, typeof TextAreaComponent, typeof TextSingleComponent, 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 DetailsDialog, typeof FormComponent, typeof CamelToWordsPipe, typeof NumberComponent, typeof SearchComponent, typeof ViewerComponent, typeof viewerDialog, typeof ListDialogComponent, typeof InvitationsTableComponent, typeof TableHeaderComponent, typeof TableRowComponent, typeof TableActionComponent, typeof AlertComponent, typeof EmailComponent, typeof PageComponent, typeof SelectCommonComponent, typeof SuffixComponent, typeof SelectContextDirective, typeof SelectLiteComponent, typeof TextMultiComponent, typeof SelectMultiComponent, typeof SelectBitwiseComponent, typeof HtmlComponent, typeof NotesComponent, typeof CapsulesComponent, typeof CardsComponent, typeof TabsComponent, typeof StatusesComponent, typeof GroupsComponent, typeof TitleActionsComponent, typeof WelcomeComponent, typeof TermsDialogComponent, typeof PrivacyDialogComponent, typeof ChartsComponent, typeof FeatureDirective, typeof SpaLandingComponent, typeof ToastComponent, typeof AgentComponent], [typeof SpaMatModule, typeof i62.HttpClientModule, typeof CurrencyInputModule, typeof i64.NgxDocViewerModule, typeof i65.BaseChartDirective, typeof i66.DragDropModule], [typeof TinSpaComponent, typeof SpaMatModule, typeof AlertComponent, typeof TextComponent, typeof TextMaskComponent, typeof TextAreaComponent, typeof TextSingleComponent, typeof TextMultiComponent, typeof messageDialog, typeof NavMenuComponent, typeof LoaderComponent, typeof TilesComponent, typeof DateComponent, typeof SelectComponent, typeof SelectBitwiseComponent, typeof SelectMultiComponent, 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 ListDialogComponent, typeof EmailComponent, typeof PageComponent, typeof HtmlComponent, typeof NotesComponent, typeof CapsulesComponent, typeof TabsComponent, typeof StatusesComponent, typeof GroupsComponent, typeof TitleActionsComponent, typeof WelcomeComponent, typeof InvitationsTableComponent, typeof TermsDialogComponent, typeof PrivacyDialogComponent, typeof SelectLiteComponent, typeof ChartsComponent, typeof FeatureDirective, typeof SpaLandingComponent, typeof AgentComponent]>;
    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 signalRService;
    private msalService;
    private dialog;
    constructor(httpService: HttpService, storageService: StorageService, router: Router, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, logService: LogService, route: ActivatedRoute, notificationsService: NotificationsService, signalRService: SignalRService, msalService: MsalService, dialog: MatDialog);
    ngOnInit(): void;
    loginWithMS(): void;
    autoLogin: boolean;
    socialUser: SocialUser | null;
    rememberMe: boolean;
    style: string;
    email: string;
    password: string;
    redirectPath: any;
    user: User;
    hide: boolean;
    isProcessing: boolean;
    appConfig: AppConfig;
    signup(): void;
    recoverAccount(): void;
    private setupForm;
    login(): void;
    notifications(): void;
    openTerms(): void;
    openPrivacy(): 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;
    dataService: DataServiceLib;
    authService: AuthService;
    private storageService;
    router: Router;
    private msalService;
    private notificationsService;
    private dialog;
    private cdr;
    constructor(httpService: HttpService, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, storageService: StorageService, router: Router, msalService: MsalService, notificationsService: NotificationsService, dialog: MatDialog, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    appConfig: AppConfig;
    style: string;
    signupData: SignupData;
    step: 'provider' | 'form' | 'invitations' | 'complete';
    isProcessing: boolean;
    handleProviderAuth(token: string, authType: string, userName: string): void;
    loginWithMS(): void;
    toggleInvitation(invitation: any): void;
    submit(): void;
    completeLogin(apiResponse: ApiResponse): void;
    goToDashboard(): void;
    goToLogin(): void;
    openTerms(): void;
    openPrivacy(): 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 i4.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof TinSpaModule, typeof i7$1.SocialLoginModule], [typeof i4.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 i4.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof TinSpaModule], [typeof i4.CommonModule, typeof i3.FormsModule, typeof TinSpaModule, typeof ChangePasswordComponent, typeof ProfileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpaUserModule>;
}

declare class UsersComponent implements OnInit {
    private httpService;
    private router;
    private authService;
    private dataService;
    private dialog;
    private messageService;
    userBaseFormConfig: FormConfig;
    createDialog: DetailsDialogConfig;
    editDialog: DetailsDialogConfig;
    passwordDialog: DetailsDialogConfig;
    usersTableConfig: TableConfig;
    pageConfig: PageConfig;
    ngOnInit(): void;
    inputChanged(x: any): void;
    loadMeta(): void;
    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;
    addRoleDialogConfig: DetailsDialogConfig;
    addRoleButton: 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 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 CategoriesComponent {
    private generalService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<CategoriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CategoriesComponent, "spa-categories", never, {}, {}, never, never, true, never>;
}

declare class SubCategoriesComponent {
    private generalService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubCategoriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubCategoriesComponent, "spa-subcategories", never, {}, {}, never, never, true, never>;
}

declare class BrandsComponent {
    private generalService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrandsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrandsComponent, "spa-brands", never, {}, {}, never, never, true, never>;
}

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

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

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

declare class PreferencesComponent implements OnInit {
    dataServiceLib: DataServiceLib;
    private messageService;
    constructor(dataServiceLib: DataServiceLib, messageService: MessageService);
    preference: any;
    ngOnInit(): void;
    loadPreferences(): void;
    onSubmit(): void;
    monthOptions: any[];
    dayOptions: any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<PreferencesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreferencesComponent, "spa-preferences", never, {}, {}, never, never, false, never>;
}

declare class GptCachesComponent {
    private dataService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<GptCachesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GptCachesComponent, "spa-gpt-caches", never, {}, {}, never, never, true, never>;
}

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

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

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

declare class AccountsComponent implements OnInit {
    private dataServiceLib;
    accountingService: AccountingService;
    constructor(dataServiceLib: DataServiceLib, accountingService: AccountingService);
    ngOnInit(): void;
    accountTabConfigs: TableConfig[];
    accountTileConfig: TileConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccountsComponent, "spa-accounts", never, {}, {}, never, never, false, never>;
}

declare class AggregatesComponent implements OnInit {
    private dataServiceLib;
    accountingService: AccountingService;
    constructor(dataServiceLib: DataServiceLib, accountingService: AccountingService);
    ngOnInit(): void;
    aggregateTabConfigs: TableConfig[];
    static ɵfac: i0.ɵɵFactoryDeclaration<AggregatesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AggregatesComponent, "spa-aggregates", never, {}, {}, never, never, false, never>;
}

declare class AgingComponent implements OnInit {
    private dataServiceLib;
    accountingService: AccountingService;
    ngOnInit(): void;
    summaryData: any;
    loadSummaryData(): void;
    agingTableConfigs: TableConfig[];
    tileConfig: TileConfig;
    constructor(dataServiceLib: DataServiceLib);
    static ɵfac: i0.ɵɵFactoryDeclaration<AgingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgingComponent, "spa-aging", never, {}, {}, never, never, false, never>;
}

declare class PurchasingService {
    private dataService;
    private inventoryService;
    constructor();
    private paymentTypeOptions;
    purchaseOrderItemFormConfig: FormConfig;
    purchaseOrderItemsTableConfig: TableConfig;
    purchaseOrderFormConfig: FormConfig;
    receiveGoodsFormConfig: FormConfig;
    receiveGoodsDetailsConfig: DetailsDialogConfig;
    purchaseOrderEditButton: Button;
    purchaseOrderConfirmButton: Button;
    purchaseOrderCancelButton: Button;
    purchaseOrderReceiveButton: Button;
    purchaseOrderDetailsConfig: DetailsDialogConfig;
    purchaseOrderViewButton: Button;
    purchaseOrdersTableConfig: TableConfig;
    purchaseItemFormConfig: FormConfig;
    purchaseItemsTableConfig: TableConfig;
    purchaseFormConfig: FormConfig;
    purchaseEditButton: Button;
    purchaseCompleteButton: Button;
    purchaseStepConfig: StepConfig;
    purchaseDetailsConfig: DetailsDialogConfig;
    purchaseViewButton: Button;
    quickPurchaseButton: Button;
    purchasesTableConfig: TableConfig;
    receiptItemFormConfig: FormConfig;
    receiptItemsTableConfig: TableConfig;
    receiptFormConfig: FormConfig;
    receiptCompleteButton: Button;
    receiptEditButton: Button;
    receiptDetailsConfig: DetailsDialogConfig;
    receiptViewButton: Button;
    receiptsTableConfig: TableConfig;
    supplierPaymentFormConfig: FormConfig;
    supplierPaymentCreateButton: Button;
    supplierPaymentCreateDetailsConfig: DetailsDialogConfig;
    supplierRecordPaymentButton: Button;
    supplierPaymentsTableConfig: TableConfig;
    apAgingTileConfig: TileConfig;
    apAgingBaseTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PurchasingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PurchasingService>;
}

declare class SupplierAgingComponent implements OnInit {
    private dataServiceLib;
    purchasingService: PurchasingService;
    ngOnInit(): void;
    summaryData: any;
    loadSummaryData(): void;
    agingTableConfigs: TableConfig[];
    tileConfig: TileConfig;
    constructor(dataServiceLib: DataServiceLib);
    static ɵfac: i0.ɵɵFactoryDeclaration<SupplierAgingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SupplierAgingComponent, "spa-supplier-aging", never, {}, {}, never, never, false, never>;
}

declare class TransactionTypesComponent implements OnInit {
    private accountingService;
    pageConfig: PageConfig;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TransactionTypesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TransactionTypesComponent, "spa-transaction-types", never, {}, {}, never, never, false, never>;
}

declare class TransactionsComponent implements OnInit {
    private accountingService;
    pageConfig: PageConfig;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TransactionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TransactionsComponent, "spa-transactions", never, {}, {}, never, never, false, never>;
}

declare class InvoicesComponent implements OnInit {
    accountingService: AccountingService;
    private httpService;
    private http;
    private messageService;
    pageConfig: PageConfig;
    ngOnInit(): void;
    actionClicked(event: {
        name: string;
        data: any;
    }): void;
    download(invoice: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvoicesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InvoicesComponent, "spa-invoices", never, {}, {}, never, never, false, never>;
}

declare class StatementComponent implements OnInit {
    accountingService: AccountingService;
    pageConfig: PageConfig;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatementComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatementComponent, "spa-statement", never, {}, {}, never, never, false, never>;
}

declare class ReportsComponent implements OnInit {
    private dataServiceLib;
    accountingService: AccountingService;
    constructor(dataServiceLib: DataServiceLib, accountingService: AccountingService);
    ngOnInit(): void;
    reportTabConfigs: TableConfig[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ReportsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReportsComponent, "spa-reports", never, {}, {}, never, never, false, never>;
}

declare class BudgetsComponent {
    private accountingService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<BudgetsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BudgetsComponent, "spa-budgets", never, {}, {}, never, never, false, never>;
}

declare class BudgetVsActualComponent {
    private accountingService;
    private httpService;
    selectedBudgetID: number | null;
    reportTabConfigs: TableConfig[];
    summaryTileConfig: TileConfig;
    onBudgetSelected(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BudgetVsActualComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BudgetVsActualComponent, "spa-budget-vs-actual", never, {}, {}, never, never, false, never>;
}

declare class AccountingDashboardComponent {
    summaryTiles: TileConfig;
    chartTiles: TileConfig;
    chartConfig: ChartConfig;
    cashBankChartConfig: ChartConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountingDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccountingDashboardComponent, "spa-accounting-dashboard", never, {}, {}, never, never, false, never>;
}

declare class InvoiceDashboardComponent implements OnInit {
    private dataService;
    constructor(dataService: DataServiceLib);
    attentionItems: any[];
    summaryTiles: TileConfig;
    chartTiles: TileConfig;
    chartConfig: ChartConfig;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvoiceDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InvoiceDashboardComponent, "spa-invoice-dashboard", never, {}, {}, never, never, false, never>;
}

declare class TaxRatesComponent {
    private accountingService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaxRatesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TaxRatesComponent, "spa-tax-rates", never, {}, {}, never, never, true, never>;
}

declare class StandingOrdersComponent {
    private accountingService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<StandingOrdersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StandingOrdersComponent, "spa-standing-orders", never, {}, {}, never, never, true, never>;
}

declare class CurrenciesComponent {
    private accountingService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrenciesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrenciesComponent, "spa-currencies", never, {}, {}, never, never, true, never>;
}

declare class AccountingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AccountingModule, [typeof AccountsComponent, typeof AggregatesComponent, typeof AgingComponent, typeof SupplierAgingComponent, typeof TransactionTypesComponent, typeof TransactionsComponent, typeof InvoicesComponent, typeof StatementComponent, typeof ReportsComponent, typeof BudgetsComponent, typeof BudgetVsActualComponent, typeof AccountingDashboardComponent, typeof InvoiceDashboardComponent], [typeof i4.CommonModule, typeof SpaAdminModule, typeof TaxRatesComponent, typeof StandingOrdersComponent, typeof CurrenciesComponent], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AccountingModule>;
}

declare class ProductsComponent implements OnInit {
    private inventoryService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProductsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProductsComponent, "spa-products", never, {}, {}, never, never, false, never>;
}

declare class InventoryItemsComponent implements OnInit {
    private inventoryService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InventoryItemsComponent, "spa-inventory-items", never, {}, {}, never, never, false, never>;
}

declare class RequisitionsComponent implements OnInit {
    private inventoryService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequisitionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RequisitionsComponent, "spa-requisitions", never, {}, {}, never, never, false, never>;
}

declare class InventoryAdjustmentsComponent implements OnInit {
    private inventoryService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryAdjustmentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InventoryAdjustmentsComponent, "spa-inventory-adjustments", never, {}, {}, never, never, false, never>;
}

declare class InventoryReturnsComponent implements OnInit {
    private inventoryService;
    tableConfig: tin_spa.TableConfig;
    pageConfig: PageConfig;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryReturnsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InventoryReturnsComponent, "spa-inventory-returns", never, {}, {}, never, never, false, never>;
}

declare class InventoryTransactionsComponent implements OnInit {
    private inventoryService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryTransactionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InventoryTransactionsComponent, "spa-inventory-transactions", never, {}, {}, never, never, false, never>;
}

declare class InventoryDashboardComponent {
    summaryTiles: TileConfig;
    chartTiles: TileConfig;
    chartConfig: ChartConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InventoryDashboardComponent, "spa-inventory-dashboard", never, {}, {}, never, never, false, never>;
}

declare class InventoryStockComponent implements OnInit {
    private inventoryService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryStockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InventoryStockComponent, "spa-inventory-stock", never, {}, {}, never, never, false, never>;
}

declare class BundleProductsComponent implements OnInit {
    private inventoryService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<BundleProductsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BundleProductsComponent, "spa-bundle-products", never, {}, {}, never, never, false, never>;
}

declare class ServiceItemsComponent {
    private inventoryService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceItemsComponent, "spa-service-items", never, {}, {}, never, never, false, never>;
}

declare class InventoryModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InventoryModule, [typeof ProductsComponent, typeof InventoryItemsComponent, typeof RequisitionsComponent, typeof InventoryAdjustmentsComponent, typeof InventoryReturnsComponent, typeof InventoryTransactionsComponent, typeof InventoryDashboardComponent, typeof InventoryStockComponent, typeof BundleProductsComponent, typeof ServiceItemsComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InventoryModule>;
}

declare class SalesOrdersComponent implements OnInit {
    private salesService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SalesOrdersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SalesOrdersComponent, "spa-sales-orders", never, {}, {}, never, never, false, never>;
}

declare class SalesComponent {
    private salesService;
    config: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SalesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SalesComponent, "app-sales", never, {}, {}, never, never, false, never>;
}

declare class SalesDashboardComponent {
    summaryTiles: TileConfig;
    chartTiles: TileConfig;
    chartConfig: ChartConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SalesDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SalesDashboardComponent, "spa-sales-dashboard", never, {}, {}, never, never, false, never>;
}

declare class SalesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SalesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SalesModule, [typeof SalesOrdersComponent, typeof SalesComponent, typeof SalesDashboardComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SalesModule>;
}

declare class PurchaseOrdersComponent implements OnInit {
    private purchasingService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PurchaseOrdersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PurchaseOrdersComponent, "spa-purchase-orders", never, {}, {}, never, never, false, never>;
}

declare class InventoryReceiptsComponent implements OnInit {
    private purchasingService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InventoryReceiptsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InventoryReceiptsComponent, "spa-inventory-receipts", never, {}, {}, never, never, false, never>;
}

declare class PurchasingDashboardComponent {
    summaryTiles: TileConfig;
    chartTiles: TileConfig;
    chartConfig: ChartConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PurchasingDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PurchasingDashboardComponent, "spa-purchasing-dashboard", never, {}, {}, never, never, false, never>;
}

declare class PurchasingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PurchasingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PurchasingModule, [typeof PurchaseOrdersComponent, typeof InventoryReceiptsComponent, typeof PurchasingDashboardComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PurchasingModule>;
}

declare class EmployeesComponent {
    private dataService;
    private authService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmployeesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmployeesComponent, "spa-employees", never, {}, {}, never, never, false, never>;
}

declare class DepartmentsComponent {
    private dataService;
    private messageService;
    private authService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<DepartmentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DepartmentsComponent, "spa-departments", never, {}, {}, never, never, false, never>;
}

declare class PositionsComponent {
    private dataService;
    private authService;
    pageConfig: PageConfig;
    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 OnboardingComponent 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<OnboardingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OnboardingComponent, "spa-onboarding", never, {}, {}, never, never, false, never>;
}

declare class HRModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HRModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HRModule, [typeof EmployeesComponent, typeof DepartmentsComponent, typeof PositionsComponent, typeof GradesComponent, typeof OnboardingComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HRModule>;
}

declare class SalaryStructuresComponent {
    private payrollService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SalaryStructuresComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SalaryStructuresComponent, "spa-salary-structures", never, {}, {}, never, never, false, never>;
}

declare class StatutoryDeductionsComponent {
    private payrollService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatutoryDeductionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatutoryDeductionsComponent, "spa-statutory-deductions", never, {}, {}, never, never, false, never>;
}

declare class PayrollRunsComponent {
    private payrollService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PayrollRunsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PayrollRunsComponent, "spa-payroll-runs", never, {}, {}, never, never, false, never>;
}

declare class CommissionConfigsComponent {
    private payrollService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommissionConfigsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommissionConfigsComponent, "spa-commission-configs", never, {}, {}, never, never, false, never>;
}

declare class CommissionEntriesComponent {
    private payrollService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommissionEntriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommissionEntriesComponent, "spa-commission-entries", never, {}, {}, never, never, false, never>;
}

declare class SalaryAdvancesComponent {
    private payrollService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SalaryAdvancesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SalaryAdvancesComponent, "spa-salary-advances", never, {}, {}, never, never, false, never>;
}

declare class OvertimeEntriesComponent {
    private payrollService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<OvertimeEntriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OvertimeEntriesComponent, "spa-overtime-entries", never, {}, {}, never, never, false, never>;
}

declare class PayrollDashboardComponent implements OnInit {
    private dataService;
    constructor(dataService: DataServiceLib);
    recentRuns: any[];
    summaryTiles: TileConfig;
    chartTiles: TileConfig;
    chartConfig: ChartConfig;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PayrollDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PayrollDashboardComponent, "spa-payroll-dashboard", never, {}, {}, never, never, false, never>;
}

declare class PayrollModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PayrollModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PayrollModule, [typeof SalaryStructuresComponent, typeof StatutoryDeductionsComponent, typeof PayrollRunsComponent, typeof CommissionConfigsComponent, typeof CommissionEntriesComponent, typeof SalaryAdvancesComponent, typeof OvertimeEntriesComponent, typeof PayrollDashboardComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PayrollModule>;
}

declare class ProductionRecipesComponent implements OnInit {
    private productionService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProductionRecipesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProductionRecipesComponent, "spa-production-recipes", never, {}, {}, never, never, false, never>;
}

declare class ProductionOrdersComponent implements OnInit {
    private productionService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProductionOrdersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProductionOrdersComponent, "spa-production-orders", never, {}, {}, never, never, false, never>;
}

declare class ManufacturingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ManufacturingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ManufacturingModule, [typeof ProductionRecipesComponent, typeof ProductionOrdersComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ManufacturingModule>;
}

declare class LoanProductsComponent {
    private loansService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoanProductsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoanProductsComponent, "spa-loan-products", never, {}, {}, never, never, false, never>;
}

declare class LoansComponent {
    private loansService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoansComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoansComponent, "spa-loans", never, {}, {}, never, never, false, never>;
}

declare class LoanPaymentsComponent {
    private loansService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoanPaymentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoanPaymentsComponent, "spa-loan-payments", never, {}, {}, never, never, false, never>;
}

declare class LoansModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LoansModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LoansModule, [typeof LoanProductsComponent, typeof LoansComponent, typeof LoanPaymentsComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LoansModule>;
}

declare class CustomersComponent {
    private dataService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomersComponent, "spa-customers", never, {}, {}, never, never, false, never>;
}

declare class SuppliersComponent {
    private dataService;
    private messageService;
    private authService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SuppliersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SuppliersComponent, "spa-suppliers", 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 GeneralModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<GeneralModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<GeneralModule, [typeof CustomersComponent, typeof SuppliersComponent, typeof TasksComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<GeneralModule>;
}

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 {
    private dataService;
    private messageService;
    private authService;
    tenantFormConfig: FormConfig;
    tenantsTableConfig: TableConfig;
    pageConfig: PageConfig;
    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 {
    private authService;
    formConfig: FormConfig;
    membersTableConfig: TableConfig;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<MembershipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MembershipComponent, "spa-membership", never, {}, {}, never, never, false, never>;
}

declare class PlansComponent {
    private authService;
    formConfig: FormConfig;
    plansTableConfig: TableConfig;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlansComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlansComponent, "spa-plans", never, {}, {}, never, never, false, never>;
}

declare class FeaturesComponent {
    private authService;
    formConfig: FormConfig;
    featuresTableConfig: TableConfig;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<FeaturesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FeaturesComponent, "spa-features", never, {}, {}, never, never, false, never>;
}

declare class PlanFeaturesComponent {
    private authService;
    formConfig: FormConfig;
    planFeaturesTableConfig: TableConfig;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlanFeaturesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlanFeaturesComponent, "spa-plan-features", never, {}, {}, never, never, false, never>;
}

declare class SubscriptionPageComponent implements OnInit {
    private httpService;
    private subscriptionService;
    private snackBar;
    currentSubscription: any;
    availablePlans: any[];
    loading: boolean;
    showConfirmation: boolean;
    selectedPlan: any;
    changingPlan: boolean;
    constructor(httpService: HttpService, subscriptionService: SubscriptionService, snackBar: MatSnackBar);
    ngOnInit(): void;
    loadCurrentSubscription(): void;
    loadAvailablePlans(): void;
    getStatusLabel(status: number): string;
    isPlanUpgrade(plan: any): boolean;
    confirmChangePlan(plan: any): void;
    cancelChange(): void;
    executePlanChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionPageComponent, "spa-subscription", never, {}, {}, never, never, false, never>;
}

declare class BillingPageComponent implements OnInit {
    private httpService;
    private snackBar;
    currentSubscription: any;
    invoices: any[];
    loading: boolean;
    showDetail: boolean;
    selectedInvoice: any;
    showPayment: boolean;
    paymentInvoice: any;
    paymentProcessing: boolean;
    paymentResult: any;
    constructor(httpService: HttpService, snackBar: MatSnackBar);
    ngOnInit(): void;
    loadCurrentSubscription(): void;
    loadInvoices(): void;
    getStatusLabel(status: number): string;
    getInvoiceStatusLabel(status: number): string;
    getPaymentStatusLabel(status: number): string;
    viewInvoiceDetail(invoice: any): void;
    closeDetail(): void;
    initiatePayment(invoice: any): void;
    processPayment(): void;
    closePayment(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BillingPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BillingPageComponent, "spa-billing", never, {}, {}, never, never, false, never>;
}

declare class TenancyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TenancyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TenancyModule, [typeof TenantSettingsComponent, typeof TenantsComponent, typeof BugComponent, typeof MembershipComponent, typeof PlansComponent, typeof FeaturesComponent, typeof PlanFeaturesComponent, typeof SubscriptionPageComponent, typeof BillingPageComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TenancyModule>;
}

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 NotificationsComponent implements OnInit {
    private dataService;
    private notificationsService;
    createDialog: DetailsDialogConfig;
    notificationsTableConfig: TableConfig;
    pageConfig: PageConfig;
    ngOnInit(): void;
    actionClicked(x: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationsComponent, "spa-notifications", never, {}, {}, never, never, false, never>;
}

declare class AppModelsComponent {
    private dataService;
    constructor(dataService: DataServiceLib);
    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 WorkflowModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<WorkflowModule, [typeof ApprovalsComponent, typeof ApprovalsConfigComponent, typeof NotificationsComponent, typeof AppModelsComponent, typeof NotificationsConfigComponent], [typeof i4.CommonModule, typeof SpaAdminModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<WorkflowModule>;
}

declare class OverviewDashboardComponent {
    summaryTiles: TileConfig;
    chartTiles: TileConfig;
    chartConfig: ChartConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverviewDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OverviewDashboardComponent, "spa-overview-dashboard", never, {}, {}, never, never, false, never>;
}

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

declare class FixedAssetsDashboardComponent {
    summaryTiles: TileConfig;
    chartTiles: TileConfig;
    chartConfig: ChartConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<FixedAssetsDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FixedAssetsDashboardComponent, "spa-fixed-assets-dashboard", never, {}, {}, never, never, false, never>;
}

declare class FixedAssetsComponent {
    private assetsService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<FixedAssetsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FixedAssetsComponent, "spa-fixed-assets", never, {}, {}, never, never, true, never>;
}

declare class FixedAssetCategoriesComponent {
    private assetsService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<FixedAssetCategoriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FixedAssetCategoriesComponent, "spa-fixed-asset-categories", never, {}, {}, never, never, true, never>;
}

declare class AssetsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AssetsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AssetsModule, [typeof FixedAssetsDashboardComponent], [typeof i4.CommonModule, typeof SpaAdminModule, typeof FixedAssetsComponent, typeof FixedAssetCategoriesComponent], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AssetsModule>;
}

declare class SpaHomeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaHomeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SpaHomeModule, never, [typeof SpaHomeRoutingModule, typeof AdminModule, typeof UserModule, typeof AccountingModule, typeof InventoryModule, typeof SalesModule, typeof PurchasingModule, typeof HRModule, typeof PayrollModule, typeof ManufacturingModule, typeof LoansModule, typeof GeneralModule, typeof TenancyModule, typeof WorkflowModule, typeof OverviewModule, typeof AssetsModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpaHomeModule>;
}

export { ALSQUARE_SVG_DARK, ALSQUARE_SVG_WHITE, Account, AccountsComponent as AccountingAccountsComponent, AggregatesComponent as AccountingAggregatesComponent, AgingComponent as AccountingAgingComponent, CurrenciesComponent as AccountingCurrenciesComponent, AccountingDashboardComponent, InvoicesComponent as AccountingInvoicesComponent, AccountingModule, ReportsComponent as AccountingReportsComponent, AccountingService, StatementComponent as AccountingStatementComponent, TransactionTypesComponent as AccountingTransactionTypesComponent, TransactionsComponent as AccountingTransactionsComponent, Action, ActivityComponent, AdminModule, AgentComponent, AgentService, AlertComponent, AlertConfig, AlertMessage, AnalyticsService, ApiResponse, AppConfig, AppModelsComponent, AssetStatus, AssetsService, AttachComponent, AuthService, BillingPageComponent, BrandsComponent, CacheConfig, CapItem, CapsulesComponent, CategoriesComponent, ChangePasswordComponent, ChangeUserPassword, ChartConfig, ChartsComponent, CheckComponent, ChipsComponent, Constants, Core, CreateAccountComponent, CustomersComponent, DataServiceLib, DateComponent, DatetimeComponent, DepartmentsComponent, DetailsDialog, DetailsDialogConfig, DetailsDialogProcessor, DetailsSource, DialogService, EmailComponent, EmployeesComponent, ExportService, FeatureDirective, FilterComponent, FormComponent, FormConfig, GeneralModule, GeneralService, GradesComponent, GroupsComponent, HRModule, HtmlComponent, HttpService, IndexModule, InventoryDashboardComponent, InventoryModule, InventoryService, InvitationsTableComponent, InvoiceDashboardComponent, InvoiceItemType, InvoiceStatus, LabelComponent, ListDialogComponent, ListDialogConfig, LoaderComponent, LoaderService, LoanPaymentsComponent, LoanProductsComponent, LoansComponent, LoansModule, LoansService, LogLevel, LogService, LoginComponent, LogsComponent, ManufacturingModule, MembershipComponent, MessageService, MoneyComponent, MovementType, NavMenuComponent, NotesComponent, NotesConfig, NotificationsService, NumberComponent, OnboardingComponent, OptionComponent, OverviewDashboardComponent, OverviewModule, PageComponent, PageConfig, PayrollDashboardComponent, PayrollModule, PlansComponent, PositionsComponent, PreferencesComponent, PrivacyDialogComponent, Profile, ProfileComponent, PurchaseStatus, PurchasingDashboardComponent, PurchasingModule, PushNotificationService, ReceiptStatus, RecoverAccountComponent, Register, Role, RoleAccess, RolesComponent, SalesDashboardComponent, SalesModule, SearchComponent, SearchConfig, SecurityConfig, SelectBitwiseComponent, SelectComponent, SelectLiteComponent, SelectMultiComponent, SettingsComponent, SignupComponent, SignupData, SpaAdminModule, SpaHomeModule, SpaIndexModule, SpaLandingComponent, SpaMatModule, SpaUserModule, StatusesComponent, Step, StepConfig, StepsComponent, StorageService, SubCategoriesComponent, SubscriptionPageComponent, SubscriptionService, SuppliersComponent, TabService, TableComponent, TableConfig, TabsComponent, TasksComponent, TenancyModule, TenantsComponent, TermsDialogComponent, TextAreaComponent, TextComponent, TextMaskComponent, TextMultiComponent, TextSingleComponent, TileConfig, TilesComponent, TinSpaComponent, TinSpaModule, TinSpaService, TitleActionsComponent, TransactionTiming, UnitOfMeasure, UpdateService, User, UserModule, UsersComponent, ViewerComponent, WelcomeComponent, WorkflowModule, authGuard, dialogOptions, featureGuard, loginConfig, messageDialog, viewerDialog };
export type { AgentMessage, AutoRefreshConfig, BitwiseOption, Button, CacheRule, CapsuleConfig, CardConfig, ChartItem, ChildField, CloseOptions, Color, Column, Confirm, ConversationSummary, Field, GroupConfig, GroupData, Icon, LandingBrandOverride, LandingColors, LandingConfig, LandingFeature, LandingFooterColumn, LandingFooterLink, LandingMetric, LandingModuleGroup, LandingModuleTile, LandingNavLink, LandingPricingPlan, LandingSecurityItem, LandingStep, LandingTestimonial, SearchField, SpaChartType, StatusConfig, StatusItem, StatusState, TableViewType, Tile, TileChartConfig, TileChartType, TileStyle, VisibleTab };