import * as _angular_core from '@angular/core';
import { EventEmitter, OnDestroy, OnInit, Type, AfterViewInit, ElementRef, ChangeDetectorRef, PipeTransform } from '@angular/core';
import { Observable, Subscription } from 'rxjs';
import { AutoCompleteSelectEvent } from 'primeng/autocomplete';
import { DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';

declare class AlphaPrimeService {
    postNavigationLog: (path: string, title: string) => any;
    getTr: (key: string, languageCode?: string) => string;
    isProduction: boolean;
    /** OAuthService */
    signIn: (username: string, password: string, rememberMe: boolean) => Observable<boolean>;
    /** UploadApiService */
    upload: (data: any, notifyProgress: (progress: number) => any) => Observable<string>;
    deleteUpload: (uploadId: string) => Observable<any>;
    /** LocalBusService*/
    publish: (payload: any, channel: string) => number;
    subscribe: (callback: (payload: any) => any, channel?: string) => number;
    unsubscribe: (id: number) => any;
    /**
     * Initializes the service.
     *
     * @param {boolean} isProduction - A flag indicating if the application is running in production mode.
     * @param translationService
     * @param loggerService
     * @param oAuthService
     * @param uploadService
     * @param localBusService
     * @return {void}
     */
    init(isProduction: boolean, translationService: {
        getTr: (key: string, languageCode?: string) => string;
    }, loggerService?: {
        postNavigationLog: (path: string, title: string) => any;
    }, oAuthService?: {
        signIn: (username: string, password: string, rememberMe: boolean) => Observable<boolean>;
    }, uploadService?: {
        upload: (data: any, notifyProgress: (progress: number) => any) => Observable<string>;
        deleteUpload: (uploadId: string) => Observable<any>;
    }, localBusService?: {
        publish: (payload: any, channel: string) => number;
        subscribe: (callback: (payload: any) => any, channel?: string) => number;
        unsubscribe: (id: number) => any;
    }): void;
    addLoggerService(postNavigationLog: (path: string, title: string) => any): void;
    addOAuthService(signIn: (username: string, password: string, rememberMe: boolean) => Observable<boolean>): void;
    addUploadService(upload: (data: any, notifyProgress: (progress: number) => any) => Observable<string>, deleteUpload: (uploadId: string) => Observable<any>): void;
    addLocalBusService(publish: (payload: any, channel: string) => number, subscribe: (callback: (payload: any) => any, channel?: string) => number, unsubscribe: (id: number) => any): void;
    generateRandomName(len?: number): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AlphaPrimeService>;
}

declare class AlphaPrimeAddButtonComponent {
    private mPs;
    disabled: _angular_core.InputSignal<boolean>;
    caption: _angular_core.InputSignal<string>;
    effectiveCaption: _angular_core.Signal<string>;
    sm: _angular_core.InputSignal<boolean>;
    showLabel: _angular_core.InputSignal<boolean>;
    clicked: EventEmitter<any>;
    constructor(mPs: AlphaPrimeService);
    onClicked(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeAddButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeAddButtonComponent, "alpha-prime-add-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

interface IAlphaPrimeAutoCompleteEntry {
    id: string;
    caption: any;
    data?: any;
}
declare class AlphaPrimeAutoComplete {
    /**
     * Helper that eases the translation of a service feeder
     * returning domain entities to a view feeder returning
     * @param term the searched term
     * @param feeder a method that returns an observable of <T> items for the given term
     * @param mapper a method that converts a T item into a IAlphaAutoComplete item
     * @return  array of IAlphaAutoComplete entries
     */
    static mapFeeder<T>(term: string, feeder: (term: string) => Observable<T[]>, mapper: (item: T) => IAlphaPrimeAutoCompleteEntry): Observable<IAlphaPrimeAutoCompleteEntry[]>;
}

declare class AlphaPrimeAutoCompleteComponent implements OnDestroy {
    feeder: (term: string) => Observable<IAlphaPrimeAutoCompleteEntry[]>;
    set entry(entry: IAlphaPrimeAutoCompleteEntry | undefined);
    disabled: _angular_core.InputSignal<boolean>;
    placeHolder: _angular_core.InputSignal<string>;
    emptyMessage: _angular_core.InputSignal<string>;
    showAdd: _angular_core.InputSignal<boolean>;
    readonly: _angular_core.InputSignal<boolean>;
    readonlyCaption: _angular_core.InputSignal<string>;
    sm: _angular_core.InputSignal<boolean>;
    clearOnSelect: boolean;
    timeout: number;
    cleared: EventEmitter<void>;
    selected: EventEmitter<IAlphaPrimeAutoCompleteEntry>;
    addClicked: EventEmitter<string>;
    baseInputStyle: Record<string, string>;
    smInputStyle: Record<string, string>;
    get inputStyle(): any;
    model: IAlphaPrimeAutoCompleteEntry | undefined;
    term: string;
    searching: boolean;
    searchFailed: boolean;
    valid: boolean;
    feedTimer: ReturnType<typeof setTimeout> | undefined;
    feed: Subscription | undefined;
    constructor();
    suggestions: _angular_core.WritableSignal<IAlphaPrimeAutoCompleteEntry[]>;
    onFeed(event: any): void;
    clear(emit: boolean): void;
    onClear(): void;
    onSelected(event: AutoCompleteSelectEvent): void;
    onAdd(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeAutoCompleteComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeAutoCompleteComponent, "alpha-prime-auto-complete", never, { "feeder": { "alias": "feeder"; "required": true; }; "entry": { "alias": "entry"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "showAdd": { "alias": "showAdd"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "readonlyCaption": { "alias": "readonlyCaption"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "clearOnSelect": { "alias": "clearOnSelect"; "required": false; }; "timeout": { "alias": "timeout"; "required": false; }; }, { "cleared": "cleared"; "selected": "selected"; "addClicked": "addClicked"; }, never, never, true, never>;
}

declare class AlphaPrimeCancelButtonComponent {
    private mPs;
    disabled: _angular_core.InputSignal<boolean>;
    caption: _angular_core.InputSignal<string>;
    effectiveCaption: _angular_core.Signal<string>;
    sm: _angular_core.InputSignal<boolean>;
    showLabel: _angular_core.InputSignal<boolean>;
    clicked: EventEmitter<any>;
    constructor(mPs: AlphaPrimeService);
    onClicked(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeCancelButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeCancelButtonComponent, "alpha-prime-cancel-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

declare class AlphaPrimeConfirmationModalComponent implements OnInit {
    private mPs;
    private mDdr;
    private mDdc;
    onClose: (confirmed: boolean) => any;
    title: string;
    message: string;
    yes: string;
    no: string;
    constructor(mPs: AlphaPrimeService, mDdr: DynamicDialogRef, mDdc: DynamicDialogConfig);
    ngOnInit(): void;
    init(onClose: (confirmed: boolean) => any, title?: string, message?: string, yes?: string, no?: string): void;
    onYes(): void;
    onNo(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeConfirmationModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeConfirmationModalComponent, "alpha-prime-confirmation-modal", never, {}, {}, never, never, true, never>;
}

declare class AlphaPrimeCurrencyInputComponent {
    private mPs;
    realNumber: RegExp;
    name: string;
    disabled: boolean;
    placeHolder: string;
    min: number;
    max: number;
    currency: string;
    currencySymbol: string;
    locale: string;
    readonly: boolean;
    readonlyCaption: string | undefined;
    sm: boolean;
    showClear: boolean;
    sVal: string | number | undefined;
    set value(value: number | undefined);
    get value(): number | undefined;
    valueChange: EventEmitter<number>;
    constructor(mPs: AlphaPrimeService);
    invalid: boolean;
    baseInputStyle: {
        width: string;
        'border-top-right-radius': string;
        'border-bottom-right-radius': string;
    };
    smInputStyle: {
        width: string;
        'border-top-right-radius': string;
        'border-bottom-right-radius': string;
        'font-size': string;
    };
    get inputStyle(): any;
    onTextChange(sVal: string | number | undefined): void;
    onClear(): void;
    onBlur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeCurrencyInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeCurrencyInputComponent, "alpha-prime-currency-input", never, { "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeHolder": { "alias": "placeHolder"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "currency": { "alias": "currency"; "required": false; }; "currencySymbol": { "alias": "currencySymbol"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "readonlyCaption": { "alias": "readonlyCaption"; "required": false; }; "sm": { "alias": "sm"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "value": { "alias": "value"; "required": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class AlphaPrimeDatePickerComponent implements OnDestroy {
    private mPs;
    name: string;
    phInterval: any;
    ph: _angular_core.WritableSignal<string>;
    set placeHolder(ph: string | string[]);
    disabled: boolean;
    showClear: boolean;
    showTime: boolean;
    showSeconds: boolean;
    dateFormat: string;
    minDate: Date;
    maxDate: Date;
    date: Date | undefined;
    readonly: boolean;
    readonlyCaption: string | undefined | null;
    sm: boolean;
    dateChange: EventEmitter<Date | undefined>;
    constructor(mPs: AlphaPrimeService);
    baseInputStyle: {
        width: string;
        'border-top-right-radius': string;
        'border-bottom-right-radius': string;
    };
    smInputStyle: {
        width: string;
        'border-top-right-radius': string;
        'border-bottom-right-radius': string;
        'font-size': string;
    };
    get inputStyle(): any;
    ngOnDestroy(): void;
    onClear(): void;
    onDateChanged(dt: Date): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeDatePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeDatePickerComponent, "alpha-prime-date-picker", never, { "name": { "alias": "name"; "required": false; }; "placeHolder": { "alias": "placeHolder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "date": { "alias": "date"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "readonlyCaption": { "alias": "readonlyCaption"; "required": false; }; "sm": { "alias": "sm"; "required": false; }; }, { "dateChange": "dateChange"; }, never, never, true, never>;
}

declare class AlphaPrimeDateRangePickerComponent {
    dateRange: Date[] | undefined;
    startDate: Date | undefined;
    startDateChange: EventEmitter<Date | undefined>;
    endDate: Date | undefined;
    endDateChange: EventEmitter<Date | undefined>;
    disabled: boolean;
    minDate: Date;
    maxDate: Date;
    displayMonths: number;
    dateFormat: string;
    placeHolder: string;
    readonly: boolean;
    readonlyCaption: string;
    sm: boolean;
    baseInputStyle: {
        width: string;
        'border-top-right-radius': string;
        'border-bottom-right-radius': string;
    };
    smInputStyle: {
        width: string;
        'border-top-right-radius': string;
        'border-bottom-right-radius': string;
        'font-size': string;
    };
    get inputStyle(): any;
    onSelection(dateRange: Date[]): void;
    onClear(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeDateRangePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeDateRangePickerComponent, "alpha-prime-date-range-picker", never, { "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "displayMonths": { "alias": "displayMonths"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "placeHolder": { "alias": "placeHolder"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "readonlyCaption": { "alias": "readonlyCaption"; "required": false; }; "sm": { "alias": "sm"; "required": false; }; }, { "startDateChange": "startDateChange"; "endDateChange": "endDateChange"; }, never, never, true, never>;
}

declare class AlphaPrimeDebugTagComponent {
    private mPs;
    visible: boolean;
    tagSignal: _angular_core.WritableSignal<string>;
    set tag(value: string);
    get tag(): string;
    constructor(mPs: AlphaPrimeService);
    ngOnInit(): void;
    static hide(hidden: boolean): void;
    static get hidden(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeDebugTagComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeDebugTagComponent, "alpha-prime-debug-tag", never, { "tag": { "alias": "tag"; "required": true; }; }, {}, never, never, true, never>;
}

interface IAlphaPrimeModalConfig {
    data?: any;
    header?: string;
    footer?: string;
    width?: string;
    height?: string;
    closeOnEscape?: boolean;
    focusOnShow?: boolean;
    focusTrap?: boolean;
    baseZIndex?: number;
    autoZIndex?: boolean;
    dismissableMask?: boolean;
    rtl?: boolean;
    style?: Object;
    contentStyle?: Object;
    styleClass?: string;
    transitionOptions?: string;
    closable?: boolean;
    maskStyleClass?: string;
    resizable?: boolean;
    /** true by default*/
    draggable?: boolean;
    keepInViewport?: boolean;
    minX?: number;
    maxX?: number;
    maximizable?: boolean;
    maximizeIcon?: string;
    minimizeIcon?: string;
    position?: 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
    closeArialLabel?: string;
    appendTo?: any;
    duplicate?: boolean;
    breakpoints?: any;
}

declare class AlphaPrimeModalService {
    private dsOpen;
    private modalStyleClass;
    private postNavigationLog;
    init(dsOpen: (component: Type<any>, ddc: IAlphaPrimeModalConfig) => any, postNavigationLog?: (path: string, title: string) => any, modalStyleClass?: string): void;
    /**
     * Opens a modal dialog.
     *
     * @template T - The type of the component to be opened in the modal.
     *
     * @param {Type<T>} component - The component to be opened in the modal.
     * @param {string} anchor - The name of the component calling the openModal method.
     * @param {string} modal - The name of the modal.
     * @param {IAlphaPrimeModalConfig} [ddc] - Configuration options for the modal (optional).
     *
     * @return {Observable<T>} - An Observable that emits an instance of the opened component when the modal is displayed.
     *                           If an error occurs during the opening of the modal, the Observable will emit an error instead.
     */
    openModal<T>(component: Type<T>, anchor: string, modal: string, ddc?: IAlphaPrimeModalConfig): Observable<T>;
    openConfirmationModal(anchor: string, title?: string, message?: string, confirmButtonText?: string, cancelButtonText?: string, ddc?: IAlphaPrimeModalConfig): Observable<boolean>;
    openLoginModal(anchor: string, title?: string, usernameLabel?: string, passwordLabel?: string, connectLabel?: string, failureMessage?: string, invalidCredentialMessage?: string, showCancelButton?: boolean, ddc?: IAlphaPrimeModalConfig): Observable<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeModalService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AlphaPrimeModalService>;
}

declare class AlphaPrimeDeleteButtonComponent {
    private mPs;
    private mMs;
    private readonly logRoute;
    disabled: _angular_core.InputSignal<boolean>;
    caption: _angular_core.InputSignal<string>;
    effectiveCaption: _angular_core.Signal<string>;
    sm: _angular_core.InputSignal<boolean>;
    busy: _angular_core.InputSignal<boolean>;
    showLabel: _angular_core.InputSignal<boolean>;
    showConfirmationModal: _angular_core.InputSignal<boolean>;
    modalTitle: _angular_core.InputSignal<string | undefined>;
    modalMessage: _angular_core.InputSignal<string | undefined>;
    modalYes: _angular_core.InputSignal<string | undefined>;
    modalNo: _angular_core.InputSignal<string | undefined>;
    clicked: EventEmitter<any>;
    constructor(mPs: AlphaPrimeService, mMs: AlphaPrimeModalService);
    onClicked(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeDeleteButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeDeleteButtonComponent, "alpha-prime-delete-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "showConfirmationModal": { "alias": "showConfirmationModal"; "required": false; "isSignal": true; }; "modalTitle": { "alias": "modalTitle"; "required": false; "isSignal": true; }; "modalMessage": { "alias": "modalMessage"; "required": false; "isSignal": true; }; "modalYes": { "alias": "modalYes"; "required": false; "isSignal": true; }; "modalNo": { "alias": "modalNo"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

declare class AlphaPrimeEditButtonComponent {
    private mPs;
    disabled: _angular_core.InputSignal<boolean>;
    caption: _angular_core.InputSignal<string>;
    effectiveCaption: _angular_core.Signal<string>;
    sm: _angular_core.InputSignal<boolean>;
    showLabel: _angular_core.InputSignal<boolean>;
    clicked: EventEmitter<any>;
    constructor(mPs: AlphaPrimeService);
    onClicked(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeEditButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeEditButtonComponent, "alpha-prime-edit-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

interface IAlphaPrimeFileUpload {
    uploadId: string;
    fileName: string;
    fileData: string;
}

declare class FormModel$1 {
    fileName: string;
    fileData: string;
    get hasData(): boolean;
    get invalid(): boolean;
}
declare class AlphaPrimeFileUploadComponent implements AfterViewInit {
    private mPs;
    private cdr;
    name: _angular_core.InputSignal<string | undefined>;
    effectiveName(): string;
    accept: _angular_core.InputSignal<string | undefined>;
    normalizedAccept: _angular_core.Signal<string | undefined>;
    disabled: _angular_core.InputSignal<boolean>;
    /** when a new file is loaded it is automatically
     * uploaded to the Server
     */
    autoUpload: _angular_core.InputSignal<boolean>;
    deleteOnClear: _angular_core.InputSignal<boolean>;
    readonly: _angular_core.InputSignal<boolean>;
    readonlyCaption: _angular_core.InputSignal<string>;
    sm: _angular_core.InputSignal<boolean>;
    fileInput: ElementRef<HTMLInputElement>;
    fileUploaded: EventEmitter<IAlphaPrimeFileUpload>;
    fileDeleted: EventEmitter<string>;
    /**
     * AfterViewInit will emit a delegate to the resetForm method
     * so that the parent component can invoke this method from
     * inside its own code */
    ready: EventEmitter<() => any>;
    busy: boolean;
    fm: FormModel$1;
    fu: IAlphaPrimeFileUpload | undefined;
    uploading: boolean;
    progress: number;
    fileLit: string;
    constructor(mPs: AlphaPrimeService, cdr: ChangeDetectorRef);
    ngAfterViewInit(): void;
    private delete;
    private upload;
    resetForm(): void;
    onFileInputChanged(changeEvent: Event): void;
    onBrowse(): void;
    onClear(): void;
    onSave(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeFileUploadComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeFileUploadComponent, "alpha-prime-file-upload", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "autoUpload": { "alias": "autoUpload"; "required": false; "isSignal": true; }; "deleteOnClear": { "alias": "deleteOnClear"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "readonlyCaption": { "alias": "readonlyCaption"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; }, { "fileUploaded": "fileUploaded"; "fileDeleted": "fileDeleted"; "ready": "ready"; }, never, never, true, never>;
}

declare class AlphaPrimeFilterBoxComponent implements OnDestroy {
    delay: _angular_core.InputSignal<number>;
    showAdd: _angular_core.InputSignal<boolean>;
    disabled: _angular_core.InputSignal<boolean>;
    placeholder: _angular_core.InputSignal<string>;
    term: _angular_core.ModelSignal<string | undefined>;
    empty: _angular_core.Signal<boolean>;
    addClicked: _angular_core.OutputEmitterRef<string | undefined>;
    name: string;
    timer: ReturnType<typeof setTimeout> | undefined;
    constructor(ps: AlphaPrimeService);
    ngOnDestroy(): void;
    private changeTerm;
    onTermChanged(newTerm: string): void;
    onClear(): void;
    onAddClicked(): void;
    private stopTimerIfSet;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeFilterBoxComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeFilterBoxComponent, "alpha-prime-filter-box", never, { "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "showAdd": { "alias": "showAdd"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "term": { "alias": "term"; "required": false; "isSignal": true; }; }, { "term": "termChange"; "addClicked": "addClicked"; }, never, never, true, never>;
}

declare class AlphaPrimeLabelComponent implements OnInit, OnDestroy {
    /** payload => show: boolean  */
    static readonly SHOW_MESSAGE = "AlphaPrimeLabelComponent.ShowMessage";
    private readonly primeService;
    caption: _angular_core.InputSignal<string>;
    value: _angular_core.InputSignal<string>;
    invalid: _angular_core.InputSignal<boolean>;
    invalidMessage: _angular_core.InputSignal<string | undefined>;
    private readonly isEmpty;
    isEmptyOrInvalid: _angular_core.Signal<boolean>;
    showMessage: _angular_core.InputSignal<boolean>;
    private _showMessage;
    effectiveShowMessage: _angular_core.Signal<boolean>;
    readonly effectiveInvalidMessage: _angular_core.Signal<string>;
    private showMessageSub;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeLabelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeLabelComponent, "alpha-prime-label", never, { "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "invalidMessage": { "alias": "invalidMessage"; "required": false; "isSignal": true; }; "showMessage": { "alias": "showMessage"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class FormModel {
    username: _angular_core.WritableSignal<string>;
    password: _angular_core.WritableSignal<string | undefined>;
    private isEmpty;
    invalid: _angular_core.Signal<boolean>;
}
declare class AlphaPrimeLoginFormComponent {
    private readonly mPs;
    showCancelButton: _angular_core.InputSignal<boolean>;
    usernameLabel: _angular_core.InputSignal<string | undefined>;
    passwordLabel: _angular_core.InputSignal<string | undefined>;
    failureMessage: _angular_core.InputSignal<string | undefined>;
    invalidCredentialsMessage: _angular_core.InputSignal<string | undefined>;
    connectLabel: _angular_core.InputSignal<string | undefined>;
    fm: FormModel;
    busy: _angular_core.WritableSignal<boolean>;
    errorMessage: _angular_core.WritableSignal<string | undefined>;
    loggedIn: _angular_core.OutputEmitterRef<void>;
    cancelled: _angular_core.OutputEmitterRef<void>;
    usernameLit: _angular_core.Signal<string>;
    passwordLit: _angular_core.Signal<string>;
    failureLit: _angular_core.Signal<string>;
    invalidCredentialsLit: _angular_core.Signal<string>;
    connectLabelLit: _angular_core.Signal<string>;
    onCancel(): void;
    onSubmit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeLoginFormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeLoginFormComponent, "alpha-prime-login-form", never, { "showCancelButton": { "alias": "showCancelButton"; "required": false; "isSignal": true; }; "usernameLabel": { "alias": "usernameLabel"; "required": false; "isSignal": true; }; "passwordLabel": { "alias": "passwordLabel"; "required": false; "isSignal": true; }; "failureMessage": { "alias": "failureMessage"; "required": false; "isSignal": true; }; "invalidCredentialsMessage": { "alias": "invalidCredentialsMessage"; "required": false; "isSignal": true; }; "connectLabel": { "alias": "connectLabel"; "required": false; "isSignal": true; }; }, { "loggedIn": "loggedIn"; "cancelled": "cancelled"; }, never, never, true, never>;
}

declare class AlphaPrimeLoginModalComponent implements OnInit {
    private readonly mPs;
    private readonly mDdr;
    private readonly mDdc;
    ready: _angular_core.WritableSignal<boolean>;
    onClose: (loggedIn: boolean) => any;
    usernameLabel?: string;
    passwordLabel?: string;
    failureMessage?: string;
    invalidCredentialsMessage?: string;
    connectLabel?: string;
    showCancelButton: boolean;
    ngOnInit(): void;
    init(onClose: (loggedIn: boolean) => any, usernameLabel?: string, passwordLabel?: string, connectLabel?: string, failureMessage?: string, invalidCredentialsMessage?: string, showCancelButton?: boolean): void;
    onLoggedIn(): void;
    onCancelled(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeLoginModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeLoginModalComponent, "alpha-prime-login-modal", never, {}, {}, never, never, true, never>;
}

declare class AlphaPrimeNumberInputComponent {
    private readonly mPs;
    name: _angular_core.InputSignal<string | undefined>;
    disabled: _angular_core.InputSignal<boolean>;
    placeHolder: _angular_core.InputSignal<string>;
    prefix: _angular_core.InputSignal<string>;
    suffix: _angular_core.InputSignal<string>;
    decimals: _angular_core.InputSignal<number>;
    min: _angular_core.InputSignal<number>;
    max: _angular_core.InputSignal<number>;
    locale: _angular_core.InputSignal<string>;
    readonly: _angular_core.InputSignal<boolean>;
    readonlyCaption: _angular_core.InputSignal<string | undefined>;
    sm: _angular_core.InputSignal<boolean>;
    showClear: _angular_core.InputSignal<boolean>;
    value: _angular_core.InputSignal<number | undefined>;
    sVal: _angular_core.WritableSignal<string | undefined>;
    invalid: _angular_core.WritableSignal<boolean>;
    readonly realNumber: RegExp;
    valueChange: _angular_core.OutputEmitterRef<number | undefined>;
    private readonly baseInputStyle;
    private readonly smInputStyle;
    inputStyle: _angular_core.Signal<{
        width: string;
        'border-top-right-radius': string;
        'border-bottom-right-radius': string;
    }>;
    constructor();
    /**
     * Converts the internal string value to a number
     * @returns the parsed number or undefined if invalid
     */
    getNumericValue(): number | undefined;
    /**
     * Handles text input changes and validates the value
     * @param sVal the string value from the input
     */
    onTextChange(sVal: string | number | undefined): void;
    /**
     * Clears the input value and emits undefined
     */
    onClear(): void;
    /**
     * Validates input character based on regex
     * @param char the character to validate
     * @returns true if character is valid
     */
    isValidCharacter(char: string): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeNumberInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeNumberInputComponent, "alpha-prime-number-input", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "readonlyCaption": { "alias": "readonlyCaption"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class AlphaPrimeOkButton {
    private readonly mPs;
    disabled: _angular_core.InputSignal<boolean>;
    clicked: _angular_core.OutputEmitterRef<void>;
    caption: _angular_core.InputSignal<string>;
    sm: _angular_core.InputSignal<boolean>;
    showLabel: _angular_core.InputSignal<boolean>;
    onClicked(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeOkButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeOkButton, "alpha-prime-ok-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

declare class AlphaPrimePasswordInputComponent {
    private readonly mPs;
    inputType: _angular_core.WritableSignal<"password" | "text">;
    name: _angular_core.InputSignal<string>;
    disabled: _angular_core.InputSignal<boolean>;
    password: _angular_core.ModelSignal<string | undefined>;
    empty: _angular_core.Signal<boolean>;
    onShowHide(): void;
    onPasswordChanged(password: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimePasswordInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimePasswordInputComponent, "alpha-prime-password-input", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "password": { "alias": "password"; "required": false; "isSignal": true; }; }, { "password": "passwordChange"; }, never, never, true, never>;
}

declare class AlphaPrimeProgressBarComponent {
    private tOut;
    private _busy;
    color: _angular_core.InputSignal<string | undefined>;
    value: _angular_core.InputSignal<number>;
    delay: _angular_core.InputSignal<number>;
    mode: _angular_core.InputSignal<"determinate" | "indeterminate" | "tiny">;
    set busy(busy: boolean);
    get busy(): boolean;
    private showProgressBar;
    private hideProgressBar;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeProgressBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeProgressBarComponent, "alpha-prime-progress-bar", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": true; }; }, {}, never, never, true, never>;
}

declare class AlphaPrimeSaveButtonComponent {
    private readonly mPs;
    disabled: _angular_core.InputSignal<boolean>;
    clicked: _angular_core.OutputEmitterRef<void>;
    caption: _angular_core.InputSignal<string>;
    busy: _angular_core.InputSignal<boolean>;
    sm: _angular_core.InputSignal<boolean>;
    showLabel: _angular_core.InputSignal<boolean>;
    publishMouseEvent: _angular_core.Signal<boolean>;
    onClicked(): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeSaveButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeSaveButtonComponent, "alpha-prime-save-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

interface VirtualRow<T> {
    index: number;
    data: T;
}
type AlphaPrimeScrollerPredicate<T> = (item: T, index: number, items: readonly T[]) => boolean;
declare class AlphaPrimeScrollerComponent<T = unknown> implements AfterViewInit, OnDestroy {
    private readonly alphaPrimeService;
    private resizeObserver?;
    loadMoreThreshold: _angular_core.InputSignal<number>;
    itemHeight: _angular_core.InputSignal<number>;
    bufferSize: _angular_core.InputSignal<number>;
    showLoadingIndicator: _angular_core.InputSignal<boolean>;
    loadingMessage: _angular_core.InputSignal<string | undefined>;
    effectiveLoadingMessage: _angular_core.Signal<string>;
    loadMore: _angular_core.OutputEmitterRef<number>;
    scrolled: _angular_core.OutputEmitterRef<number>;
    private scrollContainer;
    private allItems;
    private isNearBottom;
    loading: _angular_core.WritableSignal<boolean>;
    private scrollTop;
    private containerHeight;
    private visibleStartIndex;
    private visibleEndIndex;
    visibleRows: _angular_core.Signal<VirtualRow<T>[]>;
    paddingTop: _angular_core.Signal<number>;
    paddingBottom: _angular_core.Signal<number>;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    addItems(newItems: readonly T[]): void;
    resetItems(items?: readonly T[]): void;
    insertAtTop(itemOrItems: T | readonly T[]): void;
    replaceAt(index: number, item: T): boolean;
    findIndex(predicate: AlphaPrimeScrollerPredicate<T>): number;
    find(predicate: AlphaPrimeScrollerPredicate<T>): T | undefined;
    itemCount(): number;
    onScroll(): void;
    private checkScroll;
    private shiftScrollTop;
    private syncScrollSignals;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeScrollerComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeScrollerComponent<any>, "alpha-prime-scroller", never, { "loadMoreThreshold": { "alias": "loadMoreThreshold"; "required": false; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; "bufferSize": { "alias": "bufferSize"; "required": false; "isSignal": true; }; "showLoadingIndicator": { "alias": "showLoadingIndicator"; "required": false; "isSignal": true; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; "isSignal": true; }; }, { "loadMore": "loadMore"; "scrolled": "scrolled"; }, never, ["*"], true, never>;
}

interface IAlphaPrimeSelectOption {
    id: string;
    caption: any;
    disabled: boolean;
    data?: any;
}
declare class AlphaPrimeSelectInfo {
    /** determine how to set the initial option Id out of 8 options:
     *
     * 'first': first,
     * 'none': undefined,
     * 'idOrNone': id if found,
     * 'idOrFirst': id or first.
     *
     * 'lsOrFirst': localStorage item or first,
     * 'lsOrNone' : localStorage item if found,
     * 'lsOrIdOrNone': localStorage item or id if found,
     * 'lsOrIdOrFirst': localStorage item or id or first.
     *
     * The default value is 'first' */
    initMode: 'first' | 'none' | 'idOrNone' | 'idOrFirst' | 'lsOrFirst' | 'lsOrNone' | 'lsOrIdOrNone' | 'lsOrIdOrFirst';
    options: IAlphaPrimeSelectOption[];
    /** key if the localStorage item to retrieved/set */
    lsItemKey: string | undefined;
    /** initial value */
    optionId: string | undefined;
    getOption(optionId: string | undefined): IAlphaPrimeSelectOption | undefined;
    static First(options: IAlphaPrimeSelectOption[]): AlphaPrimeSelectInfo;
    static None(options: IAlphaPrimeSelectOption[]): AlphaPrimeSelectInfo;
    static OptionId(options: IAlphaPrimeSelectOption[], optionId: string | undefined): AlphaPrimeSelectInfo;
    static OptionIdOrFirst(options: IAlphaPrimeSelectOption[], optionId: string | undefined): AlphaPrimeSelectInfo;
    static LsOrFirst(options: IAlphaPrimeSelectOption[], lsItemKey: string): AlphaPrimeSelectInfo;
    static LsOrNone(options: IAlphaPrimeSelectOption[], lsItemKey: string): AlphaPrimeSelectInfo;
    static LsOrIdOrFirst(options: IAlphaPrimeSelectOption[], lsItemKey: string, optionId: string | undefined): AlphaPrimeSelectInfo;
    static LsOrIdOrNone(options: IAlphaPrimeSelectOption[], lsItemKey: string, optionId: string | undefined): AlphaPrimeSelectInfo;
    private setIdOrNone;
    private setFirst;
    private setIdOrFirst;
    private setLsOrNone;
    private setLsOrFirst;
    private setLsOrIdOrNone;
    private setLsOrIdOrFirst;
    private constructor();
}

declare class AlphaPrimeSelectComponent {
    private readonly mPs;
    name: _angular_core.InputSignal<string>;
    asi: _angular_core.InputSignal<AlphaPrimeSelectInfo | undefined>;
    options: _angular_core.InputSignal<IAlphaPrimeSelectOption[]>;
    placeholder: _angular_core.InputSignal<string>;
    placeHolder: _angular_core.InputSignal<string>;
    disabled: _angular_core.InputSignal<boolean>;
    readonly: _angular_core.InputSignal<boolean>;
    readonlyCaption: _angular_core.InputSignal<string | null | undefined>;
    showAdd: _angular_core.InputSignal<boolean>;
    showClear: _angular_core.InputSignal<boolean>;
    optionId: _angular_core.ModelSignal<string | undefined>;
    optionChange: _angular_core.OutputEmitterRef<IAlphaPrimeSelectOption | undefined>;
    addClicked: _angular_core.OutputEmitterRef<void>;
    effectiveOptions: _angular_core.Signal<IAlphaPrimeSelectOption[]>;
    effectivePlaceholder: _angular_core.Signal<string>;
    showActionButtons: _angular_core.Signal<boolean>;
    constructor();
    private setOptionId;
    onOptionChange(id: string | undefined): void;
    onClear(): void;
    onAdd(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeSelectComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeSelectComponent, "alpha-prime-select", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "asi": { "alias": "asi"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "readonlyCaption": { "alias": "readonlyCaption"; "required": false; "isSignal": true; }; "showAdd": { "alias": "showAdd"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "optionId": { "alias": "optionId"; "required": false; "isSignal": true; }; }, { "optionId": "optionIdChange"; "optionChange": "optionChange"; "addClicked": "addClicked"; }, never, never, true, never>;
}

declare class AlphaPrimeSubmitButtonComponent {
    private readonly mPs;
    disabled: _angular_core.InputSignal<boolean>;
    busy: _angular_core.InputSignal<boolean>;
    sm: _angular_core.InputSignal<boolean>;
    showLabel: _angular_core.InputSignal<boolean>;
    caption: _angular_core.InputSignal<string>;
    clicked: _angular_core.OutputEmitterRef<void>;
    publishMouseEvent: _angular_core.Signal<boolean>;
    onClicked(): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeSubmitButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeSubmitButtonComponent, "alpha-prime-submit-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "sm": { "alias": "sm"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

interface IAlphaPrimeSwitchOption {
    id: string;
    caption: string;
    selected: boolean;
    /** optional localStorage item key that can store the selected value */
    lsItemKey?: string;
}
declare class AlphaPrimeSwitchOption implements IAlphaPrimeSwitchOption {
    id: string;
    caption: string;
    selected: boolean;
    lsItemKey?: string;
    /**
     * When lsItemKey is provided, selected is initialized from localStorage if available.
     */
    constructor(id: string, caption: string, selected: boolean, lsItemKey?: string);
}

declare class AlphaPrimeSwitchComponent {
    private readonly mPs;
    name: _angular_core.InputSignal<string>;
    disabled: _angular_core.InputSignal<boolean>;
    switchOption: _angular_core.InputSignal<IAlphaPrimeSwitchOption>;
    switchOptionChange: _angular_core.OutputEmitterRef<IAlphaPrimeSwitchOption>;
    private readonly resolvedSwitchOption;
    effectiveSwitchOption: _angular_core.Signal<IAlphaPrimeSwitchOption>;
    constructor();
    private check;
    onChange(event: {
        checked: boolean;
    }): void;
    onCaptionClicked(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeSwitchComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlphaPrimeSwitchComponent, "alpha-prime-switch", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "switchOption": { "alias": "switchOption"; "required": false; "isSignal": true; }; }, { "switchOptionChange": "switchOptionChange"; }, never, never, true, never>;
}

declare class AlphaPrimeRemainingHeightDirective implements OnInit, OnDestroy {
    private elementRef;
    /** bottom margin in pixels (default value is 0) */
    bottomMarginInPx: number;
    constructor(elementRef: ElementRef<HTMLDivElement>);
    interval: any;
    private lastHeight;
    private setElementHeight;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeRemainingHeightDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AlphaPrimeRemainingHeightDirective, "[alphaPrimeRemainingHeight]", never, { "bottomMarginInPx": { "alias": "bottomMarginInPx"; "required": false; }; }, {}, never, never, true, never>;
}

/** returns the inner HTML boldifying the given.
 * Usage alphaBoldify:term
 * where term is then part of the text to display in bold */
declare class AlphaPrimeBoldifyPipe implements PipeTransform {
    /** returns the inner HTML boldifying the given term.
     * Usage alphaBoldify:term
     * where term is then part of the text to display in bold.
     * Example 'France' | alphaBoldify:'fr'
     * will return &lt;strong&gt;Fr&lt;/strong&gt;ance */
    transform(value: unknown, ...args: unknown[]): unknown;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlphaPrimeBoldifyPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<AlphaPrimeBoldifyPipe, "alphaPrimeBoldify", true>;
}

export { AlphaPrimeAddButtonComponent, AlphaPrimeAutoComplete, AlphaPrimeAutoCompleteComponent, AlphaPrimeBoldifyPipe, AlphaPrimeCancelButtonComponent, AlphaPrimeConfirmationModalComponent, AlphaPrimeCurrencyInputComponent, AlphaPrimeDatePickerComponent, AlphaPrimeDateRangePickerComponent, AlphaPrimeDebugTagComponent, AlphaPrimeDeleteButtonComponent, AlphaPrimeEditButtonComponent, AlphaPrimeFileUploadComponent, AlphaPrimeFilterBoxComponent, AlphaPrimeLabelComponent, AlphaPrimeLoginFormComponent, AlphaPrimeLoginModalComponent, AlphaPrimeModalService, AlphaPrimeNumberInputComponent, AlphaPrimeOkButton, AlphaPrimePasswordInputComponent, AlphaPrimeProgressBarComponent, AlphaPrimeRemainingHeightDirective, AlphaPrimeSaveButtonComponent, AlphaPrimeScrollerComponent, AlphaPrimeSelectComponent, AlphaPrimeSelectInfo, AlphaPrimeService, AlphaPrimeSubmitButtonComponent, AlphaPrimeSwitchComponent, AlphaPrimeSwitchOption };
export type { AlphaPrimeScrollerPredicate, IAlphaPrimeAutoCompleteEntry, IAlphaPrimeFileUpload, IAlphaPrimeModalConfig, IAlphaPrimeSelectOption, IAlphaPrimeSwitchOption, VirtualRow };