import * as i0 from '@angular/core';
import { OnInit, OnChanges, OnDestroy, EventEmitter, ElementRef, NgZone, SimpleChanges, PipeTransform, AfterViewInit, Renderer2, ChangeDetectorRef, AfterContentInit, TemplateRef, QueryList } from '@angular/core';
import * as i2 from '@angular/common';
import * as i3 from '@angular/forms';
import { ValidatorFn, FormGroup, FormBuilder, FormControl, AbstractControl } from '@angular/forms';
import * as i5 from 'primeng/table';
import { Table, TableRowReorderEvent } from 'primeng/table';
import { MenuItem as MenuItem$1, ConfirmationService, MessageService } from 'primeng/api';
import * as i8 from 'primeng/contextmenu';
import { ContextMenu } from 'primeng/contextmenu';
import * as i6 from 'primeng/inputtext';
import * as i3$1 from 'primeng/button';
import * as i9 from 'primeng/datepicker';
import * as i4 from 'primeng/multiselect';
import * as i11 from 'primeng/tag';
import * as i12 from 'primeng/iconfield';
import * as i13 from 'primeng/inputicon';
import * as i14 from 'primeng/progressspinner';
import * as i4$1 from 'primeng/tooltip';
import * as i16 from 'primeng/progressbar';
import * as i8$1 from 'primeng/inputnumber';
import * as i9$1 from 'primeng/panel';
import * as i4$2 from 'primeng/checkbox';
import * as i4$3 from 'primeng/inputgroup';
import * as i5$1 from 'primeng/inputgroupaddon';
import * as i4$4 from 'primeng/toggleswitch';
import * as i4$5 from 'primeng/textarea';
import * as i7 from 'primeng/password';
import * as i4$6 from 'primeng/select';
import * as i4$7 from 'primeng/inputotp';
import { ChartType, ChartData, ChartOptions } from 'chart.js';
import * as i3$2 from '@angular/router';
import { Router } from '@angular/router';
import * as rxjs from 'rxjs';
import { Subscription } from 'rxjs';
import * as i3$3 from 'primeng/breadcrumb';
import * as i3$4 from 'primeng/confirmdialog';
import * as i3$5 from 'primeng/toast';
import * as i4$8 from 'primeng/accordion';
import * as i3$6 from 'primeng/dialog';
import * as i5$2 from 'primeng/menu';
import { Menu as Menu$1 } from 'primeng/menu';
import * as i3$7 from 'primeng/paginator';
import { PaginatorState } from 'primeng/paginator';

