@xiriframework/xiri-ng 0.2.0

package/types/xiriframework-xiri-ng.d.ts

@@ -0,0 +1,1219 @@
+import * as _angular_core from '@angular/core';
+import { PipeTransform, OnInit, OnDestroy, ChangeDetectorRef, TemplateRef, Signal, WritableSignal, EnvironmentProviders } from '@angular/core';
+import { FormControl, UntypedFormGroup, UntypedFormControl } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import { MatTableDataSource, MatTable } from '@angular/material/table';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import { SelectionModel } from '@angular/cdk/collections';
+import { MatDialogRef } from '@angular/material/dialog';
+import { MatStepper } from '@angular/material/stepper';
+import { StepperSelectionEvent } from '@angular/cdk/stepper';
+import { Locale } from 'date-fns';
+import { MatSnackBarRef, TextOnlySnackBar } from '@angular/material/snack-bar';
+
+type XiriThemeColor = 'primary' | 'secondary' | 'tertiary' | 'accent' | 'warn' | 'error' | 'success';
+type XiriExtendedColor = 'emerald' | 'red' | 'yellow' | 'green' | 'blue' | 'purple' | 'gray' | 'lightgray' | 'darkgray' | 'orange';
+type XiriColor = XiriThemeColor | XiriExtendedColor;
+
+declare class SafehtmlPipe implements PipeTransform {
+    private sanitizer;
+    transform(style: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SafehtmlPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SafehtmlPipe, "safeHtml", true>;
+}
+
+interface XiriFormValidator {
+    id: string;
+    name?: string;
+    validator: any;
+    message: string;
+}
+interface XiriFormFieldSelectOption {
+    id: number;
+    name: string;
+    disabled?: boolean;
+    color?: XiriColor;
+}
+interface XiriTagChip {
+    label: string;
+    color?: XiriColor;
+}
+type XiriFormFieldConditionOperator = 'equals' | 'notEquals' | 'contains' | 'greaterThan' | 'lessThan' | 'in' | 'notEmpty';
+interface XiriFormFieldCondition {
+    field: string;
+    operator: XiriFormFieldConditionOperator;
+    value?: any;
+}
+interface XiriFormField {
+    id: string;
+    type: string;
+    subtype?: string;
+    formtype?: string;
+    name?: string;
+    hint?: string;
+    class?: string;
+    textPrefix?: string;
+    textSuffix?: string;
+    iconPrefix?: string;
+    iconSuffix?: string;
+    locale?: string;
+    value?: any;
+    validations?: XiriFormValidator[];
+    list?: XiriFormFieldSelectOption[];
+    texts?: object;
+    hide?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    multiple?: boolean;
+    url?: string;
+    search?: boolean;
+    serverSideSearch?: boolean;
+    params?: object;
+    rows?: number;
+    accept?: string;
+    pwdhide?: boolean;
+    icon?: string;
+    iconColor?: XiriColor;
+    done?: boolean;
+    showWhen?: XiriFormFieldCondition | XiriFormFieldCondition[];
+    control?: FormControl;
+    placeholder?: string;
+    array?: any[];
+    tree?: boolean;
+}
+
+type XiriFormFieldDisplay = 'full' | 'line' | 'small';
+declare class XiriFormFieldsComponent implements OnInit, OnDestroy {
+    private formBuilder;
+    protected _changeDetectorRef: ChangeDetectorRef;
+    form: _angular_core.InputSignal<XiriFormField[]>;
+    display: _angular_core.InputSignal<XiriFormFieldDisplay>;
+    formChange: _angular_core.OutputEmitterRef<any>;
+    check: _angular_core.InputSignal<Observable<void>>;
+    formGroup: UntypedFormGroup;
+    private subs;
+    private lastValue;
+    private _fields;
+    private _fieldsLoaded;
+    private _initialEmitDone;
+    constructor();
+    ngOnInit(): void;
+    fields: _angular_core.Signal<XiriFormField[]>;
+    private createControl;
+    private bindValidations;
+    ngOnDestroy(): void;
+    private validateAllFormFields;
+    isFieldVisible(field: XiriFormField): boolean;
+    toggleSection(header: XiriFormField): void;
+    private isInCollapsedSection;
+    private evaluateCondition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriFormFieldsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriFormFieldsComponent, "xiri-form-fields", never, { "form": { "alias": "form"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "check": { "alias": "check"; "required": false; "isSignal": true; }; }, { "formChange": "formChange"; }, never, never, true, never>;
+}
+
+type XiriSelectPredicate = <T>(filter: string, element: XiriFormFieldSelectOption) => boolean;
+declare const DEFAULT_PREDICATE: XiriSelectPredicate;
+type XiriSelectCompare = <T>(a: XiriFormFieldSelectOption, b: XiriFormFieldSelectOption) => boolean;
+declare const DEFAULT_COMPARE: XiriSelectCompare;
+declare class XiriSelectDirective<T> {
+    private dataService;
+    private cdr;
+    get formControl(): UntypedFormControl;
+    get filter(): rxjs.Observable<XiriFormFieldSelectOption[]>;
+    /** control for the MatSelect filter keyword multi-selection */
+    private _filterFormControl;
+    /** list of _allValues filtered by search keyword */
+    private _filteredValuesSubject;
+    /** indicate search operation is in progress */
+    searching: boolean;
+    /** Subject that emits when the component has been destroyed. */
+    protected _onDestroy: Subject<void>;
+    searchPredicate: _angular_core.InputSignal<XiriSelectPredicate>;
+    compareWith: _angular_core.InputSignal<XiriSelectCompare>;
+    serverSideSearch: _angular_core.InputSignal<boolean>;
+    serverUrl: _angular_core.InputSignal<string>;
+    serverParams: _angular_core.InputSignal<any>;
+    /** list of _allValues */
+    private _allValues;
+    allValues: _angular_core.InputSignal<XiriFormFieldSelectOption[]>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private applyFilter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriSelectDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<XiriSelectDirective<any>, "[xiriSelect]", ["xiriSelect"], { "searchPredicate": { "alias": "predicate"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compare"; "required": false; "isSignal": true; }; "serverSideSearch": { "alias": "serverSideSearch"; "required": false; "isSignal": true; }; "serverUrl": { "alias": "serverUrl"; "required": false; "isSignal": true; }; "serverParams": { "alias": "serverParams"; "required": false; "isSignal": true; }; "allValues": { "alias": "values"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriButton {
+    text: string;
+    type: string;
+    action: string;
+    default?: boolean;
+    url?: string;
+    hide?: boolean;
+    color?: XiriColor;
+    icon?: string;
+    iconColor?: XiriColor;
+    fontIcon?: string;
+    fontSet?: string;
+    class?: string;
+    hint?: string;
+    tabIndex?: number;
+    inline?: boolean;
+    disabled?: boolean;
+    data?: any;
+    target?: string;
+    loading?: boolean;
+    filename?: string;
+    check?: any;
+    send?: any;
+    menuItems?: {
+        action: string;
+        url?: string;
+        icon?: string;
+        color?: string;
+        text?: string;
+        data?: any;
+    }[];
+}
+interface XiriButtonResult {
+    button: XiriButton;
+    result: any;
+    done: boolean;
+    loading: boolean;
+}
+declare class XiriButtonComponent implements OnDestroy {
+    button: _angular_core.InputSignal<XiriButton>;
+    disabled: _angular_core.InputSignal<boolean>;
+    filterData: _angular_core.InputSignal<any>;
+    url: _angular_core.InputSignal<string>;
+    result: _angular_core.OutputEmitterRef<XiriButtonResult>;
+    private dialogRef?;
+    private subs;
+    private loading;
+    private dataService;
+    private location;
+    private router;
+    private dialog;
+    private downloadService;
+    _disabled: _angular_core.Signal<boolean>;
+    _url: _angular_core.Signal<string>;
+    clicked(event: MouseEvent): void;
+    private actionDialog;
+    openMenuDialog(event: MouseEvent, item: any): void;
+    private actionApi;
+    private actionDownload;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriButtonComponent, "xiri-button", never, { "button": { "alias": "button"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "filterData": { "alias": "filterData"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; }, { "result": "result"; }, never, never, true, never>;
+}
+
+interface XiriTableField {
+    id: string;
+    name: string;
+    format?: string;
+    search?: boolean;
+    sort?: boolean;
+    buttons?: XiriButton[];
+    icons?: {
+        icon: string;
+        color?: string;
+        hint?: string;
+    }[];
+    display?: string;
+    header?: string;
+    sticky?: boolean;
+    inputType?: string;
+    inputRequired?: boolean;
+    inputLang?: string;
+    inputPaste?: boolean;
+    textPrefix?: string;
+    textSuffix?: string;
+    width?: string;
+    minWidth?: string;
+    hide?: boolean;
+    headerSpan?: number;
+    align?: 'left' | 'center' | 'right';
+    footer?: 'no' | 'count' | 'sum' | 'static';
+    webformat?: string;
+}
+
+interface XiriRawTableSettings {
+    data: any;
+    fields?: XiriTableField[];
+    dense?: number;
+    forceMinWidth?: boolean;
+}
+declare class XiriRawTableComponent {
+    settings: _angular_core.InputSignal<XiriRawTableSettings>;
+    displayedColumns: any[];
+    columnsToDisplay: string[];
+    dataSource: MatTableDataSource<any>;
+    tableClass: string;
+    constructor();
+    private loadFields;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriRawTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriRawTableComponent, "xiri-raw-table", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriButtonlineSettings {
+    buttons: XiriButton[];
+    class: string;
+}
+declare class XiriButtonlineComponent {
+    settings: _angular_core.InputSignal<XiriButtonlineSettings>;
+    disabled: _angular_core.InputSignal<boolean>;
+    filterData: _angular_core.InputSignal<any>;
+    result: _angular_core.OutputEmitterRef<XiriButtonResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriButtonlineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriButtonlineComponent, "xiri-buttonline", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "filterData": { "alias": "filterData"; "required": false; "isSignal": true; }; }, { "result": "result"; }, never, never, true, never>;
+}
+
+interface XiriDynData {
+    id?: number;
+    type: string;
+    data?: any;
+    display?: string;
+    newRow?: boolean;
+}
+
+interface XiriTableEmptyState {
+    icon?: string;
+    iconColor?: XiriColor;
+    title?: string;
+    description?: string;
+}
+interface XiriTableOptions {
+    reload?: boolean;
+    dense?: boolean;
+    sort?: boolean;
+    search?: boolean;
+    class?: string;
+    pagination?: boolean;
+    itemsPerPage?: number;
+    pageSizes?: number[];
+    select?: boolean;
+    selectButtons?: XiriButton[];
+    title?: string;
+    textNoData?: string;
+    emptyState?: XiriTableEmptyState;
+    buttons?: XiriButtonlineSettings;
+    minWidth?: string;
+    saveState?: boolean;
+    saveStateId?: string;
+    saveInput?: string;
+    saveInputUrl?: string;
+    borders?: boolean;
+    bordersHeader?: boolean;
+    footer?: boolean;
+    serverSide?: boolean;
+    scrollHeight?: string;
+}
+interface XiriTableSettings {
+    url?: string;
+    data?: any;
+    fields?: XiriTableField[];
+    options?: XiriTableOptions;
+    hasFilter?: boolean;
+}
+declare class XiriTableComponent implements OnInit, OnDestroy {
+    private dialog;
+    private dataService;
+    private router;
+    private sessionStorageService;
+    private numberService;
+    private snackbar;
+    protected _changeDetectorRef: ChangeDetectorRef;
+    dyncomponent: _angular_core.InputSignal<TemplateRef<any>>;
+    settings: _angular_core.InputSignal<XiriTableSettings>;
+    filterData: _angular_core.InputSignal<any>;
+    clickedRow: _angular_core.OutputEmitterRef<any>;
+    paginator: _angular_core.Signal<MatPaginator>;
+    sort: _angular_core.Signal<MatSort>;
+    table: _angular_core.Signal<MatTable<any>>;
+    loading: _angular_core.WritableSignal<boolean>;
+    private _totalCount;
+    displayedColumns: XiriTableField[];
+    columnsToDisplay: string[];
+    columnsToSearch: string[];
+    dataSource: MatTableDataSource<any>;
+    protected _displayeddata: readonly any[];
+    _alldata: _angular_core.WritableSignal<any[]>;
+    footer: any[];
+    extraHeaderFields: XiriTableField[];
+    extraHeaders: string[];
+    selection: SelectionModel<any>;
+    private dialogRef?;
+    private subs;
+    private subsStatic;
+    options: XiriTableOptions;
+    dynData: {
+        data: XiriDynData[];
+        filterData: any;
+    };
+    errorMsg: string;
+    private _firstData;
+    searchText: string;
+    _filterData: _angular_core.Signal<any>;
+    constructor();
+    ngOnInit(): void;
+    private loadData;
+    private loadFields;
+    private setData;
+    private setFooter;
+    reload(): void;
+    searchDo($event: any): void;
+    isAllSelected(): boolean;
+    masterToggle(): void;
+    clicked(row: any): void;
+    openDialog(event: MouseEvent, button: any, id: any, subid: any, row: any): void;
+    openMenuDialog(event: MouseEvent, item: any, columnId: string, buttonIndex: number, menuItemIndex: number, row: any): void;
+    openDialogSelection(event: MouseEvent, button: XiriButton): boolean;
+    private startDialog;
+    apiCall(event: MouseEvent, url: string): void;
+    apiCallSelection(event: MouseEvent, button: XiriButton): void;
+    saveCall(event: MouseEvent, button: XiriButton, row: any, url: string): void;
+    saveCallCheck(button: XiriButton, row: any): boolean;
+    downloadSelection(event: MouseEvent, button: XiriButton): void;
+    private makeApiCall;
+    buttonReturn(event: XiriButtonResult): void;
+    private callReturn;
+    private getSelectionIDs;
+    ngOnDestroy(): void;
+    pasteInput($event: any, row: any, column: XiriTableField): boolean;
+    saveInputData(): void;
+    private cleanup;
+    private getSortingDataAccessor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriTableComponent, "xiri-table", never, { "dyncomponent": { "alias": "dyncomponent"; "required": false; "isSignal": true; }; "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "filterData": { "alias": "filterData"; "required": false; "isSignal": true; }; }, { "clickedRow": "clickedRow"; }, never, never, true, never>;
+}
+
+interface XiriFormSettings {
+    load?: boolean;
+    url: string;
+    fields?: any[];
+    buttons?: XiriButton[];
+    header?: string;
+}
+declare class XiriFormComponent implements OnInit, OnDestroy {
+    settings: _angular_core.InputSignal<XiriFormSettings>;
+    private location;
+    private formService;
+    formFields: _angular_core.WritableSignal<XiriFormField[]>;
+    loading: _angular_core.WritableSignal<boolean>;
+    done: _angular_core.WritableSignal<boolean>;
+    error: _angular_core.WritableSignal<string>;
+    private subs;
+    private url;
+    buttons: XiriButton[];
+    private extra;
+    private formValues;
+    formValid: boolean;
+    checkSubject: Subject<void>;
+    ngOnInit(): void;
+    private send;
+    private loadData;
+    clickButton(button: XiriButton): void;
+    private startSend;
+    formChanged(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriFormComponent, "xiri-form", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriDialogSettings {
+    url?: string;
+    size?: string;
+    type: "form" | "data" | "question" | "waiting" | "table";
+    data?: any;
+    filter?: any;
+}
+declare class XiriDialogComponent implements OnDestroy {
+    dialogRef: MatDialogRef<XiriDialogComponent, any>;
+    initData: any;
+    private breakpointObserver;
+    private dataService;
+    private router;
+    private snackbar;
+    type: _angular_core.WritableSignal<string>;
+    header: _angular_core.WritableSignal<string>;
+    buttons: _angular_core.WritableSignal<XiriButton[]>;
+    private url;
+    private extra;
+    private subs;
+    private downloadService;
+    formFields: _angular_core.WritableSignal<XiriFormField[]>;
+    loading: _angular_core.WritableSignal<boolean>;
+    done: _angular_core.WritableSignal<boolean>;
+    error: _angular_core.WritableSignal<string>;
+    private formValues;
+    formValid: _angular_core.WritableSignal<boolean>;
+    checkSubject: Subject<void>;
+    private to;
+    private refreshTime;
+    rawTable: XiriRawTableSettings;
+    constructor();
+    private send;
+    private showError;
+    private loadData;
+    private refresh;
+    download(data: any): void;
+    clickButton(button: XiriButton): void;
+    private startSend;
+    formChanged(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriDialogComponent, "xiri-dialog", never, {}, {}, never, never, true, never>;
+}
+
+interface XiriQuerySettings {
+    fields?: XiriFormField[];
+    dyn?: any[];
+    url?: string;
+    buttonline?: XiriDynData;
+    extra?: any;
+    saveState?: boolean;
+    saveStateId?: string;
+}
+declare class XiriQueryComponent implements OnInit, OnDestroy {
+    private dataService;
+    private formService;
+    private cdr;
+    settings: _angular_core.InputSignal<XiriQuerySettings>;
+    dyncomponent: _angular_core.InputSignal<TemplateRef<any>>;
+    change: _angular_core.OutputEmitterRef<any>;
+    private subs;
+    private waiter;
+    dynData: {
+        data: XiriDynData[];
+        filterData: any;
+    };
+    private saveState;
+    private saveStateId;
+    private extra;
+    private _initialChangeDone;
+    data: _angular_core.WritableSignal<XiriDynData[]>;
+    error: _angular_core.WritableSignal<string>;
+    formFields: _angular_core.WritableSignal<XiriFormField[]>;
+    formValid: _angular_core.WritableSignal<boolean>;
+    filterData: _angular_core.WritableSignal<any>;
+    loading: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
+    formChanged(event: any): void;
+    ngOnDestroy(): void;
+    clickedButton(event: XiriButtonResult): void;
+    private load;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriQueryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriQueryComponent, "xiri-query", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "dyncomponent": { "alias": "dyncomponent"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+interface XiriCardSettings {
+    url?: string;
+    reload?: boolean;
+    data?: any;
+    fields?: XiriTableField[];
+    header?: string;
+    headerSub?: string;
+    headerIcon?: string;
+    headerIconColor?: XiriColor;
+    buttons?: XiriButton[];
+    buttonsTop?: XiriButtonlineSettings;
+    buttonsBottom?: XiriButtonlineSettings;
+    dense?: number;
+    forceMinWidth?: boolean;
+}
+declare class XiriCardComponent implements OnDestroy {
+    private dataService;
+    private cdr;
+    private subs;
+    settings: _angular_core.InputSignal<XiriCardSettings>;
+    loading: _angular_core.WritableSignal<boolean>;
+    errorMsg: _angular_core.WritableSignal<string>;
+    private _data;
+    cardData: Signal<any>;
+    rawTable: Signal<XiriRawTableSettings | null>;
+    constructor();
+    private loadData;
+    reload(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriCardComponent, "xiri-card", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class XiriButtonstyleComponent {
+    button: _angular_core.InputSignal<XiriButton>;
+    disabled: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriButtonstyleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriButtonstyleComponent, "xiri-buttonstyle", never, { "button": { "alias": "button"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class XiriDynComponentComponent {
+    data: _angular_core.InputSignal<XiriDynData[]>;
+    filterData: _angular_core.InputSignal<any>;
+    dyncomponent: _angular_core.InputSignal<TemplateRef<any>>;
+    dataInt: _angular_core.Signal<XiriDynData[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriDynComponentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriDynComponentComponent, "xiri-dyncomponent", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "filterData": { "alias": "filterData"; "required": false; "isSignal": true; }; "dyncomponent": { "alias": "dyncomponent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriCardlinkSettings {
+    link: string;
+    icon?: string;
+    iconSet: string;
+    text?: string;
+    sub?: string;
+}
+declare class XiriCardlinkComponent {
+    settings: _angular_core.InputSignal<XiriCardlinkSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriCardlinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriCardlinkComponent, "xiri-cardlink", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriLinksSettings {
+    data: XiriButton[];
+    headerIcon?: string;
+    headerIconColor?: XiriColor;
+    headerSub?: string;
+    header?: string;
+}
+declare class XiriLinksComponent implements OnDestroy {
+    settings: _angular_core.InputSignal<XiriLinksSettings>;
+    private dialog;
+    private router;
+    private dialogRef?;
+    ngOnDestroy(): void;
+    openDialog(item: XiriButton): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriLinksComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriLinksComponent, "xiri-links", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriAlertConfig {
+    header: string;
+    text: string;
+    icon: string;
+    buttons: XiriButton[];
+}
+declare class XiriAlertComponent implements OnInit, OnDestroy {
+    dialogRef: MatDialogRef<XiriAlertComponent, any>;
+    initData: any;
+    private breakpointObserver;
+    loading: _angular_core.WritableSignal<boolean>;
+    header: _angular_core.WritableSignal<string>;
+    buttons: _angular_core.WritableSignal<XiriButton[]>;
+    text: _angular_core.WritableSignal<string>;
+    icon: _angular_core.WritableSignal<string>;
+    private sub;
+    ngOnInit(): void;
+    private loadData;
+    clickButton(button: XiriButton): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriAlertComponent, "xiri-alert", never, {}, {}, never, never, true, never>;
+}
+
+interface XiriStepperSettings {
+    url?: string;
+    steps: XiriStepperStep[];
+}
+interface XiriStepperStep {
+    url?: string;
+    title: string;
+    fields: XiriFormField[];
+    data?: any;
+    extra?: any;
+    buttons: XiriButton[];
+}
+interface StepState {
+    url?: string;
+    title: string;
+    completed: WritableSignal<boolean>;
+    check: WritableSignal<boolean>;
+    valid: WritableSignal<boolean>;
+    load: WritableSignal<boolean>;
+    gotonext: WritableSignal<boolean>;
+    errorMsg: WritableSignal<string | null>;
+    fields: WritableSignal<XiriFormField[]>;
+    buttons: WritableSignal<XiriButton[]>;
+    data?: any;
+    extra?: any;
+}
+declare class XiriStepperComponent implements OnInit {
+    private dataService;
+    private location;
+    private router;
+    private destroyRef;
+    settings: _angular_core.InputSignal<XiriStepperSettings>;
+    done: WritableSignal<boolean>;
+    private calls;
+    stepper: _angular_core.Signal<MatStepper>;
+    steps: WritableSignal<StepState[]>;
+    ngOnInit(): void;
+    stepChanged($event: StepperSelectionEvent): void;
+    formChanged(step: StepState, event: any, i: number): void;
+    clickButton(button: XiriButton): void;
+    private checkStep;
+    private showError;
+    private sendStep;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriStepperComponent, "xiri-stepper", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class XiriDoneComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriDoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriDoneComponent, "xiri-done", never, {}, {}, never, never, true, never>;
+}
+
+declare class XiriErrorComponent {
+    text: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriErrorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriErrorComponent, "xiri-error", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriHeaderSettings {
+    text: string;
+    color: string;
+    size: string;
+}
+declare class XiriHeaderComponent {
+    settings: _angular_core.InputSignal<XiriHeaderSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriHeaderComponent, "xiri-header", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriListSettings {
+    sections: XiriListSection[];
+}
+interface XiriListSection {
+    name: string;
+    data: XiriListItem[];
+}
+interface XiriListItem {
+    name: string;
+    info: string;
+    icon: string;
+    iconSet?: string;
+    iconColor: string;
+    url: string;
+    hasFavorite?: boolean;
+    isFavorite?: boolean;
+    favoriteUrl?: string;
+    favoriteHint?: string;
+}
+declare class XiriListComponent implements OnDestroy {
+    settings: _angular_core.InputSignal<XiriListSettings>;
+    private dataService;
+    private subs;
+    changeFavorite(item: XiriListItem, event: Event): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriListComponent, "xiri-list", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriInfopointSettings {
+    text: string;
+    info: string;
+    url?: string;
+    urlParams?: object;
+    icon: string;
+    iconSet?: string;
+    iconColor: XiriColor;
+    dense?: boolean;
+}
+declare class XiriInfopointComponent {
+    settings: _angular_core.InputSignal<XiriInfopointSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriInfopointComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriInfopointComponent, "xiri-infopoint", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriMultiprogressSettings {
+    data: XiriMultiprogressItem[];
+    headerIcon?: string;
+    headerIconColor?: XiriColor;
+    header?: string;
+    show?: number;
+}
+interface XiriMultiprogressItem {
+    text: string;
+    value: string;
+    progress: number;
+    color?: XiriColor;
+}
+declare class XiriMultiprogressComponent {
+    isOpen: _angular_core.WritableSignal<boolean>;
+    settings: _angular_core.InputSignal<XiriMultiprogressSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriMultiprogressComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriMultiprogressComponent, "xiri-multiprogress", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriImagetextSettings {
+    url: string;
+    info: string;
+    headerIcon?: string;
+    headerIconColor?: XiriColor;
+    headerSub?: string;
+    header?: string;
+}
+declare class XiriImagetextComponent {
+    settings: _angular_core.InputSignal<XiriImagetextSettings>;
+    loading: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriImagetextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriImagetextComponent, "xiri-imagetext", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class XiriSearchComponent implements OnInit, OnDestroy {
+    changed: _angular_core.OutputEmitterRef<string>;
+    placeholder: _angular_core.InputSignal<string>;
+    open: _angular_core.InputSignal<boolean>;
+    reset: _angular_core.InputSignal<number>;
+    escape: _angular_core.InputSignal<boolean>;
+    focus: _angular_core.InputSignal<number>;
+    private _search;
+    private subs;
+    private filter;
+    _text: string;
+    show: boolean;
+    constructor();
+    ngOnInit(): void;
+    onKeydownHandler(): void;
+    text: _angular_core.InputSignal<string>;
+    searchDo(): void;
+    ngOnDestroy(): void;
+    click(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriSearchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriSearchComponent, "xiri-search", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "reset": { "alias": "reset"; "required": false; "isSignal": true; }; "escape": { "alias": "escape"; "required": false; "isSignal": true; }; "focus": { "alias": "focus"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+interface XiriSidebarSettings {
+    prefix: string;
+    fields: XiriNavigationField[];
+}
+interface XiriNavigationField {
+    name: string;
+    link?: string;
+    icon: string;
+    iconSet?: string;
+    extern?: string;
+    active?: boolean;
+    path?: string;
+    regex?: RegExp;
+    menu?: boolean;
+    showSubmenu?: boolean;
+    sub?: XiriNavigationField[];
+}
+declare class XiriSidenavComponent {
+    private router;
+    private cdr;
+    settings: _angular_core.InputSignal<XiriSidebarSettings>;
+    loading: boolean;
+    fields: XiriNavigationField[];
+    private prefix;
+    constructor();
+    private checkUrl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriSidenavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriSidenavComponent, "xiri-sidenav", never, { "settings": { "alias": "settings"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriTabSettings {
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    data: XiriDynData[];
+    lazy?: boolean;
+    unload?: boolean;
+}
+interface XiriTabsSettings {
+    tabs: XiriTabSettings[];
+    selectedIndex?: number;
+    dynamicHeight?: boolean;
+    animationDuration?: string;
+    lazy?: boolean;
+    unload?: boolean;
+    headerPosition?: 'above' | 'below';
+    alignTabs?: 'start' | 'center' | 'end';
+    stretchTabs?: boolean;
+}
+declare class XiriTabsComponent {
+    settings: _angular_core.InputSignal<XiriTabsSettings>;
+    filterData: _angular_core.InputSignal<any>;
+    dyncomponent: _angular_core.InputSignal<TemplateRef<any>>;
+    selectedIndex: _angular_core.WritableSignal<number>;
+    visitedTabs: _angular_core.WritableSignal<Set<number>>;
+    constructor();
+    onTabChange(index: number): void;
+    shouldRenderContent(index: number, tab: XiriTabSettings): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriTabsComponent, "xiri-tabs", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "filterData": { "alias": "filterData"; "required": false; "isSignal": true; }; "dyncomponent": { "alias": "dyncomponent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriExpansionPanelSettings {
+    title: string;
+    description?: string;
+    icon?: string;
+    disabled?: boolean;
+    expanded?: boolean;
+    data: XiriDynData[];
+    lazy?: boolean;
+    unload?: boolean;
+}
+interface XiriExpansionSettings {
+    panels: XiriExpansionPanelSettings[];
+    multi?: boolean;
+    displayMode?: 'default' | 'flat';
+    togglePosition?: 'before' | 'after';
+    hideToggle?: boolean;
+    lazy?: boolean;
+    unload?: boolean;
+}
+declare class XiriExpansionComponent {
+    settings: _angular_core.InputSignal<XiriExpansionSettings>;
+    filterData: _angular_core.InputSignal<any>;
+    dyncomponent: _angular_core.InputSignal<TemplateRef<any>>;
+    openedPanels: _angular_core.WritableSignal<Set<number>>;
+    visitedPanels: _angular_core.WritableSignal<Set<number>>;
+    onPanelOpened(index: number): void;
+    onPanelClosed(index: number): void;
+    shouldRenderContent(index: number, panel: XiriExpansionPanelSettings): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriExpansionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriExpansionComponent, "xiri-expansion", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "filterData": { "alias": "filterData"; "required": false; "isSignal": true; }; "dyncomponent": { "alias": "dyncomponent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriBreadcrumbItem {
+    label: string;
+    link?: string;
+    icon?: string;
+    extern?: boolean;
+}
+declare class XiriBreadcrumbComponent {
+    items: _angular_core.InputSignal<XiriBreadcrumbItem[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriBreadcrumbComponent, "xiri-breadcrumb", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type XiriSkeletonType = 'text' | 'circle' | 'rect' | 'table-row';
+declare class XiriSkeletonComponent {
+    type: _angular_core.InputSignal<XiriSkeletonType>;
+    width: _angular_core.InputSignal<string>;
+    height: _angular_core.InputSignal<string>;
+    lines: _angular_core.InputSignal<number>;
+    columns: _angular_core.InputSignal<number>;
+    animate: _angular_core.InputSignal<boolean>;
+    linesArray: _angular_core.Signal<unknown[]>;
+    columnsArray: _angular_core.Signal<unknown[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriSkeletonComponent, "xiri-skeleton", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "animate": { "alias": "animate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriEmptyStateSettings {
+    icon?: string;
+    iconColor?: XiriColor;
+    title?: string;
+    description?: string;
+    button?: XiriButton;
+}
+declare class XiriEmptyStateComponent {
+    settings: _angular_core.InputSignal<XiriEmptyStateSettings>;
+    buttonResult: _angular_core.OutputEmitterRef<XiriButtonResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriEmptyStateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriEmptyStateComponent, "xiri-empty-state", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, { "buttonResult": "buttonResult"; }, never, never, true, never>;
+}
+
+interface XiriStatTrend {
+    value: number;
+    direction: 'up' | 'down' | 'neutral';
+}
+interface XiriStatSettings {
+    value: string | number;
+    label: string;
+    icon?: string;
+    iconColor?: XiriColor;
+    trend?: XiriStatTrend;
+    prefix?: string;
+    suffix?: string;
+    color?: XiriColor;
+}
+declare class XiriStatComponent {
+    settings: _angular_core.InputSignal<XiriStatSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriStatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriStatComponent, "xiri-stat", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriTimelineItem {
+    title: string;
+    description?: string;
+    datetime?: string;
+    icon?: string;
+    iconColor?: XiriColor;
+}
+interface XiriTimelineSettings {
+    items: XiriTimelineItem[];
+}
+declare class XiriTimelineComponent {
+    settings: _angular_core.InputSignal<XiriTimelineSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriTimelineComponent, "xiri-timeline", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriPageHeaderSettings {
+    title: string;
+    subtitle?: string;
+    icon?: string;
+    iconColor?: string;
+    buttons?: XiriButtonlineSettings;
+}
+declare class XiriPageHeaderComponent {
+    settings: _angular_core.InputSignal<XiriPageHeaderSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriPageHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriPageHeaderComponent, "xiri-page-header", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriSectionSettings {
+    title?: string;
+    subtitle?: string;
+    icon?: string;
+    iconColor?: string;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    buttons?: XiriButtonlineSettings;
+    components?: XiriDynData[];
+}
+declare class XiriSectionComponent {
+    settings: _angular_core.InputSignal<XiriSectionSettings>;
+    dyncomponent: _angular_core.InputSignal<TemplateRef<any>>;
+    collapsed: _angular_core.WritableSignal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriSectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriSectionComponent, "xiri-section", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "dyncomponent": { "alias": "dyncomponent"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface XiriDividerSettings {
+    text?: string;
+    icon?: string;
+    spacing?: 'compact' | 'normal' | 'large';
+}
+declare class XiriDividerComponent {
+    settings: _angular_core.InputSignal<XiriDividerSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriDividerComponent, "xiri-divider", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriStatGridSettings {
+    stats: XiriStatSettings[];
+    columns?: number;
+    title?: string;
+}
+declare class XiriStatGridComponent {
+    settings: _angular_core.InputSignal<XiriStatGridSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriStatGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriStatGridComponent, "xiri-stat-grid", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface XiriToolbarSearchConfig {
+    placeholder?: string;
+}
+interface XiriToolbarSettings {
+    title?: string;
+    icon?: string;
+    search?: boolean | XiriToolbarSearchConfig;
+    buttons?: XiriButtonlineSettings;
+}
+declare class XiriToolbarComponent {
+    settings: _angular_core.InputSignal<XiriToolbarSettings>;
+    filterData: _angular_core.InputSignal<any>;
+    searchChanged: _angular_core.OutputEmitterRef<string>;
+    searchPlaceholder: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriToolbarComponent, "xiri-toolbar", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "filterData": { "alias": "filterData"; "required": false; "isSignal": true; }; }, { "searchChanged": "searchChanged"; }, never, never, true, never>;
+}
+
+interface XiriDescriptionListItem {
+    label: string;
+    value: string;
+    icon?: string;
+    color?: string;
+    type?: 'text' | 'link' | 'html' | 'badge';
+}
+interface XiriDescriptionListSettings {
+    items: XiriDescriptionListItem[];
+    columns?: 1 | 2 | 3;
+    layout?: 'horizontal' | 'stacked';
+}
+declare class XiriDescriptionListComponent {
+    settings: _angular_core.InputSignal<XiriDescriptionListSettings>;
+    layoutClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriDescriptionListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XiriDescriptionListComponent, "xiri-description-list", never, { "settings": { "alias": "settings"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class XiriDataServiceConfig {
+    api: string;
+}
+declare const defaultXiriDataServiceConfig: XiriDataServiceConfig;
+declare class XiriDataService {
+    private http;
+    private config;
+    private snackbar;
+    get(url: string): Observable<Object>;
+    post(url: string, data: any): Observable<any>;
+    postFile(url: string, data: any): Observable<any>;
+    postFileResponse(url: string, data: any): Observable<any>;
+    postDownload(url: string, data: any): void;
+    getConfigApi(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriDataService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XiriDataService>;
+}
+
+declare class XiriDateService {
+    private currentTimezone;
+    private dateAdapter;
+    setTimezone(tz: string): void;
+    setLocale(localeString: string, locale: Locale): void;
+    unixToLocal(stime: number): Date | null;
+    unixToStringDateTime(stime: number): string;
+    unixToStringDate(stime: number): string;
+    unixToStringDateYear(stime: number): string;
+    dateToUnix(date: Date): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriDateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XiriDateService>;
+}
+
+interface XiriFormServiceReturn {
+    url?: string;
+    fields?: XiriFormField[];
+    buttons?: XiriButton[];
+    done?: boolean;
+    goto?: string;
+    model?: object;
+    extra?: object;
+    type?: string;
+    header?: string;
+    time?: number;
+}
+interface XiriFormServiceData {
+    url: string;
+    fields?: XiriFormField[];
+    buttons?: XiriButton[];
+    extra?: object;
+    done?: Observable<void>;
+    type?: string;
+    header?: string;
+    time?: number;
+}
+interface XiriFormServiceError {
+    error: string;
+}
+declare class XiriFormService {
+    private dataService;
+    private router;
+    private sessionStorageService;
+    get(url: string, data?: any, extra?: any): Observable<XiriFormServiceData>;
+    parse(res: XiriFormServiceReturn): XiriFormServiceData;
+    loadState(saveStateId: string | null | undefined, fields: XiriFormField[]): XiriFormField[];
+    saveState(saveStateId: string | null | undefined, values: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriFormService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XiriFormService>;
+}
+
+declare class XiriLocalStorageService {
+    private readonly isSupported;
+    private data;
+    constructor();
+    clear(): void;
+    set(name: string, value: any): void;
+    private getStruct;
+    remove(name: string): void;
+    get(name: string): any;
+    /**
+     * @param name
+     * @param maxTime in seconds
+     */
+    getTimeout(name: string, maxTime: number): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriLocalStorageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XiriLocalStorageService>;
+}
+
+declare class XiriSessionStorageService {
+    private readonly isSupported;
+    private data;
+    constructor();
+    clear(): void;
+    set(name: string, value: any): void;
+    private getStruct;
+    remove(name: string): void;
+    get(name: string): any;
+    /**
+     * @param name
+     * @param maxTime in seconds
+     */
+    getTimeout(name: string, maxTime: number): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriSessionStorageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XiriSessionStorageService>;
+}
+
+declare class XiriNumberService {
+    private currentLocale;
+    setLocale(locale: string): void;
+    formatNumber(value: number, webformat?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriNumberService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XiriNumberService>;
+}
+
+type ThemeMode = 'light' | 'dark' | 'auto';
+declare class ThemeService {
+    private readonly platformId;
+    private readonly isBrowser;
+    /** Current theme mode setting */
+    private readonly _mode;
+    /** Observable theme mode */
+    readonly mode: _angular_core.Signal<ThemeMode>;
+    /** Whether dark mode is currently active (considering auto mode) */
+    readonly isDark: _angular_core.Signal<boolean>;
+    /** Whether light mode is currently active */
+    readonly isLight: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Set the theme mode
+     * @param mode - 'light', 'dark', or 'auto' (follow system preference)
+     */
+    setTheme(mode: ThemeMode): void;
+    /**
+     * Toggle between light and dark mode
+     * If currently auto, switches to opposite of current system preference
+     */
+    toggle(): void;
+    /**
+     * Reset to auto (system preference)
+     */
+    resetToAuto(): void;
+    private getSystemPreference;
+    private applyTheme;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+type XiriSnackbarType = 'success' | 'error' | 'info' | 'warning';
+declare class XiriSnackbarService {
+    private snackbar;
+    success(message: string, duration?: number, action?: string): MatSnackBarRef<TextOnlySnackBar>;
+    error(message: string, duration?: number, action?: string): MatSnackBarRef<TextOnlySnackBar>;
+    info(message: string, duration?: number, action?: string): MatSnackBarRef<TextOnlySnackBar>;
+    warning(message: string, duration?: number, action?: string): MatSnackBarRef<TextOnlySnackBar>;
+    handleResponse(response: any): boolean;
+    private show;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XiriSnackbarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XiriSnackbarService>;
+}
+
+declare function provideXiriServices(config: Partial<XiriDataServiceConfig>): EnvironmentProviders;
+
+export { DEFAULT_COMPARE, DEFAULT_PREDICATE, SafehtmlPipe, ThemeService, XiriAlertComponent, XiriBreadcrumbComponent, XiriButtonComponent, XiriButtonlineComponent, XiriButtonstyleComponent, XiriCardComponent, XiriCardlinkComponent, XiriDataService, XiriDataServiceConfig, XiriDateService, XiriDescriptionListComponent, XiriDialogComponent, XiriDividerComponent, XiriDoneComponent, XiriDynComponentComponent, XiriEmptyStateComponent, XiriErrorComponent, XiriExpansionComponent, XiriFormComponent, XiriFormFieldsComponent, XiriFormService, XiriHeaderComponent, XiriImagetextComponent, XiriInfopointComponent, XiriLinksComponent, XiriListComponent, XiriLocalStorageService, XiriMultiprogressComponent, XiriNumberService, XiriPageHeaderComponent, XiriQueryComponent, XiriRawTableComponent, XiriSearchComponent, XiriSectionComponent, XiriSelectDirective, XiriSessionStorageService, XiriSidenavComponent, XiriSkeletonComponent, XiriSnackbarService, XiriStatComponent, XiriStatGridComponent, XiriStepperComponent, XiriTableComponent, XiriTabsComponent, XiriTimelineComponent, XiriToolbarComponent, defaultXiriDataServiceConfig, provideXiriServices };
+export type { ThemeMode, XiriAlertConfig, XiriBreadcrumbItem, XiriButton, XiriButtonResult, XiriButtonlineSettings, XiriCardSettings, XiriCardlinkSettings, XiriColor, XiriDescriptionListItem, XiriDescriptionListSettings, XiriDialogSettings, XiriDividerSettings, XiriDynData, XiriEmptyStateSettings, XiriExpansionPanelSettings, XiriExpansionSettings, XiriExtendedColor, XiriFormField, XiriFormFieldCondition, XiriFormFieldConditionOperator, XiriFormFieldDisplay, XiriFormFieldSelectOption, XiriFormServiceData, XiriFormServiceError, XiriFormSettings, XiriFormValidator, XiriHeaderSettings, XiriImagetextSettings, XiriInfopointSettings, XiriLinksSettings, XiriListItem, XiriListSection, XiriListSettings, XiriMultiprogressItem, XiriMultiprogressSettings, XiriNavigationField, XiriPageHeaderSettings, XiriQuerySettings, XiriRawTableSettings, XiriSectionSettings, XiriSelectCompare, XiriSelectPredicate, XiriSidebarSettings, XiriSkeletonType, XiriSnackbarType, XiriStatGridSettings, XiriStatSettings, XiriStatTrend, XiriStepperSettings, XiriStepperStep, XiriTabSettings, XiriTableEmptyState, XiriTableField, XiriTableOptions, XiriTableSettings, XiriTabsSettings, XiriTagChip, XiriThemeColor, XiriTimelineItem, XiriTimelineSettings, XiriToolbarSearchConfig, XiriToolbarSettings };
+//# sourceMappingURL=xiriframework-xiri-ng.d.ts.map