import * as i0 from '@angular/core';
import { InjectionToken, EnvironmentProviders, Injector, NgZone, OnInit, AfterViewInit, OnDestroy, SimpleChanges, EventEmitter, QueryList, TemplateRef, ViewContainerRef, OnChanges, ChangeDetectorRef, ElementRef, DoCheck, PipeTransform, AfterViewChecked } 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 i72 from '@angular/common/http';
import { HttpClient, HttpContext, HttpErrorResponse, HttpContextToken } from '@angular/common/http';
import * as i7$1 from '@abacritt/angularx-social-login';
import { SocialUser, SocialAuthService, SocialAuthServiceConfig } from '@abacritt/angularx-social-login';
import * as i4 from '@angular/common';
import { PlatformLocation, LocationStrategy, DecimalPipe, Location } from '@angular/common';
import { IPublicClientApplication } from '@azure/msal-browser';
import { BreakpointObserver } from '@angular/cdk/layout';
import { DomSanitizer, SafeResourceUrl, SafeHtml } from '@angular/platform-browser';
import { SwUpdate } from '@angular/service-worker';
import * as _angular_material_paginator from '@angular/material/paginator';
import { MatPaginator, PageEvent } from '@angular/material/paginator';
import * as tin_spa from 'tin-spa';
import * as i3 from '@angular/forms';
import { FormControl, ControlValueAccessor } from '@angular/forms';
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 * as i74 from '@kolkov/angular-editor';
import { AngularEditorConfig } from '@kolkov/angular-editor';
import * as i76 from '@angular/cdk/drag-drop';
import { CdkDragEnter, CdkDragExit, CdkDragDrop } from '@angular/cdk/drag-drop';
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 i75 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;
    errorWithSubject(subject: string, details: string, reference?: string): void;
    warning(details: string, subject?: string): void;
    success(details: string, subject?: string): void;
    confirm(msg: string, confirmLabel?: string, cancelLabel?: string, destructive?: boolean): 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,
    WrittenOff = 5
}
declare enum CreditNoteStatus {
    Draft = 0,
    Submitted = 1,
    Applied = 2,
    Discarded = 3
}
declare enum FiscalPeriodStatus {
    Open = 0,
    Closed = 1,
    Locked = 2
}
declare enum QuoteStatus {
    Draft = 0,
    Sent = 1,
    Accepted = 2,
    Rejected = 3,
    Expired = 4,
    Converted = 5
}
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, context?: HttpContext): 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, context?: HttpContext): Observable<Object>;
    Get(service: string, context?: HttpContext): Observable<any>;
    Get_Raw(url: string): Observable<any>;
    Error(error: HttpErrorResponse): "Unauthorized" | "Connection failed";
    private withContext;
    private httpOptions_Legacy;
    private httpOptions_Files;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HttpService>;
}

interface TinSpaMsalConfig {
    clientId: string;
    authority: string;
    redirectUri: string;
}
interface TinSpaTableDefaults {
    /** Default for TableConfig.realTime. */
    realTime?: boolean;
    /** Default for TableConfig.offline. `true` is shorthand for { enabled: true }. */
    offline?: any;
    /** Default for TableConfig.pagination. `true` is shorthand for the library's default page size. */
    pagination?: any;
}
interface TinSpaRuntimeConfig {
    /** Use path routing (/home) instead of hash routing (/#/home). Default false (hash). */
    pathRouting: boolean;
    /** Enable real-time (SignalR) features. Default false (disabled). */
    realTime: boolean;
    /** Enable offline capability (TinSync: read cache + outbox + sync tray + connectivity indicator). Default false —
     * apps that never use offline tables should leave this off so none of the offline machinery ever runs for them. */
    offline?: boolean;
    /** Enable Microsoft SSO (MSAL). Only activates in a secure context (HTTPS/localhost). Default false. */
    microsoftAuth: boolean;
    /** MSAL credentials — required only when microsoftAuth is used. */
    msal?: TinSpaMsalConfig;
    /** Added: app-wide defaults applied to every spa-table that does not state its own value. */
    tableDefaults?: TinSpaTableDefaults;
}
declare const TIN_SPA_RUNTIME_CONFIG: InjectionToken<TinSpaRuntimeConfig>;
declare function tinSpaLocationStrategyFactory(platformLocation: PlatformLocation, baseHref: string, config: TinSpaRuntimeConfig): LocationStrategy;
/** Overlays assets/appsettings.json values (when the app loaded one) onto the code-declared config. */
declare function tinSpaRuntimeConfigFactory(codeConfig: TinSpaRuntimeConfig): TinSpaRuntimeConfig;
declare function tinSpaMsalInstanceFactory(config: TinSpaRuntimeConfig): IPublicClientApplication;
/**
 * Wires up tin-spa runtime behaviours (routing strategy, real-time, MSAL) from a single config.
 * Add the result to your AppModule (or bootstrap) providers.
 */
declare function provideTinSpaRuntime(config: Partial<TinSpaRuntimeConfig>): EnvironmentProviders;