interface PTTableActionConfig {
    code: string;
    icon?: string;
    styleClass?: string;
    tooltip?: string;
    action: any;
    visible?: boolean | ((row: any) => boolean);
    disabled?: boolean | ((row: any) => boolean);
}
interface PTTableLazyLoadEvent {
    page: number;
    rows: number;
    first: number;
    search?: string;
    sortField?: string | null;
    sortOrder?: 1 | -1 | null;
    filters?: Record<string, any>;
}
interface PTTableRowOrderItem {
    id: any;
    order: number;
}
interface PTTableRowReorderEvent {
    oldIndex: number;
    newIndex: number;
    movedRow: any;
    data: any[];
    ordering: PTTableRowOrderItem[];
}
declare class PTAdvancedPrimeTableComponent implements OnInit, OnChanges, OnDestroy {
    private readonly zone;
    data: any[];
    columns: TableColumn[];
    totalRecords: number;
    rowsPerPage: number[];
    hasSearchFilter: boolean;
    hasExportExcel: boolean;
    hasExportPDF: boolean;
    hasColumnFilter: boolean;
    cellPadding: string;
    isPaginated: boolean;
    isLazy: boolean;
    actions: PTTableActionConfig[];
    isSortable: boolean;
    loading: boolean;
    maxHeight: string | null;
    isRowReorderable: boolean;
    showRowMoveArrows: boolean;
    rowReorderIdField: string;
    rowOrderStartAt: number;
    selectionDataKey: string;
    selectionMode: 'single' | 'multiple' | null;
    selection: any | any[] | null;
    cellHeight: string | null;
    hasContextMenu: boolean;
    selectionChange: EventEmitter<any>;
    rowSelect: EventEmitter<any>;
    rowUnselect: EventEmitter<any>;
    lazyLoad: EventEmitter<PTTableLazyLoadEvent>;
    search: EventEmitter<string>;
    exportExcelEvent: EventEmitter<void>;
    exportPdfEvent: EventEmitter<void>;
    onPageChange: EventEmitter<{
        page: number;
        rows: number;
    }>;
    onSortColumn: EventEmitter<any>;
    onFilterColumn: EventEmitter<any>;
    rowReorderChange: EventEmitter<PTTableRowReorderEvent>;
    filteredData: EventEmitter<any[]>;
    dt: Table;
    tableContainer?: ElementRef<HTMLElement>;
    contextMenu?: ContextMenu;
    contextMenuItems: MenuItem$1[];
    contextMenuRow: any | null;
    private editingRows;
    TableTypeEnum: typeof TableTypeEnum;
    AlignEnum: typeof AlignEnum;
    SeverityEnum: typeof SeverityEnum;
    searchValue: string;
    tableData: any[];
    readonly rowTrackBy: (_index: number, row: any) => any;
    private activeRowsForReorder;
    private reorderIndexByRow;
    private draggedRowForReorder;
    private draggedRowElement;
    private activeDropTarget;
    private activeDropBefore;
    private pointerMoveListener?;
    private pointerUpListener?;
    private dragAnimationFrameId;
    private latestPointerEvent;
    private pendingReorderSignature;
    filters: {
        [key: string]: any;
    };
    latestFilterValues: {
        [field: string]: any;
    };
    private clearedFields;
    private validCurrencyCodes;
    iconWidth: number;
    rows: number;
    first: number;
    currentPage: number;
    currentSortField: string | null;
    currentSortOrder: 1 | -1 | null;
    hasGroupedColumns: boolean;
    isDelete: boolean;
    isEdit: boolean;
    Delete: (value: any) => void;
    initEditableRow: (data: any) => void;
    saveEditableRow: (data: any) => void;
    cancelEditableRow: (item: any) => void;
    customActions: PTTableActionConfig[];
    dataMap: Map<any, any>;
    map: Map<any, Map<any, any>>;
    optionEntries: Map<string, any[]>;
    optionValues: any[];
    globalFilterFields: string[];
    constructor(zone: NgZone);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private buildGlobalFilterFields;
    private emitLazyLoad;
    private resetToFirstPage;
    canUseRowReorder(): boolean;
    getRowReorderColumnWidth(): string;
    canMoveRowUp(row: any): boolean;
    canMoveRowDown(row: any): boolean;
    moveRowUp(row: any): void;
    moveRowDown(row: any): void;
    onRowPointerDown(event: PointerEvent, row: any): void;
    private onRowPointerMove;
    private updatePointerDropTarget;
    private onRowPointerUp;
    private getRowDataFromElement;
    private clearPointerDropTarget;
    private cleanupPointerDrag;
    /**
     * Kept for consumers that call the previous PrimeNG event handler directly.
     * The component template uses the low-latency native handler above.
     */
    onRowReorder(event: TableRowReorderEvent): void;
    private moveRowByOffset;
    private resolveDropIndex;
    private refreshReorderIndexes;
    private scheduleReorderIndexRefresh;
    private resolveActiveRowsForReorder;
    private getRowIdentity;
    private buildRowOrdering;
    private moveRow;
    private mergeReorderedRows;
    private reorderRows;
    private isPendingReorderEcho;
    getHeaderTitleClass(col: TableColumn): string;
    getHeaderAlignClass(col: TableColumn): string;
    getDataAlignClass(col: TableColumn): string;
    getCellInnerAlignClass(col: TableColumn): string;
    private initializeActions;
    private initializeEditActions;
    onCustomActionClick(action: PTTableActionConfig, row: any): void;
    private initializeComposedFilters;
    getComposedFieldType(col: TableColumn, composedName: string): TableTypeEnum | undefined;
    onComposedColumnClear(col: TableColumn): void;
    onComposedFilterValueChange(col: TableColumn, composedName: string, value: any[], filterModel?: any): void;
    onFilterClear(field: string | undefined): void;
    onFilterValueChange(field: string | undefined, filterModel: any | null, value: any): void;
    onNumberFilterChange(field: string | undefined, value: any): void;
    private findColumnByField;
    filterColumn(event: any): void;
    changePage(event: any): void;
    sortColumn(event: any): void;
    private parseDate_ddMMyyyy;
    onChange(event: Event, id: number, key: any): void;
    changeHandler(id: number, key: any, value: any): void;
    getColumnFilterType(column: TableColumn): string;
    isEditable(key: string | undefined): boolean;
    isMultiSelect(key: any): boolean;
    isDatePicker(key: any): boolean;
    isDateTimePicker(key: any): boolean;
    filterGlobal(event: Event): void;
    private filterComposedColumn;
    parseAnyDate(input: any): Date | null;
    private formatWithPattern;
    formatDate(date: any): string;
    formatDateWithColumn(d: Date | null, col: TableColumn): string;
    formatDateTimeWithColumn(d: Date | null, col: TableColumn): string;
    private calculateColumnWidth;
    getHeaderWidth(col: TableColumn): string;
    clear(table: Table): void;
    private refreshTableData;
    private filterDataByGlobalSearch;
    private initializePagination;
    getCurrencySymbol(column: TableColumn): string | undefined;
    private isValidCurrencyCode;
    exportExcel(): void;
    exportPdf(): void;
    getImageStyle(style: TitleStyle | ImageStyle | undefined): {
        [key: string]: string;
    };
    getTitleStyle(style: TitleStyle | ImageStyle | undefined): {
        [key: string]: string;
    };
    formatNumber(value: number, decimalPlaces?: number, thousandSeparator?: 'comma' | 'space', decimalSeparator?: 'comma' | 'dot'): string;
    isActionVisible(action: PTTableActionConfig, row: any): boolean;
    isActionDisabled(action: PTTableActionConfig, row: any): boolean;
    getComposedCellStyle(col: TableColumn, composedName: string, row: any): {
        [key: string]: string;
    };
    mergeStyles(...styles: Array<{
        [key: string]: string;
    } | null | undefined>): {
        [key: string]: string;
    };
    getMergedComposedTextStyle(col: TableColumn, composedName: string, row: any): {
        [key: string]: string;
    };
    getMergedComposedImageStyle(col: TableColumn, composedName: string, row: any): {
        [key: string]: string;
    };
    getTagValue(col: TableColumn, row: any): string;
    getTagSeverity(col: TableColumn, row: any): SeverityEnum;
    getTagIcon(col: TableColumn, row: any): string | undefined;
    isTagRounded(col: TableColumn): boolean;
    getActionTooltip(action: PTTableActionConfig | undefined, row: any): string;
    getDefaultActionTooltip(code: string): string;
    getProgressValue(col: TableColumn, row: any): number;
    isProgressShowValue(col: TableColumn): boolean;
    getProgressUnit(col: TableColumn): string;
    getProgressSeverity(col: TableColumn, row: any): SeverityEnum;
    getMultiSelectValues(value: any): any[];
    getCellHeight(): string | null;
    getColumnCellPadding(col: TableColumn): string;
    getColumnCellMargin(col: TableColumn): string;
    getCellInnerStyle(col: TableColumn, defaultMargin?: string): {
        [key: string]: string;
    };
    getCellStyle(col: TableColumn, row: any): {
        [key: string]: string;
    };
    getHeaderCellStyle(col: TableColumn): {
        [key: string]: string;
    };
    getStaticCellStyle(): {
        [key: string]: string;
    };
    onRowContextMenu(event: MouseEvent, row: any): void;
    onContextMenuHide(): void;
    private buildContextMenuItems;
    startRowEdit(row: any): void;
    saveRowEdit(row: any): void;
    cancelRowEdit(row: any): void;
    private saveRowFromContextMenu;
    private cancelRowFromContextMenu;
    private isRowEditing;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTAdvancedPrimeTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTAdvancedPrimeTableComponent, "pt-advanced-prime-table", never, { "data": { "alias": "data"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "totalRecords": { "alias": "totalRecords"; "required": false; }; "rowsPerPage": { "alias": "rowsPerPage"; "required": false; }; "hasSearchFilter": { "alias": "hasSearchFilter"; "required": false; }; "hasExportExcel": { "alias": "hasExportExcel"; "required": false; }; "hasExportPDF": { "alias": "hasExportPDF"; "required": false; }; "hasColumnFilter": { "alias": "hasColumnFilter"; "required": false; }; "cellPadding": { "alias": "cellPadding"; "required": false; }; "isPaginated": { "alias": "isPaginated"; "required": false; }; "isLazy": { "alias": "isLazy"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "isSortable": { "alias": "isSortable"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "isRowReorderable": { "alias": "isRowReorderable"; "required": false; }; "showRowMoveArrows": { "alias": "showRowMoveArrows"; "required": false; }; "rowReorderIdField": { "alias": "rowReorderIdField"; "required": false; }; "rowOrderStartAt": { "alias": "rowOrderStartAt"; "required": false; }; "selectionDataKey": { "alias": "selectionDataKey"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "cellHeight": { "alias": "cellHeight"; "required": false; }; "hasContextMenu": { "alias": "hasContextMenu"; "required": false; }; }, { "selectionChange": "selectionChange"; "rowSelect": "rowSelect"; "rowUnselect": "rowUnselect"; "lazyLoad": "lazyLoad"; "search": "search"; "exportExcelEvent": "exportExcelEvent"; "exportPdfEvent": "exportPdfEvent"; "onPageChange": "onPageChange"; "onSortColumn": "onSortColumn"; "onFilterColumn": "onFilterColumn"; "rowReorderChange": "rowReorderChange"; "filteredData": "filteredData"; }, never, never, false, never>;
}

declare class CustomDatePipe implements PipeTransform {
    transform(value: any, format?: string): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CustomDatePipe, "customDate", false>;
}

declare class CustomCurrencyPipe implements PipeTransform {
    transform(value: number, currency?: string, decimalPlaces?: number, thousandSeparator?: 'comma' | 'space', decimalSeparator?: 'comma' | 'dot'): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomCurrencyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CustomCurrencyPipe, "customCurrency", true>;
}

declare enum TableTypeEnum {
    DATE = "DATE",
    DATETIME = "DATETIME",
    STRING = "STRING",
    AMOUNT = "AMOUNT",
    NUMBER = "NUMBER",
    MULTISELECT = "MULTISELECT",
    CURRENCY = "CURRENCY",
    BOOLEAN = "BOOLEAN",
    ACTION = "ACTION",
    COMPOSED = "COMPOSED",
    IMAGE = "IMAGE",
    TAG = "TAG",
    PROGRESS = "PROGRESS"
}

declare enum SearchCriteriaTypeEnum {
    DATE = "DATE",
    DATERANGE = "DATERANGE",
    STRING = "STRING",
    AMOUNT = "AMOUNT",
    NUMBER = "NUMBER",
    MULTISELECT = "MULTISELECT"
}

declare enum FormInputTypeEnum {
    DATE = "DATE",
    TEXT = "TEXT",
    EMAIL = "EMAIL",
    TEXTAREA = "TEXTAREA",
    AMOUNT = "AMOUNT",
    NUMBER = "NUMBER",
    MULTISELECT = "MULTISELECT",
    SELECT = "SELECT",
    CURRENCY = "CURRENCY",
    CHECKBOX = "CHECKBOX",
    SWITCH = "SWITCH",
    PASSWORD = "PASSWORD",
    OTP = "OTP"
}

declare enum ButtonColorEnum {
    PRIMARY = "p-button-primary",
    SECONDARY = "p-button-secondary",
    SUCCESS = "p-button-success",
    INFO = "p-button-info",
    WARNING = "p-button-warning",
    DANGER = "p-button-danger"
}

declare enum InputValidationEnum {
    ONLY_LETTERS = "^[A-Za-z ]+$",
    ONLY_NUMBERS = "^[0-9]+$",
    LETTERS_AND_NUMBERS = "^[A-Za-z0-9 ]+$",
    PHONE_NUMBER = "^[0-9 ]+$",
    EMAIL = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[A-Za-z]{2,}$"
}

declare enum BadgeType {
    Info = "info",
    Danger = "danger",
    Warning = "warning"
}
declare const BadgeTypeStyles: {
    info: {
        color: string;
        backgroundColor: string;
    };
    danger: {
        color: string;
        backgroundColor: string;
    };
    warning: {
        color: string;
        backgroundColor: string;
    };
};

declare enum SeverityEnum {
    SUCCESS = "success",
    SECONDARY = "secondary",
    INFO = "info",
    WARN = "warn",
    WARNING = "warn",
    DANGER = "danger",
    CONTRAST = "contrast",
    HELP = "help",
    PRIMARY = "primary"
}

declare enum AlignEnum {
    LEFT = "left",
    CENTER = "center",
    RIGHT = "right"
}

interface FormField {
    hidden?: boolean | ((formValue: Record<string, any>) => boolean);
    disabled?: boolean;
    type?: FormInputTypeEnum;
    label?: string;
    name: string;
    value?: any;
    required?: boolean;
    errorText?: string;
    validationMessages?: Record<string, string>;
    validators?: ValidatorFn[];
    width?: string;
    height?: string;
    margin?: string;
    placeholder?: string;
    minLength?: number;
    maxLength?: number;
    pattern?: string | RegExp;
    inputValidation?: InputValidationEnum;
    otpLength?: number;
    otpIntegerOnly?: boolean;
    otpMask?: boolean;
}

interface FormMultiSelectField extends FormField {
    options: any[];
    optionLabel?: string;
    optionValue?: string;
    filter?: boolean;
    filterBy?: string;
    display?: 'comma' | 'chip';
    maxSelectedLabels?: number;
    selectedItemsLabel?: string;
}

interface PTMultiSelectConfig {
    name?: string;
    label?: string;
    value?: any[];
    options?: any[];
    placeholder?: string;
    width?: string;
    hidden?: boolean;
    required?: boolean;
    disabled?: boolean;
    errorText?: string;
    optionLabel?: string;
    optionValue?: string;
    filter?: boolean;
    filterBy?: string;
    display?: 'comma' | 'chip';
    maxSelectedLabels?: number;
    selectedItemsLabel?: string;
}

declare class PTMultiSelectComponent implements OnInit, OnChanges, OnDestroy {
    formGroup?: FormGroup;
    formField?: FormMultiSelectField;
    config?: PTMultiSelectConfig;
    value: any[];
    valueChange: EventEmitter<any[]>;
    selectionChange: EventEmitter<any[]>;
    private readonly standaloneFormGroup;
    private valueChangesSubscription?;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get activeFormGroup(): FormGroup;
    get controlName(): string;
    get inputId(): string;
    get resolvedHidden(): boolean;
    get resolvedLabel(): string | undefined;
    get resolvedWidth(): string;
    get resolvedOptions(): any[];
    get resolvedPlaceholder(): string;
    get resolvedOptionLabel(): string;
    get resolvedOptionValue(): string;
    get resolvedRequired(): boolean;
    get resolvedDisabled(): boolean;
    get resolvedErrorText(): string | undefined;
    get resolvedFilter(): boolean;
    get resolvedFilterBy(): string;
    get resolvedDisplay(): 'comma' | 'chip';
    get resolvedMaxSelectedLabels(): number;
    get resolvedSelectedItemsLabel(): string;
    getErrorMessage(): string;
    private setupControl;
    private getInitialValue;
    private getValidators;
    private normalizeValue;
    private resolveHiddenValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMultiSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTMultiSelectComponent, "pt-multi-select", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; "config": { "alias": "config"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "selectionChange": "selectionChange"; }, never, never, false, never>;
}

declare class PTMultiSelectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMultiSelectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTMultiSelectModule, [typeof PTMultiSelectComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MultiSelectModule], [typeof PTMultiSelectComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTMultiSelectModule>;
}

interface ImageStyle {
    altText: string;
    imageUrl: string;
    routerLink?: string;
    color?: string;
    width?: string;
    height?: string;
    margin?: string;
    marginLeft?: string;
    marginRight?: string;
    marginTop?: string;
    marginBottom?: string;
}

interface IconStyle {
    code: string;
    color?: string;
    fontSize?: string;
    position?: 'left' | 'right';
    backgroundColor?: string;
    shape?: 'circular' | 'rounded-square';
}

interface TitleStyle {
    text: string;
    icon?: string | IconStyle;
    position?: 'left' | 'center' | 'right';
    color?: string;
    fontSize?: string;
    fontWeight?: string;
}

interface TableColumn {
    title: string;
    code?: string;
    type?: TableTypeEnum;
    options?: any[];
    isEditable?: boolean;
    isFilter?: boolean;
    dateFormat?: string;
    dateTimeFormat?: string;
    currency?: string;
    filterOptions?: any[];
    decimalPlaces?: number;
    isSortable?: boolean;
    thousandSeparator?: 'comma' | 'space';
    decimalSeparator?: 'comma' | 'dot';
    width?: string;
    totalWidth?: string;
    children?: TableColumn[];
    composedTypes?: TableTypeEnum[];
    composedNames?: string[];
    composedStyles?: Record<string, TitleStyle | ImageStyle>;
    headerAlign?: AlignEnum;
    dataAlign?: AlignEnum;
    /**
     * Padding applied to the table cell <td>/<th>.
     * Example: '0', '4px 8px', '0.5rem'
     */
    cellPadding?: string;
    /**
     * Margin applied to the inner cell wrapper.
     * Do not apply margin directly on <td>; table layout ignores it in many cases.
     * Example: '0', '4px', '0 8px'
     */
    cellMargin?: string;
    cellStyle?: {
        [key: string]: string;
    } | ((row: any) => {
        [key: string]: string;
    });
    composedCellStyles?: Record<string, {
        [key: string]: string;
    } | ((row: any) => {
        [key: string]: string;
    })>;
    tagSeverity?: SeverityEnum | ((row: any) => SeverityEnum);
    tagValue?: string | ((row: any) => string);
    tagIcon?: string | ((row: any) => string);
    tagRounded?: boolean;
    progressValue?: number | ((row: any) => number);
    progressShowValue?: boolean;
    progressUnit?: string;
    progressStyleClass?: string | ((row: any) => string);
}

interface FilterOption {
    label: string;
    value: string;
}

interface SearchCriteria {
    title: string;
    code: string;
    type: SearchCriteriaTypeEnum;
    value?: any;
    filterOptions?: FilterOption[];
    currency?: string;
    thousandSeparator?: 'comma' | 'space';
    decimalSeparator?: 'comma' | 'dot';
    minFractionDigits?: number;
    maxFractionDigits?: number;
}

interface FormButton {
    text: string;
    action?: () => void;
    color?: ButtonColorEnum;
    fontColor?: string;
    backgroundColor?: string;
    borderColor?: string;
    icon?: string;
    isSubmit?: boolean;
    isClear?: boolean;
    disabled?: boolean;
}

interface FormFieldGroup {
    fields?: FormField[];
    groups?: FormFieldGroup[];
    width?: string;
}

interface FormCheckBoxField extends FormField {
}

type DateFormatType = 'mm/dd/yy' | 'yy/mm/dd' | 'dd.mm.yy' | 'dd-mm-yy' | 'dd/mm/yy' | 'HH:mm' | 'HH:mm:ss' | 'dd/mm/yy HH:mm' | 'dd-mm-yy HH:mm' | 'dd.mm.yy HH:mm' | 'mm/dd/yy HH:mm' | 'yy/mm/dd HH:mm' | 'dd/mm/yy HH:mm:ss' | 'dd-mm-yy HH:mm:ss' | 'dd.mm.yy HH:mm:ss' | 'mm/dd/yy HH:mm:ss' | 'yy/mm/dd HH:mm:ss';

type DateInputType = 'date' | 'time' | 'datetime' | 'range';

interface FormDateField extends FormField {
    dateFormat?: DateFormatType;
    dateInputType?: DateInputType;
    hourFormat?: '12' | '24';
    minValue?: string;
    maxValue?: string;
}

interface IconImageStyle {
    url: string;
    position?: 'left' | 'right';
    shape?: 'circular' | 'rounded-square';
    width?: string;
    height?: string;
    marginLeft?: string;
    marginRight?: string;
    marginTop?: string;
    marginBottom?: string;
}

interface FormDropdownField extends FormField {
    options: any[];
    icon?: string | IconStyle | IconImageStyle;
    filter?: boolean;
    filterBy?: string;
    optionLabel?: string;
    optionValue?: string;
    optionDisabled?: string;
}

interface FormNumberField extends FormField {
    minValue?: string;
    maxValue?: string;
    currency?: string;
    numberFormat?: 'fr-FR' | 'en-US';
    decimalDigits?: number;
    iconClass?: string;
    iconPosition?: 'left' | 'right';
}

interface FormSwitchField extends FormField {
}

interface FormTextAreaField extends FormField {
    rows?: number;
    cols?: number;
    autoResize?: boolean;
    minLength?: number;
    maxLength?: number;
    iconClass?: string;
    iconPosition?: 'left' | 'right';
}

interface FormTextField extends FormField {
    minLength?: number;
    maxLength?: number;
    iconClass?: string;
    iconPosition?: 'left' | 'right';
    width?: string;
    height?: string;
    margin?: string;
    toggleMask?: boolean;
    feedback?: boolean;
}

interface PTDateInputConfig {
    name?: string;
    label?: string;
    value?: Date | Date[] | string | null;
    placeholder?: string;
    width?: string;
    hidden?: boolean;
    required?: boolean;
    disabled?: boolean;
    errorText?: string;
    dateInputType?: DateInputType;
    dateFormat?: DateFormatType;
    minValue?: string;
    maxValue?: string;
    hourFormat?: '12' | '24';
    showIcon?: boolean;
}

interface PTDropdownConfig {
    name?: string;
    label?: string;
    value?: any;
    options?: any[];
    placeholder?: string;
    width?: string;
    hidden?: boolean;
    required?: boolean;
    disabled?: boolean;
    errorText?: string;
    optionLabel?: string;
    optionValue?: string;
    optionDisabled?: string;
    filter?: boolean;
    filterBy?: string;
    icon?: string | IconStyle | IconImageStyle;
}

interface PTSwitchConfig {
    name?: string;
    label?: string;
    value?: boolean | null;
    width?: string;
    hidden?: boolean;
    disabled?: boolean;
    required?: boolean;
    errorText?: string;
}

interface TextStyle {
    text: string;
    color?: string;
    fontSize?: string;
    fontWeight?: string;
    position?: 'left' | 'center' | 'right';
}

interface LabelSetting extends TextStyle {
    position?: 'left' | 'right';
}
interface ValueSetting extends TextStyle {
    label?: LabelSetting | string;
}
interface Size {
    minWidth?: string;
    maxWidth?: string;
    fixedWidth?: string;
}
interface Divider {
    show?: boolean;
    color?: string;
}
interface VerticalLine {
    show?: boolean;
    color?: string;
}
interface Appearance {
    backgroundColor?: string;
}
interface MetricCardData {
    icon: IconStyle | string;
    title?: TextStyle | string;
    value?: ValueSetting | string;
    additionalInfo?: TextStyle | string;
    size?: Size;
    divider?: Divider;
    verticalLine?: VerticalLine;
    appearance?: Appearance;
}

interface MetricIndicateurData {
    icon?: IconStyle;
    title?: string | TitleStyle;
    value: string | TitleStyle;
    url?: string;
    tooltip?: string;
    highlighted?: boolean;
}

interface MetricPanelData {
    title?: string | TitleStyle;
    indicators: MetricIndicateurData[];
}

interface Dataset {
    label?: string;
    data: number[] | any[];
    backgroundColor?: string | string[];
    borderColor?: string | string[];
    borderWidth?: number;
    fill?: boolean;
    tension?: number;
    stack?: string;
    type?: ChartType;
}
interface ChartConfig {
    type: ChartType;
    data: ChartData;
    chartHeight?: string;
    chartWidth?: string;
    medianTitle?: string;
    xAxisTitle?: string;
    yAxisTitle?: string;
    scales?: {
        y?: {
            min?: number;
            max?: number;
            ticks?: {
                stepSize?: number;
                beginAtZero?: boolean;
            };
        };
    };
    options?: ChartOptions;
}

interface MenuItem extends TextStyle {
    icon?: string | IconStyle;
    action?: () => void;
    /** ✅ optional: render but do not allow click */
    disabled?: boolean;
    /** ✅ optional: render as a header (username line) */
    isHeader?: boolean;
}

interface MenuConfig {
    menuItems?: MenuItem[];
    icon?: IconStyle;
    color?: string;
    fontSize?: string;
    menuDirection?: 'left' | 'right';
}

interface Pattern {
    imageUrl: string;
    transparencyPercentage?: string;
    backgroundColor?: string;
    width?: string;
    height?: string;
    repeatX?: boolean;
    repeatY?: boolean;
    repeatCount?: number;
    position?: 'left top' | 'top center' | 'right top' | 'left bottom' | 'bottom center' | 'right bottom' | 'center';
}

interface CardConfig {
    identifier?: string;
    title?: string | TitleStyle;
    backgroundColor?: string;
    transparencyPercentage?: string;
    width?: string;
    height?: string;
    padding?: string;
    bodyPadding?: string;
    margin?: string;
    borderColor?: string;
    borderWidth?: string;
    menu?: MenuConfig;
    menuPosition?: 'left' | 'right';
    scrollableVertical?: boolean;
    scrollableHorizontal?: boolean;
    pattern?: Pattern;
    noBorder?: boolean;
    borderRadius?: string;
    boxShadow?: string;
    zIndex?: number;
    alignContent?: 'center' | 'default';
    alignBodyContent?: 'center' | 'default';
    alignHeaderContent?: 'center' | 'default';
}

interface AxisChartConfig {
    chartIdentifier?: string;
    xAxisTitle?: string;
    yAxisTitle?: string;
    chartMenu?: Array<{
        text: string;
        action: () => void;
        icon?: string | {
            code: string;
            color?: string;
        };
    }>;
    chartWidth?: string;
    cardConfig?: CardConfig;
}

interface AxisChartData {
    label: string;
    value: number;
}

type PTAccordionValue = string | number;
type PTAccordionActiveValue = string | number | string[] | number[] | null;
interface PTAccordionPanelTemplateContext {
    $implicit: PTAccordionPanelConfig;
    panel: PTAccordionPanelConfig;
    expanded: boolean;
}
interface PTAccordionTagConfig {
    value: string;
    severity?: SeverityEnum;
    icon?: string;
    rounded?: boolean;
    visible?: boolean;
    styleClass?: string;
}
interface PTAccordionPanelConfig {
    value: PTAccordionValue;
    title: TitleStyle;
    description?: TextStyle;
    tag?: PTAccordionTagConfig;
    disabled?: boolean;
    visible?: boolean;
    lazy?: boolean;
    styleClass?: string;
    headerStyleClass?: string;
    contentStyleClass?: string;
    /**
     * Configuration applied to the PTCard used inside the panel body.
     *
     * By default, the generated card is:
     * - horizontally scrollable
     * - vertically scrollable
     * - transparent
     * - borderless
     * - without shadow
     * - without outer margin
     */
    bodyCardConfig?: CardConfig;
    /**
     * Optional minimum width applied to wide projected content,
     * particularly pt-advanced-prime-table.
     */
    contentMinWidth?: string;
}
interface PTAccordionConfig {
    panels: PTAccordionPanelConfig[];
    multiple?: boolean;
    expandIcon?: string;
    collapseIcon?: string;
    styleClass?: string;
    panelStyleClass?: string;
    headerStyleClass?: string;
    contentStyleClass?: string;
    animationDuration?: string;
}

declare enum PTNewsTickerDirection {
    LEFT = "left",
    RIGHT = "right"
}
declare enum PTNewsTickerType {
    DEFAULT = "DEFAULT",
    INFO = "INFO",
    SUCCESS = "SUCCESS",
    WARNING = "WARNING",
    DANGER = "DANGER",
    FLASH = "FLASH"
}
declare enum PTNewsTickerTrend {
    UP = "UP",
    DOWN = "DOWN",
    STABLE = "STABLE"
}
type PTNewsTickerTarget = '_self' | '_blank';
interface PTNewsTickerSegment {
    label: string;
    value?: string;
    trend?: PTNewsTickerTrend;
    icon?: string;
    iconColor?: string;
    textColor?: string;
    tooltip?: string;
}
interface PTNewsTickerItem {
    id: string | number;
    text: string;
    type?: PTNewsTickerType;
    icon?: string;
    iconColor?: string;
    textColor?: string;
    backgroundColor?: string;
    borderColor?: string;
    flash?: boolean;
    flashBackgroundColor?: string;
    flashAlternateBackgroundColor?: string;
    flashTextColor?: string;
    flashDuration?: number;
    link?: string;
    target?: PTNewsTickerTarget;
    removable?: boolean;
    disabled?: boolean;
    tooltip?: string;
    styleClass?: string;
    segments?: PTNewsTickerSegment[];
    segmentSeparator?: string;
    createdAt?: string | Date;
    showNewBadge?: boolean;
    newBadgeText?: string;
    newBadgeDuration?: number;
}
interface PTNewsTickerChangeEvent {
    news: PTNewsTickerItem[];
    addedItem?: PTNewsTickerItem;
    removedItem?: PTNewsTickerItem;
}
interface PTNewsTickerPlayStateChangeEvent {
    playing: boolean;
    speed: number;
}
interface PTNewsTickerSpeedChangeEvent {
    previousSpeed: number;
    speed: number;
}

interface Badge {
    type?: BadgeType;
    count: number;
    color?: string;
    backgroundColor?: string;
}

interface Menu {
    id: number;
    label: string;
    idParent: number | null;
    url: string;
    code: string;
    icon?: string;
    children?: Menu[];
    isExpanded?: boolean;
    badge?: Badge;
}

type DateFormat = 'dd/MM/YYYY' | 'MM/dd/YYYY' | 'YYYY-MM-dd';
type TimeFormat = 'HH:mm:ss' | 'HH:mm';
type DateTimePosition = 'left' | 'center' | 'right';
type DateTimeSource = 'CLIENT' | 'SERVER';
type NavBarUserAvatarMode = 'ICON' | 'INITIALS';
type NavBarUserProfilePosition = 'NONE' | 'LEFT_OF_AVATAR';
type NavBarUserMenuItemSeverity = 'default' | 'danger';
interface NavBarDateTimeConfig {
    dateFormat?: DateFormat;
    timeFormat?: TimeFormat;
    /** FIXED mode */
    dateValue?: string;
    /** style datetime using TextStyle */
    textStyle?: Omit<TextStyle, 'text'>;
    /** position between left and actions */
    position?: DateTimePosition;
    /** CLIENT or SERVER */
    source?: DateTimeSource;
}
interface NavBarUserMenuItem {
    text: string;
    icon?: string;
    severity?: NavBarUserMenuItemSeverity;
    disabled?: boolean;
    visible?: boolean;
    separatorBefore?: boolean;
    action?: () => void;
}
interface NavBarUserConfig {
    username?: string;
    firstName?: string;
    lastName?: string;
    fullName?: string;
    profile?: string;
    avatarMode?: NavBarUserAvatarMode;
    showProfileInMenu?: boolean;
    profilePosition?: NavBarUserProfilePosition;
    avatarBackgroundColor?: string;
    avatarTextColor?: string;
    avatarBorderColor?: string;
    profileTextStyle?: Omit<TextStyle, 'text'>;
    menuItems?: NavBarUserMenuItem[];
}
interface NavBarMenuConfig {
    logo?: string | ImageStyle;
    appName?: string | TextStyle;
    menus?: MenuConfig[];
    pattern?: Pattern;
    toggleButtonIcon?: string;
    toggleButtonColor?: string;
    dateTime?: NavBarDateTimeConfig;
    user?: NavBarUserConfig;
    height?: string;
    minHeight?: string;
    paddingTop?: string;
    paddingBottom?: string;
}

interface SideMenuBarConfig {
    menus: Menu[];
    isVisible: boolean;
    searchable: boolean;
    width?: string;
    height?: string;
    scrollable?: boolean;
    title?: string | TitleStyle;
    backgroundColor?: string;
    pattern?: Pattern;
    fontColor?: string;
    fontColorSubMenu?: string;
    hoverColor?: string;
    hoverFontColor?: string;
    hoverColorSubMenu?: string;
    hoverFontColorSubMenu?: string;
}

interface BreadCrumbConfig {
    menuData: Menu[];
    pattern?: Pattern;
}

interface FooterConfig {
    appName?: string;
    version?: string;
    productionYear?: number;
    cardConfig?: CardConfig;
}

interface PageSkeletonConfig {
    navBarMenuConfig: NavBarMenuConfig;
    sideMenuBarConfig: SideMenuBarConfig;
    contentCardConfig: CardConfig;
    backgroundCardConfig?: CardConfig;
    footerConfig?: FooterConfig;
    breadCrumbConfig?: BreadCrumbConfig;
    onUserClick?: () => void;
    onLogoutClick?: () => void;
}

interface ButtonModel {
    label?: string;
    icon?: string;
    iconPos?: 'left' | 'right';
    disabled?: boolean;
    styleClass?: string;
    loading?: boolean;
    type?: 'button' | 'submit' | 'reset';
    width?: string;
    height?: string;
    fontColor?: string;
    backgroundColor?: string;
    borderColor?: string;
    severity?: SeverityEnum;
    outlined?: boolean;
}

interface FooterModel {
    version: string;
    copyright: string;
}

interface ForgotPasswordConfig {
    text: string;
    url: string;
    target?: '_self' | '_blank' | '_parent' | '_top';
    style?: {
        [key: string]: string;
    };
    styleClass?: string;
    align?: AlignEnum;
}

type LoginAdditionalContentType = 'text' | 'link' | 'text-with-link';
type LoginAdditionalContentAlign = 'left' | 'center' | 'right';
type LoginAdditionalContentLinkPosition = 'before' | 'after';
interface LoginAdditionalContent {
    /**
     * Optional unique identifier.
     */
    id?: string;
    /**
     * Content type.
     *
     * text:
     *   Displays only text.
     *
     * link:
     *   Displays only a clickable link.
     *
     * text-with-link:
     *   Displays text with a clickable link before or after it.
     */
    type?: LoginAdditionalContentType;
    /**
     * Plain text displayed by the item.
     */
    text?: string;
    /**
     * Text displayed by the clickable link.
     */
    linkText?: string;
    /**
     * Destination URL.
     */
    url?: string;
    /**
     * Link target.
     */
    target?: '_self' | '_blank' | '_parent' | '_top';
    /**
     * Link relationship attribute.
     *
     * When target is _blank, noopener noreferrer is applied by default.
     */
    rel?: string;
    /**
     * Positions the link before or after the plain text.
     *
     * Default: after.
     */
    linkPosition?: LoginAdditionalContentLinkPosition;
    /**
     * Horizontal alignment.
     *
     * Default: center.
     */
    align?: LoginAdditionalContentAlign;
    /**
     * Optional CSS class applied to the complete item.
     */
    styleClass?: string;
    /**
     * Optional inline styles applied to the complete item.
     */
    style?: Record<string, string>;
    /**
     * Optional CSS class applied to the link.
     */
    linkStyleClass?: string;
    /**
     * Optional inline styles applied to the link.
     */
    linkStyle?: Record<string, string>;
    /**
     * Whether this item should be displayed.
     *
     * Default: true.
     */
    visible?: boolean;
}

interface LoginModel {
    username: string;
    password: string;
    errorMessage?: string;
    emptyFieldsErrorMessage?: string;
}

interface LoginPageConfig {
    backgroundImage?: Pattern;
    title?: TitleStyle;
    logoUrl?: ImageStyle;
    footer?: FooterModel;
    login?: LoginModel;
    loginCardConfig?: CardConfig;
    centerCardConfig?: CardConfig;
    leftCardConfig?: CardConfig;
    rightCardConfig?: CardConfig;
    usernameField?: FormTextField;
    passwordField?: FormTextField;
    loginButtonLabel?: string;
    buttonConfig?: ButtonModel;
    position?: 'center' | 'left' | 'right';
    forgotPasswordConfig?: ForgotPasswordConfig;
    additionalContent?: LoginAdditionalContent[];
}

type OtpPagePosition = 'center' | 'left' | 'right';
interface OtpPageConfig {
    position: OtpPagePosition;
    centerCardConfig?: CardConfig;
    leftCardConfig?: CardConfig;
    rightCardConfig?: CardConfig;
    otpCardConfig?: CardConfig;
    logoUrl?: {
        imageUrl?: string;
        altText?: string;
        width?: string;
        height?: string;
    };
    title?: {
        text?: string;
        position?: 'left' | 'center' | 'right';
        color?: string;
        fontSize?: string;
    };
    description?: {
        text?: string;
        color?: string;
        fontSize?: string;
    };
    otp?: {
        otpCode?: string;
        errorMessage?: string;
        emptyFieldErrorMessage?: string;
    };
    otpCodeField?: FormField;
    buttonConfig?: ButtonModel;
    footer?: {
        version?: string;
        copyright?: string;
    };
    backButtonConfig?: ButtonModel;
}

interface ChangePasswordModel {
    currentPassword?: string;
    newPassword: string;
    confirmationPassword: string;
}

interface PasswordPolicyRuleModel {
    code: string;
    label: string;
    valid: boolean;
    backendOnly?: boolean;
    visible?: boolean;
}

interface ChangePasswordPageConfig {
    backgroundImage?: Pattern;
    title?: TitleStyle;
    logoUrl?: ImageStyle;
    footer?: FooterModel;
    changePassword?: ChangePasswordModel;
    changePasswordCardConfig?: CardConfig;
    centerCardConfig?: CardConfig;
    leftCardConfig?: CardConfig;
    rightCardConfig?: CardConfig;
    currentPasswordField?: FormTextField;
    newPasswordField?: FormTextField;
    confirmationPasswordField?: FormTextField;
    showCurrentPasswordField?: boolean;
    buttonConfig?: ButtonModel;
    position?: 'center' | 'left' | 'right';
    errorMessage?: string;
    emptyFieldsErrorMessage?: string;
    passwordMismatchErrorMessage?: string;
    showPasswordStrength?: boolean;
    passwordStrengthLabel?: string;
    passwordStrengthText?: string;
    passwordStrengthPercentage?: number;
    passwordStrengthSeverity?: PasswordStrengthSeverity;
    passwordPolicyTitle?: string;
    passwordPolicyRules?: PasswordPolicyRuleModel[];
    additionalContent?: LoginAdditionalContent[];
}
type PasswordStrengthSeverity = 'neutral' | 'danger' | 'warn' | 'success';

interface ToastMessage {
    severity: 'success' | 'info' | 'warn' | 'error';
    summary: string;
    detail: string;
    life?: number;
}

interface PTConfirmDialogConfig {
    header?: string | TitleStyle;
    visible?: boolean;
    width?: string;
    height?: string;
    content?: string | TitleStyle;
    closeOnEscape?: boolean;
    confirmButtonConfig?: ButtonModel;
    cancelButtonConfig?: ButtonModel;
    toastOnConfirm?: ToastMessage;
    toastOnCancel?: ToastMessage;
    dialogStyle?: SeverityEnum;
    footerAlign?: AlignEnum;
}

type DialogPosition = 'right' | 'left' | 'center' | 'top' | 'bottom' | 'topleft' | 'topright' | 'bottomleft' | 'bottomright';
interface PTDialogConfig {
    /** Title text in the header */
    header?: string;
    /** Inline style for the whole dialog container (PrimeNG [style]) */
    style?: {
        [key: string]: any;
    };
    /** Extra classes applied to PrimeNG dialog */
    styleClass?: string;
    /** Optional icon in the header (e.g. 'pi pi-info-circle text-blue-500') */
    headerIconClass?: string;
    /** Optional body max width / height (e.g. '500px', '60vh') */
    bodyWidth?: string;
    bodyHeight?: string;
    /** Enable scroll when body exceeds given height/width (default: true) */
    bodyScrollable?: boolean;
    /** Control footer visibility (default: true) */
    showFooter?: boolean;
    /** PrimeNG dialog behavior flags */
    modal?: boolean;
    closable?: boolean;
    draggable?: boolean;
    resizable?: boolean;
    maximizable?: boolean;
    dismissableMask?: boolean;
    closeOnEscape?: boolean;
    blockScroll?: boolean;
    /** Responsive breakpoints */
    breakpoints?: {
        [key: string]: string;
    };
    /** Dialog position (PrimeNG <p-dialog> position) */
    position?: DialogPosition;
    /** Extra style for content (PrimeNG [contentStyle]) */
    contentStyle?: {
        [key: string]: any;
    };
    dialogStyle?: SeverityEnum;
}

interface PTNotificationMenuAction {
    id: string;
    label: string;
    icon?: string;
    disabled?: boolean;
    visible?: boolean;
    danger?: boolean;
}
interface PTNotificationItem {
    id: string | number;
    text: string;
    icon?: string;
    iconColor?: string;
    sender?: string;
    date?: Date | string;
    read?: boolean;
    disabled?: boolean;
    styleClass?: string;
    link?: string;
    actions?: PTNotificationMenuAction[];
}
interface PTNotificationClickEvent {
    notification: PTNotificationItem;
}
interface PTNotificationActionEvent {
    notification: PTNotificationItem;
    action: PTNotificationMenuAction;
}
interface PTNotificationGlobalActionEvent {
    action: PTNotificationMenuAction;
    notifications: PTNotificationItem[];
}
interface PTNotificationLoadMoreEvent {
    /**
     * Zero-based page requested from the server.
     */
    page: number;
    /**
     * Number of records requested.
     */
    size: number;
    /**
     * Zero-based offset.
     */
    first: number;
}
interface PTNotificationConfig {
    visible?: boolean;
    title?: string;
    emptyText?: string;
    bellIcon?: string;
    badgeLimit?: number;
    width?: string;
    maxHeight?: string;
    showBadge?: boolean;
    showHeaderCount?: boolean;
    closePanelOnNotificationClick?: boolean;
    closeActionMenuOnAction?: boolean;
    showViewAll?: boolean;
    viewAllText?: string;
    viewAllIcon?: string;
    showGlobalActions?: boolean;
    globalActions?: PTNotificationMenuAction[];
    closeGlobalActionMenuOnAction?: boolean;
    /**
     * Enables server-side infinite scroll.
     *
     * Default: false.
     */
    infiniteScroll?: boolean;
    /**
     * Distance in pixels from the bottom of the list
     * at which the next server page is requested.
     *
     * Default: 80.
     */
    infiniteScrollThreshold?: number;
    /**
     * Text displayed while the next page is loading.
     */
    loadingText?: string;
}
type PTNotificationsPageFilter = 'ALL' | 'UNREAD' | 'READ';
interface PTNotificationsPageQueryEvent {
    page: number;
    size: number;
    first: number;
    filter: PTNotificationsPageFilter;
    search: string;
}
interface PTNotificationsPageConfig {
    title?: string;
    subtitle?: string;
    emptyText?: string;
    emptyIcon?: string;
    searchPlaceholder?: string;
    showSearch?: boolean;
    showFilters?: boolean;
    showCounters?: boolean;
    allLabel?: string;
    unreadLabel?: string;
    readLabel?: string;
    showGlobalActions?: boolean;
    globalActions?: PTNotificationMenuAction[];
    defaultFilter?: PTNotificationsPageFilter;
    noSearchResultText?: string;
    showPagination?: boolean;
    rowsPerPageOptions?: number[];
    showCurrentPageReport?: boolean;
    currentPageReportTemplate?: string;
}

type PTReleaseNotesLanguage = 'FR' | 'EN';
type PTReleaseNoteDetailType = 'NEW' | 'IMPROVEMENT' | 'BUG_FIX';
type PTReleaseNotesPageFilter = 'ALL' | 'UNREAD' | 'READ';
interface PTReleaseNoteDetail {
    id: string | number;
    type: PTReleaseNoteDetailType;
    title: string;
    description?: string;
    icon?: string;
    link?: string;
    disabled?: boolean;
    styleClass?: string;
}
interface PTReleaseNoteItem {
    id: string | number;
    version: string;
    title: string;
    summary?: string;
    date?: Date | string;
    newCount?: number;
    improvementCount?: number;
    bugFixCount?: number;
    details?: PTReleaseNoteDetail[];
    read?: boolean;
    disabled?: boolean;
    styleClass?: string;
    detailsUrl?: string;
}
interface PTReleaseNoteClickEvent {
    release: PTReleaseNoteItem;
}
interface PTReleaseNoteLoadMoreEvent {
    page: number;
    size: number;
    first: number;
}
interface PTReleaseNotesPageQueryEvent {
    page: number;
    size: number;
    first: number;
    filter: PTReleaseNotesPageFilter;
    search: string;
}
interface PTReleaseNoteMenuAction {
    id: string;
    label: string;
    icon?: string;
    visible?: boolean;
    disabled?: boolean;
    danger?: boolean;
}
interface PTReleaseNoteActionEvent {
    release: PTReleaseNoteItem;
    action: PTReleaseNoteMenuAction;
}
interface PTReleaseNoteGlobalActionEvent {
    action: PTReleaseNoteMenuAction;
    releases: PTReleaseNoteItem[];
}
interface PTReleaseNotesConfig {
    visible?: boolean;
    language?: PTReleaseNotesLanguage;
    title?: string;
    emptyText?: string;
    icon?: string;
    badgeLimit?: number;
    width?: string;
    maxHeight?: string;
    showBadge?: boolean;
    showHeaderCount?: boolean;
    closePanelOnReleaseClick?: boolean;
    showViewAll?: boolean;
    viewAllText?: string;
    viewAllIcon?: string;
    detailsText?: string;
    newLabel?: string;
    improvementLabel?: string;
    bugFixLabel?: string;
    infiniteScroll?: boolean;
    infiniteScrollThreshold?: number;
    loadingText?: string;
    showDetailsText?: string;
    hideDetailsText?: string;
    /**
     * Enables the per-release action menu.
     *
     * Example:
     * MARK_AS_READ
     */
    showActions?: boolean;
    /**
     * Enables the global action menu in the panel header.
     *
     * Example:
     * MARK_ALL_AS_READ
     */
    showGlobalActions?: boolean;
    /**
     * Controls whether the per-release action menu
     * closes after an action is emitted.
     */
    closeActionMenuOnAction?: boolean;
    /**
     * Controls whether the global action menu
     * closes after an action is emitted.
     */
    closeGlobalActionMenuOnAction?: boolean;
    /**
     * Actions available for each release.
     *
     * If undefined, pt-release-notes can use its
     * default MARK_AS_READ action.
     */
    actions?: PTReleaseNoteMenuAction[];
    /**
     * Global actions available from the release-notes header.
     *
     * If undefined, pt-release-notes can use its
     * default MARK_ALL_AS_READ action.
     */
    globalActions?: PTReleaseNoteMenuAction[];
}

declare class PTButtonComponent implements OnInit, AfterViewInit, OnChanges {
    private renderer;
    private el;
    buttonConfig: ButtonModel;
    constructor(renderer: Renderer2, el: ElementRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    getIconPos(): 'left' | 'right';
    getType(): string;
    hasCustomColors(): boolean;
    /**
     * When custom colors are provided, do not pass PrimeNG severity.
     * Otherwise PrimeNG theme classes can override the custom colors.
     */
    getSeverity(): SeverityEnum | undefined;
    getStyleClass(): string;
    /**
     * Direct style binding for PrimeNG p-button.
     * This is the reliable fallback for PrimeNG v21 themes.
     */
    getButtonStyle(): {
        [key: string]: string;
    };
    private getButtonElement;
    private updateDisabledStyles;
    /**
     * We delegate colors to PrimeNG theme when no manual color is provided.
     */
    private shouldUseThemeColors;
    applyButtonStyles(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTButtonComponent, "pt-button", never, { "buttonConfig": { "alias": "buttonConfig"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTButtonModule, [typeof PTButtonComponent], [typeof i2.CommonModule, typeof i3$1.ButtonModule], [typeof PTButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTButtonModule>;
}

declare class PTAdvancedPrimeTableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTAdvancedPrimeTableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTAdvancedPrimeTableModule, [typeof PTAdvancedPrimeTableComponent, typeof CustomDatePipe], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i5.TableModule, typeof i6.InputTextModule, typeof i3$1.ButtonModule, typeof i8.ContextMenuModule, typeof i9.DatePickerModule, typeof i4.MultiSelectModule, typeof i11.TagModule, typeof i12.IconFieldModule, typeof i13.InputIconModule, typeof i14.ProgressSpinnerModule, typeof i4$1.TooltipModule, typeof i16.ProgressBarModule, typeof CustomCurrencyPipe, typeof PTMultiSelectModule, typeof PTButtonModule], [typeof PTAdvancedPrimeTableComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTAdvancedPrimeTableModule>;
}

declare class MultiSearchCriteriaComponent implements OnInit {
    SearchCriteriaTypeEnum: typeof SearchCriteriaTypeEnum;
    title: String;
    criteria: SearchCriteria[];
    inputsPerRow: number;
    data: any[];
    mode: 'static' | 'dynamic';
    filteredData: EventEmitter<any[]>;
    searchCriteria: EventEmitter<{
        [key: string]: any;
    }>;
    selectAll: boolean;
    selected: FilterOption[];
    ngOnInit(): void;
    getCurrencySymbol(input: SearchCriteria): string;
    getMinFractionDigits(input: SearchCriteria): number;
    getMaxFractionDigits(input: SearchCriteria): number | undefined;
    getStepValue(input: SearchCriteria): number;
    search(): void;
    clear(): void;
    onSelectAllChange(event: any, criterion: SearchCriteria): void;
    private parseDate;
    getDecimalSeparator(input: SearchCriteria): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSearchCriteriaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSearchCriteriaComponent, "multi-search-criteria", never, { "title": { "alias": "title"; "required": false; }; "criteria": { "alias": "criteria"; "required": false; }; "inputsPerRow": { "alias": "inputsPerRow"; "required": false; }; "data": { "alias": "data"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; }, { "filteredData": "filteredData"; "searchCriteria": "searchCriteria"; }, never, never, false, never>;
}

declare class MultiSearchCriteriaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSearchCriteriaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MultiSearchCriteriaModule, [typeof MultiSearchCriteriaComponent], [typeof i2.CommonModule, typeof i9.DatePickerModule, typeof i6.InputTextModule, typeof i4.MultiSelectModule, typeof i3$1.ButtonModule, typeof i3.FormsModule, typeof i8$1.InputNumberModule, typeof i9$1.PanelModule], [typeof MultiSearchCriteriaComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MultiSearchCriteriaModule>;
}

declare class PTCheckBoxInputComponent implements OnInit, OnChanges {
    formGroup: FormGroup;
    formField: FormCheckBoxField;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    get inputId(): string;
    get errorId(): string;
    get isInvalid(): boolean;
    getErrorMessage(): string;
    private setupControl;
    private resolveInitialValue;
    private getValidators;
    private resolveFirstErrorKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTCheckBoxInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTCheckBoxInputComponent, "pt-check-box-input", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTCheckBoxInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTCheckBoxInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTCheckBoxInputModule, [typeof PTCheckBoxInputComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4$2.CheckboxModule], [typeof PTCheckBoxInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTCheckBoxInputModule>;
}

declare class PTDateService {
    constructor();
    assignDefaultDateFormat(dateInputType: DateInputType, currentFormat?: DateFormatType): DateFormatType;
    validateDateFormatAndType(dateFormat: DateFormatType, dateInputType: DateInputType, minValue?: string, maxValue?: string, hourFormat?: '12' | '24'): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PTDateService>;
}

declare class PTDateInputComponent implements OnInit, OnChanges, OnDestroy {
    private readonly dateService;
    formGroup?: FormGroup;
    formField?: FormDateField;
    config?: PTDateInputConfig;
    value: Date | Date[] | string | null;
    valueChange: EventEmitter<string | Date | Date[] | null>;
    dateChange: EventEmitter<string | Date | Date[] | null>;
    minDate: Date | null;
    maxDate: Date | null;
    defaultPlaceholder: string;
    defaultDateFormat: DateFormatType;
    private readonly standaloneFormGroup;
    private valueChangesSubscription?;
    constructor(dateService: PTDateService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get activeFormGroup(): FormGroup;
    get controlName(): string;
    get inputId(): string;
    get labelId(): string;
    get errorId(): string;
    get resolvedHidden(): boolean;
    get resolvedLabel(): string | undefined;
    get resolvedWidth(): string;
    get resolvedPlaceholder(): string;
    get resolvedDateInputType(): DateInputType;
    get resolvedDateFormat(): DateFormatType;
    get resolvedHourFormat(): '12' | '24';
    get resolvedRequired(): boolean;
    get resolvedDisabled(): boolean;
    get resolvedShowIcon(): boolean;
    get resolvedMinValue(): string | undefined;
    get resolvedMaxValue(): string | undefined;
    get resolvedErrorText(): string | undefined;
    get isInvalid(): boolean;
    getErrorMessage(): string;
    private initializeComponent;
    private setupControl;
    private getInitialValue;
    private initializeDateLimits;
    private validateConfiguration;
    private getValidators;
    private minDateValidator;
    private maxDateValidator;
    private extractDates;
    private convertToDate;
    private resolveFirstErrorKey;
    private resolveHiddenValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDateInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTDateInputComponent, "pt-date-input", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; "config": { "alias": "config"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "dateChange": "dateChange"; }, never, never, false, never>;
}

declare class PTDateInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDateInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTDateInputModule, [typeof PTDateInputComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i9.DatePickerModule], [typeof PTDateInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTDateInputModule>;
}

declare class PTFormBuilderComponent implements OnInit, OnChanges, OnDestroy {
    private readonly fb;
    private readonly cdr;
    mainGroup: FormFieldGroup;
    buttons: FormButton[];
    title?: string;
    titleStyle?: {
        [key: string]: string;
    };
    inputWidth: string;
    formWidth: string;
    language: 'en' | 'fr';
    formSubmit: EventEmitter<{
        [key: string]: any;
    }>;
    formReady: EventEmitter<FormGroup<any>>;
    formChange: EventEmitter<{
        [key: string]: any;
    }>;
    form: FormGroup;
    readonly FormInputTypeEnum: typeof FormInputTypeEnum;
    private formValueChangesSub?;
    private readonly errorMessages;
    constructor(fb: FormBuilder, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    isFieldHidden(field: FormField): boolean;
    isInvalid(field: FormField): boolean;
    getErrorMessage(field: FormField): string;
    onSubmit(): void;
    onClear(): void;
    private rebuildForm;
    private buildFormGroup;
    private resolveInitialValue;
    private buildValidators;
    private buildOtpPattern;
    private resolveFirstErrorKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTFormBuilderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTFormBuilderComponent, "pt-form-builder", never, { "mainGroup": { "alias": "mainGroup"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "title": { "alias": "title"; "required": false; }; "titleStyle": { "alias": "titleStyle"; "required": false; }; "inputWidth": { "alias": "inputWidth"; "required": false; }; "formWidth": { "alias": "formWidth"; "required": false; }; "language": { "alias": "language"; "required": false; }; }, { "formSubmit": "formSubmit"; "formReady": "formReady"; "formChange": "formChange"; }, never, never, false, never>;
}

declare class PTDynamicFormFieldComponent {
    field: FormField;
    form: FormGroup;
    inputWidth: string;
    FormInputTypeEnum: typeof FormInputTypeEnum;
    asTextField(field: FormField): FormTextField;
    asNumberField(field: FormField): FormNumberField;
    asTextAreaField(field: FormField): FormTextAreaField;
    asDateField(field: FormField): FormDateField;
    asSelectField(field: FormField): FormDropdownField;
    asMultiSelectField(field: FormField): FormMultiSelectField;
    asCheckboxField(field: FormField): FormCheckBoxField;
    asSwitchField(field: FormField): FormSwitchField;
    asOtpField(field: FormField): FormField;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDynamicFormFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTDynamicFormFieldComponent, "pt-dynamic-form-field", never, { "field": { "alias": "field"; "required": false; }; "form": { "alias": "form"; "required": false; }; "inputWidth": { "alias": "inputWidth"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTNumberInputComponent implements OnInit, OnChanges {
    formGroup: FormGroup;
    formField: FormNumberField;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    get inputId(): string;
    get errorId(): string;
    get isInvalid(): boolean;
    getErrorMessage(): string;
    private setupControl;
    private getValidators;
    private validateWithInputValidation;
    private resolveFirstErrorKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNumberInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTNumberInputComponent, "pt-number-input", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTNumberInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNumberInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTNumberInputModule, [typeof PTNumberInputComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i3.FormsModule, typeof i4$3.InputGroupModule, typeof i5$1.InputGroupAddonModule, typeof i6.InputTextModule, typeof i8$1.InputNumberModule], [typeof PTNumberInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTNumberInputModule>;
}

declare class PTSwitchInputComponent implements OnInit, OnChanges, OnDestroy {
    formGroup?: FormGroup;
    formField?: FormSwitchField;
    config?: PTSwitchConfig;
    value: boolean | null;
    valueChange: EventEmitter<boolean | null>;
    switchChange: EventEmitter<boolean | null>;
    private readonly standaloneFormGroup;
    private valueChangesSubscription?;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get activeFormGroup(): FormGroup;
    get controlName(): string;
    get inputId(): string;
    get labelId(): string;
    get resolvedHidden(): boolean;
    get resolvedLabel(): string | undefined;
    get resolvedWidth(): string;
    get resolvedRequired(): boolean;
    get resolvedDisabled(): boolean;
    get resolvedErrorText(): string | undefined;
    getErrorMessage(): string;
    private setupControl;
    private getInitialValue;
    private hasExplicitFieldValue;
    private getValidators;
    private requireChoiceValidator;
    private resolveHiddenValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTSwitchInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTSwitchInputComponent, "pt-switch-input", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; "config": { "alias": "config"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "switchChange": "switchChange"; }, never, never, false, never>;
}

declare class PTSwitchInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTSwitchInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTSwitchInputModule, [typeof PTSwitchInputComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4$4.ToggleSwitchModule], [typeof PTSwitchInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTSwitchInputModule>;
}

declare class PTTextAreaInputComponent implements OnInit, OnChanges, OnDestroy {
    formGroup: FormGroup;
    formField: FormTextAreaField;
    characterCount: number;
    private valueChangesSubscription?;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get inputId(): string;
    get errorId(): string;
    get isInvalid(): boolean;
    getErrorMessage(): string;
    private setupControl;
    private updateCharacterCount;
    private getValidators;
    private validateWithInputValidation;
    private resolveFirstErrorKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTTextAreaInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTTextAreaInputComponent, "pt-text-area-input", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTTextAreaInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTTextAreaInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTTextAreaInputModule, [typeof PTTextAreaInputComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4$5.TextareaModule, typeof i4$3.InputGroupModule, typeof i5$1.InputGroupAddonModule], [typeof PTTextAreaInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTTextAreaInputModule>;
}

declare class PTTextInputComponent implements OnInit, OnChanges, OnDestroy {
    formGroup: FormGroup;
    formField: FormTextField;
    characterCount: number;
    private valueChangesSubscription?;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get inputId(): string;
    get errorId(): string;
    get isInvalid(): boolean;
    getInputType(): string;
    isPasswordInput(): boolean;
    getPasswordToggleMask(): boolean;
    getPasswordFeedback(): boolean;
    hasCharacterCounter(): boolean;
    hasInfoRow(): boolean;
    getErrorMessage(): string;
    private setupControl;
    private updateCharacterCount;
    private getValidators;
    private validateWithInputValidation;
    private resolveFirstErrorKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTTextInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTTextInputComponent, "pt-text-input", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTTextInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTTextInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTTextInputModule, [typeof PTTextInputComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i6.InputTextModule, typeof i12.IconFieldModule, typeof i13.InputIconModule, typeof i7.PasswordModule], [typeof PTTextInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTTextInputModule>;
}

declare class PTDropdownComponent implements OnInit, OnChanges, OnDestroy {
    /**
     * Form-builder / reactive-form usage.
     */
    formGroup?: FormGroup;
    formField?: FormDropdownField;
    /**
     * Standalone usage.
     */
    config?: PTDropdownConfig;
    /**
     * Two-way standalone value.
     */
    value: any;
    valueChange: EventEmitter<any>;
    selectionChange: EventEmitter<any>;
    private standaloneFormGroup;
    private valueChangesSubscription?;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get activeFormGroup(): FormGroup;
    get controlName(): string;
    get inputId(): string;
    get labelId(): string;
    get resolvedHidden(): boolean;
    get resolvedLabel(): string | undefined;
    get resolvedWidth(): string;
    get resolvedOptions(): any[];
    get resolvedPlaceholder(): string;
    get resolvedOptionLabel(): string;
    get resolvedOptionValue(): string;
    get resolvedOptionDisabled(): string;
    get resolvedFilter(): boolean;
    get resolvedFilterBy(): string;
    get resolvedRequired(): boolean;
    get resolvedDisabled(): boolean;
    get resolvedErrorText(): string | undefined;
    get resolvedIcon(): string | IconStyle | IconImageStyle | undefined;
    private setupControl;
    private getInitialValue;
    private hasExplicitFieldValue;
    private normalizeValue;
    private getValidators;
    getErrorMessage(): string;
    getResolvedIcon(option: any): {
        type: 'none' | 'font' | 'image';
        fontIconClass?: string;
        fontIconStyle?: {
            [k: string]: any;
        };
        imageUrl?: string;
        imageStyle?: {
            [k: string]: any;
        };
    };
    private isIconStyle;
    private isIconImageStyle;
    private buildFontIconStyle;
    private buildImageStyle;
    getIconPosition(option: any): 'left' | 'right';
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTDropdownComponent, "pt-dropdown", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; "config": { "alias": "config"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "selectionChange": "selectionChange"; }, never, never, false, never>;
}

declare class PTDropdownModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDropdownModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTDropdownModule, [typeof PTDropdownComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4$6.SelectModule], [typeof PTDropdownComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTDropdownModule>;
}

declare class PTOtpInputComponent implements OnInit, OnDestroy {
    formGroup: FormGroup;
    formField: FormField;
    private valueChangesSubscription?;
    ngOnInit(): void;
    ngOnDestroy(): void;
    get inputId(): string;
    get resolvedLength(): number;
    get resolvedIntegerOnly(): boolean;
    get resolvedMask(): boolean;
    get control(): FormControl | null;
    setupControl(): void;
    hasError(): boolean;
    getErrorMessage(): string;
    private initializeDefaults;
    private getValidators;
    private buildOtpPattern;
    private normalizeOtpValue;
    get labelId(): string;
    get errorId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTOtpInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTOtpInputComponent, "pt-otp-input", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTOtpInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTOtpInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTOtpInputModule, [typeof PTOtpInputComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i4$7.InputOtpModule], [typeof PTOtpInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTOtpInputModule>;
}

declare class PTPasswordInputComponent implements OnInit, OnChanges, OnDestroy {
    formGroup: FormGroup;
    formField: FormTextField;
    characterCount: number;
    private valueChangesSubscription?;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get inputId(): string;
    get errorId(): string;
    get isInvalid(): boolean;
    getPasswordToggleMask(): boolean;
    getPasswordFeedback(): boolean;
    hasCharacterCounter(): boolean;
    hasInfoRow(): boolean;
    getErrorMessage(): string;
    private setupControl;
    private updateCharacterCount;
    private getValidators;
    private validateWithInputValidation;
    private resolveFirstErrorKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTPasswordInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTPasswordInputComponent, "pt-password-input", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTPasswordInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTPasswordInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTPasswordInputModule, [typeof PTPasswordInputComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i12.IconFieldModule, typeof i13.InputIconModule, typeof i7.PasswordModule], [typeof PTPasswordInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTPasswordInputModule>;
}

declare class PTDynamicFormFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDynamicFormFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTDynamicFormFieldModule, [typeof PTDynamicFormFieldComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof PTCheckBoxInputModule, typeof PTDateInputModule, typeof PTNumberInputModule, typeof PTSwitchInputModule, typeof PTTextAreaInputModule, typeof PTTextInputModule, typeof PTDropdownModule, typeof PTMultiSelectModule, typeof PTOtpInputModule, typeof PTPasswordInputModule], [typeof PTDynamicFormFieldComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTDynamicFormFieldModule>;
}

declare class PTFormBuilderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTFormBuilderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTFormBuilderModule, [typeof PTFormBuilderComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i3$1.ButtonModule, typeof PTDynamicFormFieldModule], [typeof PTFormBuilderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTFormBuilderModule>;
}

declare class PTMetricCardComponent {
    private static readonly DEFAULT_ICON_COLOR;
    private static readonly DEFAULT_ICON_SIZE;
    private static readonly DEFAULT_TITLE_COLOR;
    private static readonly DEFAULT_TITLE_SIZE;
    private static readonly DEFAULT_VALUE_COLOR;
    private static readonly DEFAULT_VALUE_SIZE;
    private static readonly DEFAULT_LABEL_COLOR;
    private static readonly DEFAULT_LABEL_SIZE;
    private static readonly DEFAULT_ADDITIONAL_INFO_COLOR;
    private static readonly DEFAULT_ADDITIONAL_INFO_SIZE;
    private static readonly DEFAULT_BACKGROUND_COLOR;
    cardData: MetricCardData;
    isIconObject(): boolean;
    isTitleObject(): boolean;
    isValueObject(): boolean;
    isLabelObject(label: LabelSetting | string | undefined): boolean;
    isAdditionalInfoObject(): boolean;
    getIconText(): string;
    getTitleText(): string;
    getValueText(): string;
    getLabelText(): string;
    getAdditionalInfoText(): string;
    getIconStyles(): {
        color: string;
        fontSize: string;
        backgroundColor: string;
        borderRadius: string;
        padding: string;
        display: string;
    } | {
        color?: undefined;
        fontSize?: undefined;
        backgroundColor?: undefined;
        borderRadius?: undefined;
        padding?: undefined;
        display?: undefined;
    };
    getTitleStyles(): {
        color: string;
        fontSize: string;
        fontWeight: string;
    } | {
        color?: undefined;
        fontSize?: undefined;
        fontWeight?: undefined;
    };
    getValueStyles(): {
        color: string;
        fontSize: string;
        fontWeight: string;
        textAlign: string;
        width: string;
        display: string;
        justifyContent: string;
        alignItems: string;
    };
    getValueTextStyles(): {
        textAlign: string;
    };
    getLabelStyles(position: 'left' | 'right'): {
        color: string;
        fontSize: string;
        fontWeight: string;
    };
    getAdditionalInfoStyles(): {
        color: string;
        fontSize: string;
        fontWeight: string;
    };
    isLabelOnLeft(): boolean;
    isLabelOnRight(): boolean;
    getMetricCardContainerStyle(): {
        minWidth: string;
        maxWidth: string;
        width: string;
    };
    getMetricCardStyle(): {
        backgroundColor: string;
        minWidth: string;
        maxWidth: string;
        width: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMetricCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTMetricCardComponent, "pt-metric-card", never, { "cardData": { "alias": "cardData"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class PTMetricCardGroupComponent {
    cardsData: MetricCardData[];
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMetricCardGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTMetricCardGroupComponent, "pt-metric-card-group", never, { "cardsData": { "alias": "cardsData"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTMetricCardGroupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMetricCardGroupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTMetricCardGroupModule, [typeof PTMetricCardGroupComponent], [typeof i2.CommonModule, typeof PTMetricCardModule], [typeof PTMetricCardGroupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTMetricCardGroupModule>;
}

declare class PTChartComponent implements AfterViewInit, OnChanges, OnDestroy {
    private readonly document;
    chartConfig: ChartConfig;
    canvasRef: ElementRef<HTMLCanvasElement>;
    private chart?;
    private currentChartType?;
    private viewInitialized;
    private resizeObserver?;
    private themeMutationObserver?;
    private colorSchemeMediaQuery?;
    private readonly colorSchemeChangeListener;
    constructor(document: Document);
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get chartContainerStyle(): Record<string, string>;
    get chartAriaLabel(): string;
    private initializeChart;
    private updateChart;
    private buildChartConfiguration;
    private buildDefaultOptions;
    private mergeChartOptions;
    private mergeScales;
    private buildTooltipLabel;
    private formatDataLabel;
    private calculateDatasetTotal;
    private extractNumericValue;
    private formatNumber;
    private cloneChartData;
    private observeContainerResize;
    private scheduleChartResize;
    private observeThemeChanges;
    private refreshTheme;
    private resolveTheme;
    private isDarkMode;
    private resolveCssVariable;
    private resolveFontFamily;
    private asObject;
    private destroyChart;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTChartComponent, "pt-chart", never, { "chartConfig": { "alias": "chartConfig"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class PTCardComponent implements AfterViewInit {
    private readonly cd;
    config: CardConfig;
    private static readonly DEFAULT_TITLE_COLOR;
    private static readonly DEFAULT_TITLE_FONT_SIZE;
    private static readonly DEFAULT_ICON_COLOR;
    private static readonly DEFAULT_ICON_FONT_SIZE;
    private static readonly DEFAULT_ICON_POSITION;
    private static readonly DEFAULT_TITLE_POSITION;
    private static readonly DEFAULT_MENU_POSITION;
    private static readonly DEFAULT_BORDER_COLOR;
    private static readonly DEFAULT_BORDER_WIDTH;
    private static readonly DEFAULT_WIDTH;
    private static readonly DEFAULT_HEIGHT;
    /**
     * Padding for the outer card container.
     */
    private static readonly DEFAULT_PADDING;
    /**
     * Padding for the projected content area.
     * Keep it 0 by default to avoid double spacing:
     * card padding + body padding.
     */
    private static readonly DEFAULT_BODY_PADDING;
    private static readonly DEFAULT_MARGIN;
    private static readonly DEFAULT_BORDER_RADIUS;
    private static readonly DEFAULT_BOX_SHADOW;
    constructor(cd: ChangeDetectorRef);
    ngAfterViewInit(): void;
    private logPatternUrl;
    updateStyles(): void;
    isTitleObject(): boolean;
    hasTitle(): boolean;
    getTitleText(): string;
    getTitleStyles(): {
        [key: string]: string;
    };
    getIconClass(): string | null;
    getIconStyles(): {
        [key: string]: string;
    };
    getIconPosition(): 'left' | 'right' | null;
    getMenuPosition(): 'left' | 'right';
    getCardStyles(): {
        [key: string]: string | number;
    };
    getBodyStyles(): {
        [key: string]: string | number;
    };
    getHeaderStyles(): {
        [key: string]: string;
    };
    isScrollableHorizontal(): boolean;
    isScrollableVertical(): boolean;
    getCardClass(): string;
    getBodyClass(): string;
    getHeaderClass(): string;
    private hexToRgba;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTCardComponent, "pt-card", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class PTMenuComponent {
    config: MenuConfig;
    private static readonly DEFAULT_TEXT_COLOR;
    private static readonly DEFAULT_TEXT_FONT_SIZE;
    private static readonly DEFAULT_ICON_COLOR;
    private static readonly DEFAULT_ICON_FONT_SIZE;
    private static readonly DEFAULT_ICON_CODE;
    private static openMenuInstance;
    isOpen: boolean;
    toggleMenu(): void;
    closeMenu(): void;
    getMenuItemIconClass(item: MenuItem): string;
    getMenuItemIconStyles(item: MenuItem): {
        color: string;
        fontSize: string;
    };
    getIconClass(): string;
    getIconStyles(): {
        color: string;
        fontSize: string;
    };
    getTextStyles(item: MenuItem): {
        color: string;
        fontSize: string;
    };
    onItemClick(item: MenuItem): void;
    onDocumentClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTMenuComponent, "pt-menu", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class PTCardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTCardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTCardModule, [typeof PTCardComponent], [typeof i2.CommonModule, typeof PTMenuModule], [typeof PTCardComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTCardModule>;
}

declare class PTMenuFancyComponent {
    config: MenuConfig;
    cardMenuConfig: CardConfig;
    private static readonly DEFAULT_TEXT_COLOR;
    private static readonly DEFAULT_TEXT_FONT_SIZE;
    private static readonly DEFAULT_ICON_COLOR;
    private static readonly DEFAULT_ICON_FONT_SIZE;
    private static readonly DEFAULT_ICON_CODE;
    private static openMenuInstance;
    isOpen: boolean;
    toggleMenu(): void;
    closeMenu(): void;
    getMenuItemIconClass(item: MenuItem): string;
    getMenuItemIconStyles(item: MenuItem): {
        color: string;
        fontSize: string;
    };
    getIconClass(): string;
    getIconStyles(): {
        color: string;
        fontSize: string;
    };
    getTextStyles(item: MenuItem): {
        color: string;
        fontSize: string;
    };
    isItemDisabled(item: MenuItem): boolean;
    onItemClick(item: MenuItem): void;
    onDocumentClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMenuFancyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTMenuFancyComponent, "pt-menu-fancy", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTMenuFancyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMenuFancyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTMenuFancyModule, [typeof PTMenuFancyComponent], [typeof i2.CommonModule, typeof PTCardModule], [typeof PTMenuFancyComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTMenuFancyModule>;
}

declare class PTNavbarMenuComponent implements OnInit, OnDestroy, OnChanges {
    navBarMenuConfig: NavBarMenuConfig;
    serverDateTime?: {
        date: string;
        time: string;
    } | string;
    notifications: PTNotificationItem[];
    notificationConfig: PTNotificationConfig;
    notificationTotalRecords: number;
    notificationTotalUnreadRecords?: number;
    notificationPage: number;
    notificationRows: number;
    notificationLoading: boolean;
    releaseNotes: PTReleaseNoteItem[];
    releaseNotesConfig: PTReleaseNotesConfig;
    releaseNotesLoading: boolean;
    releaseNotesHasMore: boolean;
    releaseNotesPageSize: number;
    releaseNotesTotalUnreadRecords?: number;
    toggleSidebar: EventEmitter<void>;
    notificationAction: EventEmitter<PTNotificationActionEvent>;
    notificationClick: EventEmitter<PTNotificationClickEvent>;
    notificationPanelOpened: EventEmitter<void>;
    notificationPanelClosed: EventEmitter<void>;
    notificationGlobalAction: EventEmitter<PTNotificationGlobalActionEvent>;
    notificationViewAll: EventEmitter<void>;
    notificationLoadMore: EventEmitter<PTNotificationLoadMoreEvent>;
    releaseNoteClick: EventEmitter<PTReleaseNoteClickEvent>;
    releaseNoteAction: EventEmitter<PTReleaseNoteActionEvent>;
    releaseNoteGlobalAction: EventEmitter<PTReleaseNoteGlobalActionEvent>;
    releaseNotesViewAll: EventEmitter<void>;
    releaseNotesLoadMore: EventEmitter<PTReleaseNoteLoadMoreEvent>;
    private readonly destroy$;
    dateTimeText: string;
    isUserMenuOpen: boolean;
    private dateFormat;
    private timeFormat;
    private fixedStart;
    private fixedSetAt;
    manualDateTimeLocal: string;
    private static readonly DEFAULT_LOGO_URL;
    private static readonly DEFAULT_LOGO_ALT_TEXT;
    private static readonly DEFAULT_LOGO_WIDTH;
    private static readonly DEFAULT_LOGO_HEIGHT;
    private static readonly DEFAULT_APP_NAME;
    private static readonly DEFAULT_APP_NAME_COLOR;
    private static readonly DEFAULT_APP_NAME_FONT_SIZE;
    private static readonly DEFAULT_TRANSPARENCY;
    private static readonly DEFAULT_ICON_COLOR;
    private static readonly DEFAULT_TOGGLE_BUTTON_ICON;
    private static readonly DEFAULT_TOGGLE_BUTTON_COLOR;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    closeUserMenu(): void;
    private applyConfigFormatsAndFixedBase;
    hasNotifications(): boolean;
    onNotificationAction(event: PTNotificationActionEvent): void;
    onNotificationClick(event: PTNotificationClickEvent): void;
    onNotificationGlobalAction(event: PTNotificationGlobalActionEvent): void;
    onNotificationViewAll(): void;
    onNotificationPanelOpened(): void;
    onNotificationPanelClosed(): void;
    onNotificationLoadMore(event: PTNotificationLoadMoreEvent): void;
    hasReleaseNotes(): boolean;
    onReleaseNoteClick(event: PTReleaseNoteClickEvent): void;
    onReleaseNoteAction(event: PTReleaseNoteActionEvent): void;
    onReleaseNoteGlobalAction(event: PTReleaseNoteGlobalActionEvent): void;
    onReleaseNotesViewAll(): void;
    onReleaseNotesLoadMore(event: PTReleaseNoteLoadMoreEvent): void;
    hasDateTime(): boolean;
    isFixedMode(): boolean;
    isServerMode(): boolean;
    onManualDateTimeChange(value: string): void;
    getDateTimePositionClass(): string;
    private refreshDateTime;
    private normalizeServerDateTime;
    private getServerPlaceholder;
    private setFixedDateTime;
    private buildFixedBaseDateFromConfig;
    private parseDateByFormat;
    hasUser(): boolean;
    toggleUserMenu(): void;
    isInitialsAvatar(): boolean;
    showProfileInMenu(): boolean;
    showProfileLeftOfAvatar(): boolean;
    getUsername(): string;
    getUserFullName(): string;
    getUserInitials(): string;
    getUserProfile(): string;
    getUserAvatarStyles(): {
        [key: string]: string;
    };
    getUserProfileTextStyles(): {
        [key: string]: string;
    };
    getUserMenuItems(): NavBarUserMenuItem[];
    hasUserMenuItems(): boolean;
    getUserMenuItemIcon(item: NavBarUserMenuItem): string;
    getUserMenuItemClasses(item: NavBarUserMenuItem): string;
    onUserMenuItemClick(item: NavBarUserMenuItem): void;
    private pad2;
    private replaceAllCompat;
    private formatDateTime;
    private toDateTimeLocalValue;
    private fromDateTimeLocalValue;
    isImageStyle(object: any): object is ImageStyle;
    isTextStyle(object: any): object is TextStyle;
    getLogoUrl(): string;
    getLogoAltText(): string;
    getLogoStyles(): {
        [key: string]: string;
    };
    getAppName(): string;
    getAppNameStyles(): {
        [key: string]: string;
    };
    getNavbarStyles(): {
        [key: string]: string;
    };
    toggleMenu(): void;
    getToggleButtonIcon(): string;
    getToggleButtonStyles(): {
        [key: string]: string;
    };
    getDateTimeTextStyles(): {
        [key: string]: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNavbarMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTNavbarMenuComponent, "pt-nav-bar-menu", never, { "navBarMenuConfig": { "alias": "navBarMenuConfig"; "required": false; }; "serverDateTime": { "alias": "serverDateTime"; "required": false; }; "notifications": { "alias": "notifications"; "required": false; }; "notificationConfig": { "alias": "notificationConfig"; "required": false; }; "notificationTotalRecords": { "alias": "notificationTotalRecords"; "required": false; }; "notificationTotalUnreadRecords": { "alias": "notificationTotalUnreadRecords"; "required": false; }; "notificationPage": { "alias": "notificationPage"; "required": false; }; "notificationRows": { "alias": "notificationRows"; "required": false; }; "notificationLoading": { "alias": "notificationLoading"; "required": false; }; "releaseNotes": { "alias": "releaseNotes"; "required": false; }; "releaseNotesConfig": { "alias": "releaseNotesConfig"; "required": false; }; "releaseNotesLoading": { "alias": "releaseNotesLoading"; "required": false; }; "releaseNotesHasMore": { "alias": "releaseNotesHasMore"; "required": false; }; "releaseNotesPageSize": { "alias": "releaseNotesPageSize"; "required": false; }; "releaseNotesTotalUnreadRecords": { "alias": "releaseNotesTotalUnreadRecords"; "required": false; }; }, { "toggleSidebar": "toggleSidebar"; "notificationAction": "notificationAction"; "notificationClick": "notificationClick"; "notificationPanelOpened": "notificationPanelOpened"; "notificationPanelClosed": "notificationPanelClosed"; "notificationGlobalAction": "notificationGlobalAction"; "notificationViewAll": "notificationViewAll"; "notificationLoadMore": "notificationLoadMore"; "releaseNoteClick": "releaseNoteClick"; "releaseNoteAction": "releaseNoteAction"; "releaseNoteGlobalAction": "releaseNoteGlobalAction"; "releaseNotesViewAll": "releaseNotesViewAll"; "releaseNotesLoadMore": "releaseNotesLoadMore"; }, never, never, false, never>;
}

declare class PTNotificationComponent {
    /**
     * Notifications already loaded from the server.
     *
     * With infinite scroll, the consumer should append each
     * newly loaded server page to this array.
     */
    notifications: PTNotificationItem[];
    config: PTNotificationConfig;
    /**
     * Total number of notifications available on the server.
     *
     * Used to determine whether another page can be loaded.
     */
    totalRecords: number;
    /**
     * Total number of unread notifications on the server.
     *
     * Used by the bell badge/header count.
     */
    totalUnreadRecords?: number;
    /**
     * Last server page currently loaded.
     *
     * Zero-based.
     */
    page: number;
    /**
     * Server page size.
     */
    rows: number;
    /**
     * True while the consumer is fetching the next page.
     *
     * Prevents duplicate loadMore events.
     */
    loading: boolean;
    notificationClick: EventEmitter<PTNotificationClickEvent>;
    action: EventEmitter<PTNotificationActionEvent>;
    globalAction: EventEmitter<PTNotificationGlobalActionEvent>;
    viewAll: EventEmitter<void>;
    panelOpened: EventEmitter<void>;
    panelClosed: EventEmitter<void>;
    /**
     * Emitted when the list approaches its bottom
     * and another server page is available.
     */
    loadMore: EventEmitter<PTNotificationLoadMoreEvent>;
    isOpen: boolean;
    openedActionMenuId: string | number | null;
    isGlobalActionMenuOpen: boolean;
    private lastRequestedPage;
    private readonly defaultActions;
    private readonly defaultGlobalActions;
    onDocumentClick(): void;
    isVisible(): boolean;
    togglePanel(event: Event): void;
    closePanel(): void;
    onPanelClick(event: Event): void;
    onListScroll(event: Event): void;
    onNotificationClick(notification: PTNotificationItem, event: Event): void;
    toggleActionMenu(notification: PTNotificationItem, event: Event): void;
    onActionMenuClick(event: Event): void;
    onActionClick(notification: PTNotificationItem, menuAction: PTNotificationMenuAction, event: Event): void;
    toggleGlobalActionMenu(event: Event): void;
    onGlobalActionMenuClick(event: Event): void;
    onGlobalActionClick(menuAction: PTNotificationMenuAction, event: Event): void;
    onViewAllClick(event: Event): void;
    getNotifications(): PTNotificationItem[];
    hasNotifications(): boolean;
    getUnreadCount(): number;
    hasUnreadNotifications(): boolean;
    getBadgeText(): string;
    showBadge(): boolean;
    showHeaderCount(): boolean;
    showViewAll(): boolean;
    showGlobalActions(): boolean;
    isInfiniteScrollEnabled(): boolean;
    hasMoreNotifications(): boolean;
    showInfiniteScrollLoader(): boolean;
    getLoadingText(): string;
    getInfiniteScrollThreshold(): number;
    getTitle(): string;
    getEmptyText(): string;
    getBellIcon(): string;
    getViewAllText(): string;
    getViewAllIcon(): string;
    getPanelStyles(): {
        [key: string]: string;
    };
    getListStyles(): {
        [key: string]: string;
    };
    getNotificationClasses(notification: PTNotificationItem): string;
    getNotificationIcon(notification: PTNotificationItem): string;
    getNotificationIconStyles(notification: PTNotificationItem): {
        [key: string]: string;
    };
    getActions(notification: PTNotificationItem): PTNotificationMenuAction[];
    getGlobalActions(): PTNotificationMenuAction[];
    hasActions(notification: PTNotificationItem): boolean;
    isActionMenuOpen(notification: PTNotificationItem): boolean;
    getActionClasses(menuAction: PTNotificationMenuAction): string;
    getDateText(notification: PTNotificationItem): string;
    hasMetadata(notification: PTNotificationItem): boolean;
    private requestNextPage;
    private formatRelativeDate;
    private getCalendarDayDifference;
    private toDate;
    private formatAbsoluteDate;
    private formatTime;
    private pad2;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNotificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTNotificationComponent, "pt-notification", never, { "notifications": { "alias": "notifications"; "required": false; }; "config": { "alias": "config"; "required": false; }; "totalRecords": { "alias": "totalRecords"; "required": false; }; "totalUnreadRecords": { "alias": "totalUnreadRecords"; "required": false; }; "page": { "alias": "page"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "notificationClick": "notificationClick"; "action": "action"; "globalAction": "globalAction"; "viewAll": "viewAll"; "panelOpened": "panelOpened"; "panelClosed": "panelClosed"; "loadMore": "loadMore"; }, never, never, false, never>;
}

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

declare class PTReleaseNotesComponent implements OnChanges {
    releases: PTReleaseNoteItem[];
    config: PTReleaseNotesConfig;
    loading: boolean;
    hasMore: boolean;
    pageSize: number;
    totalUnreadRecords?: number;
    releaseClick: EventEmitter<PTReleaseNoteClickEvent>;
    action: EventEmitter<PTReleaseNoteActionEvent>;
    globalAction: EventEmitter<PTReleaseNoteGlobalActionEvent>;
    viewAll: EventEmitter<void>;
    loadMore: EventEmitter<PTReleaseNoteLoadMoreEvent>;
    panelOpened: EventEmitter<void>;
    panelClosed: EventEmitter<void>;
    isOpen: boolean;
    openedActionMenuId: string | number | null;
    isGlobalActionMenuOpen: boolean;
    private currentPage;
    private loadMoreRequested;
    private readonly defaultActions;
    private readonly defaultGlobalActions;
    onDocumentClick(): void;
    ngOnChanges(changes: SimpleChanges): void;
    get language(): PTReleaseNotesLanguage;
    get resolvedConfig(): Required<PTReleaseNotesConfig>;
    isVisible(): boolean;
    togglePanel(event: Event): void;
    closePanel(): void;
    onPanelClick(event: Event): void;
    getReleases(): PTReleaseNoteItem[];
    hasReleases(): boolean;
    getUnreadCount(): number;
    hasUnreadReleases(): boolean;
    getBadgeText(): string;
    showBadge(): boolean;
    showHeaderCount(): boolean;
    showViewAll(): boolean;
    showGlobalActions(): boolean;
    getTitle(): string;
    getEmptyText(): string;
    getLoadingText(): string;
    getViewAllText(): string;
    getViewAllIcon(): string;
    getPanelStyles(): {
        [key: string]: string;
    };
    getListStyles(): {
        [key: string]: string;
    };
    getReleaseClasses(release: PTReleaseNoteItem): string;
    onReleaseClick(release: PTReleaseNoteItem, event: Event): void;
    onReleaseKeyboardClick(release: PTReleaseNoteItem, event: Event): void;
    getActions(release: PTReleaseNoteItem): PTReleaseNoteMenuAction[];
    hasActions(release: PTReleaseNoteItem): boolean;
    toggleActionMenu(release: PTReleaseNoteItem, event: Event): void;
    isActionMenuOpen(release: PTReleaseNoteItem): boolean;
    onActionMenuClick(event: Event): void;
    onActionClick(release: PTReleaseNoteItem, menuAction: PTReleaseNoteMenuAction, event: Event): void;
    getGlobalActions(): PTReleaseNoteMenuAction[];
    toggleGlobalActionMenu(event: Event): void;
    onGlobalActionMenuClick(event: Event): void;
    onGlobalActionClick(menuAction: PTReleaseNoteMenuAction, event: Event): void;
    getActionClasses(menuAction: PTReleaseNoteMenuAction): string;
    getNewCount(release: PTReleaseNoteItem): number;
    getImprovementCount(release: PTReleaseNoteItem): number;
    getBugFixCount(release: PTReleaseNoteItem): number;
    hasNewItems(release: PTReleaseNoteItem): boolean;
    hasImprovements(release: PTReleaseNoteItem): boolean;
    hasBugFixes(release: PTReleaseNoteItem): boolean;
    hasCounters(release: PTReleaseNoteItem): boolean;
    isInfiniteScrollEnabled(): boolean;
    showInfiniteScrollLoader(): boolean;
    onListScroll(event: Event): void;
    onViewAllClick(event: Event): void;
    private closeMenus;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTReleaseNotesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTReleaseNotesComponent, "pt-release-notes", never, { "releases": { "alias": "releases"; "required": false; }; "config": { "alias": "config"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "hasMore": { "alias": "hasMore"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "totalUnreadRecords": { "alias": "totalUnreadRecords"; "required": false; }; }, { "releaseClick": "releaseClick"; "action": "action"; "globalAction": "globalAction"; "viewAll": "viewAll"; "loadMore": "loadMore"; "panelOpened": "panelOpened"; "panelClosed": "panelClosed"; }, never, never, false, never>;
}

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

declare class PTNavbarMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNavbarMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTNavbarMenuModule, [typeof PTNavbarMenuComponent], [typeof i2.CommonModule, typeof i3$2.RouterModule, typeof PTMenuFancyModule, typeof PTNotificationModule, typeof PTReleaseNotesModule], [typeof PTNavbarMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTNavbarMenuModule>;
}

declare class PTSideBarMenuComponent implements OnInit, AfterViewInit {
    private renderer;
    private el;
    menuConfig: SideMenuBarConfig;
    searchCardConfig: CardConfig;
    cardConfig: CardConfig;
    formGroup: FormGroup;
    searchField: FormTextField;
    filteredMenus: Menu[];
    constructor(renderer: Renderer2, el: ElementRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private initializeConfigs;
    isSearchEnabled(): boolean;
    toggleMenu(item: Menu, event: Event): void;
    getChevronClass(item: Menu): string;
    hasChildren(item: Menu | null | undefined): boolean;
    getBadgeStyles(badge: Badge): {
        [key: string]: string;
    };
    getDefaultBadgeColors(type: BadgeType): {
        color: string;
        backgroundColor: string;
    };
    onSearch(searchTerm: string): void;
    private searchInMenu;
    private collapseAllMenus;
    private cloneMenus;
    getMenuItemStyles(): {
        [key: string]: string;
    };
    getMenuLinkStyles(): {
        [key: string]: string;
    };
    getSubMenuLinkStyles(level?: number): {
        [key: string]: string;
    };
    getMenuHoverBackground(): string;
    getSubMenuHoverBackground(): string;
    getMenuHoverColor(): string;
    getSubMenuHoverColor(): string;
    private applyHoverEffects;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTSideBarMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTSideBarMenuComponent, "pt-side-bar-menu", never, { "menuConfig": { "alias": "menuConfig"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTSideBarMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTSideBarMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTSideBarMenuModule, [typeof PTSideBarMenuComponent], [typeof i2.CommonModule, typeof i3$2.RouterModule, typeof PTCardModule, typeof PTTextInputModule], [typeof PTSideBarMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTSideBarMenuModule>;
}

declare class PTPageSkeletonComponent implements OnInit {
    pageSkeletonConfig: PageSkeletonConfig;
    serverDateTime?: {
        date: string;
        time: string;
    } | string;
    notifications: PTNotificationItem[];
    notificationConfig: PTNotificationConfig;
    notificationTotalRecords: number;
    notificationTotalUnreadRecords?: number;
    notificationPage: number;
    notificationRows: number;
    notificationLoading: boolean;
    releaseNotes: PTReleaseNoteItem[];
    releaseNotesConfig: PTReleaseNotesConfig;
    releaseNotesLoading: boolean;
    releaseNotesHasMore: boolean;
    releaseNotesPageSize: number;
    releaseNotesTotalUnreadRecords?: number;
    toggleSidebar: EventEmitter<void>;
    notificationAction: EventEmitter<PTNotificationActionEvent>;
    notificationClick: EventEmitter<PTNotificationClickEvent>;
    notificationPanelOpened: EventEmitter<void>;
    notificationPanelClosed: EventEmitter<void>;
    notificationGlobalAction: EventEmitter<PTNotificationGlobalActionEvent>;
    notificationViewAll: EventEmitter<void>;
    notificationLoadMore: EventEmitter<PTNotificationLoadMoreEvent>;
    releaseNoteClick: EventEmitter<PTReleaseNoteClickEvent>;
    releaseNoteAction: EventEmitter<PTReleaseNoteActionEvent>;
    releaseNoteGlobalAction: EventEmitter<PTReleaseNoteGlobalActionEvent>;
    releaseNotesViewAll: EventEmitter<void>;
    releaseNotesLoadMore: EventEmitter<PTReleaseNoteLoadMoreEvent>;
    isSidebarVisible: boolean;
    ngOnInit(): void;
    onToggleSidebar(): void;
    onNotificationAction(event: PTNotificationActionEvent): void;
    onNotificationClick(event: PTNotificationClickEvent): void;
    onNotificationGlobalAction(event: PTNotificationGlobalActionEvent): void;
    onNotificationViewAll(): void;
    onNotificationPanelOpened(): void;
    onNotificationPanelClosed(): void;
    onNotificationLoadMore(event: PTNotificationLoadMoreEvent): void;
    onReleaseNoteClick(event: PTReleaseNoteClickEvent): void;
    onReleaseNoteAction(event: PTReleaseNoteActionEvent): void;
    onReleaseNoteGlobalAction(event: PTReleaseNoteGlobalActionEvent): void;
    onReleaseNotesViewAll(): void;
    onReleaseNotesLoadMore(event: PTReleaseNoteLoadMoreEvent): void;
    private initializeBackgroundCardConfig;
    private initializeContentCardConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTPageSkeletonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTPageSkeletonComponent, "pt-page-skeleton", never, { "pageSkeletonConfig": { "alias": "pageSkeletonConfig"; "required": false; }; "serverDateTime": { "alias": "serverDateTime"; "required": false; }; "notifications": { "alias": "notifications"; "required": false; }; "notificationConfig": { "alias": "notificationConfig"; "required": false; }; "notificationTotalRecords": { "alias": "notificationTotalRecords"; "required": false; }; "notificationTotalUnreadRecords": { "alias": "notificationTotalUnreadRecords"; "required": false; }; "notificationPage": { "alias": "notificationPage"; "required": false; }; "notificationRows": { "alias": "notificationRows"; "required": false; }; "notificationLoading": { "alias": "notificationLoading"; "required": false; }; "releaseNotes": { "alias": "releaseNotes"; "required": false; }; "releaseNotesConfig": { "alias": "releaseNotesConfig"; "required": false; }; "releaseNotesLoading": { "alias": "releaseNotesLoading"; "required": false; }; "releaseNotesHasMore": { "alias": "releaseNotesHasMore"; "required": false; }; "releaseNotesPageSize": { "alias": "releaseNotesPageSize"; "required": false; }; "releaseNotesTotalUnreadRecords": { "alias": "releaseNotesTotalUnreadRecords"; "required": false; }; }, { "toggleSidebar": "toggleSidebar"; "notificationAction": "notificationAction"; "notificationClick": "notificationClick"; "notificationPanelOpened": "notificationPanelOpened"; "notificationPanelClosed": "notificationPanelClosed"; "notificationGlobalAction": "notificationGlobalAction"; "notificationViewAll": "notificationViewAll"; "notificationLoadMore": "notificationLoadMore"; "releaseNoteClick": "releaseNoteClick"; "releaseNoteAction": "releaseNoteAction"; "releaseNoteGlobalAction": "releaseNoteGlobalAction"; "releaseNotesViewAll": "releaseNotesViewAll"; "releaseNotesLoadMore": "releaseNotesLoadMore"; }, never, never, false, never>;
}

declare class PTFooterComponent {
    footerConfig: FooterConfig;
    private readonly defaultFooterCardConfig;
    getCurrentYear(): number;
    getCardConfig(): CardConfig;
    displayYears(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTFooterComponent, "pt-footer", never, { "footerConfig": { "alias": "footerConfig"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTFooterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTFooterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTFooterModule, [typeof PTFooterComponent], [typeof i2.CommonModule, typeof PTCardModule], [typeof PTFooterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTFooterModule>;
}

declare class PTBreadCrumbService {
    private router;
    private _breadcrumb;
    breadcrumb$: rxjs.Observable<MenuItem$1[]>;
    private menuData;
    constructor(router: Router);
    setMenuData(menuData: any[]): void;
    createBreadcrumb(url?: string, breadcrumbs?: MenuItem$1[]): MenuItem$1[];
    private buildParentBreadcrumbs;
    private buildChildBreadcrumbs;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTBreadCrumbService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PTBreadCrumbService>;
}

declare class PTBreadCrumbComponent implements OnInit, OnDestroy, AfterViewInit {
    private breadcrumbService;
    private renderer;
    private el;
    breadCrumbConfig: BreadCrumbConfig;
    items: MenuItem$1[] | undefined;
    home: MenuItem$1 | undefined;
    breadCrumbSubscription: Subscription;
    constructor(breadcrumbService: PTBreadCrumbService, renderer: Renderer2, el: ElementRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    applyBackgroundStyles(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTBreadCrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTBreadCrumbComponent, "pt-bread-crumb", never, { "breadCrumbConfig": { "alias": "breadCrumbConfig"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTBreadCrumbModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTBreadCrumbModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTBreadCrumbModule, [typeof PTBreadCrumbComponent], [typeof i2.CommonModule, typeof i3$3.BreadcrumbModule], [typeof PTBreadCrumbComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTBreadCrumbModule>;
}

declare class PTPageSkeletonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTPageSkeletonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTPageSkeletonModule, [typeof PTPageSkeletonComponent], [typeof i2.CommonModule, typeof PTNavbarMenuModule, typeof PTCardModule, typeof PTSideBarMenuModule, typeof i3$2.RouterModule, typeof PTFooterModule, typeof PTBreadCrumbModule], [typeof PTPageSkeletonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTPageSkeletonModule>;
}

declare class PTLoginPageComponent implements OnInit {
    loginPageConfig: LoginPageConfig;
    loginErrorMessage: string | null;
    loginSubmit: EventEmitter<LoginModel>;
    private defaultCardConfig;
    ngOnInit(): void;
    private applyDefaultConfigs;
    private applyDefaults;
    onLoginSubmit(loginModel: LoginModel): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTLoginPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTLoginPageComponent, "pt-login-page", never, { "loginPageConfig": { "alias": "loginPageConfig"; "required": false; }; "loginErrorMessage": { "alias": "loginErrorMessage"; "required": false; }; }, { "loginSubmit": "loginSubmit"; }, never, never, false, never>;
}

declare class PTLoginCardComponent implements OnInit, OnDestroy {
    private readonly fb;
    loginPageConfig: LoginPageConfig;
    loginErrorMessage: string | null;
    loginSubmit: EventEmitter<LoginModel>;
    formGroup: FormGroup;
    private readonly destroy$;
    constructor(fb: FormBuilder);
    ngOnInit(): void;
    ngOnDestroy(): void;
    get visibleAdditionalContent(): LoginAdditionalContent[];
    initializeDefaults(): void;
    onSubmit(): void;
    setupFormFields(): void;
    getAdditionalContentClass(item: LoginAdditionalContent): string[];
    getLinkRel(item: LoginAdditionalContent): string | null;
    private resolveItemType;
    private updateButtonDisabledState;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTLoginCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTLoginCardComponent, "pt-login-card", never, { "loginPageConfig": { "alias": "loginPageConfig"; "required": false; }; "loginErrorMessage": { "alias": "loginErrorMessage"; "required": false; }; }, { "loginSubmit": "loginSubmit"; }, never, never, true, never>;
}

declare class PTLoginPageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTLoginPageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTLoginPageModule, [typeof PTLoginPageComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof PTTextInputModule, typeof PTCardModule, typeof PTButtonModule, typeof PTLoginCardComponent], [typeof PTLoginPageComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTLoginPageModule>;
}

declare class PTOtpPageComponent implements OnInit {
    otpPageConfig: OtpPageConfig;
    otpErrorMessage: string | null;
    otpValidated: boolean | null;
    otpSubmit: EventEmitter<string>;
    backClick: EventEmitter<void>;
    private readonly defaultCardConfig;
    ngOnInit(): void;
    onOtpSubmit(otpCode: string): void;
    onBackClick(): void;
    private applyDefaultConfigs;
    private applyDefaults;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTOtpPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTOtpPageComponent, "pt-otp-page", never, { "otpPageConfig": { "alias": "otpPageConfig"; "required": true; }; "otpErrorMessage": { "alias": "otpErrorMessage"; "required": false; }; "otpValidated": { "alias": "otpValidated"; "required": false; }; }, { "otpSubmit": "otpSubmit"; "backClick": "backClick"; }, never, never, false, never>;
}

declare class PTOtpCardComponent implements OnInit, OnDestroy {
    private readonly fb;
    otpPageConfig: OtpPageConfig;
    set otpErrorMessage(value: string | null);
    otpValidated: boolean | null;
    otpSubmit: EventEmitter<string>;
    backClick: EventEmitter<void>;
    formGroup: FormGroup;
    externalOtpErrorMessage: string | null;
    private readonly destroy$;
    constructor(fb: FormBuilder);
    ngOnInit(): void;
    ngOnDestroy(): void;
    get otpControl(): FormControl | null;
    get otpIconClass(): string;
    get otpIconStateClass(): string;
    onSubmit(): void;
    onBack(): void;
    private initializeDefaults;
    private setupFormField;
    private clearOtpValidationState;
    private updateButtonDisabledState;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTOtpCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTOtpCardComponent, "pt-otp-card", never, { "otpPageConfig": { "alias": "otpPageConfig"; "required": true; }; "otpErrorMessage": { "alias": "otpErrorMessage"; "required": false; }; "otpValidated": { "alias": "otpValidated"; "required": false; }; }, { "otpSubmit": "otpSubmit"; "backClick": "backClick"; }, never, never, true, never>;
}

declare class PTOtpPageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTOtpPageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTOtpPageModule, [typeof PTOtpPageComponent], [typeof PTCardModule, typeof PTOtpCardComponent], [typeof PTOtpPageComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTOtpPageModule>;
}

declare class PTConfirmDialogComponent implements OnChanges, AfterContentInit {
    private readonly confirmationService;
    dialogConfig: PTConfirmDialogConfig;
    formGroup?: FormGroup | null;
    confirm: EventEmitter<void>;
    cancel: EventEmitter<void>;
    dialogBodyTpl?: TemplateRef<unknown>;
    projectedFormBuilder?: PTFormBuilderComponent;
    overlayStyleClass: string;
    private isDialogOpen;
    constructor(confirmationService: ConfirmationService);
    ngAfterContentInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onEscapeKey(event: Event): void;
    showDialog(): void;
    onConfirmClick(): void;
    onCancelClick(): void;
    hasFooter(): boolean;
    get confirmButtonModel(): any;
    get cancelButtonModel(): any;
    getFooterButtonsStyle(): Record<string, string>;
    getDialogHeaderText(): string;
    getDialogContentText(): string;
    getDialogIconClass(): string;
    getDialogIconStyle(): Record<string, string>;
    getDialogHeaderStyle(): Record<string, string | number>;
    getDialogContentStyle(): Record<string, string>;
    getDialogBodyStyle(): Record<string, string>;
    getIconWrapperStyle(): Record<string, string>;
    private handleConfirm;
    private handleCancel;
    private closeDialog;
    private getActiveForm;
    private isConfirmDisabled;
    private getSeverityClass;
    private getNormalizedSeverity;
    private getColors;
    private getDefaultHeaderText;
    private getButtonSeverity;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTConfirmDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTConfirmDialogComponent, "pt-confirm-dialog", never, { "dialogConfig": { "alias": "dialogConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "confirm": "confirm"; "cancel": "cancel"; }, ["dialogBodyTpl", "projectedFormBuilder"], never, false, never>;
}

declare class PTConfirmDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTConfirmDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTConfirmDialogModule, [typeof PTConfirmDialogComponent], [typeof i2.CommonModule, typeof i3$4.ConfirmDialogModule, typeof PTButtonModule], [typeof PTConfirmDialogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTConfirmDialogModule>;
}

declare class PTToastNotifierComponent {
    private messageService;
    constructor(messageService: MessageService);
    show(toast: ToastMessage): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTToastNotifierComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTToastNotifierComponent, "pt-toast-notifier", never, {}, {}, never, never, false, never>;
}

declare class PTToastNotifierModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTToastNotifierModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTToastNotifierModule, [typeof PTToastNotifierComponent], [typeof i2.CommonModule, typeof i3$5.ToastModule], [typeof PTToastNotifierComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTToastNotifierModule>;
}

declare class PTAccordionPanelDirective {
    readonly templateRef: TemplateRef<PTAccordionPanelTemplateContext>;
    panelValue: PTAccordionValue;
    constructor(templateRef: TemplateRef<PTAccordionPanelTemplateContext>);
    static ɵfac: i0.ɵɵFactoryDeclaration<PTAccordionPanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PTAccordionPanelDirective, "ng-template[ptAccordionPanel]", never, { "panelValue": { "alias": "panelValue"; "required": true; }; }, {}, never, never, false, never>;
}

declare class PTAccordionComponent implements AfterContentInit, OnChanges, OnDestroy {
    private readonly changeDetectorRef;
    config: PTAccordionConfig;
    value: PTAccordionActiveValue;
    valueChange: EventEmitter<PTAccordionActiveValue>;
    panelOpen: EventEmitter<PTAccordionPanelConfig>;
    panelClose: EventEmitter<PTAccordionPanelConfig>;
    panelTemplates: QueryList<PTAccordionPanelDirective>;
    resolvedConfig: PTAccordionConfig;
    private panelTemplatesSubscription?;
    private readonly templateMap;
    constructor(changeDetectorRef: ChangeDetectorRef);
    ngAfterContentInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get visiblePanels(): PTAccordionPanelConfig[];
    get multiple(): boolean;
    get expandIcon(): string;
    get collapseIcon(): string;
    get animationDuration(): string;
    getRootClasses(): string[];
    getPanelClasses(panel: PTAccordionPanelConfig): string[];
    getHeaderClasses(panel: PTAccordionPanelConfig): string[];
    /**
     * Returns generic content-viewport classes.
     *
     * These classes are not linked to any projected component type.
     */
    getContentClasses(panel: PTAccordionPanelConfig): string[];
    /**
     * Applies viewport dimensions and overflow directly.
     *
     * Direct overflow styles guarantee that scrolling does not depend
     * on consumer CSS or CSS class precedence.
     */
    getContentStyles(panel: PTAccordionPanelConfig): Record<string, string>;
    /**
     * Applies the configured minimum width directly to the generic
     * projected-content wrapper.
     *
     * This creates overflow whenever contentMinWidth is wider than
     * the visible accordion viewport.
     */
    getContentInnerStyles(panel: PTAccordionPanelConfig): Record<string, string>;
    getTitleText(panel: PTAccordionPanelConfig): string;
    getTitleStyles(panel: PTAccordionPanelConfig): Record<string, string>;
    getDescriptionStyles(panel: PTAccordionPanelConfig): Record<string, string>;
    getTitleIconClass(panel: PTAccordionPanelConfig): string | null;
    getTitleIconPosition(panel: PTAccordionPanelConfig): 'left' | 'right';
    getTitleIconStyles(panel: PTAccordionPanelConfig): Record<string, string>;
    getTagSeverity(panel: PTAccordionPanelConfig): 'success' | 'secondary' | 'info' | 'warn' | 'danger' | 'contrast' | undefined;
    getTagClasses(panel: PTAccordionPanelConfig): string[];
    isTagVisible(panel: PTAccordionPanelConfig): boolean;
    isPanelExpanded(panelValue: PTAccordionValue): boolean;
    shouldRenderPanelContent(panel: PTAccordionPanelConfig): boolean;
    resolvePanelTemplate(panelValue: PTAccordionValue): TemplateRef<PTAccordionPanelTemplateContext> | null;
    getTemplateContext(panel: PTAccordionPanelConfig): PTAccordionPanelTemplateContext;
    onValueChange(nextValue: string | number | string[] | number[] | null | undefined): void;
    trackPanel(_index: number, panel: PTAccordionPanelConfig): PTAccordionValue;
    private normalizeActiveValue;
    private normalizeIncomingValue;
    private toHomogeneousArray;
    private rebuildTemplateMap;
    private emitPanelStateChanges;
    private findPanel;
    private toValueArray;
    private resolveIconBorderRadius;
    private toClassList;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTAccordionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTAccordionComponent, "pt-accordion", never, { "config": { "alias": "config"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "panelOpen": "panelOpen"; "panelClose": "panelClose"; }, ["panelTemplates"], never, false, never>;
}

declare class PTAccordionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTAccordionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTAccordionModule, [typeof PTAccordionComponent, typeof PTAccordionPanelDirective], [typeof i2.CommonModule, typeof i2.NgClass, typeof i2.NgStyle, typeof i2.NgTemplateOutlet, typeof i4$8.AccordionModule, typeof i11.TagModule], [typeof PTAccordionComponent, typeof PTAccordionPanelDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTAccordionModule>;
}

declare class PTDialogComponent {
    private _config;
    set config(value: PTDialogConfig | undefined);
    get config(): PTDialogConfig;
    _internalVisible: boolean;
    isFullscreen: boolean;
    get visible(): boolean;
    set visible(v: boolean);
    visibleChange: EventEmitter<boolean>;
    onEscape(): void;
    get dialogSeverity(): SeverityEnum;
    private getSeverityClass;
    get dialogStyleClass(): string;
    get primePosition(): DialogPosition;
    get bodyStyle(): {
        [key: string]: any;
    };
    toggleFullscreen(): void;
    onInternalVisibleChange(v: boolean): void;
    private getSeverityHeaderColor;
    get headerIconStyle(): {
        [key: string]: any;
    };
    get headerTitleStyle(): {
        [key: string]: any;
    };
    private removeTextUtilityClasses;
    get safeHeaderIconClass(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTDialogComponent, "pt-dialog", never, { "config": { "alias": "config"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, ["[ptDialogHeader]", "[ptDialogContent]", "*", "[ptDialogFooter]"], false, never>;
}

declare class PTDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTDialogModule, [typeof PTDialogComponent], [typeof i2.CommonModule, typeof i3$6.DialogModule], [typeof PTDialogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTDialogModule>;
}

declare class NgPrimeToolsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgPrimeToolsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgPrimeToolsModule, never, [typeof i2.CommonModule, typeof i3.FormsModule, typeof PTAdvancedPrimeTableModule, typeof MultiSearchCriteriaModule, typeof PTCheckBoxInputModule, typeof PTDateInputModule, typeof PTFormBuilderModule, typeof PTNumberInputModule, typeof PTSwitchInputModule, typeof PTTextAreaInputModule, typeof PTTextInputModule, typeof PTMultiSelectModule, typeof PTOtpInputModule, typeof PTPasswordInputModule, typeof PTMetricCardModule, typeof PTMetricCardGroupModule, typeof PTChartModule, typeof PTCardModule, typeof PTMenuModule, typeof PTMenuFancyModule, typeof PTNavbarMenuModule, typeof PTSideBarMenuModule, typeof PTPageSkeletonModule, typeof PTFooterModule, typeof PTBreadCrumbModule, typeof PTLoginPageModule, typeof PTOtpPageModule, typeof PTButtonModule, typeof PTConfirmDialogModule, typeof PTToastNotifierModule, typeof PTAccordionModule], [typeof PTAdvancedPrimeTableModule, typeof MultiSearchCriteriaModule, typeof PTCheckBoxInputModule, typeof PTDateInputModule, typeof PTFormBuilderModule, typeof PTNumberInputModule, typeof PTSwitchInputModule, typeof PTTextAreaInputModule, typeof PTTextInputModule, typeof PTMultiSelectModule, typeof PTOtpInputModule, typeof PTPasswordInputModule, typeof PTMetricCardModule, typeof PTMetricCardGroupModule, typeof PTChartModule, typeof PTCardModule, typeof PTMenuModule, typeof PTMenuFancyModule, typeof PTNavbarMenuModule, typeof PTSideBarMenuModule, typeof PTPageSkeletonModule, typeof PTFooterModule, typeof PTBreadCrumbModule, typeof PTLoginPageModule, typeof PTOtpPageModule, typeof PTButtonModule, typeof PTConfirmDialogModule, typeof PTDialogModule, typeof PTToastNotifierModule, typeof PTAccordionModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgPrimeToolsModule>;
}

declare class DateUtilityService {
    convertToDate(dateString: string): Date | null;
    transformDateFields(data: any[], columns: any[]): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<DateUtilityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateUtilityService>;
}

declare class PTMetricPanelComponent implements OnChanges {
    private readonly router;
    panelData: MetricPanelData;
    cardConfig: CardConfig;
    showRefresh: boolean;
    showMenu: boolean;
    menuItems: MenuItem$1[];
    set loading(value: boolean);
    get loading(): boolean;
    refresh: EventEmitter<void>;
    actionMenu?: Menu$1;
    actionMenuItems: MenuItem$1[];
    private dashboardLoading;
    private localRefreshLoading;
    private dashboardLoadingWasStarted;
    constructor(router: Router);
    ngOnChanges(changes: SimpleChanges): void;
    get isLoading(): boolean;
    get hasCustomMenuItems(): boolean;
    get shouldShowMenu(): boolean;
    getDefaultCardConfig(): CardConfig;
    getTitleText(): string;
    getTitleStyles(): Record<string, string>;
    getTitleIconStyles(): Record<string, string>;
    getIconClass(icon?: string): string;
    getIconStyles(icon?: unknown): Record<string, string>;
    getValueStyles(value: unknown): Record<string, string>;
    isTitleObject(): boolean;
    getTitleIcon(): string | undefined;
    isTitleStyle(value: unknown): value is TitleStyle;
    handleClick(url?: string): void;
    onRefreshClick(event: MouseEvent): void;
    toggleMenu(event: MouseEvent): void;
    private requestRefresh;
    private rebuildActionMenuItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMetricPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTMetricPanelComponent, "pt-metric-panel", never, { "panelData": { "alias": "panelData"; "required": false; }; "cardConfig": { "alias": "cardConfig"; "required": false; }; "showRefresh": { "alias": "showRefresh"; "required": false; }; "showMenu": { "alias": "showMenu"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "refresh": "refresh"; }, never, never, false, never>;
}

declare class PTMetricPanelModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTMetricPanelModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTMetricPanelModule, [typeof PTMetricPanelComponent], [typeof i2.CommonModule, typeof PTCardModule, typeof i4$1.TooltipModule, typeof i5$2.MenuModule], [typeof PTMetricPanelComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTMetricPanelModule>;
}

declare class PTChartComparisonComponent implements AfterViewInit, OnChanges, OnDestroy {
    chartConfig: ChartConfig;
    medianTitle: string;
    xAxisTitle: string;
    yAxisTitle: string;
    yMin?: number;
    yMax?: number;
    yStepSize?: number;
    chartHeight?: string;
    chartWidth?: string;
    canvasRef: ElementRef<HTMLCanvasElement>;
    private chart?;
    private resizeObserver?;
    private viewInitialized;
    constructor();
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get resolvedChartWidth(): string;
    get resolvedChartHeight(): string;
    private initializeChart;
    private getFormattedChartData;
    private calculateMedian;
    private getChartOptions;
    private observeResize;
    private scheduleResize;
    private destroyChart;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTChartComparisonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTChartComparisonComponent, "pt-chart-comparison", never, { "chartConfig": { "alias": "chartConfig"; "required": false; }; "medianTitle": { "alias": "medianTitle"; "required": false; }; "xAxisTitle": { "alias": "xAxisTitle"; "required": false; }; "yAxisTitle": { "alias": "yAxisTitle"; "required": false; }; "yMin": { "alias": "yMin"; "required": false; }; "yMax": { "alias": "yMax"; "required": false; }; "yStepSize": { "alias": "yStepSize"; "required": false; }; "chartHeight": { "alias": "chartHeight"; "required": false; }; "chartWidth": { "alias": "chartWidth"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class PTLineChartComponent implements OnChanges {
    chartData: AxisChartData[];
    config: AxisChartConfig;
    lineChartConfig: ChartConfig;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    private createLineChartConfig;
    private updateChartData;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTLineChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTLineChartComponent, "pt-line-chart", never, { "chartData": { "alias": "chartData"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PTLineChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTLineChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTLineChartModule, [typeof PTLineChartComponent], [typeof i2.CommonModule, typeof PTCardModule, typeof PTChartModule], [typeof PTLineChartComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTLineChartModule>;
}

declare class PTNewsTickerComponent implements OnChanges, AfterViewInit, OnDestroy {
    private readonly changeDetectorRef;
    private readonly zone;
    private static readonly SCROLL_ANIMATION_NAME;
    private static readonly MINIMUM_CYCLE_TIMEOUT_MS;
    news: PTNewsTickerItem[];
    speed: number;
    defaultSpeed: number;
    speedStep: number;
    minSpeed: number;
    maxSpeed: number;
    direction: PTNewsTickerDirection;
    autoplay: boolean;
    loop: boolean;
    pauseOnHover: boolean;
    showControls: boolean;
    showPlayPauseControl: boolean;
    showSpeedControls: boolean;
    showResetSpeedControl: boolean;
    showRemoveButton: boolean;
    showSpeedValue: boolean;
    showNewBadge: boolean;
    newBadgeText: string;
    newBadgeDuration: number;
    height: string;
    gap: string;
    itemGap: string;
    containerBackgroundColor: string;
    containerTextColor: string;
    borderColor: string;
    borderWidth: string;
    borderRadius: string;
    controlsBackgroundColor: string;
    controlsBorderColor: string;
    emptyMessage: string;
    emptyIcon: string;
    ariaLabel: string;
    newsClick: EventEmitter<PTNewsTickerItem>;
    newsRemove: EventEmitter<PTNewsTickerItem>;
    newsChange: EventEmitter<PTNewsTickerChangeEvent>;
    playStateChange: EventEmitter<PTNewsTickerPlayStateChangeEvent>;
    speedChange: EventEmitter<PTNewsTickerSpeedChangeEvent>;
    tickerViewport?: ElementRef<HTMLElement>;
    tickerTrack?: ElementRef<HTMLElement>;
    tickerGroup?: ElementRef<HTMLElement>;
    readonly PTNewsTickerType: typeof PTNewsTickerType;
    readonly PTNewsTickerTrend: typeof PTNewsTickerTrend;
    internalNews: PTNewsTickerItem[];
    animationDurationSeconds: number;
    loopGapPixels: number;
    playing: boolean;
    hovered: boolean;
    private pendingNews;
    private resizeObserver?;
    private animationFrameId;
    private pendingNewsCycleTimeoutId;
    private viewInitialized;
    private applyingPendingNews;
    private readonly newBadgeTimeouts;
    private readonly expiredNewBadgeIds;
    constructor(changeDetectorRef: ChangeDetectorRef, zone: NgZone);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    addNews(item: PTNewsTickerItem): void;
    removeNews(itemOrId: PTNewsTickerItem | string | number): void;
    clearNews(): void;
    replaceNews(news: PTNewsTickerItem[]): void;
    play(): void;
    pause(): void;
    togglePlayState(): void;
    increaseSpeed(): void;
    decreaseSpeed(): void;
    resetSpeed(): void;
    setSpeed(speed: number): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    onTrackAnimationIteration(event: AnimationEvent): void;
    onTrackAnimationEnd(event: AnimationEvent): void;
    onItemClick(event: Event, item: PTNewsTickerItem): void;
    onRemoveClick(event: MouseEvent, item: PTNewsTickerItem): void;
    hasItemLink(item: PTNewsTickerItem): boolean;
    hasSegments(item: PTNewsTickerItem): boolean;
    hasSingleNewsItem(): boolean;
    isItemRemovable(item: PTNewsTickerItem): boolean;
    isItemFlash(item: PTNewsTickerItem): boolean;
    shouldShowNewBadge(item: PTNewsTickerItem): boolean;
    getNewBadgeText(item: PTNewsTickerItem): string;
    getSegmentSeparator(item: PTNewsTickerItem): string;
    getSegmentIcon(segment: PTNewsTickerSegment): string | null;
    getSegmentStyle(segment: PTNewsTickerSegment): Record<string, string>;
    getTrackStyle(): Record<string, string>;
    getContainerStyle(): Record<string, string>;
    getItemStyle(item: PTNewsTickerItem): Record<string, string>;
    getItemClasses(item: PTNewsTickerItem): Record<string, boolean>;
    getDuplicateItemClasses(item: PTNewsTickerItem): Record<string, boolean>;
    getTrackById(index: number, item: PTNewsTickerItem): string;
    getDuplicateTrackById(index: number, item: PTNewsTickerItem): string;
    getItemRole(item: PTNewsTickerItem): string | null;
    getItemTabIndex(item: PTNewsTickerItem): number;
    private applyInputNewsPreservingAnimation;
    private captureTrackAnimationState;
    private restoreTrackAnimationState;
    private findTrackAnimation;
    private areNewsListsEquivalent;
    private areSegmentsEquivalent;
    private queueOrApplyNews;
    private shouldApplyNewsImmediately;
    private schedulePendingNewsAtCurrentCycleEnd;
    private resolveCurrentCycleRemainingDuration;
    private clearPendingNewsCycleTimeout;
    private applyPendingNewsAtCycleBoundary;
    private applyPendingNewsImmediately;
    private isTickerScrollEvent;
    private resolveItemBackgroundColor;
    private scheduleNewBadges;
    private scheduleNewBadgeExpiration;
    private getNewBadgeDuration;
    private normalizeNewBadgeDuration;
    private clearNewBadgeTimeout;
    private clearNewBadgeTimeouts;
    private resolveCreatedAt;
    private getItemKey;
    private getSegmentTrendColor;
    private prefersReducedMotion;
    private getAnimationPlayState;
    private initializeResizeObserver;
    private scheduleAnimationRefresh;
    private calculateAnimationDuration;
    private normalizeNews;
    private normalizeItem;
    private normalizeSegments;
    private cloneNews;
    private normalizeSpeed;
    private normalizeSpeedStep;
    private emitNewsChange;
    private emitPlayStateChange;
    private getTypeStyles;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNewsTickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTNewsTickerComponent, "pt-news-ticker", never, { "news": { "alias": "news"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "defaultSpeed": { "alias": "defaultSpeed"; "required": false; }; "speedStep": { "alias": "speedStep"; "required": false; }; "minSpeed": { "alias": "minSpeed"; "required": false; }; "maxSpeed": { "alias": "maxSpeed"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "autoplay": { "alias": "autoplay"; "required": false; }; "loop": { "alias": "loop"; "required": false; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; }; "showControls": { "alias": "showControls"; "required": false; }; "showPlayPauseControl": { "alias": "showPlayPauseControl"; "required": false; }; "showSpeedControls": { "alias": "showSpeedControls"; "required": false; }; "showResetSpeedControl": { "alias": "showResetSpeedControl"; "required": false; }; "showRemoveButton": { "alias": "showRemoveButton"; "required": false; }; "showSpeedValue": { "alias": "showSpeedValue"; "required": false; }; "showNewBadge": { "alias": "showNewBadge"; "required": false; }; "newBadgeText": { "alias": "newBadgeText"; "required": false; }; "newBadgeDuration": { "alias": "newBadgeDuration"; "required": false; }; "height": { "alias": "height"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "itemGap": { "alias": "itemGap"; "required": false; }; "containerBackgroundColor": { "alias": "containerBackgroundColor"; "required": false; }; "containerTextColor": { "alias": "containerTextColor"; "required": false; }; "borderColor": { "alias": "borderColor"; "required": false; }; "borderWidth": { "alias": "borderWidth"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "controlsBackgroundColor": { "alias": "controlsBackgroundColor"; "required": false; }; "controlsBorderColor": { "alias": "controlsBorderColor"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "emptyIcon": { "alias": "emptyIcon"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "newsClick": "newsClick"; "newsRemove": "newsRemove"; "newsChange": "newsChange"; "playStateChange": "playStateChange"; "speedChange": "speedChange"; }, never, never, false, never>;
}

declare class PTNewsTickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNewsTickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTNewsTickerModule, [typeof PTNewsTickerComponent], [typeof i2.CommonModule, typeof i3$1.ButtonModule, typeof i4$1.TooltipModule], [typeof PTNewsTickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTNewsTickerModule>;
}

declare class PTChangePasswordPageComponent implements OnInit {
    changePasswordPageConfig: ChangePasswordPageConfig;
    changePasswordErrorMessage: string | null;
    passwordValueChange: EventEmitter<ChangePasswordModel>;
    changePasswordSubmit: EventEmitter<ChangePasswordModel>;
    private readonly defaultCardConfig;
    ngOnInit(): void;
    onPasswordValueChange(changePasswordModel: ChangePasswordModel): void;
    onChangePasswordSubmit(changePasswordModel: ChangePasswordModel): void;
    private initializeDefaultPosition;
    private applyDefaultConfigs;
    private applyDefaults;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTChangePasswordPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTChangePasswordPageComponent, "pt-change-password-page", never, { "changePasswordPageConfig": { "alias": "changePasswordPageConfig"; "required": false; }; "changePasswordErrorMessage": { "alias": "changePasswordErrorMessage"; "required": false; }; }, { "passwordValueChange": "passwordValueChange"; "changePasswordSubmit": "changePasswordSubmit"; }, never, never, false, never>;
}

declare class PTChangePasswordCardComponent implements OnInit, OnChanges, OnDestroy {
    private readonly formBuilder;
    changePasswordPageConfig: ChangePasswordPageConfig;
    changePasswordErrorMessage: string | null;
    passwordValueChange: EventEmitter<ChangePasswordModel>;
    changePasswordSubmit: EventEmitter<ChangePasswordModel>;
    formGroup: FormGroup;
    private readonly destroy$;
    private initialized;
    constructor(formBuilder: FormBuilder);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get confirmationPasswordControl(): AbstractControl | null;
    get visiblePasswordPolicyRules(): PasswordPolicyRuleModel[];
    get visibleAdditionalContent(): LoginAdditionalContent[];
    onSubmit(): void;
    getAdditionalContentClass(item: LoginAdditionalContent): string[];
    private setupFormFields;
    private listenToPasswordChanges;
    private buildChangePasswordModel;
    private passwordMatchValidator;
    private areFrontendPasswordPolicyRulesValid;
    private updateButtonDisabledState;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTChangePasswordCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTChangePasswordCardComponent, "pt-change-password-card", never, { "changePasswordPageConfig": { "alias": "changePasswordPageConfig"; "required": false; }; "changePasswordErrorMessage": { "alias": "changePasswordErrorMessage"; "required": false; }; }, { "passwordValueChange": "passwordValueChange"; "changePasswordSubmit": "changePasswordSubmit"; }, never, never, true, never>;
}

declare class PTChangePasswordPageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTChangePasswordPageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTChangePasswordPageModule, [typeof PTChangePasswordPageComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof PTTextInputModule, typeof PTCardModule, typeof PTButtonModule, typeof PTChangePasswordCardComponent], [typeof PTChangePasswordPageComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTChangePasswordPageModule>;
}

declare class PTNotificationsPageComponent implements OnChanges, OnDestroy {
    /**
     * Current server page only.
     */
    notifications: PTNotificationItem[];
    /**
     * Number of records matching the current:
     *
     * search + selected filter
     *
     * This value is used by the paginator.
     */
    totalRecords: number;
    /**
     * Number of all notifications matching the current search,
     * before applying ALL / UNREAD / READ.
     *
     * Used by the "Toutes" counter.
     */
    totalAllRecords: number;
    /**
     * Number of unread notifications matching the current search.
     */
    totalUnreadRecords?: number;
    /**
     * Number of read notifications matching the current search.
     */
    totalReadRecords?: number;
    /**
     * Current zero-based page.
     */
    page: number;
    /**
     * Current server page size.
     */
    rows: number;
    config: PTNotificationsPageConfig;
    notificationClick: EventEmitter<PTNotificationClickEvent>;
    action: EventEmitter<PTNotificationActionEvent>;
    globalAction: EventEmitter<PTNotificationGlobalActionEvent>;
    /**
     * Request for a new server page.
     *
     * Emitted on:
     * - pagination
     * - page size change
     * - filter change
     * - search
     */
    queryChange: EventEmitter<PTNotificationsPageQueryEvent>;
    searchText: string;
    selectedFilter: PTNotificationsPageFilter;
    openedActionMenuId: string | number | null;
    isGlobalActionMenuOpen: boolean;
    private readonly destroy$;
    private readonly searchSubject;
    private readonly defaultActions;
    private readonly defaultGlobalActions;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    getNotifications(): PTNotificationItem[];
    /**
     * The supplied notifications already correspond
     * to one server page.
     *
     * No filtering, sorting or pagination is performed here.
     */
    getDisplayedNotifications(): PTNotificationItem[];
    getTotalCount(): number;
    getUnreadCount(): number;
    getReadCount(): number;
    hasNotifications(): boolean;
    hasSearch(): boolean;
    showSearch(): boolean;
    showFilters(): boolean;
    showCounters(): boolean;
    showPagination(): boolean;
    showGlobalActions(): boolean;
    getTitle(): string;
    getSubtitle(): string;
    getEmptyText(): string;
    getNoSearchResultText(): string;
    getEmptyIcon(): string;
    getSearchPlaceholder(): string;
    getAllLabel(): string;
    getUnreadLabel(): string;
    getReadLabel(): string;
    getRowsPerPageOptions(): number[];
    showCurrentPageReport(): boolean;
    getCurrentPageReportTemplate(): string;
    getFirst(): number;
    selectFilter(filter: PTNotificationsPageFilter): void;
    isFilterSelected(filter: PTNotificationsPageFilter): boolean;
    onSearch(value: string): void;
    clearSearch(): void;
    onPageChange(event: PaginatorState): void;
    onNotificationClick(notification: PTNotificationItem, event: Event): void;
    toggleActionMenu(notification: PTNotificationItem, event: Event): void;
    onActionMenuClick(event: Event): void;
    onActionClick(notification: PTNotificationItem, menuAction: PTNotificationMenuAction, event: Event): void;
    toggleGlobalActionMenu(event: Event): void;
    onGlobalActionMenuClick(event: Event): void;
    onGlobalActionClick(menuAction: PTNotificationMenuAction, event: Event): void;
    closeMenus(): void;
    getNotificationClasses(notification: PTNotificationItem): string;
    getNotificationIcon(notification: PTNotificationItem): string;
    getNotificationIconStyles(notification: PTNotificationItem): {
        [key: string]: string;
    };
    getActions(notification: PTNotificationItem): PTNotificationMenuAction[];
    getGlobalActions(): PTNotificationMenuAction[];
    hasActions(notification: PTNotificationItem): boolean;
    isActionMenuOpen(notification: PTNotificationItem): boolean;
    getActionClasses(menuAction: PTNotificationMenuAction): string;
    hasMetadata(notification: PTNotificationItem): boolean;
    getDateText(notification: PTNotificationItem): string;
    private emitQueryChange;
    private formatRelativeDate;
    private getCalendarDayDifference;
    private toDate;
    private formatAbsoluteDate;
    private formatTime;
    private pad2;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNotificationsPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTNotificationsPageComponent, "pt-notifications-page", never, { "notifications": { "alias": "notifications"; "required": false; }; "totalRecords": { "alias": "totalRecords"; "required": false; }; "totalAllRecords": { "alias": "totalAllRecords"; "required": false; }; "totalUnreadRecords": { "alias": "totalUnreadRecords"; "required": false; }; "totalReadRecords": { "alias": "totalReadRecords"; "required": false; }; "page": { "alias": "page"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "notificationClick": "notificationClick"; "action": "action"; "globalAction": "globalAction"; "queryChange": "queryChange"; }, never, never, false, never>;
}

declare class PTNotificationsPageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTNotificationsPageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTNotificationsPageModule, [typeof PTNotificationsPageComponent], [typeof i2.CommonModule, typeof i3$7.PaginatorModule], [typeof PTNotificationsPageComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTNotificationsPageModule>;
}

declare class PTReleaseNotesPageComponent implements OnDestroy {
    releases: PTReleaseNoteItem[];
    loading: boolean;
    totalRecords: number;
    totalAllRecords: number;
    totalUnreadRecords?: number;
    totalReadRecords?: number;
    page: number;
    rows: number;
    rowsPerPageOptions: number[];
    config: PTReleaseNotesConfig;
    queryChange: EventEmitter<PTReleaseNotesPageQueryEvent>;
    searchText: string;
    selectedFilter: PTReleaseNotesPageFilter;
    private readonly destroy$;
    private readonly searchSubject;
    private readonly expandedReleaseIds;
    constructor();
    ngOnDestroy(): void;
    get language(): PTReleaseNotesLanguage;
    get resolvedConfig(): Required<PTReleaseNotesConfig>;
    getReleases(): PTReleaseNoteItem[];
    getDisplayedReleases(): PTReleaseNoteItem[];
    hasReleases(): boolean;
    getTitle(): string;
    getSubtitle(): string;
    getTotalCount(): number;
    getUnreadCount(): number;
    getReadCount(): number;
    showCounters(): boolean;
    showPagination(): boolean;
    getAllLabel(): string;
    getUnreadLabel(): string;
    getReadLabel(): string;
    getSearchPlaceholder(): string;
    getEmptyText(): string;
    getNoSearchResultText(): string;
    getEmptyIcon(): string;
    getRowsPerPageOptions(): number[];
    showCurrentPageReport(): boolean;
    getCurrentPageReportTemplate(): string;
    getFirst(): number;
    hasSearch(): boolean;
    selectFilter(filter: PTReleaseNotesPageFilter): void;
    isFilterSelected(filter: PTReleaseNotesPageFilter): boolean;
    onSearch(value: string): void;
    clearSearch(): void;
    onPageChange(event: PaginatorState): void;
    getReleaseClasses(release: PTReleaseNoteItem): string;
    getNewCount(release: PTReleaseNoteItem): number;
    getImprovementCount(release: PTReleaseNoteItem): number;
    getBugFixCount(release: PTReleaseNoteItem): number;
    getTotalChangesCount(release: PTReleaseNoteItem): number;
    hasCounters(release: PTReleaseNoteItem): boolean;
    hasNewItems(release: PTReleaseNoteItem): boolean;
    hasImprovements(release: PTReleaseNoteItem): boolean;
    hasBugFixes(release: PTReleaseNoteItem): boolean;
    hasDetails(release: PTReleaseNoteItem): boolean;
    getDetails(release: PTReleaseNoteItem): PTReleaseNoteDetail[];
    getDetailsByType(release: PTReleaseNoteItem, type: PTReleaseNoteDetailType): PTReleaseNoteDetail[];
    hasDetailsByType(release: PTReleaseNoteItem, type: PTReleaseNoteDetailType): boolean;
    isDetailsExpanded(release: PTReleaseNoteItem): boolean;
    toggleDetails(release: PTReleaseNoteItem): void;
    hasExpandableReleases(): boolean;
    areAllDetailsExpanded(): boolean;
    toggleAllDetails(): void;
    expandAllDetails(): void;
    collapseAllDetails(): void;
    getToggleAllDetailsText(): string;
    getDetailsButtonText(release: PTReleaseNoteItem): string;
    getDetailIcon(detail: PTReleaseNoteDetail): string;
    getDetailTypeLabel(detail: PTReleaseNoteDetail): string;
    getDetailTypeSectionLabel(type: PTReleaseNoteDetailType): string;
    getDetailTypeSectionIcon(type: PTReleaseNoteDetailType): string;
    getDetailTypeSectionClass(type: PTReleaseNoteDetailType): string;
    getDetailClass(detail: PTReleaseNoteDetail): string;
    onDetailClick(detail: PTReleaseNoteDetail, event: Event): void;
    private emitQueryChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<PTReleaseNotesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTReleaseNotesPageComponent, "pt-release-notes-page", never, { "releases": { "alias": "releases"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "totalRecords": { "alias": "totalRecords"; "required": false; }; "totalAllRecords": { "alias": "totalAllRecords"; "required": false; }; "totalUnreadRecords": { "alias": "totalUnreadRecords"; "required": false; }; "totalReadRecords": { "alias": "totalReadRecords"; "required": false; }; "page": { "alias": "page"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "queryChange": "queryChange"; }, never, never, false, never>;
}

declare class PTReleaseNotesPageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTReleaseNotesPageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTReleaseNotesPageModule, [typeof PTReleaseNotesPageComponent], [typeof i2.CommonModule, typeof i3$7.PaginatorModule], [typeof PTReleaseNotesPageComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTReleaseNotesPageModule>;
}

declare class PTGroupComponent {
    gap: string;
    justify: 'flex-start' | 'center' | 'flex-end' | 'space-between' | 'space-around';
    display: string;
    flexWrap: string;
    get gapSize(): string;
    get justifyContent(): "center" | "flex-end" | "flex-start" | "space-between" | "space-around";
    static ɵfac: i0.ɵɵFactoryDeclaration<PTGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PTGroupComponent, "pt-group", never, { "gap": { "alias": "gap"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class PTGroupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PTGroupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PTGroupModule, [typeof PTGroupComponent], [typeof i2.CommonModule, typeof PTCardModule], [typeof PTGroupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PTGroupModule>;
}

export { AlignEnum, BadgeType, BadgeTypeStyles, ButtonColorEnum, DateUtilityService, FormInputTypeEnum, InputValidationEnum, MultiSearchCriteriaComponent, MultiSearchCriteriaModule, NgPrimeToolsModule, PTAccordionComponent, PTAccordionModule, PTAccordionPanelDirective, PTAdvancedPrimeTableComponent, PTAdvancedPrimeTableModule, PTBreadCrumbComponent, PTBreadCrumbModule, PTButtonComponent, PTButtonModule, PTCardComponent, PTCardModule, PTChangePasswordPageComponent, PTChangePasswordPageModule, PTChartComparisonComponent, PTChartComparisonModule, PTChartComponent, PTChartModule, PTCheckBoxInputComponent, PTCheckBoxInputModule, PTConfirmDialogComponent, PTConfirmDialogModule, PTDateInputComponent, PTDateInputModule, PTDialogComponent, PTDialogModule, PTDropdownComponent, PTDropdownModule, PTFooterComponent, PTFooterModule, PTFormBuilderComponent, PTFormBuilderModule, PTGroupComponent, PTGroupModule, PTLineChartComponent, PTLineChartModule, PTLoginPageComponent, PTLoginPageModule, PTMenuComponent, PTMenuFancyComponent, PTMenuFancyModule, PTMenuModule, PTMetricCardComponent, PTMetricCardGroupComponent, PTMetricCardGroupModule, PTMetricCardModule, PTMetricPanelComponent, PTMetricPanelModule, PTMultiSelectComponent, PTMultiSelectModule, PTNavbarMenuComponent, PTNavbarMenuModule, PTNewsTickerComponent, PTNewsTickerDirection, PTNewsTickerModule, PTNewsTickerTrend, PTNewsTickerType, PTNotificationComponent, PTNotificationModule, PTNotificationsPageComponent, PTNotificationsPageModule, PTNumberInputComponent, PTNumberInputModule, PTOtpInputComponent, PTOtpInputModule, PTOtpPageComponent, PTOtpPageModule, PTPageSkeletonComponent, PTPageSkeletonModule, PTPasswordInputComponent, PTPasswordInputModule, PTReleaseNotesComponent, PTReleaseNotesModule, PTReleaseNotesPageComponent, PTReleaseNotesPageModule, PTSideBarMenuComponent, PTSideBarMenuModule, PTSwitchInputComponent, PTSwitchInputModule, PTTextAreaInputComponent, PTTextAreaInputModule, PTTextInputComponent, PTTextInputModule, PTToastNotifierComponent, PTToastNotifierModule, SearchCriteriaTypeEnum, SeverityEnum, TableTypeEnum };
export type { Appearance, AxisChartConfig, AxisChartData, Badge, BreadCrumbConfig, ButtonModel, CardConfig, ChangePasswordModel, ChangePasswordPageConfig, ChartConfig, Dataset, DateFormat, DateFormatType, DateTimePosition, DateTimeSource, DialogPosition, Divider, FilterOption, FooterConfig, FooterModel, ForgotPasswordConfig, FormButton, FormCheckBoxField, FormDateField, FormDropdownField, FormField, FormFieldGroup, FormMultiSelectField, FormNumberField, FormSwitchField, FormTextAreaField, FormTextField, IconImageStyle, IconStyle, ImageStyle, LabelSetting, LoginAdditionalContent, LoginAdditionalContentAlign, LoginAdditionalContentLinkPosition, LoginAdditionalContentType, LoginModel, LoginPageConfig, Menu, MenuConfig, MenuItem, MetricCardData, MetricIndicateurData, MetricPanelData, NavBarDateTimeConfig, NavBarMenuConfig, NavBarUserAvatarMode, NavBarUserConfig, NavBarUserMenuItem, NavBarUserMenuItemSeverity, NavBarUserProfilePosition, OtpPageConfig, OtpPagePosition, PTAccordionActiveValue, PTAccordionConfig, PTAccordionPanelConfig, PTAccordionPanelTemplateContext, PTAccordionTagConfig, PTAccordionValue, PTConfirmDialogConfig, PTDateInputConfig, PTDialogConfig, PTDropdownConfig, PTMultiSelectConfig, PTNewsTickerChangeEvent, PTNewsTickerItem, PTNewsTickerPlayStateChangeEvent, PTNewsTickerSegment, PTNewsTickerSpeedChangeEvent, PTNewsTickerTarget, PTNotificationActionEvent, PTNotificationClickEvent, PTNotificationConfig, PTNotificationGlobalActionEvent, PTNotificationItem, PTNotificationLoadMoreEvent, PTNotificationMenuAction, PTNotificationsPageConfig, PTNotificationsPageFilter, PTNotificationsPageQueryEvent, PTReleaseNoteActionEvent, PTReleaseNoteClickEvent, PTReleaseNoteDetail, PTReleaseNoteDetailType, PTReleaseNoteGlobalActionEvent, PTReleaseNoteItem, PTReleaseNoteLoadMoreEvent, PTReleaseNoteMenuAction, PTReleaseNotesConfig, PTReleaseNotesLanguage, PTReleaseNotesPageFilter, PTReleaseNotesPageQueryEvent, PTSwitchConfig, PTTableActionConfig, PTTableLazyLoadEvent, PTTableRowOrderItem, PTTableRowReorderEvent, PageSkeletonConfig, PasswordPolicyRuleModel, PasswordStrengthSeverity, Pattern, SearchCriteria, SideMenuBarConfig, Size, TableColumn, TextStyle, TimeFormat, TitleStyle, ToastMessage, ValueSetting, VerticalLine };
//# sourceMappingURL=ng-prime-tools.d.ts.map