interface EntityChangeEvent {
    entityName: string;
    data: any;
}
interface NotificationEvent {
    message: string;
    category: string;
    type: string;
    sender: string;
}
declare class SignalRService {
    private runtimeConfig;
    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;
    constructor(runtimeConfig: TinSpaRuntimeConfig | null);
    /** Effective real-time enablement: legacy E2E kill-switch wins, else the configured runtime flag. */
    private realTimeEnabled;
    /** Public: whether SignalR is the authoritative connection signal (used by OfflineService to pick SignalR vs ping). */
    get isRealTime(): boolean;
    startConnection(hubUrl: string, token: string): void;
    updateToken(token: string): void;
    private forcingReconnect;
    /**
     * Reconnect the hub NOW if real-time is enabled and the connection isn't up. Driven by OfflineService
     * connectivity (the ping heartbeat) so the real-time indicator recovers on the SAME signal that flips the
     * offline indicator back to online — they stay married "hand in glove". Handles both states the built-in
     * auto-reconnect leaves us in: Reconnecting (stuck waiting on a long backoff interval → interrupt and connect
     * now) and Disconnected (auto-reconnect exhausted after a long outage → start fresh). Safe to call repeatedly.
     */
    reconnectIfNeeded(): void;
    stopConnection(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalRService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignalRService>;
}

type RefreshResult = 'success' | 'rejected' | 'network';
declare class AuthService {
    private _route;
    private socialService;
    private storage;
    router: Router;
    private httpService;
    private messageService;
    private logService;
    private signalRService;
    private injector;
    private googleAuthInitialized;
    private refreshPromise;
    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, injector: Injector);
    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 scheduleRetry;
    private initVisibilityRefresh;
    hasValidSession(): boolean;
    hasRefreshToken(): boolean;
    tryRestoreSession(): Promise<boolean>;
    silentRefresh(): Promise<RefreshResult>;
    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;
    refreshOnCloseIfActioned?: boolean;
    causeTableRefresh?: boolean;
    closeOptions?: CloseOptions;
    initAction?: Action;
    hideTablesInCreateMode?: boolean;
    allowUserKeepOpen?: boolean;
    keepOpenBehavior?: 'reset' | 'edit';
    nestingLevel?: number;
    localMode?: boolean;
    quietLoading?: boolean;
    drillIn?: boolean;
}
declare class Action {
    method?: 'get' | 'post';
    url: string;
    params?: any[];
    successMessage?: string;
    isFormData?: boolean;
    skipCache?: boolean;
    cacheDurationMinutes?: number;
    silent?: boolean;
}
interface CacheRule {
    pattern: string;
    durationMinutes: number;
}
declare class CacheConfig {
    rules: CacheRule[];
    addRule(pattern: string, durationMinutes: number): void;
    getDuration(url: string): number | null;
    private matchesPattern;
}
type OfflineOpStatus = 'pending' | 'syncing' | 'synced' | 'failed' | 'conflict' | 'stale';
interface OfflineConfig {
    enabled: boolean;
    cacheRows?: number;
    cacheLookups?: boolean | string[];
    lookupMaxAgeHours?: number;
    queue?: {
        create?: boolean;
        edit?: boolean;
        delete?: boolean;
    };
    maxQueueAgeHours?: number;
    readOnly?: boolean;
}
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;
}
type VisibilityValue = boolean | ((value: any) => 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' | 'editor';
    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?: VisibilityValue;
    visible?: VisibilityValue;
    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;
    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;
    collapseOnView?: boolean;
    maxHeight?: string;
    editorConfig?: any;
    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;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
    states: StatusState[];
}
interface StatusConfig {
    items: StatusItem[];
    sticky?: boolean;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
declare class AlertMessage {
    type?: 'success' | 'info' | 'warn' | 'critical';
    message?: string;
    messageField?: string;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
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;
    confirmLabel?: string;
    cancelLabel?: string;
    destructive?: boolean;
}
interface Button {
    name: string;
    visible?: VisibilityValue;
    hidden?: VisibilityValue;
    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)>;
    capability?: CapItem | string;
    requiredAccess?: RoleAccess;
}
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 | ((data: any) => string);
    format?: 'money' | 'number';
    selectedTile?: string;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
    info?: string;
    prefix?: string;
    suffix?: string;
    action?: Action;
    style?: TileStyle;
    icon?: string;
    footer?: string;
    footerIcon?: string;
    badge?: string;
    badgeColor?: string;
    chart?: TileChartConfig;
    filter?: (row: any) => boolean;
    data?: any;
}
declare class TileConfig {
    tiles: Tile[];
    loadAction?: Action;
    loadInit?: boolean;
    clickable?: boolean;
    headerPosition?: 'top' | 'middle';
    quietLoading?: boolean;
    layout?: 'auto' | 'wrap' | 'carousel';
    minTileWidth?: number;
    maxPerRow?: number;
    hideValueOnMobile?: boolean;
}
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?: VisibilityValue;
    visible?: VisibilityValue;
    options?: any;
}
declare class ChartConfig {
    charts: ChartItem[];
    loadAction?: Action;
    loadInit?: boolean;
    columns?: number;
}
declare class Step {
    name: string;
    value?: any;
    icon?: string;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
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' | 'monogram';
    alias?: string;
    keyField?: string;
    maxLength?: number;
    icon?: Icon;
    color?: Color;
    colors?: Color[];
    icons?: Icon[];
    options?: any[];
    optionDisplay?: string;
    optionValue?: string;
    detailsConfig?: DetailsDialogConfig;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
interface InlineEditConfig {
    fields?: string[];
}
interface CreateTabConfig {
    navigationProperty: string;
}
declare class PaginationConfig {
    pageSize?: number;
}
type TableViewType = 'table' | 'capsule' | 'card' | 'grouped';
declare class TableConfig {
    viewType?: TableViewType;
    capsuleConfig?: CapsuleConfig;
    cardConfig?: CardConfig;
    groupConfig?: GroupConfig;
    tabTitle?: string;
    tabTemplate?: any;
    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;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
    download?: {
        columns: string[];
        fileName?: string;
        hidden?: VisibilityValue;
        visible?: VisibilityValue;
    };
    upload?: {
        action: Action;
        messages?: AlertMessage[];
        hidden?: VisibilityValue;
        visible?: VisibilityValue;
    };
    import?: ImportConfig;
    realTime?: boolean;
    entityName?: string;
    offline?: OfflineConfig | boolean;
    pagination?: PaginationConfig;
    allowUserKeepOpen?: boolean;
    keepOpenBehavior?: 'reset' | 'edit';
    inlineEdit?: boolean | InlineEditConfig;
    createConfig?: CreateTabConfig;
    quietLoading?: boolean;
    sectionConfig?: TableSectionConfig;
    hideColumnHeaders?: boolean;
    hideSinglePagePaginator?: boolean;
}
interface TableSectionChip {
    text?: string;
    color?: string;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
interface TableSectionConfig {
    title: string;
    icon?: string;
    caption?: string;
    showCount?: boolean;
    chips?: TableSectionChip[];
    buttons?: Button[];
    collapsible?: boolean;
    collapsed?: boolean;
    hideWhenEmpty?: boolean;
}
declare class PageConfig {
    title?: string;
    tableConfig?: TableConfig;
    searchTableConfig?: TableConfig;
    titleActions?: Field[];
}
interface ImportConfig {
    entity: string;
    title?: string;
    securityConfig?: SecurityConfig;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
    onComplete?: (summary: any) => void;
}
declare class ApiResponse {
    success: boolean;
    message: string;
    data: any;
    total?: number;
    reason?: string;
    rowVersion?: string;
}
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";
    static readonly LAST_ROUTE = "lr";
}
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;
    moduleKey: string;
}
declare class BottomTab {
    constructor();
    name: string;
    display: string;
    icon: string;
    link: string;
    badge?: 'notifications' | '';
    moduleKey?: 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' | 'top-modern';
    docsBaseUrl: string;
    loginStyle: string;
    dialogStyle: string;
    loginTitle: string;
    loginMessage: string;
    termsUrl: string;
    privacyUrl: string;
    siteUrl: string;
    navWidth: string;
    navColor: string;
    navImage: string;
    keepSignedIn: boolean;
    resumeLastRoute: boolean;
    quietLoading: boolean;
    namedDestructiveActions: boolean;
    setupConfig: SetupConfig;
    dayBookConfig: DayBookConfig;
    appConfigurationConfig: AppConfigurationConfig;
    bottomTabs: BottomTab[];
}
interface SetupStepAction {
    button?: Button;
    link?: string;
    linkDisplay?: string;
    import?: ImportConfig;
    roleTemplates?: boolean;
    seed?: boolean;
}
interface SetupConfig {
    enabled: boolean;
    title?: string;
    stepActions: {
        [key: string]: SetupStepAction;
    };
    demoData?: boolean;
}
interface SetupStep {
    key: string;
    title: string;
    description: string;
    category: string;
    order: number;
    required: boolean;
    target: number;
    current: number;
    complete: boolean;
    link: string;
    icon: string;
    module?: string;
}
interface SetupStatus {
    steps: SetupStep[];
    completed: number;
    total: number;
    percent: number;
    pending: number;
    modules?: SetupModule$1[];
}
interface SetupModule$1 {
    key: string;
    title: string;
    description: string;
    icon: string;
    group?: string;
    order: number;
    core: boolean;
    enabled: boolean;
}
interface SetupRoleTemplate {
    key: string;
    name: string;
    description: string;
    icon: string;
    module?: string;
    exists: boolean;
}
interface SetupSeedOffer {
    key: string;
    stepKey: string;
    name: string;
    description: string;
    effect: string;
    sampleNotice: string;
    icon: string;
    module?: string;
    includes: string[];
    wouldCreate: number;
    existing: number;
    applied: boolean;
}
interface SetupPreset {
    key: string;
    name: string;
    description: string;
    effect: string;
    icon: string;
    group: string;
    module?: string;
    modelName: string;
    preferredRoleKeys: string[];
    exists: boolean;
    roleID?: number;
}
interface SetupNotificationPreset extends SetupPreset {
    operationType: number;
}
interface SetupApprovalPreset extends SetupPreset {
    createApprovalRequired: boolean;
    editApprovalRequired: boolean;
    deleteApprovalRequired: boolean;
    levelName: string;
}
interface SetupPresetSelection {
    key: string;
    roleID: number;
}
interface SetupPresetRole {
    name: string;
    value: number;
}
interface SetupPresetCatalog<T> {
    presets: T[];
    roles: SetupPresetRole[];
}
interface DayBookLane {
    key: string;
    label: string;
    icon?: string;
    valueField?: string | ((book: any) => number);
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
interface DayBookStage {
    key: string;
    lane?: string;
    label: string;
    icon?: string;
    countField: string;
    valueField?: string | ((book: any) => number);
    hint?: string;
    alert?: VisibilityValue;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
interface DayBookSection {
    key: string;
    lane?: string;
    listField: string;
    collapsed?: boolean;
    tableConfig?: TableConfig;
    label?: string;
    icon?: string;
    caption?: string | ((book: any) => string);
    tone?: 'alert' | 'quiet';
    pageSize?: number;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
interface DayBookStageTiles {
    layout?: 'wrap' | 'carousel';
    minTileWidth?: number;
    maxPerRow?: number;
}
interface DayBookConfig {
    title?: string;
    subtitle?: string;
    loadAction: Action;
    lanes?: DayBookLane[];
    stages: DayBookStage[];
    sections: DayBookSection[];
    actions?: Button[];
    stageTiles?: DayBookStageTiles;
    booksFromField?: string;
    owedField?: string | ((book: any) => number);
    allClearMessage?: string;
    loadingMessage?: string;
    pageSize?: number;
    groupLanes?: boolean;
    expandedGroups?: number;
}
interface AppConfigSection {
    key: string;
    title: string;
    icon?: string;
    hint?: string;
    collapsible?: boolean;
    collapsed?: boolean;
    toggleField?: string;
    fields: Field[];
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
interface AppConfigurationConfig {
    title?: string;
    loadAction?: Action;
    saveAction?: Action;
    security?: SecurityConfig;
    sections: AppConfigSection[];
}
interface ChecklistAction {
    type?: 'create' | 'import' | 'link' | 'custom';
    display?: string;
    icon?: string;
    primary?: boolean;
    disabled?: (item: ChecklistItem) => boolean;
    onClick: (item: ChecklistItem) => void;
}
interface ChecklistItem {
    key: string;
    title: string;
    description?: string;
    complete?: boolean;
    optional?: boolean;
    progressText?: string;
    actions?: ChecklistAction[];
    data?: any;
    hidden?: VisibilityValue;
    visible?: VisibilityValue;
}
interface ChecklistConfig {
    items: ChecklistItem[];
    expandedKey?: string;
    itemTemplate?: any;
}

type ApiErrorKind = 'network' | 'timeout' | 'ratelimited' | 'badrequest' | 'forbidden' | 'notfound' | 'server' | 'unavailable' | 'unknown' | 'appfailure' | 'appfailure-submit';
type AppFailureClass = 'opaque' | 'business';
type AppFailureContext = 'submit' | 'load' | 'action';
interface ApiErrorInfo {
    kind: ApiErrorKind;
    title: string;
    message: string;
    reference?: string;
}
declare class ApiErrorService {
    private messageService;
    private lastShownAt;
    /** How long a given kind stays suppressed after being shown. The user described "the same 10 seconds or so". */
    suppressWindowMs: number;
    submitSuppressWindowMs: number;
    constructor(messageService: MessageService);
    classify(error: HttpErrorResponse): ApiErrorInfo;
    private retryAfterText;
    retryAfterSeconds(error: HttpErrorResponse): number;
    /** True when this kind was already shown inside the suppression window — i.e. the user has already been told. */
    private isSuppressed;
    present(error: HttpErrorResponse): ApiErrorInfo;
    private opaqueMarkers;
    classifyMessage(message: string | null | undefined): AppFailureClass;
    extractReference(message: string | null | undefined): string | null;
    stripReference(message: string | null | undefined): string;
    presentAppFailure(response: {
        message?: string;
    } | null | undefined, context?: AppFailureContext, url?: string): AppFailureClass;
    /** Clears suppression so the next failure speaks up again — call after a successful request or reconnect. */
    reset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiErrorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiErrorService>;
}

interface ResolvedOfflineConfig {
    enabled: boolean;
    cacheRows: number;
    cacheLookups: boolean | string[];
    lookupMaxAgeHours: number;
    queue: {
        create: boolean;
        edit: boolean;
        delete: boolean;
    };
    maxQueueAgeHours: number;
    readOnly: boolean;
}
interface OfflineEntry {
    entity: string;
    entityName: string;
    idField: string;
    config: ResolvedOfflineConfig;
}
interface OutboxOp {
    seq?: number;
    opId: string;
    entity: string;
    entityName: string;
    url: string;
    opAction: 'create' | 'edit' | 'delete';
    payload: any;
    clientRef?: string;
    targetId?: any;
    targetClientRef?: string;
    refMap?: {
        [field: string]: string;
    };
    status: OfflineOpStatus;
    attempts: number;
    lastError?: string;
    serverRecord?: any;
    maxAgeHours: number;
    userId: string;
    enqueuedAt: number;
    syncedAt?: number;
}
declare class OfflineService {
    private httpService;
    private authService;
    private storage;
    private messageService;
    private apiErrorService;
    private signalR;
    private zone;
    private runtimeConfig;
    online$: BehaviorSubject<boolean>;
    drained$: Subject<string[]>;
    private db;
    private reads;
    private outbox;
    private meta;
    private entries;
    private readUrls;
    private readPrefixes;
    registered$: BehaviorSubject<boolean>;
    private connectivityStarted;
    private syncStarted;
    private draining;
    private backoffTimer;
    private serverRetryAfterMs;
    private retryNotBefore;
    private periodicTimer;
    private recoveryTimer;
    constructor(httpService: HttpService, authService: AuthService, storage: StorageService, messageService: MessageService, apiErrorService: ApiErrorService, // Added: shares ONE Retry-After parser with the dialog/toast path
    signalR: SignalRService, zone: NgZone, runtimeConfig: TinSpaRuntimeConfig | null);
    /** App-level gate: offline capability only runs when the app opts in via provideTinSpaRuntime({ offline: true }).
     *  When off, register()/ensureConnectivity() no-op, so a consumer that never uses offline runs none of this. */
    get enabled(): boolean;
    get hasAny(): boolean;
    get online(): boolean;
    outboxView$(): Observable<any[]>;
    private summarize;
    private statusLabel;
    register(config: TableConfig): OfflineEntry | null;
    private registerReads;
    private addReadPrefix;
    private addReadUrl;
    private registerLookups;
    private registerButtonLookups;
    cacheKey(url: string): string;
    isPagedRead(url: string): boolean;
    matchRead(url: string): OfflineEntry | null;
    matchMutation(url: string): OfflineEntry | null;
    suppressesUrl(absoluteUrl: string): boolean;
    private resolveConfig;
    pendingCount(): Promise<number>;
    clearCacheKeepOutbox(): Promise<void>;
    deleteLocalData(): Promise<void>;
    private ensureOpen;
    putRead(url: string, entity: string, data: any, maxRows: number): Promise<any>;
    private static readonly DYNAMIC_READS_PER_PREFIX;
    private pruneDynamicReads;
    private getRead;
    handleOfflineRead(action: Action, entry: OfflineEntry, networkCall: () => Observable<ApiResponse>): Observable<ApiResponse>;
    private serveCachedRead;
    enqueueOffline(action: Action, data: any, entry: OfflineEntry): Observable<ApiResponse>;
    private enqueueMutation;
    pendingOpsFor$(entity: string): Observable<OutboxOp[]>;
    activeOps$(): Observable<OutboxOp[]>;
    private pendingCreates;
    private hasPending;
    ensureConnectivity(): void;
    reportNetworkFailure(): void;
    private verify;
    private setOnline;
    private setOffline;
    private startRecoveryPolling;
    private stopRecoveryPolling;
    private startSync;
    resumeQueue(): Promise<void>;
    drain(auto?: boolean): Promise<void>;
    private drainLoop;
    private sendOp;
    private finishOp;
    private nextAutoOp;
    private resetOrphans;
    private cascadeFailure;
    private scheduleBackoff;
    retryOp(opId: string): Promise<void>;
    discardOp(opId: string): Promise<any>;
    resolveConflict(opId: string, choice: 'keepServer' | 'keepMine'): Promise<void>;
    private getOp;
    private parseAction;
    private hash;
    private sanitize;
    static ɵfac: i0.ɵɵFactoryDeclaration<OfflineService, [null, null, null, null, null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OfflineService>;
}

declare class DataServiceLib {
    private httpService;
    router: Router;
    private route;
    private authService;
    private offline;
    constructor(httpService: HttpService, router: Router, route: ActivatedRoute, authService: AuthService, offline: OfflineService);
    appConfig: AppConfig;
    private appConfigSource;
    appConfigObserv: Observable<AppConfig>;
    UpdateAppConfig(config: AppConfig): void;
    get modernDialogs(): boolean;
    get namedDestructiveActions(): boolean;
    get dialogPanelClass(): string[];
    cacheConfig: CacheConfig;
    configMonthOptions: any[];
    configDayOptions: any[];
    configSectionFinancial: AppConfigSection;
    configBaseSections: AppConfigSection[];
    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;
    capSuppliers: CapItem;
    capTasks: CapItem;
    capHR: CapItem;
    capEmployees: CapItem;
    capDepartments: CapItem;
    capPositions: CapItem;
    capUnlock: CapItem;
    capGrades: CapItem;
    capPayroll: CapItem;
    capSalaryStructures: CapItem;
    capStatutoryDeductions: CapItem;
    capPayrollRuns: CapItem;
    capCommissionConfigs: CapItem;
    capCommissionEntries: CapItem;
    capCommissionStatement: 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;
    capBudgets: CapItem;
    capBudgetVsActual: CapItem;
    capAging: CapItem;
    capTaxRates: CapItem;
    capStandingOrders: CapItem;
    capFixedAssetsModule: CapItem;
    capFixedAssetsDashboard: CapItem;
    capFixedAssets: CapItem;
    capFixedAssetCategories: CapItem;
    capCurrencies: CapItem;
    capTransactionTypes: CapItem;
    capTransactions: CapItem;
    capAccountingInvoices: CapItem;
    capCreditNotes: CapItem;
    capVatReturn: CapItem;
    capFiscalPeriods: CapItem;
    capReceipts: CapItem;
    capBankReconciliation: CapItem;
    capRevenueSchedules: CapItem;
    capQuotes: 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;
    capSupplierPurchaseOrders: 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;
    unlockDepartmentButton: Button;
    departmentDetailsConfig: DetailsDialogConfig;
    positionFormConfig: FormConfig;
    editPositionButton: Button;
    unlockPositionButton: 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;
    customerCreateWithContactsButton: Button;
    customersTableConfig: TableConfig;
    customerPurchaseOrderFormConfig: FormConfig;
    customerPurchaseOrdersTableConfig: TableConfig;
    supplierFormConfig: FormConfig;
    supplierCreateButton: Button;
    supplierEditButton: Button;
    supplierDetailsConfig: DetailsDialogConfig;
    supplierCreateWithContactsButton: Button;
    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, options?: {
        silent?: boolean;
    }): 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 viewerDialog implements OnInit {
    private httpService;
    private dataServiceLib;
    private sanitizer;
    data: any;
    constructor(httpService: HttpService, dataServiceLib: DataServiceLib, sanitizer: DomSanitizer, data: any);
    ngOnInit(): void;
    isProcessing: boolean;
    fullPath: string;
    fileNames: any[];
    fileName: string;
    currIndex: number;
    currentFileUrl: string;
    previous(): void;
    next(): void;
    imageDoc: boolean;
    safeFileUrl: SafeResourceUrl;
    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 DialogService {
    private dialog;
    private breakpointObserver;
    private defaultDialogComponent;
    private importDialogComponent;
    private dataService;
    private smallScreen;
    constructor(dialog: MatDialog, breakpointObserver: BreakpointObserver, defaultDialogComponent: any, // Changed: Inject default dialog component
    importDialogComponent: any, // Added: import wizard by token, see dialog-component.token.ts
    dataService: DataServiceLib);
    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>;
    };
    openViewerDialog(fileName: string, fileNames: string[] | string, path: string): MatDialogRef<viewerDialog>;
    private get modernPanelClass();
    openImportDialog(config: ImportConfig): Observable<any>;
    openPrintDialog(htmlContent: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, [null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

declare class AccountingService {
    private dataService;
    private inventoryService;
    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;
    invoiceWriteOffButton: 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;
    customerStatementTileConfig: TileConfig;
    supplierStatementTileConfig: TileConfig;
    statementLinesTableConfig: 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;
    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;
    generalLedgerTableConfig: TableConfig;
    creditNoteItemsFormConfig: FormConfig;
    creditNoteItemEditButton: Button;
    creditNoteItemsTableConfig: TableConfig;
    creditNoteFormConfig: FormConfig;
    creditNoteSubmitButton: Button;
    creditNoteApplyButton: Button;
    creditNoteReturnButton: Button;
    creditNoteDiscardButton: Button;
    creditNoteEditButton: Button;
    creditNoteDetailsDialogConfig: DetailsDialogConfig;
    creditNoteViewButton: Button;
    creditNoteCreateButton: Button;
    invoiceCreditNoteButton: Button;
    creditNotesTableConfig: TableConfig;
    receiptAllocateButton: Button;
    receiptPdfButton: Button;
    customerReceiptsTableConfig: TableConfig;
    quoteItemsFormConfig: FormConfig;
    quoteItemEditButton: Button;
    quoteItemsTableConfig: TableConfig;
    quoteFormConfig: FormConfig;
    quoteSendButton: Button;
    quoteAcceptButton: Button;
    quoteRejectButton: Button;
    quoteConvertButton: Button;
    quoteEditButton: Button;
    quoteDownloadButton: Button;
    quoteDetailsDialogConfig: DetailsDialogConfig;
    quoteViewButton: Button;
    quoteCreateButton: Button;
    quotesTableConfig: TableConfig;
    revenueSchedulesTableConfig: TableConfig;
    cashFlowTableConfig: TableConfig;
    equityChangesTableConfig: TableConfig;
    bankReconcileButton: Button;
    bankStatementImportsTableConfig: TableConfig;
    fiscalPeriodFormConfig: FormConfig;
    fiscalPeriodCloseButton: Button;
    fiscalPeriodReopenButton: Button;
    fiscalPeriodLockButton: Button;
    fiscalPeriodsTableConfig: TableConfig;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AccountingService>;
}

declare class AssetsService {
    private dataService;
    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 {
    private dataService;
    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 SalesService {
    private dataService;
    private inventoryService;
    private accountingService;
    salesOrderItemFormConfig: FormConfig;
    salesOrderItemsTableConfig: TableConfig;
    salesOrderFormConfig: FormConfig;
    salesOrderEditButton: Button;
    salesOrderConfirmButton: Button;
    salesOrderDeliverButton: Button;
    salesOrderDetailsConfig: DetailsDialogConfig;
    salesOrderViewButton: Button;
    salesOrdersTableConfig: TableConfig;
    saleItemFormConfig: FormConfig;
    saleItemsTableConfig: TableConfig;
    saleFormConfig: FormConfig;
    saleStepConfig: StepConfig;
    salePaymentFormConfig: FormConfig;
    salePaymentCreateButton: Button;
    salePaymentDetailsConfig: DetailsDialogConfig;
    saleRecordPaymentButton: Button;
    salePaymentsTableConfig: TableConfig;
    saleDetailsConfig: DetailsDialogConfig;
    saleViewButton: Button;
    saleCreateButton: Button;
    saleVoidButton: Button;
    salesTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SalesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SalesService>;
}

declare class PurchasingService {
    private dataService;
    private inventoryService;
    private accountingService;
    constructor();
    private paymentTypeOptions;
    supplierPurchaseOrderItemFormConfig: FormConfig;
    supplierPurchaseOrderItemsTableConfig: TableConfig;
    supplierPurchaseOrderFormConfig: FormConfig;
    receiveGoodsFormConfig: FormConfig;
    receiveGoodsDetailsConfig: DetailsDialogConfig;
    supplierPurchaseOrderEditButton: Button;
    supplierPurchaseOrderConfirmButton: Button;
    supplierPurchaseOrderCancelButton: Button;
    supplierPurchaseOrderReceiveButton: Button;
    supplierPurchaseOrderDetailsConfig: DetailsDialogConfig;
    supplierPurchaseOrderViewButton: Button;
    supplierPurchaseOrdersTableConfig: 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 ProductionService {
    private dataService;
    private inventoryService;
    recipeItemFormConfig: FormConfig;
    recipeItemsTableConfig: TableConfig;
    recipeFormConfig: FormConfig;
    recipeDetailsConfig: DetailsDialogConfig;
    recipeViewButton: Button;
    recipeCreateButton: Button;
    recipesTableConfig: TableConfig;
    orderItemFormConfig: FormConfig;
    orderItemsTableConfig: TableConfig;
    orderFormConfig: FormConfig;
    orderDetailsConfig: DetailsDialogConfig;
    orderViewButton: Button;
    orderCreateButton: Button;
    ordersTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProductionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProductionService>;
}

declare class PayrollService {
    private dataService;
    salaryComponentFormConfig: FormConfig;
    salaryComponentsTableConfig: TableConfig;
    editSalaryStructureButton: Button;
    salaryStructureFormConfig: FormConfig;
    salaryStructuresTableConfig: TableConfig;
    statutoryDeductionBandFormConfig: FormConfig;
    statutoryDeductionBandsTableConfig: TableConfig;
    editStatutoryDeductionTypeButton: Button;
    statutoryDeductionTypeFormConfig: FormConfig;
    statutoryDeductionTypesTableConfig: TableConfig;
    payslipLineFormConfig: FormConfig;
    payslipLinesTableConfig: TableConfig;
    payslipFormConfig: FormConfig;
    payslipsChildTableConfig: TableConfig;
    employeePayslipHistoryTableConfig: TableConfig;
    employeeSalaryComponentFormConfig: FormConfig;
    employeeSalaryComponentsTableConfig: TableConfig;
    editCommissionConfigButton: Button;
    commissionConfigFormConfig: FormConfig;
    commissionConfigTierFormConfig: FormConfig;
    commissionConfigTiersTableConfig: TableConfig;
    commissionConfigDetailsConfig: DetailsDialogConfig;
    viewCommissionConfigButton: Button;
    createCommissionConfigButton: Button;
    commissionConfigsTableConfig: TableConfig;
    employeeCommissionConfigsTableConfig: TableConfig;
    approveCommissionEntryButton: Button;
    returnCommissionEntryButton: Button;
    commissionEntryFormConfig: FormConfig;
    commissionEntryLinesTableConfig: TableConfig;
    commissionEntryDetailsConfig: DetailsDialogConfig;
    viewCommissionEntryButton: Button;
    commissionEntriesTableConfig: TableConfig;
    employeeCommissionEntriesTableConfig: TableConfig;
    salaryAdvanceFormConfig: FormConfig;
    salaryAdvancesTableConfig: TableConfig;
    employeeSalaryAdvancesTableConfig: TableConfig;
    overtimeEntryFormConfig: FormConfig;
    overtimeEntriesTableConfig: TableConfig;
    employeeOvertimeHistoryTableConfig: TableConfig;
    submitPayrollButton: Button;
    postPayrollButton: Button;
    markPaidButton: Button;
    recalculatePayrollButton: Button;
    payrollRunFormConfig: FormConfig;
    payrollRunsTableConfig: TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PayrollService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PayrollService>;
}

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;
    private static readonly DESTRUCTIVE_ACTIONS;
    getConfirmOptions(button: Button, row: any, fallbackMessage?: string, allowNamedDestructive?: boolean): {
        message: string;
        confirmLabel?: string;
        cancelLabel?: string;
        destructive: boolean;
    };
    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[];
    hasCapability(button: Button): boolean;
    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;
    private derivedCountActions;
    getCountAction(config: TableConfig): Action | undefined;
    resolveCountUrl(config: TableConfig, parentData?: any): string;
    initializeTabs(tableConfigs: TableConfig[], parentData?: any, eagerIndex?: number, fetchCounts?: boolean): {
        tabCounts: {
            [index: number]: number;
        };
        tableReloads: {
            [index: number]: Subject<boolean>;
        };
    };
    gridPublishesOwnTotal(config: TableConfig, index: number, eagerIndex?: number): boolean;
    private isQuiet;
    loadTabCount(tabIndex: number, countAction: any, tabCounts: {
        [index: number]: number;
    }, parentData?: any, // Changed: Accept parentData for URL placeholder replacement
    quiet?: boolean, // Added: Quiet Loading — fetch the badge silently (optional, so existing external callers are unchanged)
    onSettled?: (succeeded: boolean) => void): void;
    refreshTabCount(index: number, tableConfigs: TableConfig[], tabCounts: {
        [index: number]: number;
    }, parentData?: any, // Changed: Accept parentData for URL placeholder replacement
    onSettled?: (succeeded: boolean) => void): 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;
    pending?: boolean;
    divider?: boolean;
}
interface ConversationSummary {
    conversationID: number;
    title: string;
    appName: string;
    createdDate: Date;
    lastActivityDate?: Date;
}
interface AgentSessionInfo {
    sessionType?: string;
    modelName?: string;
    missingFields?: string[];
    conversationID?: number;
    newConversation?: boolean;
    notice?: string;
}
declare class AgentService {
    private dataService;
    private signalRService;
    private apiErrorService;
    private messages;
    private conversations;
    private typing;
    private isOpen;
    private currentConversationId;
    private greeting;
    private suggestedQuestions;
    private sessionInfo;
    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[]>;
    sessionInfo$: rxjs.Observable<AgentSessionInfo>;
    constructor(dataService: DataServiceLib, signalRService: SignalRService, apiErrorService: ApiErrorService);
    get appName(): string;
    get agentName(): string;
    private initListeners;
    loadConfig(): void;
    loadConversations(): void;
    loadMessages(conversationId: number): void;
    sendMessage(text: string): void;
    private addAssistantMessage;
    private applySessionInfo;
    transcribeOnly(audio: Blob, fileName: string): rxjs.Observable<any>;
    voiceTurn(audio: Blob, fileName: string): rxjs.Observable<any>;
    appendSpokenMessage(text: string): void;
    sendComposed(photo: Blob | null, photoName: string, audio: Blob | null, audioName: string, caption?: string): void;
    sendMedia(file: Blob, fileName: string, kind: 'voice' | 'photo', caption?: string): void;
    private replaceMessage;
    private removeMessage;
    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 class SetupService {
    private dataService;
    private apiErrorService;
    private pendingCount;
    pendingCount$: Observable<number>;
    private status;
    status$: Observable<SetupStatus>;
    private modules;
    modules$: Observable<SetupModule$1[]>;
    private modulesLoaded;
    private modulesInFlight;
    constructor(dataService: DataServiceLib, apiErrorService: ApiErrorService);
    get enabled(): boolean;
    loadCount(): void;
    loadStatus(): void;
    loadModules(): void;
    ensureModules(): Observable<boolean>;
    moduleTitle(key: string): string;
    isModuleEnabled(key: string): boolean;
    setModule(key: string, enabled: boolean): Observable<ApiResponse>;
    loadRoleTemplates(): Observable<ApiResponse>;
    createRoles(keys: string[]): Observable<ApiResponse>;
    loadNotificationPresets(): Observable<ApiResponse>;
    applyNotificationPresets(items: SetupPresetSelection[], includeEmail: boolean): Observable<ApiResponse>;
    loadApprovalPresets(): Observable<ApiResponse>;
    applyApprovalPresets(items: SetupPresetSelection[]): Observable<ApiResponse>;
    loadSeedOffers(): Observable<ApiResponse>;
    applySeedOffer(key: string): Observable<ApiResponse>;
    applySeedAll(): Observable<ApiResponse>;
    refresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SetupService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SetupService>;
}

declare class ConfigService {
    private dataService;
    private config;
    config$: rxjs.Observable<any>;
    get value(): any;
    private loaded;
    private inFlight;
    private failedAttempts;
    private static readonly maxFailedAttempts;
    constructor(dataService: DataServiceLib);
    load(force?: boolean): void;
    refresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
}

declare class LastRouteService {
    private router;
    private storage;
    private dataService;
    private started;
    private excluded;
    constructor(router: Router, storage: StorageService, dataService: DataServiceLib);
    get enabled(): boolean;
    private user;
    start(): void;
    resolve(): Promise<string | null>;
    navigateTo(target: string, fallback?: string): Promise<void>;
    clear(): Promise<void>;
    private save;
    private normalize;
    private strip;
    private isResumable;
    private role;
    private allowed;
    private flatten;
    static ɵfac: i0.ɵɵFactoryDeclaration<LastRouteService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LastRouteService>;
}

interface PresetRow {
    preset: SetupPreset;
    before: string;
    after: string;
}
interface SeedRow {
    offer: SetupSeedOffer;
    alsoAdds: string;
    hereAlready: string;
    actionLabel: string;
}
interface DemoArea {
    offer: SetupSeedOffer;
    label: string;
    state: string;
}
interface PresetPicker {
    stepKey: string;
    defaultGroup: string;
    emptyText: string;
    doneText: string;
    roleAria: string;
    showEmail: boolean;
    buttonLabel: (count: number) => string;
    toastLabel: (created: number) => string;
    loadUrl: string;
    applyUrl: string;
    load: () => Observable<any>;
    apply: (items: SetupPresetSelection[]) => Observable<any>;
    presets: SetupPreset[];
    roles: SetupPresetRole[];
    groups: {
        name: string;
        rows: PresetRow[];
        on: number;
        total: number;
    }[];
    selected: {
        [key: string]: boolean;
    };
    role: {
        [key: string]: number;
    };
    count: number;
    loaded: boolean;
    applying: boolean;
    action: ChecklistAction;
}
declare class SetupGuideComponent implements OnInit {
    dataService: DataServiceLib;
    setupService: SetupService;
    private dialogService;
    private messageService;
    private apiErrorService;
    status: SetupStatus | null;
    groups: {
        name: string;
        completed: number;
        total: number;
        config: ChecklistConfig;
    }[];
    modules: SetupModule$1[];
    moduleGroups: {
        name: string;
        modules: SetupModule$1[];
        enabled: number;
        total: number;
    }[];
    togglingKey: string;
    roleTemplates: SetupRoleTemplate[];
    selectedTemplates: {
        [key: string]: boolean;
    };
    creatingRoles: boolean;
    seedRowsByStep: {
        [key: string]: SeedRow[];
    };
    seedingKey: string;
    demoAreas: DemoArea[];
    demoPending: number;
    seedingAll: boolean;
    includeEmail: boolean;
    notificationPicker: PresetPicker;
    approvalPicker: PresetPicker;
    pickers: PresetPicker[];
    get title(): string;
    ngOnInit(): void;
    private buildGroups;
    private toItem;
    private buildActions;
    getAction(step: SetupStep): SetupStepAction;
    hasDialog(step: SetupStep): boolean;
    hasAction(step: SetupStep): boolean;
    primaryLabel(step: SetupStep): string;
    progressLabel(step: SetupStep): string;
    doPrimary(step: SetupStep): void;
    private openSuccessButton;
    navigate(step: SetupStep): void;
    private buildModuleGroups;
    toggleModule(mod: SetupModule$1): void;
    private recountModuleGroups;
    confirmModules(): void;
    get modulesConfirmed(): boolean;
    hasImport(step: SetupStep): boolean;
    doImport(step: SetupStep): void;
    hasRoleTemplates(step: SetupStep): boolean;
    private hasRoleTemplatesStep;
    private loadRoleTemplates;
    get selectedTemplateCount(): number;
    toggleTemplate(tpl: SetupRoleTemplate): void;
    hasSeed(step: SetupStep): boolean;
    private hasSeedStep;
    private loadSeedOffers;
    private buildSeedRows;
    private demoAreaLabel;
    private demoAreaState;
    private seedAlsoAdds;
    private seedHereAlready;
    private seedActionLabel;
    applySeedOffer(offer: SetupSeedOffer): void;
    pickerFor(step: SetupStep): PresetPicker | undefined;
    private hasPresetsStep;
    private loadPresets;
    private buildPresetGroups;
    private toPresetRow;
    private recountPresets;
    togglePreset(picker: PresetPicker, preset: SetupPreset): void;
    setPresetRole(picker: PresetPicker, preset: SetupPreset, value: string): void;
    toggleIncludeEmail(): void;
    applyPresets(picker: PresetPicker): void;
    demoBusy: boolean;
    get showDemoData(): boolean;
    seedDemoData(): void;
    removeDemoData(): void;
    seedAll(): void;
    private runDemoAction;
    createSelectedRoles(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SetupGuideComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SetupGuideComponent, "spa-setup-guide", never, {}, {}, 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;
    private offline;
    private apiErrorService;
    private runtimeConfig;
    constructor(dataService: DataServiceLib, messageService: MessageService, breakpointObserver: BreakpointObserver, dialog: MatDialog, buttonService: ButtonService, dialogService: DialogService, tableConfigService: TableConfigService, conditionService: ConditionService, authService: AuthService, signalRService: SignalRService, // Changed: Added SignalRService
    offline: OfflineService, // Changed: TinSync unified offline service (inert unless config.offline is set)
    apiErrorService: ApiErrorService, // Added: routes application-level (HTTP 200, success:false) failures through the shared classify + dedupe path
    runtimeConfig: TinSpaRuntimeConfig | null);
    private subs;
    ngOnInit(): void;
    private initialized;
    private ensureInitialized;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    elevation: string;
    actionsWidth: string;
    sectionCollapsed: boolean;
    get sectionHidden(): boolean;
    toggleSection(): void;
    expandSection(): void;
    sectionChipList: any[];
    sectionButtonList: any[];
    private buildSectionHeader;
    sectionChips(): any[];
    sectionButtons(): any[];
    sectionButtonClicked(button: Button, event: Event): void;
    showFilterButton: boolean;
    tileReload: Subject<boolean>;
    hasBeenActivated: boolean;
    smallScreen: boolean;
    hasFormAccess: boolean;
    tableDataSource: any;
    private dataSourceValue;
    get dataSource(): any[];
    set dataSource(rows: any[]);
    displayedColumns: any[];
    displayedButtons: any[];
    originalTableLoadAction: Action;
    tablePaginator: MatPaginator;
    data: any;
    tileData: any;
    config: TableConfig;
    localMode: boolean;
    parentDetails: any;
    reload: Subject<boolean>;
    activeTab: boolean;
    inTab: boolean;
    nestingLevel: number;
    dataLoad: EventEmitter<any>;
    totalChange: EventEmitter<number>;
    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;
    private get tableDefaults();
    get effRealTime(): boolean;
    get effOffline(): any;
    get effPagination(): any;
    get effQuietLoading(): boolean;
    static readonly STAGE_DELAY_MS = 300;
    static readonly STAGE_MIN_MS = 300;
    loadingStage: 'initial' | 'refresh' | null;
    progressPercent: number;
    progressDisplay: number;
    private progress;
    private hasLoadedOnce;
    private nextStageKind;
    private requestStartedAt;
    private stageShownAt;
    private stageDelayTimer;
    private stageHoldTimer;
    private stageInFlight;
    ghostRows: number[];
    get ghostColumns(): any[];
    ghostWidth(index: number, column: any): number;
    get filteredToNothing(): boolean;
    get filterScopePartial(): boolean;
    get filteredTotal(): number;
    get filteredRowNoun(): string;
    get stageEntityName(): string;
    ghostCards: number[];
    ghostCapsules: number[];
    ghostGroups: number[];
    private beginStage;
    private endStage;
    private clearStage;
    isSignalRConnected: boolean;
    private offlineEntry;
    private pendingOps;
    private rawRows;
    private offlineSubs;
    pagedMode: boolean;
    serverTotal: number;
    loadedRows: any[];
    filteredRows: any[];
    overlayDelta: number;
    pageIndex: number;
    pageSize: number;
    filterActive: boolean;
    private filterText;
    groupFilterText: string;
    filterEmptyTitle: string;
    filterEmptyTitlePartial: string;
    loadFailed: boolean;
    private fetchSize;
    private pagedUrlBase;
    private pageFetchInFlight;
    private initializeComponent;
    get isLocal(): boolean;
    private get localRows();
    private refreshLocalData;
    editingRow: any;
    editingModel: any;
    isRowEditing(row: any): boolean;
    getInlineField(column: Column): Field | null;
    private configuredInlineFields;
    private renderedInlineFields;
    private canEditInline;
    startInlineEdit(row: any): void;
    private seedInlineDefaults;
    cancelInlineEdit(): void;
    submitInlineEdit(): void;
    private updateTableConfiguration;
    private setupDataLoading;
    loadData(action: Action, data: any): void;
    get singlePagePaginatorHidden(): boolean;
    private setPaginator;
    private setupPagination;
    private loadDataPaged;
    private fetchChunk;
    private withPaging;
    private applyFullSet;
    private cachePagedWindow;
    private clampPageIndex;
    private updateSlice;
    private pagedRowMatches;
    onServerPage(e: PageEvent): void;
    filterChanged(text: string): void;
    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;
    private activeTileFilter;
    private applyTileFilter;
    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, button?: Button): void;
    execAction(button: Button, row: any): void;
    private getElevationClass;
    private realTimeRefreshOrFallback;
    private setupOffline;
    private placeStatusIcons;
    private placeLockIcon;
    private resolveLockHost;
    private lockIdColumnNames;
    private applyOfflineOverlay;
    private computeOverlay;
    private reapplyOverlay;
    private setupRealTimeSubscriptions;
    private isEntityWideView;
    private realTimeBaseRows;
    private applyRealTimeData;
    private deriveEntityName;
    private findIdKey;
    ngOnDestroy(): void;
    private setTableData;
    private rowIdKey;
    trackByRow: (index: number, row: any) => any;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, [null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "spa-table", never, { "data": { "alias": "data"; "required": false; }; "tileData": { "alias": "tileData"; "required": false; }; "config": { "alias": "config"; "required": false; }; "localMode": { "alias": "localMode"; "required": false; }; "parentDetails": { "alias": "parentDetails"; "required": false; }; "reload": { "alias": "reload"; "required": false; }; "activeTab": { "alias": "activeTab"; "required": false; }; "inTab": { "alias": "inTab"; "required": false; }; "nestingLevel": { "alias": "nestingLevel"; "required": false; }; }, { "dataLoad": "dataLoad"; "totalChange": "totalChange"; "actionSuccess": "actionSuccess"; "refreshClick": "refreshClick"; "searchClick": "searchClick"; "createClick": "createClick"; "actionClick": "actionClick"; "inputChange": "inputChange"; "actionResponse": "actionResponse"; }, never, never, false, never>;
}

interface DayBookSectionView {
    section: DayBookSection;
    cfg: TableConfig | null;
    all: any[];
    rows: any[];
    outletContext: {
        $implicit: DayBookSectionView;
    } | null;
    caption: string;
    count: number;
    limit: number;
    collapsed: boolean;
}
interface DayBookGroupView {
    lane: DayBookLane;
    sections: DayBookSectionView[];
    count: number;
    value: number;
    chips: {
        key: string;
        label: string;
        count: number;
    }[];
    collapsed: boolean;
}
declare class DayBookComponent implements OnInit {
    dataService: DataServiceLib;
    private messageService;
    private apiErrorService;
    private buttonService;
    private zone;
    tables: QueryList<TableComponent>;
    dayBookConfig?: DayBookConfig;
    book: any;
    loading: boolean;
    showLoading: boolean;
    lane: string;
    tileConfig: TileConfig | null;
    tileData: any;
    sectionConfigs: DayBookSectionView[];
    visibleSections: DayBookSectionView[];
    visibleGroups: DayBookGroupView[];
    ungroupedSections: DayBookSectionView[];
    lanes: DayBookLane[];
    pageActions: Button[];
    private groupState;
    grouped: boolean;
    get config(): DayBookConfig | undefined;
    get title(): string;
    ngOnInit(): void;
    private setShowLoading;
    load(): void;
    rebuild(): void;
    private buildActions;
    pageActionClicked(button: Button): void;
    private runPageAction;
    private buildLanes;
    setLane(key: string): void;
    inLane(lane?: string): boolean;
    private stageCount;
    sectionLabel(section: DayBookSection): string;
    private stageValue;
    private resolveValue;
    private buildTiles;
    onTileClick(event: any): void;
    private buildSections;
    private buildVisibleSections;
    private buildGroups;
    private laneStageValue;
    toggleGroup(group: DayBookGroupView): void;
    goTo(key: string): void;
    private scrollWhenSettled;
    get booksFrom(): any;
    get owed(): number | null;
    get allClear(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DayBookComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DayBookComponent, "spa-day-book", never, { "dayBookConfig": { "alias": "dayBookConfig"; "required": false; }; }, {}, never, ["[dayBookActions]"], false, never>;
}

declare class AppConfigurationComponent implements OnInit {
    dataService: DataServiceLib;
    private messageService;
    private authService;
    private configService;
    private apiErrorService;
    private router;
    goToModules(): void;
    configuration: any;
    loading: boolean;
    saving: boolean;
    canEdit: boolean;
    saveFailure: {
        reason: string;
        technical: boolean;
    } | null;
    cards: {
        section: AppConfigSection;
        form: FormConfig;
        collapsed: boolean;
    }[];
    visibleCards: {
        section: AppConfigSection;
        form: FormConfig;
        collapsed: boolean;
    }[];
    get config(): AppConfigurationConfig | undefined;
    get title(): string;
    get sections(): AppConfigSection[];
    ngOnInit(): void;
    load(): void;
    private buildCards;
    private fieldsFor;
    private buildVisibleCards;
    toggle(card: {
        section: AppConfigSection;
        collapsed: boolean;
    }): void;
    onInputChange(): void;
    discardChanges(): void;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppConfigurationComponent, "spa-app-configuration", never, {}, {}, never, never, false, never>;
}

declare class AgentPageComponent implements OnInit, OnDestroy {
    private agentService;
    private subs;
    constructor(agentService: AgentService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgentPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AgentPageComponent, "spa-agent-page", never, {}, {}, never, never, false, never>;
}

declare class OfflineIndicatorComponent {
    private offline;
    private router;
    state$: Observable<{
        online: boolean;
        pending: number;
        attention: number;
        badge: number;
    }>;
    enabled: boolean;
    constructor(offline: OfflineService, router: Router);
    tooltip(s: {
        online: boolean;
        pending: number;
        attention: number;
        badge: number;
    }): string;
    openSyncPage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OfflineIndicatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OfflineIndicatorComponent, "spa-offline-indicator", never, {}, {}, never, never, false, never>;
}

declare class SyncComponent implements OnInit, OnDestroy {
    private offline;
    private messageService;
    ops: OutboxOp[];
    alertConfig: AlertConfig | null;
    private sub;
    private retryButton;
    private keepServerButton;
    private keepMineButton;
    private discardButton;
    private syncNowButton;
    tableConfig: TableConfig;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private discard;
    private updateAlert;
    static ɵfac: i0.ɵɵFactoryDeclaration<SyncComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SyncComponent, "spa-sync", never, {}, {}, never, never, false, never>;
}

declare const authGuard: CanActivateFn;

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

declare const moduleGuard: (moduleKey?: 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 resolveVisibility(v: VisibilityValue | undefined, data: any): boolean | undefined;
    static isItemVisible(item: {
        visible?: VisibilityValue;
        hidden?: VisibilityValue;
    }, data: any): boolean;
    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, onInvalid?: (field: Field) => void): string;
    private static validateField;
    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 parseMultiValue(raw: any): string[];
    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;
    };
}

interface PerceivedProgressOptions {
    cap?: number;
    completeMs?: number;
    onChange?: (percent: number) => void;
}
declare class PerceivedProgress {
    private options;
    static readonly TAU_MS = 3000;
    static readonly CAP = 94;
    static readonly COMPLETE_MS = 200;
    static readonly CAP_MARGIN = 0.000001;
    static valueAt(elapsedMs: number, cap?: number): number;
    static now(): number;
    percent: number;
    running: boolean;
    private startedAt;
    private frame;
    private completing;
    private completeFrom;
    private completeStartedAt;
    private doneCallback;
    private completeGuard;
    constructor(options?: PerceivedProgressOptions);
    get display(): number;
    private get cap();
    private get completeMs();
    start(now?: number): void;
    complete(done?: () => void): void;
    stop(): void;
    tick(now?: number): void;
    private emit;
    private scheduleFrame;
    private clearGuard;
    private cancelFrame;
}

/** "Msal" section — PascalCase keys to match backend appsettings conventions. */
interface TinSpaMsalSettings {
    ClientId?: string;
    Authority?: string;
    /** Optional — when omitted or empty, tin-spa falls back to `${window.location.origin}/login`. */
    RedirectUri?: string;
}
interface TinSpaAppSettings {
    /** Selects the overlay file, exactly like ASPNETCORE_ENVIRONMENT selects
     * appsettings.{Environment}.json on the backend. Set per server, e.g. "SIT", "UAT", "Production". */
    Environment?: string;
    /** Enable/disable Microsoft SSO per environment (overrides the code-declared runtime flag). */
    MicrosoftAuth?: boolean;
    /** Enable/disable Google sign-in per environment. */
    GoogleAuth?: boolean;
    /** Routing strategy per environment: true = path routing (/home), false = hash routing (/#/home).
     * Overrides the code-declared `pathRouting`. Path routing needs a server rewrite rule (IIS
     * URL Rewrite / SPA fallback) so deep links resolve to index.html — which is exactly why this
     * has to be per-environment: the same build is promoted to servers configured differently. */
    PathRouting?: boolean;
    /** SignalR/real-time on or off per environment (overrides the code-declared `realTime`). */
    RealTime?: boolean;
    /** Offline capability on or off per environment (overrides the code-declared `offline`). */
    Offline?: boolean;
    /** Added: app-wide per-table defaults, tunable per environment without a rebuild. A table's own
     * TableConfig value always wins over these; these only fill in what a table did not state.
     * PageSize is offered as a number because tuning it per server is the main reason to expose it —
     * e.g. a slow-link deployment dropping every unstated table to 10 rows a page. */
    TableDefaults?: {
        RealTime?: boolean;
        Offline?: boolean;
        Pagination?: boolean;
        PageSize?: number;
    };
    Msal?: TinSpaMsalSettings;
    /** Same key name the backend reads for token validation — the two MUST hold the same value,
     * since the backend validates the Google id-token audience against its own GoogleClientID. */
    GoogleClientID?: string;
    /** Apps may add their own environment-specific sections. */
    [key: string]: any;
}
/** The settings loaded by loadTinSpaAppSettings(), or null when no file was found / loading failed. */
declare function getTinSpaAppSettings(): TinSpaAppSettings | null;
/**
 * Loads assets/appsettings.json (+ the appsettings.{Environment}.json overlay when the base file
 * declares an Environment) and caches the merged result for getTinSpaAppSettings().
 * Never rejects — a missing or broken file logs to the console and resolves null so the app
 * still boots with its code-declared configuration.
 */
declare function loadTinSpaAppSettings(): Promise<TinSpaAppSettings | null>;

declare const TIN_SILENT_REQUEST: HttpContextToken<boolean>;
declare function silentContext(silent?: boolean, context?: HttpContext): HttpContext | undefined;
declare function isSilentRequest(context: HttpContext | undefined | null): boolean;

interface QuietLoadingHost {
    quietLoading?: boolean;
}
declare function resolveQuietLoading(config: QuietLoadingHost | null | undefined, appDefault: boolean | undefined): boolean;
declare const QUIET_DELAY_MS = 300;
declare const QUIET_MIN_MS = 300;

declare class FieldLoadIndicator {
    spinning: boolean;
    private inFlight;
    private delayTimer;
    private minTimer;
    private shownAt;
    begin(): void;
    settle(): void;
    destroy(): void;
}

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;
    private apiErrorService;
    constructor(dataService: DataServiceLib, dialogService: DialogService, // Changed: Added DialogService injection
    buttonService: ButtonService, // Changed: Added ButtonService injection
    messageService: MessageService, // Changed: Added MessageService injection
    apiErrorService: ApiErrorService);
    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;
    readonly ADD_NEW_OPTION = "__spa_add_new__";
    addOptionLabel: string;
    private resolveAddOptionLabel;
    isHovered: boolean;
    readonly loadIndicator: FieldLoadIndicator;
    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;
    onOptionSelected(event: any): void;
    onPeekClick(event: MouseEvent, mode: 'create' | 'view'): void;
    private selectCreated;
    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>;
    hint: string;
    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; }; "hint": { "alias": "hint"; "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;
    private apiErrorService;
    constructor(messageService: MessageService, dataService: DataServiceLib, apiErrorService: ApiErrorService);
    ngOnInit(): void;
    ngOnChanges(): void;
    displayValue: any;
    isHovered: boolean;
    selectedOptionHint: string;
    readonly loadIndicator: FieldLoadIndicator;
    readonly ADD_NEW_OPTION = "__spa_add_new__";
    private previousValue;
    private defaultedOptions;
    private destroyed;
    private matSelect;
    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;
    addOptionLabel: string;
    valueChange: EventEmitter<any>;
    hoverChange: EventEmitter<boolean>;
    addNew: EventEmitter<void>;
    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; }; "addOptionLabel": { "alias": "addOptionLabel"; "required": false; }; }, { "valueChange": "valueChange"; "hoverChange": "hoverChange"; "addNew": "addNew"; }, never, ["[additionalButtons]"], false, never>;
}

declare class SelectComponent extends SelectCommonComponent implements OnInit, OnChanges {
    protected messageService: MessageService;
    protected dataService: DataServiceLib;
    private dialogService;
    private buttonService;
    constructor(messageService: MessageService, dataService: DataServiceLib, dialogService: DialogService, buttonService: ButtonService, apiErrorService: ApiErrorService);
    ngOnInit(): void;
    ngOnChanges(changes?: SimpleChanges): void;
    detailsConfig: DetailsDialogConfig;
    addOptionLabel: string;
    private resolveAddOptionLabel;
    onHoverChange(isHovered: boolean): void;
    canCreate(): boolean;
    canView(): boolean;
    onPeekClick(event: MouseEvent, mode: 'create' | 'view'): void;
    private selectCreated;
    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, OnDestroy {
    constructor();
    private filterInput$;
    private filterSub;
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(): void;
    flatButtons: boolean;
    showText: boolean;
    showButton: boolean;
    smallScreen: boolean;
    data: MatTableDataSource<unknown, _angular_material_paginator.MatPaginator>;
    refreshing: boolean;
    refreshClick: EventEmitter<any>;
    filterChange: EventEmitter<string>;
    _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; }; "refreshing": { "alias": "refreshing"; "required": false; }; }, { "refreshClick": "refreshClick"; "filterChange": "filterChange"; }, never, never, false, never>;
}

declare class messageDialog implements OnInit {
    private dialogRef;
    data: any;
    private dataService;
    constructor(dialogRef: MatDialogRef<messageDialog>, data: any, dataService: DataServiceLib);
    ngOnInit(): void;
    messageType: any;
    _messageSubject: any;
    _messageDetails: any;
    _messageReference: any;
    modern: boolean;
    destructive: boolean;
    get iconName(): string;
    private static readonly TYPES;
    private get spec();
    get title(): string;
    private paragraphSource;
    private paragraphCache;
    get paragraphs(): string[];
    get reference(): string | null;
    get isConfirm(): boolean;
    _confirmLabel: any;
    _cancelLabel: any;
    _okLabel: any;
    private label;
    get confirmLabel(): string;
    get cancelLabel(): string;
    get okLabel(): string;
    private static readonly CLASSIC_HEADINGS;
    get classicHeading(): string;
    response(resp: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<messageDialog, [null, null, { optional: true; }]>;
    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;
    editorConfig: any;
    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; }; "editorConfig": { "alias": "editorConfig"; "required": false; }; "loadAction": { "alias": "loadAction"; "required": false; }; }, { "valueChange": "valueChange"; "enterPress": "enterPress"; }, never, never, false, never>;
}

declare class TilesComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    private dataService;
    private messageService;
    private cdr;
    private apiErrorService;
    private subs;
    private chartCache;
    constructor(dataService: DataServiceLib, messageService: MessageService, cdr: ChangeDetectorRef, apiErrorService: ApiErrorService);
    get effQuietLoading(): boolean;
    private static readonly DEFAULT_MIN_TILE_WIDTH;
    private static readonly TILE_GAP;
    isAuto: boolean;
    hideValueMobile: boolean;
    isCarousel: boolean;
    tilesStyle: {
        [k: string]: string;
    };
    canScrollLeft: boolean;
    canScrollRight: boolean;
    private ctxCache;
    ctx(tile: Tile): {
        $implicit: Tile;
    };
    tileScroller: ElementRef<HTMLElement>;
    private applyLayout;
    tileBasis: string;
    ngAfterViewInit(): void;
    private updateScrollState;
    onTilesScroll(): void;
    scrollTiles(direction: number): void;
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    private getChartCache;
    getTileMiniChartData(tile: Tile): ChartData;
    getMiniChartOptions(tile: Tile): ChartOptions;
    getTileChartPlugins(tile: Tile): Plugin[];
    tiles: Tile[];
    config: TileConfig;
    tileActionSelected: EventEmitter<Action>;
    lastSearch: any;
    data: any;
    reload: Subject<boolean>;
    tileClick: EventEmitter<any>;
    tileUnClick: EventEmitter<any>;
    selectedTile: string;
    private static readonly GHOST_DELAY_MS;
    private static readonly GHOST_MIN_MS;
    loading: boolean;
    private ghostDelayTimer;
    private ghostSettleTimer;
    private pendingApply;
    private ghostShownAt;
    loadData(action: Action, data: any): void;
    showValueGhost(tile: Tile): boolean;
    private beginGhost;
    private settle;
    private finish;
    private flushPending;
    private ghostWouldRender;
    isClickable(tile: Tile): boolean;
    clicked(clickedTile: Tile): void;
    pop(x: any): void;
    isHidden(tile: Tile): boolean;
    displayValue(tile: Tile): any;
    tileColor(tile: Tile): string;
    isTileValuePrimitive(tile: Tile): boolean;
    hasTileChartData(tile: Tile): boolean;
    private buildTileMiniChartData;
    private buildMiniChartOptions;
    private buildTileChartPlugins;
    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;
    private apiErrorService;
    constructor(breakpointObserver: BreakpointObserver, dataService: DataServiceLib, apiErrorService: ApiErrorService);
    ngOnInit(): void;
    ngOnChanges(): void;
    private observeScreenSize;
    stepper: MatStepper;
    value: string;
    config: StepConfig;
    data: any;
    activeIndex: number | null;
    selectedIndex: number;
    smallScreen: boolean;
    steps: Step[];
    private loadSteps;
    private updateSelectedStep;
    get shouldShowLabels(): boolean;
    visibleSteps: Step[];
    private buildVisibleSteps;
    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; }; "activeIndex": { "alias": "activeIndex"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ChecklistComponent implements OnChanges {
    config: ChecklistConfig;
    itemTemplate: TemplateRef<any>;
    expandedKey: string;
    items: ChecklistItem[];
    ngOnChanges(changes: SimpleChanges): void;
    private buildItems;
    get template(): TemplateRef<any> | null;
    toggle(item: ChecklistItem): void;
    isExpanded(item: ChecklistItem): boolean;
    isDisabled(act: ChecklistAction, item: ChecklistItem): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChecklistComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChecklistComponent, "spa-checklist", never, { "config": { "alias": "config"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "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;
    setupService: SetupService;
    private lastRouteService;
    private offlineService;
    constructor(router: Router, authService: AuthService, storageService: StorageService, notificationsService: NotificationsService, breakpointObserver: BreakpointObserver, dataService: DataServiceLib, dialog: MatDialog, subscriptionService: SubscriptionService, setupService: SetupService, lastRouteService: LastRouteService, offlineService: OfflineService);
    ngOnInit(): void;
    notificationCount$: any;
    setupCount$: Observable<number>;
    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;
    private subItemCache;
    getSubItems(capItem: CapItem): CapItem[];
    isFeatureAllowed(cap: CapItem): boolean;
    private reversedSource;
    private reversedCache;
    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 FormComponent implements OnInit, OnDestroy, DoCheck {
    private messageService;
    private dataService;
    private authService;
    private apiErrorService;
    private subscriptions;
    visibleFields: Field[];
    private lastMode;
    constructor(messageService: MessageService, dataService: DataServiceLib, authService: AuthService, apiErrorService: ApiErrorService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    ngDoCheck(): void;
    private refreshVisibleFields;
    private subfieldCache;
    dynamicSelectTemplate: TemplateRef<any>;
    defaultDynamicSelectTemplate: TemplateRef<any>;
    get selectTemplate(): 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>;
    private loadActionCache;
    resolveLoadAction(field: Field): any;
    initializeCompositeFields(): void;
    initializeSectionStates(): void;
    private applyValueCalculations;
    getVisibleSubfields(field: Field): Field[];
    getVisibleFields(): Field[];
    testReadOnly(field: Field): boolean;
    testRequired(field: Field): boolean;
    compositeReadOnly(parent: Field): (subfield: Field) => boolean;
    private deferredOptionFields;
    private isCollapsedSectionField;
    private loadDeferredOptions;
    toggleSection(field: Field): void;
    revealSection(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>;
}

interface ExtraButtonVM {
    button: Button;
    visible: boolean;
    disabled: boolean;
    color: string;
}
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;
    private zone;
    private apiErrorService;
    constructor(breakpointObserver: BreakpointObserver, loaderService: LoaderService, dataService: DataServiceLib, messageService: MessageService, dialogRef: MatDialogRef<DetailsDialog>, detailsConfig: DetailsDialogConfig, buttonService: ButtonService, dialogService: DialogService, authService: AuthService, tableConfigService: TableConfigService, zone: NgZone, // TS-20: NgZone injected
    apiErrorService: ApiErrorService);
    private subs;
    modern: boolean;
    get effQuietLoading(): boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private refreshSubscription;
    autoRefreshEnabled: boolean;
    userKeepOpen: boolean;
    titleAction: string;
    loadByAction: boolean;
    actionPerformed: boolean;
    extraButtons: Button[];
    buttons: Button[];
    createButton: Button;
    editButton: Button;
    deleteButton: Button;
    fileField: Field;
    files: any[];
    tableReload: Subject<boolean>;
    tableConfig: TableConfig;
    tableConfigs: TableConfig[];
    private _details;
    get details(): any;
    set details(value: any);
    formConfig: FormConfig;
    stepConfig: StepConfig;
    statusConfig: StatusConfig;
    smallScreen: boolean;
    nestingLevel: number;
    showTabs: boolean;
    isLoadComplete: boolean;
    isProcessing: boolean;
    private static readonly SKELETON_DELAY_MS;
    private static readonly SKELETON_MIN_MS;
    showSkeleton: boolean;
    private readsInFlight;
    private skeletonDelayTimer;
    private skeletonSettleTimer;
    private pending;
    private skeletonShownAt;
    get entityLoading(): boolean;
    progressPercent: number;
    progressDisplay: number;
    private progress;
    private progressRunning;
    get showProgressLine(): boolean;
    private syncProgress;
    private beginRead;
    private skeletonWouldRender;
    private settleRead;
    private finishRead;
    private flushPending;
    inputChange: EventEmitter<any>;
    formComponent: FormComponent;
    private initAutoRefresh;
    private startAutoRefresh;
    private stopAutoRefresh;
    toggleAutoRefresh(): void;
    loadData(action: Action, causeTablesReload: any): void;
    inputChanged(event: any): void;
    setMode(newMode: any): void;
    setTitleAction(): void;
    extraButtonVMs: ExtraButtonVM[];
    editButtonVM: {
        visible: boolean;
        disabled: boolean;
    };
    private buildButtonWithConfig;
    private rebuildButtonVMs;
    getButton(name: string): Button;
    testDisabled(row: any, buttonName: string): boolean;
    testVisible(row: any, buttonName: string): boolean;
    getButtonColor(button: Button, row: any): string;
    getVisibleFields(): Field[];
    private revealSection;
    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>;
}

interface SkeletonUnit {
    section: boolean;
    blank: boolean;
    span: boolean;
    labelWidth: string;
    delay: string;
}
declare class FormSkeletonComponent implements OnChanges {
    private authService;
    constructor(authService: AuthService);
    config: FormConfig;
    units: SkeletonUnit[];
    multiColumn: boolean;
    ngOnChanges(): void;
    private static readonly LABEL_WIDTHS;
    private static readonly STAGGER_MS;
    private build;
    private isSpanned;
    private isVisible;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormSkeletonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormSkeletonComponent, "spa-form-skeleton", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, 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 AgentMarkdownPipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(value: string | null | undefined): SafeHtml;
    private escape;
    static ɵfac: i0.ɵɵFactoryDeclaration<AgentMarkdownPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AgentMarkdownPipe, "agentMarkdown", false>;
}

declare class NumberComponent implements OnInit, OnChanges {
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    get inputMode(): string;
    blockNonNumericKeys(event: KeyboardEvent): 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 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;
    private apiErrorService;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService, apiErrorService: ApiErrorService);
    totalChange: EventEmitter<number>;
    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, {}, { "totalChange": "totalChange"; }, 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>;
}

interface HeaderButtonVM {
    button: Button;
    visible: boolean;
    disabled: boolean;
    color: string;
}
declare class TableHeaderComponent implements OnInit, OnChanges {
    private buttonService;
    private dialogService;
    private messageService;
    private csvService;
    constructor(buttonService: ButtonService, dialogService: DialogService, messageService: MessageService, csvService: CsvService);
    ngOnInit(): void;
    ngOnChanges(): void;
    headerButtonVMs: HeaderButtonVM[];
    private buildHeaderButtons;
    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;
    refreshing: boolean;
    createClick: EventEmitter<void>;
    customClick: EventEmitter<any>;
    refreshClick: EventEmitter<void>;
    tileClick: EventEmitter<string>;
    tileUnClick: EventEmitter<string>;
    filterChange: EventEmitter<string>;
    uploadDetailsDialog: DetailsDialogConfig;
    onButtonClick(button: Button): void;
    onDownloadClick(): void;
    onUploadClick(): void;
    testVisibleImport(): boolean;
    onImportClick(): void;
    onRefreshClick(): void;
    onFilterChange(text: string): void;
    get showGroupedFilter(): boolean;
    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; }; "refreshing": { "alias": "refreshing"; "required": false; }; }, { "createClick": "createClick"; "customClick": "customClick"; "refreshClick": "refreshClick"; "tileClick": "tileClick"; "tileUnClick": "tileUnClick"; "filterChange": "filterChange"; }, never, never, false, never>;
}

interface CellVM {
    text: any;
    truncated: boolean;
    color: string;
    showColumnIcon: boolean;
    visibleIcons: Icon[];
}
declare class TableRowComponent implements OnChanges {
    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>;
    vm: CellVM;
    ngOnChanges(): void;
    private computeText;
    private computeTruncated;
    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;
    onChipClick(column: Column, row: any): void;
    onMonogramTap(label: 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>;
}

interface ActionButtonVM {
    button: Button;
    name: string;
    visible: boolean;
    disabled: boolean;
    color: string;
    icon: string;
}
declare class TableActionComponent implements OnChanges {
    private buttonService;
    constructor(buttonService: ButtonService);
    displayedButtons: Button[];
    config: TableConfig;
    row: any;
    smallScreen: boolean;
    actionClick: EventEmitter<{
        name: string;
        row: any;
    }>;
    visibleVMs: ActionButtonVM[];
    overflowVMs: ActionButtonVM[];
    ngOnChanges(): void;
    private toVM;
    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;
    private computeVisibleButtons;
    private computeOverflowButtons;
    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 InlineCellComponent {
    field: Field;
    data: any;
    valueChange: EventEmitter<any>;
    get display(): string;
    cellChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InlineCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InlineCellComponent, "app-inline-cell", never, { "field": { "alias": "field"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

type MonogramKind = 'person' | 'system' | 'unknown';
declare const MONOGRAM_TONES: string[];
declare function monogramInitials(display: string): string;
declare function monogramKind(display: string, key: string): MonogramKind;
declare function monogramPaletteIndex(key: string, buckets: number): number;
declare class MonogramComponent implements OnChanges {
    value: string;
    key: string;
    tapped: EventEmitter<string>;
    initials: string;
    kind: MonogramKind;
    tone: string;
    label: string;
    ngOnChanges(): void;
    onTap(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonogramComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MonogramComponent, "spa-monogram", never, { "value": { "alias": "value"; "required": false; }; "key": { "alias": "key"; "required": false; }; }, { "tapped": "tapped"; }, never, never, false, never>;
}

declare class AlertComponent implements OnInit, OnChanges {
    constructor();
    ngOnInit(): void;
    config: AlertConfig;
    data: any;
    private messageCache;
    ngOnChanges(): void;
    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, OnDestroy {
    private messageService;
    private dataService;
    private apiErrorService;
    constructor(messageService: MessageService, dataService: DataServiceLib, apiErrorService: ApiErrorService);
    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;
    readonly loadIndicator: FieldLoadIndicator;
    hoverChange: EventEmitter<boolean>;
    onMouseEnter(): void;
    onMouseLeave(): void;
    refresh(event: MouseEvent): void;
    getData(action: Action): void;
    ngOnDestroy(): 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, OnDestroy {
    private messageService;
    private dataService;
    private apiErrorService;
    constructor(messageService: MessageService, dataService: DataServiceLib, apiErrorService: ApiErrorService);
    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;
    private publishAutoSelection;
    private destroyed;
    selectionChange(event: any): void;
    private updateValue;
    getOptionDisplay(value: any): string;
    compareWith(v1: any, v2: any): boolean;
    clear(): void;
    copyValues(): void;
    isHovered: boolean;
    readonly loadIndicator: FieldLoadIndicator;
    hoverChange: EventEmitter<boolean>;
    onMouseEnter(): void;
    onMouseLeave(): void;
    refresh(event: MouseEvent): void;
    getData(action: Action): void;
    ngOnDestroy(): 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;
    selectedOptions: BitwiseOption[];
    private buildSelectedOptions;
    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: string;
    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 EditorComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    display: string;
    value: string;
    readonly: boolean;
    required: boolean;
    hint: string;
    infoMessage: string;
    placeholder: string;
    width: string;
    height: string;
    minHeight: string;
    defaultFontName: string;
    editorConfig: AngularEditorConfig;
    valueChange: EventEmitter<any>;
    config: AngularEditorConfig;
    private buildConfig;
    changed(val: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditorComponent, "spa-editor", 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; }; "infoMessage": { "alias": "infoMessage"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "defaultFontName": { "alias": "defaultFontName"; "required": false; }; "editorConfig": { "alias": "editorConfig"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class NotesComponent implements OnInit {
    private dataService;
    private apiErrorService;
    constructor(dataService: DataServiceLib, apiErrorService: ApiErrorService);
    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 implements OnChanges {
    buttonService: ButtonService;
    private conditionService;
    constructor(buttonService: ButtonService, conditionService: ConditionService);
    config: TableConfig;
    dataSource: any[];
    displayedButtons: Button[];
    actionClick: EventEmitter<{
        name: string;
        row: any;
    }>;
    private buttonCache;
    ngOnChanges(): void;
    getVisibleButtons(item: any): Button[];
    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 implements OnChanges {
    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;
    private contentCache;
    ngOnChanges(): void;
    getContentValues(row: any): {
        label: string;
        value: any;
    }[];
    private buildContentValues;
    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;
    private countsInitialized;
    private countUrls;
    private eagerIndex?;
    private syncTabCounts;
    private gridWillReport;
    onTabTotal(index: number, total: number): void;
    tableConfigs: TableConfig[];
    reload: Subject<boolean>;
    reloadTab?: Subject<number>;
    parentDetails: any;
    localMode: boolean;
    nestingLevel: number;
    formRefresh: EventEmitter<void>;
    actionSuccess: 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; }; "reloadTab": { "alias": "reloadTab"; "required": false; }; "parentDetails": { "alias": "parentDetails"; "required": false; }; "localMode": { "alias": "localMode"; "required": false; }; "nestingLevel": { "alias": "nestingLevel"; "required": false; }; }, { "formRefresh": "formRefresh"; "actionSuccess": "actionSuccess"; }, 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;
    private apiErrorService;
    constructor(conditionService: ConditionService, buttonService: ButtonService, dataService: DataServiceLib, // Changed: Injected for drop action API calls
    snackBar: MatSnackBar, // Changed: Injected for error feedback on failed drops (still used by the transport-error fallback below)
    apiErrorService: ApiErrorService);
    ngOnInit(): void;
    private iconCache;
    private headerButtonCache;
    private buttonCache;
    private invalidateVisibilityCaches;
    ngOnChanges(changes: SimpleChanges): void;
    config: TableConfig;
    dataSource: any[];
    displayedButtons: Button[];
    showOwnFilter: boolean;
    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[];
    private buildVisibleAdditionalIcons;
    getIconTooltip(icon: Icon, item: any): string;
    getVisibleHeaderButtons(group: GroupData): Button[];
    private buildVisibleHeaderButtons;
    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; }; "showOwnFilter": { "alias": "showOwnFilter"; "required": false; }; "filterText": { "alias": "filterText"; "required": false; }; }, { "actionClick": "actionClick"; }, never, never, false, never>;
}

declare class TitleActionsComponent implements OnInit {
    private dataService;
    private messageService;
    private apiErrorService;
    constructor(dataService: DataServiceLib, messageService: MessageService, apiErrorService: ApiErrorService);
    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, OnChanges {
    private dataService;
    private messageService;
    private apiErrorService;
    constructor(dataService: DataServiceLib, messageService: MessageService, apiErrorService: ApiErrorService);
    config: ChartConfig;
    data: any;
    reload: Subject<boolean>;
    ngOnInit(): void;
    loadData(action: Action, data: any): void;
    private chartCache;
    ngOnChanges(): void;
    private getCache;
    getChartData(chart: ChartItem): ChartData;
    getChartOptions(chart: ChartItem): ChartOptions;
    private buildChartData;
    private buildChartOptions;
    getPlugins(chart: ChartItem): Plugin[];
    private buildPlugins;
    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 lastRouteService;
    private el;
    private sanitizer;
    config: LandingConfig;
    mobileMenuOpen: boolean;
    navScrolled: boolean;
    restoring: boolean;
    currentYear: number;
    private observer;
    constructor(router: Router, authService: AuthService, lastRouteService: LastRouteService, // Added: resumeLastRoute
    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;
    private zone;
    private router;
    private breakpointObserver;
    messageContainer: ElementRef;
    messageInput: ElementRef;
    cameraInput: ElementRef<HTMLInputElement>;
    galleryInput: ElementRef<HTMLInputElement>;
    pageMode: boolean;
    smallScreen: boolean;
    onAgentRoute: boolean;
    get showFab(): boolean;
    get showWindow(): boolean;
    messages: AgentMessage[];
    conversations: ConversationSummary[];
    currentConversationId: number | null;
    showConversations: boolean;
    sessionInfo: AgentSessionInfo | null;
    isOpen: boolean;
    isTyping: boolean;
    inputText: string;
    greeting: string;
    suggestedQuestions: string[];
    isOnline: boolean;
    isRecording: boolean;
    recordSeconds: number;
    mediaError: string;
    pendingPhoto: File | null;
    isTranscribing: boolean;
    private subs;
    private shouldScroll;
    private viewportHandler;
    private recorder;
    private mediaStream;
    private chunks;
    private recordTimer;
    private stopMode;
    private static readonly MAX_RECORD_SECONDS;
    voiceMode: boolean;
    voiceState: 'idle' | 'starting' | 'listening' | 'capturing' | 'thinking' | 'speaking';
    voiceTranscript: string;
    voiceReply: string;
    voiceError: string;
    voiceLevel: number;
    voiceThreshold: number;
    noiseMultiplier: number;
    maxThreshold: number;
    onsetMs: number;
    silenceMs: number;
    minSpeechMs: number;
    noiseFloor: number;
    activeThreshold: number;
    private static readonly SETTLE_MS;
    private static readonly CALIBRATION_MS;
    private static readonly CONTINUE_RATIO;
    private static readonly MAX_UTTERANCE_MS;
    private static readonly IDLE_MS;
    private static readonly MAX_SILENT_MS;
    private calibrationEndsAt;
    private calibrationSamples;
    private loudSince;
    private voiceRecorder;
    private voiceStream;
    private voiceChunks;
    private audioContext;
    private analyser;
    private vadTimer;
    private player;
    private speechStartedAt;
    private lastLoudAt;
    private listenStartedAt;
    private silentSince;
    private abandonUtterance;
    constructor(agentService: AgentService, signalRService: SignalRService, zone: NgZone, router: Router, breakpointObserver: BreakpointObserver);
    private setVoiceState;
    get agentName(): string;
    ngOnInit(): void;
    private isAgentRoute;
    get sessionVerb(): string;
    selectConversation(id: number): void;
    toggleConversationList(): void;
    ngAfterViewChecked(): void;
    toggleChat(): void;
    onDocumentClick(event: MouseEvent): void;
    sendMessage(): void;
    get canSend(): boolean;
    clearPhoto(): void;
    sendSuggested(question: string): void;
    onKeydown(event: KeyboardEvent): void;
    newConversation(): void;
    get recordDisplay(): string;
    startRecording(): Promise<void>;
    stopRecording(): void;
    stopAndTranscribe(): void;
    cancelRecording(): void;
    micHeld: boolean;
    private micHoldTimer;
    private micHoldFired;
    private static readonly MIC_HOLD_MS;
    onMicPressStart(): void;
    onMicPressEnd(): void;
    onMicClick(): void;
    startVoiceMode(): Promise<void>;
    stopVoiceMode(): void;
    private beginListening;
    private startVad;
    private evaluateVad;
    private applyCalibration;
    private endUtterance;
    private onUtteranceCaptured;
    private onTurnAnswered;
    private speakThenListen;
    private speakFallback;
    private afterSpeaking;
    private earcon;
    private releaseMic;
    private stopVoiceCapture;
    private stopPlayback;
    get voiceStateLabel(): string;
    get voiceStateIcon(): string;
    takePhoto(): void;
    choosePhoto(): void;
    onPhotoSelected(event: Event): void;
    private pickAudioMimeType;
    private finishRecording;
    private extensionFor;
    private clearRecording;
    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, { "pageMode": { "alias": "pageMode"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BottomTabsComponent implements OnInit, OnDestroy {
    router: Router;
    dataService: DataServiceLib;
    private notificationsService;
    private setupService;
    notificationCount$: any;
    activeTab: string;
    private routerSub;
    constructor(router: Router, dataService: DataServiceLib, notificationsService: NotificationsService, setupService: SetupService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    get tabs(): BottomTab[];
    isTabVisible(tab: BottomTab): boolean;
    private setActiveTab;
    private normalize;
    navigate(tab: BottomTab): void;
    trackByName(index: number, tab: BottomTab): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BottomTabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BottomTabsComponent, "spa-bottom-tabs", never, {}, {}, never, never, false, never>;
}

declare class ImportDialogComponent implements OnInit {
    private httpService;
    private http;
    private messageService;
    private apiErrorService;
    private dialogRef;
    config: ImportConfig;
    entity: string;
    title: string;
    loading: boolean;
    stepIndex: number;
    stepsConfig: StepConfig;
    reviewTableConfig: TableConfig;
    reviewRows: any[];
    editingRow: any;
    private buildReviewTable;
    rebuildReviewRows(): void;
    batchId: number;
    status: number;
    reversible: boolean;
    fileName: string;
    fields: any[];
    headers: any[];
    mappings: any[];
    counts: {
        total: number;
        ready: number;
        warning: number;
        error: number;
    };
    rows: any[];
    committedCount: number;
    selectedFile: File;
    editingRowId: number;
    editModel: any;
    constructor(httpService: HttpService, http: HttpClient, messageService: MessageService, apiErrorService: ApiErrorService, // Changed: injected so a step failure is classified rather than shown verbatim
    dialogRef: MatDialogRef<ImportDialogComponent>, config: ImportConfig);
    ngOnInit(): void;
    loadActive(): void;
    onFileSelected(event: any): void;
    doUpload(): void;
    downloadTemplate(): void;
    private static readonly NO_SAMPLES;
    private availableFieldsCache;
    samplesFor(header: string): string[];
    fieldUsedElsewhere(property: string, header: string): boolean;
    availableFields(header: string): any[];
    unmappedRequired: string[];
    private buildMappingDerived;
    confidenceClass(m: any): string;
    onMappingChange(m: any): void;
    confirmMapping(): void;
    reviewColumns: any[];
    private computeReviewColumns;
    displayFor(property: string): string;
    rowIssueText(row: any): string;
    loadRows(after?: () => void): void;
    startEdit(row: any): void;
    cancelEdit(): void;
    saveEdit(): void;
    refreshBatch(): void;
    doCommit(): void;
    startOver(): void;
    close(): void;
    undoImport(): void;
    private applyBatch;
    private applySummary;
    private resetState;
    private gotoStepForStatus;
    private goToStep;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImportDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImportDialogComponent, "spa-import-dialog", 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;
    private sanitizeVisibleValue;
    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 ChecklistComponent, typeof AttachComponent, typeof ChipsComponent, typeof LoaderComponent, typeof NavMenuComponent, typeof TableComponent, typeof DetailsDialog, typeof FormComponent, typeof FormSkeletonComponent, typeof CamelToWordsPipe, typeof AgentMarkdownPipe, typeof NumberComponent, typeof SearchComponent, typeof ViewerComponent, typeof viewerDialog, typeof ListDialogComponent, typeof InvitationsTableComponent, typeof TableHeaderComponent, typeof TableRowComponent, typeof TableActionComponent, typeof InlineCellComponent, typeof MonogramComponent, typeof AlertComponent, typeof EmailComponent, typeof PageComponent, typeof SelectCommonComponent, typeof SuffixComponent, typeof SelectContextDirective, typeof SelectLiteComponent, typeof TextMultiComponent, typeof SelectMultiComponent, typeof SelectBitwiseComponent, typeof HtmlComponent, typeof EditorComponent, 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 AgentPageComponent, typeof BottomTabsComponent, typeof OfflineIndicatorComponent, typeof ImportDialogComponent], [typeof SpaMatModule, typeof i72.HttpClientModule, typeof CurrencyInputModule, typeof i74.AngularEditorModule, typeof i75.BaseChartDirective, typeof i76.DragDropModule], [typeof TinSpaComponent, typeof SpaMatModule, typeof MonogramComponent, 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 ChecklistComponent, typeof FilterComponent, typeof TableComponent, typeof DetailsDialog, typeof FormComponent, typeof FormSkeletonComponent, typeof NumberComponent, typeof SearchComponent, typeof ViewerComponent, typeof viewerDialog, typeof ImportDialogComponent, typeof ListDialogComponent, typeof ListDialogComponent, typeof EmailComponent, typeof PageComponent, typeof HtmlComponent, typeof EditorComponent, 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, typeof AgentPageComponent, typeof OfflineIndicatorComponent]>;
    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;
    private setupService;
    private lastRouteService;
    private runtimeConfig;
    private apiErrorService;
    private socialAuthConfig;
    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, setupService: SetupService, lastRouteService: LastRouteService, runtimeConfig: TinSpaRuntimeConfig, apiErrorService: ApiErrorService, // Added: routes application-level (HTTP 200, success:false) failures through the shared classify + dedupe path
    socialAuthConfig: SocialAuthServiceConfig | null);
    private resumeTarget;
    ngOnInit(): void;
    loginWithMS(): void;
    private doMsalLoginPopup;
    autoLogin: boolean;
    socialUser: SocialUser | null;
    rememberMe: boolean;
    style: string;
    email: string;
    password: string;
    redirectPath: any;
    user: User;
    hide: boolean;
    isProcessing: boolean;
    restoring: boolean;
    restoreOffline: boolean;
    private manualLogin;
    appConfig: AppConfig;
    signup(): void;
    recoverAccount(): void;
    signInManually(): void;
    private logSsoDiagnostics;
    private setupForm;
    login(): void;
    notifications(): void;
    openTerms(): void;
    openPrivacy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }]>;
    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 setupService;
    private dialog;
    private cdr;
    private apiErrorService;
    constructor(httpService: HttpService, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, storageService: StorageService, router: Router, msalService: MsalService, notificationsService: NotificationsService, setupService: SetupService, // Added: SetupService for setup badge
    dialog: MatDialog, cdr: ChangeDetectorRef, // Changed: Inject ChangeDetectorRef for invitation toggle
    apiErrorService: ApiErrorService);
    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;
    private doMsalLoginPopup;
    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;
    private apiErrorService;
    constructor(location: Location, dataService: DataServiceLib, authService: AuthService, messageService: MessageService, apiErrorService: ApiErrorService);
    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;
    private apiErrorService;
    constructor(router: Router, location: Location, httpService: HttpService, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, route: ActivatedRoute, apiErrorService: ApiErrorService);
    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;
    private apiErrorService;
    constructor(dataService: DataServiceLib, messageService: MessageService, httpService: HttpService, router: Router, authService: AuthService, apiErrorService: ApiErrorService);
    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;
    private apiErrorService;
    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>;
}

interface CapStat {
    self: boolean;
    on: number;
    total: number;
    matches: number;
    inconsistent: boolean;
}
interface RoleView {
    role: Role;
    expanded: boolean;
    on: number;
    total: number;
    issues: number;
    stats: {
        [capName: string]: CapStat;
    };
    visible: {
        [capName: string]: boolean;
    };
    joined: {
        [capName: string]: boolean;
    };
    anyPages: boolean;
    anyVisible: boolean;
}
declare class RolesComponent implements OnInit {
    private httpService;
    private router;
    private authService;
    private dataService;
    private dialogService;
    dialog: MatDialog;
    private messageService;
    private apiErrorService;
    constructor(httpService: HttpService, router: Router, authService: AuthService, dataService: DataServiceLib, dialogService: DialogService, dialog: MatDialog, messageService: MessageService, apiErrorService: ApiErrorService);
    ngOnInit(): void;
    isProcessing: boolean;
    roles: Role[];
    RoleAccess: typeof RoleAccess;
    appConfig: AppConfig;
    roleAccessOptions: {
        value: RoleAccess;
        name: string;
    }[];
    topPages: CapItem[];
    topGroups: CapItem[];
    views: RoleView[];
    loaded: boolean;
    filter: string;
    enabledOnly: boolean;
    loadRoles(): void;
    refresh(): void;
    private splitCaps;
    isOn(value: any): boolean;
    private buildViews;
    recount(view: RoleView): void;
    private recomputeVisibility;
    filterChanged(): void;
    clearFilter(): void;
    toggleEnabledOnly(): void;
    toggleRole(view: RoleView): void;
    setValue(view: RoleView, cap: CapItem, value: any, topLevel?: boolean): void;
    trackByRole(index: number, view: RoleView): number;
    trackByCap(index: number, cap: CapItem): string;
    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;
    private apiErrorService;
    constructor(httpService: HttpService, messageService: MessageService, dataService: DataServiceLib, authService: AuthService, router: Router, apiErrorService: ApiErrorService);
    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;
    private apiErrorService;
    constructor(dataService: DataServiceLib, messageService: MessageService, apiErrorService: ApiErrorService);
    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 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, never, [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;
    postProvision(): void;
    private messageService;
    private apiErrorService;
    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 SupplierAgingComponent implements OnInit {
    private dataServiceLib;
    purchasingService: PurchasingService;
    private apiErrorService;
    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;
    private dataService;
    private dialog;
    page?: PageComponent;
    pageConfig: PageConfig;
    ngOnInit(): void;
    newJournal(): 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;
    private httpService;
    private http;
    pageConfig: PageConfig;
    state: any;
    ngOnInit(): void;
    private query;
    load(kind: string): void;
    exportPdf(kind: string): void;
    export(kind: string): 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;
    private httpService;
    private http;
    from: string;
    to: string;
    constructor(dataServiceLib: DataServiceLib, accountingService: AccountingService);
    ngOnInit(): void;
    reportTabConfigs: TableConfig[];
    private withRange;
    buildTabs(): void;
    export(report: string): void;
    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 CreditNotesComponent {
    accountingService: AccountingService;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreditNotesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CreditNotesComponent, "spa-credit-notes", never, {}, {}, never, never, false, never>;
}

declare class VatReturnComponent implements OnInit {
    private httpService;
    private http;
    from: string;
    to: string;
    data: any;
    whtData: any[];
    ngOnInit(): void;
    load(): void;
    export(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VatReturnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VatReturnComponent, "spa-vat-return", never, {}, {}, never, never, false, never>;
}

declare class JournalEntryDialogComponent implements OnInit {
    dialogRef: MatDialogRef<any, any>;
    private httpService;
    private http;
    private messageService;
    private apiErrorService;
    date: string;
    description: string;
    journalType: string;
    accounts: any[];
    lines: any[];
    private transactionTypes;
    ngOnInit(): void;
    private get journalTypeID();
    get totalDebits(): number;
    get totalCredits(): number;
    get isBalanced(): boolean;
    get canPost(): boolean;
    addLine(): void;
    removeLine(index: number): void;
    post(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JournalEntryDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JournalEntryDialogComponent, "spa-journal-lines", never, {}, {}, never, never, false, never>;
}

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

declare class ReceiptsComponent implements OnInit {
    accountingService: AccountingService;
    private dataService;
    private dialog;
    private httpService;
    private http;
    page?: PageComponent;
    pageConfig: PageConfig;
    constructor();
    ngOnInit(): void;
    openDialog(row?: any): void;
    downloadPdf(receipt: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReceiptsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReceiptsComponent, "spa-receipts", never, {}, {}, never, never, false, never>;
}

declare class ReceiptDialogComponent implements OnInit {
    dialogRef: MatDialogRef<any, any>;
    data: any;
    private httpService;
    private http;
    private messageService;
    customerID: number | null;
    receiptDate: string;
    amount: number;
    method: number;
    reference: string;
    customers: any[];
    openInvoices: any[];
    get allocateMode(): boolean;
    get available(): number;
    get totalAllocated(): number;
    get overAllocated(): boolean;
    get canSave(): boolean;
    ngOnInit(): void;
    loadOpenInvoices(): void;
    autoAllocate(): void;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReceiptDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReceiptDialogComponent, "spa-receipt-dialog", never, {}, {}, never, never, false, never>;
}

declare class BankReconciliationComponent implements OnInit {
    accountingService: AccountingService;
    private dialog;
    private dataService;
    page?: PageComponent;
    pageConfig: PageConfig;
    constructor();
    ngOnInit(): void;
    newImport(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BankReconciliationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BankReconciliationComponent, "spa-bank-reconciliation", never, {}, {}, never, never, false, never>;
}

declare class StatementImportDialogComponent implements OnInit {
    dialogRef: MatDialogRef<any, any>;
    private httpService;
    private http;
    private messageService;
    accountID: number | null;
    statementFrom: string;
    statementTo: string;
    closingBalance: number;
    csv: string;
    parseError: string;
    accounts: any[];
    ngOnInit(): void;
    parsedLines: any[];
    netMovement: number;
    parseCsv(): void;
    get canSave(): boolean;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatementImportDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatementImportDialogComponent, "spa-statement-import-dialog", never, {}, {}, never, never, false, never>;
}

declare class ReconcileDialogComponent implements OnInit {
    dialogRef: MatDialogRef<any, any>;
    data: any;
    private httpService;
    private http;
    private messageService;
    rec: any;
    selectedLine: any;
    selectedEntry: any;
    changed: boolean;
    get difference(): number;
    ngOnInit(): void;
    load(): void;
    autoMatch(): void;
    match(): void;
    unmatch(line: any): void;
    complete(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReconcileDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReconcileDialogComponent, "spa-reconcile-dialog", never, {}, {}, never, never, false, never>;
}

declare class RevenueSchedulesComponent implements OnInit {
    accountingService: AccountingService;
    private dataService;
    private dialog;
    page?: PageComponent;
    pageConfig: PageConfig;
    ngOnInit(): void;
    newSchedule(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RevenueSchedulesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RevenueSchedulesComponent, "spa-revenue-schedules", never, {}, {}, never, never, false, never>;
}

declare class RevenueScheduleDialogComponent implements OnInit {
    dialogRef: MatDialogRef<any, any>;
    private httpService;
    private http;
    private messageService;
    invoiceID: number | null;
    startDate: string;
    endDate: string;
    invoices: any[];
    ngOnInit(): void;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RevenueScheduleDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RevenueScheduleDialogComponent, "spa-revenue-schedule-dialog", never, {}, {}, never, never, false, never>;
}

declare class QuotesComponent implements OnInit {
    accountingService: AccountingService;
    private httpService;
    private http;
    pageConfig: PageConfig;
    ngOnInit(): void;
    actionClicked(event: {
        name: string;
        data: any;
    }): void;
    download(quote: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<QuotesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<QuotesComponent, "spa-quotes", 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 CreditNotesComponent, typeof VatReturnComponent, typeof JournalEntryDialogComponent, typeof FiscalPeriodsComponent, typeof ReceiptsComponent, typeof ReceiptDialogComponent, typeof BankReconciliationComponent, typeof StatementImportDialogComponent, typeof ReconcileDialogComponent, typeof RevenueSchedulesComponent, typeof RevenueScheduleDialogComponent, typeof QuotesComponent], [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 SupplierPurchaseOrdersComponent implements OnInit {
    private purchasingService;
    ngOnInit(): void;
    pageConfig: PageConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SupplierPurchaseOrdersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SupplierPurchaseOrdersComponent, "spa-supplier-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 SupplierPurchaseOrdersComponent, 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;
    private apiErrorService;
    constructor(dataService: DataServiceLib, authService: AuthService, apiErrorService: ApiErrorService);
    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 CommissionStatementComponent implements OnInit {
    private dataService;
    private configService;
    private messageService;
    months: {
        value: number;
        name: string;
    }[];
    periodYear: number;
    periodMonth: number;
    busy: boolean;
    previewResult: any;
    generateResult: any;
    entries: any[];
    statementLoaded: boolean;
    totals: {
        draft: number;
        approved: number;
        paid: number;
        reversed: number;
        carried: number;
    };
    tripCommissionEnabled: boolean;
    ngOnInit(): void;
    periodLabel(): string;
    get previewTotal(): number;
    statusClass(entry: any): string;
    clearResults(): void;
    loadStatement(): void;
    private recalculateTotals;
    preview(): void;
    generate(): void;
    private validPeriod;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommissionStatementComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommissionStatementComponent, "spa-commission-statement", 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 CommissionStatementComponent, 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>;
}

type SectionKey = 'members' | 'orgs' | 'invites' | 'email';
declare class TenantSettingsComponent implements OnInit {
    dataService: DataServiceLib;
    private messageService;
    authService: AuthService;
    dialog: MatDialog;
    private apiErrorService;
    constructor(dataService: DataServiceLib, messageService: MessageService, authService: AuthService, dialog: MatDialog, apiErrorService: ApiErrorService);
    ngOnInit(): void;
    newName: any;
    myRole: any;
    tenants: any;
    currTenant: any;
    currentTenantID: any;
    ownTenant: any;
    closed: {
        [K in SectionKey]: boolean;
    };
    counts: {
        members?: number;
        orgs?: number;
        invites?: number;
        email?: number;
    };
    currentTenantName: string;
    belongText: string;
    setWhere(): void;
    toggle(key: SectionKey): void;
    summary(n: number | undefined, one: string, many: string): string;
    emailSummary(n: number | undefined): string;
    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;
    private dataService;
    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;
    private dataService;
    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;
    private dataService;
    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;
    private dataService;
    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;
    private apiErrorService;
    currentSubscription: any;
    availablePlans: any[];
    loading: boolean;
    showConfirmation: boolean;
    selectedPlan: any;
    changingPlan: boolean;
    constructor(httpService: HttpService, subscriptionService: SubscriptionService, snackBar: MatSnackBar, apiErrorService: ApiErrorService);
    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;
    private apiErrorService;
    currentSubscription: any;
    invoices: any[];
    loading: boolean;
    showDetail: boolean;
    selectedInvoice: any;
    showPayment: boolean;
    paymentInvoice: any;
    paymentProcessing: boolean;
    paymentResult: any;
    constructor(httpService: HttpService, snackBar: MatSnackBar, apiErrorService: ApiErrorService);
    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;
    private paymentFailureText;
    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 SyncComponent], [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 SpaDayBookModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaDayBookModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SpaDayBookModule, [typeof DayBookComponent], [typeof i4.CommonModule, typeof SpaMatModule, typeof TinSpaModule], [typeof DayBookComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpaDayBookModule>;
}

declare class SetupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SetupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SetupModule, [typeof SetupGuideComponent, typeof AppConfigurationComponent], [typeof i4.CommonModule, typeof SpaMatModule, typeof TinSpaModule, typeof SpaDayBookModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SetupModule>;
}

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, typeof SetupModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SpaHomeModule>;
}

export { ALSQUARE_SVG_DARK, ALSQUARE_SVG_WHITE, Account, AccountsComponent as AccountingAccountsComponent, AggregatesComponent as AccountingAggregatesComponent, AgingComponent as AccountingAgingComponent, CreditNotesComponent as AccountingCreditNotesComponent, CurrenciesComponent as AccountingCurrenciesComponent, AccountingDashboardComponent, InvoicesComponent as AccountingInvoicesComponent, AccountingModule, ReportsComponent as AccountingReportsComponent, AccountingService, StatementComponent as AccountingStatementComponent, TransactionTypesComponent as AccountingTransactionTypesComponent, TransactionsComponent as AccountingTransactionsComponent, VatReturnComponent as AccountingVatReturnComponent, Action, ActivityComponent, AdminModule, AgentComponent, AgentPageComponent, AgentService, AlertComponent, AlertConfig, AlertMessage, AnalyticsService, ApiErrorService, ApiResponse, AppConfig, AppConfigurationComponent, AppModelsComponent, AssetStatus, AssetsService, AttachComponent, AuthService, BankReconciliationComponent, BillingPageComponent, BottomTab, BrandsComponent, CacheConfig, CapItem, CapsulesComponent, CategoriesComponent, ChangePasswordComponent, ChangeUserPassword, ChartConfig, ChartsComponent, CheckComponent, ChecklistComponent, ChipsComponent, ConfigService, Constants, Core, CreateAccountComponent, CreditNoteStatus, CustomersComponent, DataServiceLib, DateComponent, DatetimeComponent, DayBookComponent, DepartmentsComponent, DetailsDialog, DetailsDialogConfig, DetailsDialogProcessor, DetailsSource, DialogService, EditorComponent, EmailComponent, EmployeesComponent, ExportService, FeatureDirective, FieldLoadIndicator, FilterComponent, FiscalPeriodStatus, FiscalPeriodsComponent, FormComponent, FormConfig, FormSkeletonComponent, GeneralModule, GeneralService, GradesComponent, GroupsComponent, HRModule, HtmlComponent, HttpService, ImportDialogComponent, IndexModule, InventoryDashboardComponent, InventoryModule, InventoryService, InvitationsTableComponent, InvoiceDashboardComponent, InvoiceItemType, InvoiceStatus, JournalEntryDialogComponent, LabelComponent, LastRouteService, ListDialogComponent, ListDialogConfig, LoaderComponent, LoaderService, LoanPaymentsComponent, LoanProductsComponent, LoansComponent, LoansModule, LoansService, LogLevel, LogService, LoginComponent, LogsComponent, MONOGRAM_TONES, ManufacturingModule, MembershipComponent, MessageService, MoneyComponent, MonogramComponent, MovementType, NavMenuComponent, NotesComponent, NotesConfig, NotificationsService, NumberComponent, OfflineIndicatorComponent, OfflineService, OnboardingComponent, OptionComponent, OverviewDashboardComponent, OverviewModule, PageComponent, PageConfig, PaginationConfig, PayrollDashboardComponent, PayrollModule, PayrollService, PerceivedProgress, PlansComponent, PositionsComponent, PrivacyDialogComponent, ProductionService, Profile, ProfileComponent, PurchaseStatus, PurchasingDashboardComponent, PurchasingModule, PurchasingService, PushNotificationService, QUIET_DELAY_MS, QUIET_MIN_MS, QuoteStatus, QuotesComponent, ReceiptDialogComponent, ReceiptStatus, ReceiptsComponent, ReconcileDialogComponent, RecoverAccountComponent, Register, RevenueScheduleDialogComponent, RevenueSchedulesComponent, Role, RoleAccess, RolesComponent, SalesDashboardComponent, SalesModule, SalesService, SearchComponent, SearchConfig, SecurityConfig, SelectBitwiseComponent, SelectComponent, SelectLiteComponent, SelectMultiComponent, SettingsComponent, SetupGuideComponent, SetupService, SignupComponent, SignupData, SpaAdminModule, SpaDayBookModule, SpaHomeModule, SpaIndexModule, SpaLandingComponent, SpaMatModule, SpaUserModule, StatementImportDialogComponent, StatusesComponent, Step, StepConfig, StepsComponent, StorageService, SubCategoriesComponent, SubscriptionPageComponent, SubscriptionService, SuppliersComponent, SyncComponent, TIN_SILENT_REQUEST, TIN_SPA_RUNTIME_CONFIG, 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, getTinSpaAppSettings, isSilentRequest, loadTinSpaAppSettings, loginConfig, messageDialog, moduleGuard, monogramInitials, monogramKind, monogramPaletteIndex, provideTinSpaRuntime, resolveQuietLoading, silentContext, tinSpaLocationStrategyFactory, tinSpaMsalInstanceFactory, tinSpaRuntimeConfigFactory, viewerDialog };
export type { AgentMessage, AgentSessionInfo, ApiErrorInfo, ApiErrorKind, AppConfigSection, AppConfigurationConfig, AppFailureClass, AppFailureContext, AutoRefreshConfig, BitwiseOption, Button, CacheRule, CapsuleConfig, CardConfig, ChartItem, ChecklistAction, ChecklistConfig, ChecklistItem, ChildField, CloseOptions, Color, Column, Confirm, ConversationSummary, CreateTabConfig, DayBookConfig, DayBookGroupView, DayBookLane, DayBookSection, DayBookSectionView, DayBookStage, DayBookStageTiles, Field, GroupConfig, GroupData, Icon, ImportConfig, InlineEditConfig, LandingBrandOverride, LandingColors, LandingConfig, LandingFeature, LandingFooterColumn, LandingFooterLink, LandingMetric, LandingModuleGroup, LandingModuleTile, LandingNavLink, LandingPricingPlan, LandingSecurityItem, LandingStep, LandingTestimonial, MonogramKind, OfflineConfig, OfflineEntry, OfflineOpStatus, OutboxOp, PerceivedProgressOptions, QuietLoadingHost, RefreshResult, SearchField, SetupApprovalPreset, SetupConfig, SetupModule$1 as SetupModule, SetupNotificationPreset, SetupPreset, SetupPresetCatalog, SetupPresetRole, SetupPresetSelection, SetupRoleTemplate, SetupSeedOffer, SetupStatus, SetupStep, SetupStepAction, SpaChartType, StatusConfig, StatusItem, StatusState, TableSectionChip, TableSectionConfig, TableViewType, Tile, TileChartConfig, TileChartType, TileStyle, TinSpaAppSettings, TinSpaMsalConfig, TinSpaMsalSettings, TinSpaRuntimeConfig, TinSpaTableDefaults, VisibilityValue, VisibleTab };