@fuentis/phoenix-ui 0.0.9-alpha.62 → 0.0.9-alpha.620

package/index.d.ts

@@ -1,5 +1,1603 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, ElementRef, OnChanges, SimpleChanges, QueryList, OnDestroy, OnInit, InjectionToken } from '@angular/core';
+import { ButtonProps } from 'primeng/button';
+import { Popover } from 'primeng/popover';
+import { TranslateService } from '@ngx-translate/core';
+import * as rxjs from 'rxjs';
+import { Subject, Subscription, Observable } from 'rxjs';
+import { Router } from '@angular/router';
+import { Table } from 'primeng/table';
+import * as _angular_forms from '@angular/forms';
+import { FormGroup, FormBuilder, AbstractControl } from '@angular/forms';
+import { HttpClient } from '@angular/common/http';
+import { DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { Drawer } from 'primeng/drawer';
+
+declare class InnerHeaderComponent {
+    title: string;
+    tooltipContent: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InnerHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InnerHeaderComponent, "pho-inner-header", never, { "title": { "alias": "title"; "required": false; }; "tooltipContent": { "alias": "tooltipContent"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarComponent {
+    toggleSidebar: EventEmitter<boolean>;
+    sliderClick: EventEmitter<any>;
+    classname: string;
+    mainItems: any;
+    footerItem: any;
+    isHovered: boolean;
+    isSlim: boolean;
+    get hoverState(): "default" | "hovered";
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onToggleSidebar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "pho-sidebar", never, { "classname": { "alias": "classname"; "required": false; }; "mainItems": { "alias": "mainItems"; "required": false; }; "footerItem": { "alias": "footerItem"; "required": false; }; }, { "toggleSidebar": "toggleSidebar"; "sliderClick": "sliderClick"; }, never, never, true, never>;
+}
+
+declare class ActionStateService {
+    private _disabledActions;
+    get disabledActions(): i0.Signal<Set<string>>;
+    disableAction(id: string): void;
+    enableAction(id: string): void;
+    isDisabled(id: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionStateService>;
+}
+
+declare enum ActionTypes {
+    BASIC = "BASIC",
+    SELECT = "SELECT"
+}
+interface Actions {
+}
+type RegisteredActionEnums = Actions[keyof Actions];
+type AllActionValues = RegisteredActionEnums[keyof RegisteredActionEnums];
+interface Action<T = AllActionValues> {
+    id?: string;
+    actionId: T;
+    label: string;
+    icon: string;
+    severity: Exclude<ButtonProps['severity'], 'warning'> | 'warn';
+    iconPos?: 'right' | 'left';
+    type: keyof typeof ActionTypes;
+    text?: boolean;
+    tooltip?: string;
+    key?: string;
+    requiredPermission?: string;
+    data?: any;
+    disabled?: boolean;
+    visible?: boolean;
+    loading?: boolean;
+    class?: string;
+    items?: {
+        key?: string;
+        actionId?: T;
+        label?: string;
+        separator?: boolean;
+        icon?: string;
+        requiredPermission?: string;
+    }[];
+}
+declare class ActionsComponent {
+    actionStateService: ActionStateService;
+    actions: Action[];
+    actionClick: EventEmitter<Action<never>>;
+    onActionClick($event: any, action: Action, menuRef?: Popover): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionsComponent, "pho-actions", never, { "actions": { "alias": "actions"; "required": false; }; }, { "actionClick": "actionClick"; }, never, never, true, never>;
+}
+
+declare enum ActionKinds {
+    CREATE = "CREATE",
+    SUBMIT = "SUBMIT",
+    ASSIGN = "ASSIGN",
+    NEW = "NEW",
+    UPDATE = "UPDATE",
+    RELOAD = "RELOAD",
+    CLOSE = "CLOSE",
+    OPEN = "OPEN",
+    EDIT = "EDIT",
+    DELETE = "DELETE",
+    EDIT_TRANSITION = "EDIT_TRANSITION",
+    ADD_TRANSITION = "ADD_TRANSITION",
+    READ = "READ"
+}
+
+interface cardConfig {
+    name: string;
+    subName: string;
+    description: string;
+    actions: any[];
+    additional: any[];
+}
+declare class CardComponent<T extends Record<string, any>> {
+    card: i0.InputSignal<T>;
+    cardEventEmmiter: i0.OutputEmitterRef<{
+        data: T;
+        action: string;
+    }>;
+    actionEnum: typeof ActionKinds;
+    cardActions: i0.InputSignal<any>;
+    getObjectValueByKey(obj: any, key: string): any;
+    descEl: ElementRef<HTMLElement>;
+    showTooltip: boolean;
+    ngAfterViewInit(): void;
+    onCardClick(event: any, actionType?: string): void;
+    shouldShowTitleTooltip(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent<any>, "phoenix-card", never, { "card": { "alias": "card"; "required": true; "isSignal": true; }; "cardActions": { "alias": "cardActions"; "required": false; "isSignal": true; }; }, { "cardEventEmmiter": "cardEventEmmiter"; }, never, ["[custom]", "[footer]"], true, never>;
+}
+
+interface SearchTabs {
+    id: number;
+    apiUrl: string;
+    header: string;
+    linkUrl: string;
+}
+
+interface SidebarItem {
+    module: string;
+    items: any;
+}
+interface TopbarItem {
+    label: string;
+    icon?: string;
+    url?: string;
+    routerLink?: string[];
+    disabled?: boolean;
+    path: string;
+}
+interface User {
+    email: string;
+    username: string;
+    imageUrl: string;
+    bindImageUrl: string;
+    firstname?: string;
+    lastname?: string;
+}
+interface ShellConfig {
+    user: User;
+    mainItems: SidebarItem[][];
+    shortModuleName: string;
+    footerItem: TopbarItem[];
+    topbarModulesMenu: any[];
+    searchConfig?: SearchTabs[];
+}
+
+interface TopbarModuleItem {
+    label: string;
+    fullName?: string;
+    icon?: string;
+    url?: string;
+    routerLink?: string[];
+    disabled?: boolean;
+}
+interface TopbarModuleGroup {
+    label: string;
+    layout: 'full' | 'grid';
+    showIconBackground: boolean;
+    items: TopbarModuleItem[];
+}
+interface TopbarFooterConfig {
+    companyName: string;
+    companyUrl: string;
+    guideLabel: string;
+    guideUrl: string;
+    copyrightText: string;
+}
+interface UrlConfig {
+    url: string | null;
+    disabled?: boolean;
+}
+declare class TopbarComponent {
+    sidebarConfig: {
+        visible: boolean;
+        type: string;
+    };
+    currentYear: number;
+    isSidebarVisible: boolean;
+    homeUrl: string;
+    user: User;
+    shortModuleName?: string;
+    hidelogo?: boolean;
+    topbarModulesMenu: any[];
+    darkModeSelector: any;
+    urlConfig?: UrlConfig;
+    footerConfig: TopbarFooterConfig;
+    onDarkModeSelect: EventEmitter<void>;
+    onUserPopoverAction: EventEmitter<string>;
+    closeCallback(event: any): void;
+    searchConfig: i0.InputSignal<SearchTabs[] | undefined>;
+    openSidebarPanel(): void;
+    private messageService;
+    private translateService;
+    /** ✅ Zatvara sidebar */
+    closeSidebar(): void;
+    ngOnInit(): void;
+    onDarkModeSelectEmit(): void;
+    goToHome(): void;
+    goToTicketCenter(): void;
+    copyToClipboard($event: any, linkUrl: any): void;
+    get bindImageUrl(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TopbarComponent, "pho-topbar", never, { "homeUrl": { "alias": "homeUrl"; "required": false; }; "user": { "alias": "user"; "required": false; }; "shortModuleName": { "alias": "shortModuleName"; "required": false; }; "hidelogo": { "alias": "hidelogo"; "required": false; }; "topbarModulesMenu": { "alias": "topbarModulesMenu"; "required": false; }; "darkModeSelector": { "alias": "darkModeSelector"; "required": false; }; "urlConfig": { "alias": "urlConfig"; "required": false; }; "footerConfig": { "alias": "footerConfig"; "required": false; }; "searchConfig": { "alias": "searchConfig"; "required": false; "isSignal": true; }; }, { "onDarkModeSelect": "onDarkModeSelect"; "onUserPopoverAction": "onUserPopoverAction"; }, never, ["*"], true, never>;
+}
+
+declare class BaseObject {
+    name: string;
+    uuid: string;
+    constructor(partial: Partial<BaseObject>);
+}
+declare class BaseObjectType {
+    id: number;
+    labelKey: string;
+    labelKeyValEn: string;
+    labelKeyValDe: string;
+    labelKeyValSr?: string;
+    labelKeyVal?: string;
+    [key: string]: any;
+    constructor(partial: Partial<BaseObjectType>);
+}
+
+declare class SearchResult {
+    name: string;
+    title: string;
+    uuid: string;
+    type?: BaseObjectType;
+    entity?: BaseObject;
+    scopes?: BaseObject[];
+    asset?: BaseObject;
+    score?: number;
+    togType?: string;
+    url?: string;
+    constructor(partial: Partial<SearchResult>);
+}
+
+interface TypesFilter {
+    title: string;
+    checkboxes: any;
+}
+declare class SearchBarComponent {
+    translate: TranslateService;
+    op: any;
+    elm: ElementRef;
+    private crudService;
+    tabs: i0.InputSignal<SearchTabs[] | undefined>;
+    isOpen: boolean;
+    valueChanges: Subject<Event>;
+    inputEvent: Event;
+    clonedData?: SearchResult[];
+    searchData?: SearchResult[];
+    size: number;
+    tabIndex: number;
+    trigg: boolean;
+    inputText?: string;
+    textValue: string;
+    checkboxes: {
+        [key: string]: boolean;
+    };
+    valueSub$: Subscription;
+    reloadSubscription$?: Subscription;
+    mocekedFilters: TypesFilter[];
+    constructor(translate: TranslateService);
+    expand(): void;
+    onParentClick(event: Event): void;
+    onTabClick(id: number): void;
+    onScroll(scrollObj: Event): void;
+    populateFilters(data?: SearchResult[]): void;
+    onClick(data: {
+        value: {
+            checked: boolean;
+        };
+        name: string;
+    }): void;
+    filterData(makeNewFilters?: boolean): void;
+    setCheckBoxes(): void;
+    setLinkUrl(data?: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SearchBarComponent, "pho-search-bar", never, { "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SidebarItemComponent implements OnChanges {
+    private router;
+    item: any;
+    classname: string;
+    sliderClick: EventEmitter<any>;
+    constructor(router: Router);
+    onSliderClick($event: any, menu: any): void;
+    onSliderItemsClick(event: any): void;
+    ngOnChanges(_: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarItemComponent, "pho-sidebar-item", never, { "item": { "alias": "item"; "required": false; }; "classname": { "alias": "classname"; "required": false; }; }, { "sliderClick": "sliderClick"; }, never, never, true, never>;
+}
+
+declare class UserComponent {
+    user: User;
+    actionEmmiter: EventEmitter<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserComponent, "pho-user", never, { "user": { "alias": "user"; "required": false; }; }, { "actionEmmiter": "actionEmmiter"; }, never, never, true, never>;
+}
+
+declare class StatusHeaderComponent {
+    onQuickPickClickEmiter: EventEmitter<void>;
+    onToggleClickEmmiter: EventEmitter<"forward" | "back">;
+    onCloseEvent: EventEmitter<void>;
+    type: any;
+    items: any;
+    name: string;
+    title: string;
+    tag?: {
+        icon?: string;
+        text?: string;
+        variant?: string;
+    };
+    tags?: Array<{
+        icon?: string;
+        value?: string;
+        variant?: string;
+        color?: string;
+        tooltip?: string;
+    }>;
+    enableQuickPick: boolean;
+    actions: any[];
+    panelState: boolean;
+    customClose: boolean;
+    validSeverities: string[];
+    onToggleClick(direction: 'forward' | 'back'): void;
+    toggleSidePanel(): void;
+    closePanel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatusHeaderComponent, "phoenix-status-header", never, { "type": { "alias": "type"; "required": false; }; "items": { "alias": "items"; "required": false; }; "name": { "alias": "name"; "required": false; }; "title": { "alias": "title"; "required": false; }; "tag": { "alias": "tag"; "required": false; }; "tags": { "alias": "tags"; "required": false; }; "enableQuickPick": { "alias": "enableQuickPick"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "panelState": { "alias": "panelState"; "required": false; }; "customClose": { "alias": "customClose"; "required": false; }; }, { "onQuickPickClickEmiter": "onQuickPickClickEmiter"; "onToggleClickEmmiter": "onToggleClickEmmiter"; "onCloseEvent": "onCloseEvent"; }, never, never, true, never>;
+}
+
+declare enum StatusColType {
+    TAG = "TAG",
+    STRING = "STRING",
+    PERSON = "PERSON",
+    LINK = "LINK",
+    DATE = "DATE",
+    DATE_ONLY = "DATE_ONLY",
+    LIST = "LIST",
+    COUNTRY = "COUNTRY",
+    COPY_TO_CLIPBOARD = "COPY_TO_CLIPBOARD"
+}
+
+declare enum StatusTooltipType {
+    TAG = "TAG",
+    STRING = "STRING",
+    PERSON = "PERSON",
+    LINK = "LINK",
+    DATE = "DATE",
+    DATE_ONLY = "DATE_ONLY",
+    COPY_TO_CLIPBOARD = "COPY_TO_CLIPBOARD",
+    DATE_PERSON = "DATE_PERSON"
+}
+interface StatusTooltipItem {
+    label: string;
+    value: string | null;
+    type: StatusTooltipType;
+    value1?: string;
+    value2?: string;
+}
+interface StatusAttribute {
+    type: StatusColType;
+    label: string;
+    value: any;
+    dateFormat?: string;
+    key?: string;
+    color?: string;
+    icon?: string;
+    value1?: string;
+    value2?: string;
+    tooltip?: StatusTooltipItem[];
+    url?: string;
+    item?: {
+        name: string;
+        url?: string;
+        disabled?: boolean;
+    }[] | string | null;
+}
+
+interface ContextObjectTag {
+    text: string;
+    icon?: string;
+    variant?: string;
+    color?: string;
+    label?: string;
+    group?: string;
+}
+interface ContextObjectConfig {
+    showHeader?: boolean;
+    type?: string;
+    name?: string;
+    title?: string;
+    tags?: ContextObjectTag[];
+    labels?: ContextObjectTag[];
+    otherInfo?: StatusAttribute[];
+    backRoute?: any[];
+}
+
+declare class ContexObjectComponent {
+    config?: ContextObjectConfig;
+    dateFormat: string;
+    dateOnlyFormat: string;
+    router: Router;
+    statusTooltipType: typeof StatusTooltipType;
+    validSeverities: string[];
+    get ctxType(): string | undefined;
+    get ctxName(): string;
+    get ctxTitle(): string;
+    get ctxTags(): ContextObjectTag[];
+    /**
+     * Groups tags by their `group` property.
+     * Ungrouped tags are returned as-is.
+     * Grouped tags collapse into one display entry showing the first tag + remaining count.
+     */
+    get displayTags(): {
+        tag: ContextObjectTag;
+        groupedTags: ContextObjectTag[];
+        remainingCount: number;
+    }[];
+    get ctxLabels(): {
+        text: string;
+    }[];
+    get ctxBackRoute(): any[] | undefined;
+    get ctxOtherInfo(): StatusAttribute[];
+    tagPopovers: QueryList<Popover>;
+    onTagPopoverEnter(event: Event, currentPopover: Popover): void;
+    onTagPopoverLeave(event: Event, currentPopover: Popover): void;
+    onBackClick(): void;
+    getFullUrl(path: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContexObjectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContexObjectComponent, "phoenix-contex-object", never, { "config": { "alias": "config"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "dateOnlyFormat": { "alias": "dateOnlyFormat"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface ShellTheme {
+    mode: 'light' | 'dark' | 'system';
+}
+declare class ShellComponent {
+    config: {
+        user: any;
+        shortModuleName: string;
+        hidelogo?: boolean;
+        /** header control */
+        headerContext?: ContextObjectConfig;
+        searchConfig?: any;
+        topbarModulesMenu?: any;
+        urlConfig?: {
+            url: string | null;
+            disabled?: boolean;
+        };
+        mainItems?: any[];
+        footerItem?: any;
+    };
+    darkModeSelector: {
+        mode: string;
+    };
+    theme: ShellTheme;
+    onDarkModeSelect: EventEmitter<any>;
+    onIsSlimSelect: EventEmitter<any>;
+    onUserAction: EventEmitter<string>;
+    sliderClick: EventEmitter<any>;
+    themeChange: EventEmitter<ShellTheme>;
+    isSlim: boolean;
+    readonly gridTemplateColumns = "auto 1fr";
+    /** if showHeader=true adding additional row between topbar and content */
+    get gridTemplateRows(): string;
+    toggleSidebar(isSlim: boolean): void;
+    onThemeChange(mode: ShellTheme['mode']): void;
+    selectDarkMode(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShellComponent, "pho-shell", never, { "config": { "alias": "config"; "required": false; }; "darkModeSelector": { "alias": "darkModeSelector"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; }, { "onDarkModeSelect": "onDarkModeSelect"; "onIsSlimSelect": "onIsSlimSelect"; "onUserAction": "onUserAction"; "sliderClick": "sliderClick"; "themeChange": "themeChange"; }, never, ["*"], true, never>;
+}
+
+declare enum tableActionType {
+    CREATE = "create",
+    EDIT = "edit",
+    BULK_EDIT = "bulk_edit",
+    DELETE = "delete",
+    DETAILS = "details",
+    ASSIGN = "assign",
+    APPLY = "apply",
+    OPEN_IN_NEW_TAB = "open_in_new_tab",
+    TAB = "tab",
+    OPEN_FULL_SCREEN = "open_full_screen",
+    ADD_LINK = "add_link",
+    DISCONNECT = "disconnect",
+    REMOVE = "remove",
+    SYNC = "sync",
+    MENU = "menu",
+    DROP = "drop",
+    OVERVIEW = "overview",
+    HISTORY = "syncHistory",
+    DOWNLOAD = "download",
+    ATTACH = "attach",
+    IMPORT = "import",
+    ROW_DELETE = "row_delete",
+    RUN = "run",
+    ASSIGN_FROM_CATALOG = "ASSIGN_FROM_CATALOG",
+    ASSIGN_FROM_ITEM = "ASSIGN_FROM_ITEM",
+    ASSIGN_CONTROLS = "ASSING_CONTROLS",
+    ASSIGN_MEASURE = "ASSGIN_MEASURE",
+    CREATE_ADITIONAL_MEASURE = "CREATE_ADITIONAL_MEASURE"
+}
+declare enum tableButtonFormat {
+    TEXT_ICON = "TEXT_ICON",
+    TEXT = "TEXT",
+    ICON = "ICON",
+    ICON_ROUNDED = "ICON_ROUNDED"
+}
+declare enum tableButtonContext {
+    GLOBAL = "GLOBAL",
+    MORE = "MORE",
+    BULK = "BULK",
+    ROW = "ROW"
+}
+declare enum tableColumnType {
+    TEXT = "TEXT",
+    TIMEPERIOD = "TIMEPERIOD",
+    RICH_TEXT = "RICH_TEXT",
+    TEXT_AREA = "TEXT_AREA",
+    DATE = "DATE",
+    DATE_COMPLEX = "DATE_COMPLEX",//Date and time
+    TAG = "TAG",
+    OBJ_TAG = "OBJ_TAG",
+    LIST_TAG = "LIST_TAG",
+    NUMBER = "NUMBER",
+    PERSON = "PERSON",
+    COMPLETNESS = "COMPLETNESS",
+    BOOLEAN = "BOOLEAN",
+    LIST = "LIST",
+    CUSTOM = "CUSTOM",
+    EMAIL = "EMAIL"
+}
+declare enum tableSelectionType {
+    CHECKBOX = "checkbox",
+    RADIO_BTN = "radio_btn"
+}
+declare enum tableFilterType {
+    DATE = "date",
+    BOOLEAN = "boolean",
+    MULTISELECT = "multiselect",
+    COMPLETNESS = "completness"
+}
+
+type SortOrder = 1 | -1;
+interface InitialSortMeta {
+    /**
+     * Column field used for initial sorting.
+     * Must match TableColumn.field (dot paths allowed if your table supports it).
+     */
+    field: string;
+    /**
+     * Sort direction:
+     *  1  => ASC
+     * -1  => DESC
+     * Defaults to ASC (1).
+     */
+    order?: SortOrder;
+}
+interface TableConfiguration {
+    /**
+     * Unique table key (used for caching filters/columns state, analytics, etc).
+     * NOTE: you already use `key` for checkbox id override; keep that,
+     * but consider also adding tableKey if you want to separate concerns.
+     */
+    key?: string;
+    /**
+     * Alternative unique key ONLY for localStorage/state (recommended).
+     * If not provided, fallback to `key`.
+     */
+    stateKey?: string;
+    /**
+     * Row identity field used by PrimeNG dataKey (default: 'id').
+     * Use this when records don’t have `id` (e.g. GAP tab).
+     */
+    dataKey?: string;
+    /** Actions rendered in bulk mode (when selection exists). */
+    bulkActions?: TableAction[];
+    /** Actions rendered per row (right-side action column). */
+    rowActions?: TableAction[];
+    /** Actions rendered in caption left side (near tabs). */
+    globalActions?: TableAction[];
+    /** “More” dropdown action config (menu/split button). */
+    moreActions?: TableAction;
+    /** Tabs in table (if exists). */
+    tabs?: TabAction[];
+    /** Enables export buttons / export actions. */
+    exportTable: boolean;
+    /** Enables filter popover + filter icon. */
+    hasFilter?: boolean;
+    /** Enables column visibility popover + columns icon. */
+    hasColumns?: boolean;
+    /** Enables global search input. */
+    hasSearch?: boolean;
+    /** Enables “More” dropdown area. */
+    hasMore?: boolean;
+    /** Show/hide columns feature (legacy) */
+    toggleColumns?: boolean;
+    toogleColumnsData?: TableColumn[];
+    /** Enables row cell click behavior (open details etc). */
+    hasCellClick?: boolean;
+    /**
+     * How many left-most columns are clickable (default: 1).
+     * If hasCellClick = true, only first N columns will trigger row click.
+     */
+    clickableColumnCount?: number;
+    /** Table height, required for scroll/virtual scroll. */
+    scrollHeight?: string;
+    /** Number of rows per page (PrimeNG paginator / virtual scroll configs). */
+    rows?: number;
+    /** Checkbox / radio selection behavior. */
+    selectionType?: tableSelectionType;
+    /**
+     * If you need click on row table use 'single'.
+     * If using radio/checkbox selection, omit or manage carefully.
+     */
+    selectionMode?: 'single' | 'multiple';
+    /** Enables global filter (legacy flag). */
+    globalFilter?: boolean;
+    /** Filter config shown in caption/popover (your old config). */
+    filterConfiguration?: any[];
+    /**
+     * Initial sort configuration.
+     * - Single column: { field: 'createdAt', order: -1 }
+     * - Multi-sort: [{ field: 'status', order: 1 }, { field: 'createdAt', order: -1 }]
+     */
+    initialSort?: InitialSortMeta | InitialSortMeta[];
+    /**
+     * @deprecated Legacy single-field initial sort support.
+     * Prefer `initialSort`.
+     */
+    initialSortField?: string;
+    /**
+     * @deprecated Legacy order for initialSortField.
+     *  1 = ASC, -1 = DESC
+     */
+    initialSortOrder?: SortOrder;
+}
+interface TableAction {
+    key?: string;
+    label: string;
+    format?: tableButtonFormat;
+    context: tableButtonContext;
+    type: tableActionType;
+    disabled?: boolean;
+    notauthorized?: boolean;
+    buttonType?: string;
+    ui?: 'button' | 'menu' | 'switch' | 'checkbox';
+    /** Action menu items (type-safe version recommended later). */
+    items?: any;
+    checkboxrelatedauth?: boolean;
+    icon?: string;
+    /** Optional confirmation behavior. */
+    confirmationMsgKey?: string;
+    confirmationMode?: ConfirmationMode;
+    typing?: TypingConfirmationConfig;
+}
+interface TabAction {
+    key?: string;
+    label: string;
+    type: tableActionType;
+    badgeCount?: number;
+    disabled?: boolean;
+}
+type ConfirmationMode = 'DEFAULT' | 'TYPING';
+interface TypingConfirmationConfig {
+    confirmText?: string;
+    warningKey?: string;
+    typeBelowKey?: string;
+    submitLabelKey?: string;
+    cancelLabelKey?: string;
+    subtitleKey?: string;
+    caseInsensitive?: boolean;
+}
+interface TableColumn {
+    header: string;
+    field: string;
+    columnType: string;
+    filter?: string;
+    filterOptions?: any;
+    /** Enables/disables sorting for the column. */
+    sortable?: boolean;
+    /** Custom HTML renderer for the cell (if you use it). */
+    customRenderer?: (rowData: any) => string;
+}
+
+type SortMeta = {
+    field: string;
+    order: 1 | -1;
+};
+type ColumnTypeMap = Record<string, string>;
+interface SortRequest {
+    reqId: number;
+    data: any[];
+    multiSortMeta: SortMeta[];
+    columnTypeMap: ColumnTypeMap;
+    dateTypeKey?: string;
+}
+interface SortResponse {
+    reqId: number;
+    sorted: any[];
+}
+declare class TableComponent implements OnChanges, OnDestroy {
+    /** PrimeNG Table reference (used for sort meta + virtual scroll helpers). */
+    dt: Table;
+    translateService: TranslateService;
+    private cdr;
+    /**
+     * originalData:
+     * The raw dataset received through @Input() set data().
+     * We never mutate this array; it is the "source of truth".
+     */
+    originalData: any[];
+    /**
+     * allData:
+     * The dataset after applying filters and global search.
+     * This is the "base dataset" that sorting runs on.
+     */
+    allData: any[];
+    /**
+     * tableData:
+     * The final dataset rendered by the table.
+     * IMPORTANT: This is still the full array; PrimeNG virtual scroll renders only visible rows.
+     */
+    tableData: any[];
+    /** Total record count shown (used in footer and table metadata). */
+    totalRecords: number;
+    /** Selected rows (signal so UI updates fast). */
+    selectedItems: i0.WritableSignal<any[]>;
+    /** Currently visible columns (based on table-caption selection). */
+    selectedColumns: any[];
+    searchQuery: string;
+    bulkMode: boolean;
+    selectionTypeEnum: typeof tableSelectionType;
+    columnTypeEnum: typeof tableColumnType;
+    /** Latest active filters coming from table-caption. */
+    private currentFilters;
+    /**
+     * columnTypeMap:
+     * field -> columnType (DATE/BOOLEAN/TEXT/etc).
+     * The sort worker uses this to normalize values correctly (e.g., DATE parsing, BOOLEAN 0/1).
+     */
+    columnTypeMap: Record<string, string>;
+    dateFormat: string;
+    columns: any[];
+    selectedColumnsInput: any[];
+    tableConfiguration: TableConfiguration;
+    filters: any;
+    actionClick: EventEmitter<any>;
+    rowSelection: EventEmitter<any>;
+    checkBoxSelection: EventEmitter<any>;
+    saveColumns: EventEmitter<string[]>;
+    private sortWorker;
+    /**
+     * reqId counters ensure we can ignore outdated results
+     * if user triggers multiple sorts quickly.
+     */
+    private workerReqId;
+    private latestWorkerReqId;
+    /**
+     * lastSortKey prevents re-sorting when PrimeNG emits same multiSortMeta repeatedly.
+     */
+    private lastSortKey;
+    /** Ensures initial sort runs only once per dataset/config change */
+    private initialSortApplied;
+    /** Remembers which field was used last time for initial sort (optional safety) */
+    private initialSortFieldApplied;
+    /** True while initial sort is running to avoid "flash" of unsorted data */
+    initialSortLoading: boolean;
+    private createSortWorkerInline;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Whenever parent sets data, we reset base datasets and invalidate sort cache.
+     */
+    set data(value: any[]);
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * PrimeNG calls this when sorting changes.
+     * We run worker sort only when meta changes.
+     */
+    onCustomSort(event: any): void;
+    /**
+     * Dispatches sort request to the worker (or sync fallback).
+     */
+    private runWorkerSort;
+    /**
+     * Synchronous sort fallback (used if WebWorker is not available).
+     * Uses the same normalization logic as your worker approach.
+     */
+    private sortSync;
+    private normalizeInitialSort;
+    /**
+     * Applies initial sort once:
+     * - Uses tableConfiguration.initialSortField if provided
+     * - Otherwise uses the first available column field
+     * - Always ASC (order = 1)
+     *
+     * Runs only when:
+     * - we have data
+     * - we have columns/selectedColumns
+     * - it hasn't been applied yet for current dataset
+     */
+    private applyInitialSortIfNeeded;
+    /**
+     * Applies global search over the currently filtered dataset.
+     * Then re-applies sort if any sort is active.
+     */
+    onSearch(query: string): void;
+    /**
+     * Called from table-caption when filter form changes.
+     * Rebuilds allData and re-applies current sorting.
+     */
+    applyFilters(filters: Record<string, any>): void;
+    /**
+     * If table is currently sorted, re-run sort on new base dataset.
+     * Otherwise just render base dataset.
+     */
+    private applyCurrentSortOrReset;
+    private getValueByPath;
+    private matchesQuery;
+    /**
+     * Applies currentFilters to originalData and returns the filtered result.
+     * Supports:
+     * - single value (primitive or {key,...})
+     * - multi-select arrays (primitives or objects with .key)
+     * - empty filters mean "match all"
+     */
+    private getFilteredData;
+    /**
+     * Reads nested values using dot paths and unwraps `.key` when present.
+     */
+    private getNestedValue;
+    /**
+     * Produces comparable primitives for sorting (sync fallback).
+     * The worker uses its own copy of this logic.
+     */
+    private getComparableValue;
+    private compareStringsNatural;
+    onSelectionChange(selected: any[]): void;
+    onRowClick(event: Event, rowData: any): void;
+    clearSelection(): void;
+    /**
+     * Handles export actions locally, otherwise bubbles up to parent.
+     */
+    handleActionClick(event: any): void;
+    /**
+     * Used by checkbox template to disable selection on specific rows.
+     */
+    isRowSelectable(event: any): boolean;
+    /**
+     * Some tables allow click on first N columns to open details.
+     */
+    isColumnClickable(columnIndex: number): boolean;
+    /**
+     * Utility for copy icons inside cells (prevents row-click).
+     */
+    copyToClipboard(event: Event, text: string): void;
+    /**
+     * Generic nested getter used by templates (flags etc).
+     */
+    getNested(obj: any, path?: string): any;
+    /**
+     * Applies column selection coming from table-caption (array of field names).
+     */
+    applyColumns(selected: any[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "phoenix-table", never, { "columns": { "alias": "columns"; "required": false; }; "selectedColumnsInput": { "alias": "selectedColumnsInput"; "required": false; }; "tableConfiguration": { "alias": "tableConfiguration"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "actionClick": "actionClick"; "rowSelection": "rowSelection"; "checkBoxSelection": "checkBoxSelection"; "saveColumns": "saveColumns"; }, never, never, true, never>;
+}
+
+interface MetaControl {
+    id: any;
+    position: number;
+    readOnly?: boolean;
+    userFriendlyMessage: string;
+    mandatory: boolean;
+    hidden?: boolean;
+    style: {
+        colWidth: number;
+    };
+    configuration: {
+        id?: number;
+        key: string;
+        type: string;
+        options?: {
+            key: string;
+            userFriendlyMessage: string;
+        }[];
+    };
+    validators?: any;
+}
+
+declare class MetaFormService {
+    router: Router;
+    private formEvent;
+    private formReadOnlySubject;
+    private formTabContent;
+    private formDirtyStatus;
+    private formBuildCompletedSubject;
+    currentFormState: rxjs.Observable<any>;
+    formReadOnlyState: rxjs.Observable<boolean>;
+    currentFormTabContent: rxjs.Observable<string>;
+    currentFormDirtyStatus: rxjs.Observable<boolean>;
+    /**
+     * Notify when form is completed
+     * @description Notifies you about when form bild is completed in meta-form component class. Usefull when you need to attach some listeners on form controls or any other action related to form when all controls are avaiable
+     * @returns {boolean}
+     */
+    formBuildCompleted: rxjs.Observable<boolean>;
+    constructor();
+    setFormEvent(event: any): void;
+    setFormReadOnlyState(state: boolean): void;
+    setFormTabContent(tabContent: string): void;
+    setFormDirtyStatus(status: boolean): void;
+    /**
+     * Sets the form build completion status to indicate when the form is created.
+     *
+     * @param {boolean} isCompleted - A boolean value to indicate whether the form build is completed.
+     *                               Set to `true` when the form is fully created.
+     *
+     * @description This method is used to notify when the form is created and ready for use.
+     */
+    setFormBuildCompletition(isCompleted: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetaFormService>;
+}
+
+declare abstract class MetaFormAbstract {
+    private fb;
+    metaService: MetaFormService;
+    private translateService;
+    private http;
+    metaForm: FormGroup;
+    metaFormValues: any;
+    metaFormControls: any;
+    loading: boolean;
+    disableForm: boolean;
+    formButtons: boolean;
+    groupForm: boolean;
+    formStyle: any;
+    onFormSubmit: EventEmitter<any>;
+    onFormCancel: EventEmitter<any>;
+    formActive$: Observable<boolean>;
+    formSub$: Subscription;
+    constructor(fb: FormBuilder, metaService: MetaFormService, translateService: TranslateService, http: HttpClient);
+    createForm(controls: MetaControl[] | any): void;
+    activateForm(): void;
+    addControlValidators(control: any): void;
+    onSubmit(): void;
+    onCancel(): void;
+    /**
+     * Resets form to initial state
+     *
+     * @description Useful when user interact with form (edit some inputs) and than clicks CANCEL. This method patch original values to FormGroup again
+     *
+     */
+    resetToInitialValues(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormAbstract, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MetaFormAbstract, never, never, { "metaForm": { "alias": "metaForm"; "required": false; }; "metaFormValues": { "alias": "metaFormValues"; "required": false; }; "metaFormControls": { "alias": "metaFormControls"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "disableForm": { "alias": "disableForm"; "required": false; }; "formButtons": { "alias": "formButtons"; "required": false; }; "groupForm": { "alias": "groupForm"; "required": false; }; "formStyle": { "alias": "formStyle"; "required": false; }; }, { "onFormSubmit": "onFormSubmit"; "onFormCancel": "onFormCancel"; }, never, never, true, never>;
+}
+
+declare enum ControlType {
+    TEXT = "TEXT",
+    NUMBER = "NUMBER",
+    MS_OPTION = "MS_OPTION",
+    SS_OPTION = "SS_OPTION",
+    TEXT_AREA = "TEXT_AREA",
+    TEXT_EDITOR = "TEXT_EDITOR",
+    DATE = "DATE",
+    START_DUE_DATE = "START_DUE_DATE",
+    CHECKBOX = "CHECKBOX",
+    CHECKBOX_COLOR = "CHECKBOX_COLOR",
+    LINKS_DATA = "LINKS_DATA",
+    PASSWORD = "PASSWORD",
+    SWITCH = "SWITCH",
+    TIMEPERIOD = "TIMEPERIOD",
+    CURRENCY = "CURRENCY",
+    ASSIGN = "ASSIGN",
+    ASSIGN_ASSET = "ASSIGN_ASSET",
+    COLOR = "COLOR",
+    SELECT_BUTTON = "SELECT_BUTTON",
+    UPLOAD = "UPLOAD",
+    UPLOAD_DRAG_DROP = "UPLOAD_DRAG_DROP",
+    SLOT = "SLOT",
+    SS_OPTION_OBJECT_BASED = "SS_OPTION_OBJECT_BASED"
+}
+
+declare class MetaFormComponent extends MetaFormAbstract implements OnChanges {
+    constructor(fb: FormBuilder, metaService: MetaFormService, translateService: TranslateService, http: HttpClient);
+    ControlType: typeof ControlType;
+    optionLabel: string;
+    ngOnChanges(simpleChanges: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaFormComponent, "phoenix-meta-form", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MetaFormButtonsComponent implements OnInit, OnDestroy {
+    private metaFormService;
+    isDisabled: i0.InputSignal<boolean | undefined>;
+    isCreateAnother: i0.InputSignal<boolean>;
+    isLoading: i0.InputSignal<boolean>;
+    handleSave: EventEmitter<any>;
+    handleCancel: EventEmitter<any>;
+    display: boolean;
+    formActive$: Observable<boolean>;
+    createAnother: boolean;
+    sub$: Subscription;
+    constructor(metaFormService: MetaFormService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaFormButtonsComponent, "phoenix-meta-form-buttons", never, { "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "isCreateAnother": { "alias": "isCreateAnother"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; }, { "handleSave": "handleSave"; "handleCancel": "handleCancel"; }, never, never, true, never>;
+}
+
+declare class GroupsFormComponent extends MetaFormAbstract implements OnChanges {
+    activePanelsIndex: number[];
+    ControlType: typeof ControlType;
+    optionLabel: string;
+    notiffication?: any;
+    private trans;
+    ngOnChanges(simpleChanges?: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupsFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupsFormComponent, "phoenix-groups-form", never, { "activePanelsIndex": { "alias": "activePanelsIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare enum SimpleButtonType {
+    REGULAR = "regular",
+    SPLIT = "split"
+}
+type Severity = 'success' | 'info' | 'warn' | 'danger' | 'help' | 'primary' | 'secondary' | 'contrast' | null | undefined;
+interface ActionButton {
+    id?: number | string;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    type?: SimpleButtonType;
+    severity?: Severity;
+    tooltip?: string;
+    action?: () => void;
+    splitItems?: {
+        label: string;
+        icon?: string;
+        command: () => void;
+    }[];
+}
+
+declare class ObjectItemDialogComponent implements OnInit {
+    ref: DynamicDialogRef;
+    config: DynamicDialogConfig;
+    table: TableComponent;
+    columns: any;
+    disableButton: boolean;
+    tableData: never[];
+    hasSelection: boolean;
+    constructor(ref: DynamicDialogRef, config: DynamicDialogConfig);
+    ngOnInit(): void;
+    actions: ActionButton[];
+    onSelectionChanged(selectedItem: any): void;
+    actionClick(key: any): void;
+    tableConfiguration: {
+        lazy: boolean;
+        scrollHeight: string;
+        hasSearch: boolean;
+        hasFilter: boolean;
+        key: string;
+        rows: number;
+        selectionType: tableSelectionType;
+        actions: never[];
+        exportTable: boolean;
+        filterConfiguration: never[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectItemDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectItemDialogComponent, "phoenix-object-item-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class QuickPickComponent {
+    onBack: EventEmitter<void>;
+    onQuickPick: EventEmitter<void>;
+    onForward: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuickPickComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuickPickComponent, "phoenix-quick-pick", never, {}, { "onBack": "onBack"; "onQuickPick": "onQuickPick"; "onForward": "onForward"; }, never, never, true, never>;
+}
+
+interface StatusBarConfig {
+    type?: string;
+    icon?: string;
+    name: string;
+    title: string;
+    description?: {
+        label: string;
+        value: any;
+        icon?: string;
+        type?: StatusColType;
+        dateFormat?: string;
+    }[];
+    attributes?: StatusAttribute[];
+}
+
+declare class StatusBarComponent {
+    statusBarConfig: StatusBarConfig;
+    iconEnable: boolean;
+    enableClosing: boolean;
+    description: boolean;
+    dateFormat: string;
+    onListItemClick: EventEmitter<any>;
+    StatusColType: typeof StatusColType;
+    iconStyle: {
+        height: number;
+        width: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatusBarComponent, "phoenix-status-bar", never, { "statusBarConfig": { "alias": "statusBarConfig"; "required": false; }; "iconEnable": { "alias": "iconEnable"; "required": false; }; "enableClosing": { "alias": "enableClosing"; "required": false; }; "description": { "alias": "description"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; }, { "onListItemClick": "onListItemClick"; }, never, never, true, never>;
+}
+
+declare class QuickPickSidePanelComponent {
+    drawer: Drawer;
+    title: string;
+    data: any[];
+    columns: any[];
+    tableConfiguration: any;
+    widthClass: string;
+    isFullScreen: boolean;
+    private _panelVisible;
+    set panelState(value: boolean);
+    panelStateChange: EventEmitter<boolean>;
+    onRowClick: EventEmitter<any>;
+    lazyLoadData: EventEmitter<void>;
+    handlePanelFullScreen: EventEmitter<void>;
+    drawerVisible: i0.Signal<boolean>;
+    visibleChange(newVal: boolean): void;
+    onDrawerShow(): void;
+    onTableRowClick(row: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuickPickSidePanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuickPickSidePanelComponent, "phoenix-quick-pick-sidepanel", never, { "title": { "alias": "title"; "required": false; }; "data": { "alias": "data"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "tableConfiguration": { "alias": "tableConfiguration"; "required": false; }; "widthClass": { "alias": "widthClass"; "required": false; }; "isFullScreen": { "alias": "isFullScreen"; "required": false; }; "panelState": { "alias": "panelState"; "required": false; }; }, { "panelStateChange": "panelStateChange"; "onRowClick": "onRowClick"; "lazyLoadData": "lazyLoadData"; "handlePanelFullScreen": "handlePanelFullScreen"; }, never, never, true, never>;
+}
+
+type MetaFieldType = 'TEXT' | 'URL' | 'NUMBER' | 'TIMEPERIOD' | 'CURRENCY' | 'TEXT_AREA' | 'SS_OPTION' | 'SS_OPTION_OBJECT_BASED' | 'MS_OPTION' | 'START_DUE_DATE' | 'DATE' | 'TEXT_EDITOR' | 'CHECKBOX' | 'CHECKBOX_COLOR' | 'SWITCH' | 'SELECT_BUTTON' | 'ASSIGN' | 'ASSIGN_ASSET' | 'PASSWORD' | 'COLOR' | 'UPLOAD' | 'UPLOAD_DRAG_DROP' | 'LINKS_DATA' | 'SLOT';
+type MetaOption = {
+    label: string;
+    value: any;
+    disabled?: boolean;
+};
+type MetaValidators = {
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    email?: boolean;
+    regex?: {
+        regexType: string;
+    };
+    phone?: boolean;
+    timeperiod?: boolean;
+    tpMin?: number;
+    dueDate?: boolean;
+};
+interface MetaFieldConfig {
+    id?: string | number;
+    order?: number;
+    hidden?: boolean;
+    userFriendlyMessage: string;
+    configuration: {
+        key: string;
+        type: MetaFieldType;
+        placeholderKey?: string;
+        options?: MetaOption[];
+        extra?: Record<string, any>;
+    };
+    mandatory?: boolean;
+    disable?: boolean;
+    readOnly?: boolean;
+    validators?: MetaValidators;
+    style: {
+        colWidth: string;
+    };
+}
+type AssignExtra = {
+    items: any[];
+    dialogHeaderKey?: string;
+    columns?: Array<{
+        field: string;
+        header: string;
+        columnType: any;
+    }>;
+    dialog?: {
+        width?: string;
+        modal?: boolean;
+    };
+};
+
+type UniqueValidationResponse = {
+    isValid: boolean;
+    control?: string;
+    message?: string;
+};
+interface MetaSubmitValidatorConfig {
+    /**
+     * Which control should receive the error when invalid.
+     * If backend returns {control}, that wins.
+     */
+    controlKey: string;
+    /**
+     * Called ONLY on submit validation.
+     * If returns null/undefined => skip validator (e.g. empty value).
+     */
+    buildRequest: (form: FormGroup) => {
+        url: string;
+        body?: any;
+    } | null;
+    /**
+     * Optional: map raw response to standard format.
+     * Default expects {isValid, control?}.
+     */
+    mapResponse?: (raw: any) => UniqueValidationResponse;
+    /**
+     * Error key to set on the target control.
+     * Default: 'unique'
+     */
+    errorKey?: string;
+}
+
+interface MetaFormGroupConfig {
+    id?: string | number;
+    groupName?: string;
+    collapsed?: boolean;
+    ctrl: MetaFieldConfig[];
+}
+type MetaFormControls = MetaFieldConfig[] | MetaFormGroupConfig[];
+interface MetaFormV2Config {
+    controls: MetaFormControls;
+    initialValues?: any;
+    /**
+     * Submit-only async validators (unique name/title etc).
+     * They DO NOT run on valueChanges, only when parent triggers submit validation.
+     */
+    submitValidators?: MetaSubmitValidatorConfig[];
+    /**
+     * Dependency hook (category -> color, entity -> assignees etc.)
+     * V2 will bind once and clean up on meta change.
+     */
+    setupDependencies?: (ctx: {
+        form: FormGroup;
+        flatControls: MetaFieldConfig[];
+        initialValues: any;
+        getControl: (key: string) => AbstractControl | null;
+        findField: (key: string) => MetaFieldConfig | null;
+    }) => void | (() => void);
+}
+
+type AccordionValue = string | number | string[] | number[] | null | undefined;
+declare class MetaFormV2Component implements OnChanges, OnDestroy {
+    /** Form instance created/owned by the parent (dialog/page) */
+    form: FormGroup;
+    /**
+     * V2 metadata/config:
+     * - controls (grouped or flat)
+     * - initialValues
+     * - submitValidators (run on submit only)
+     * - setupDependencies (optional runtime bindings)
+     */
+    config: MetaFormV2Config;
+    /**
+     * Page-level readOnly state controlled by parent.
+     * Used both for rendering and for "enter edit mode" behavior.
+     */
+    readOnly: boolean;
+    /** Optional layout customization for inner content wrapper */
+    contentStyle: Record<string, any> | null;
+    /** Optional class name(s) applied to inner content wrapper */
+    contentClass: string | null;
+    /** Builds/ensures controls exist (ensures validators & default values are wired) */
+    private fb;
+    /** Registers and executes submit-only validators (async validation on submit) */
+    private submitValidator;
+    /** Used for validator localization (lang-dependent validators / messages) */
+    private translate;
+    /**
+     * A lightweight signature of the current metadata structure.
+     * Used to detect when the form schema changes (and avoid unnecessary resets).
+     */
+    private lastSignature;
+    /**
+     * Cleanup function returned by setupDependencies (if any).
+     * Called only when metadata structure changes or on destroy.
+     */
+    private depCleanup?;
+    /**
+     * PrimeNG Accordion "value" for opened panels.
+     * For multiple panels, PrimeNG expects an array of ids.
+     */
+    expandedGroupIds: string[];
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * PrimeNG Accordion emits value as:
+     * - single id (string/number)
+     * - array of ids
+     * We normalize everything into string[] for stable internal state.
+     */
+    onAccordionValueChange(v: AccordionValue): void;
+    /** Normalizes Accordion value into a stable string[] representation */
+    private normalizeAccordionValue;
+    /** True when metadata contains at least one control definition */
+    get hasControls(): boolean;
+    /**
+     * Heuristic: grouped config has "ctrl" on first element.
+     * (Keeps template simple and avoids extra schema fields.)
+     */
+    get isGrouped(): boolean;
+    /** Returns grouped schema structure (accordion groups) */
+    get groupedControls(): any[];
+    /** Returns flat schema structure (grid mode) */
+    get flatControls(): any[];
+    /** TrackBy for group rendering */
+    groupTrack(g: any, idx: number): any;
+    /**
+     * PrimeNG accordion panel `value` must match accordion `value` type.
+     * We always convert group id to string for consistent behavior.
+     */
+    panelValue(g: any): string;
+    /**
+     * Marks & validates ONLY controls that already have meaningful values.
+     * This is used when switching from readOnly -> edit mode to avoid:
+     * - triggering "required" errors for empty fields
+     * - expanding groups based on empty mandatory fields on CREATE dialogs
+     */
+    private touchAndValidateOnlyFilledControls;
+    /**
+     * Defines what counts as a "meaningful" value:
+     * - non-empty strings
+     * - numbers / booleans
+     * - non-empty arrays
+     * - objects with common identifiers (key/uuid/id) or any own keys
+     */
+    private hasMeaningfulValue;
+    /**
+     * "Visible invalid" means:
+     * - invalid
+     * - AND user has interacted with it (touched or dirty)
+     * This matches typical UI behavior: show errors only after interaction.
+     */
+    private isVisibleInvalid;
+    /**
+     * Checks if a group contains at least one visible invalid control.
+     * Used to auto-expand groups when entering edit mode.
+     */
+    private groupHasVisibleInvalid;
+    /**
+     * Expands all groups that contain visible invalid controls,
+     * while preserving any groups already expanded by the user.
+     */
+    private expandVisibleInvalidGroupsUnion;
+    /** Cleanup dependency subscriptions when component is destroyed */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormV2Component, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaFormV2Component, "phoenix-meta-form-v2", never, { "form": { "alias": "form"; "required": true; }; "config": { "alias": "config"; "required": true; }; "readOnly": { "alias": "readOnly"; "required": false; }; "contentStyle": { "alias": "contentStyle"; "required": false; }; "contentClass": { "alias": "contentClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MetaFormFieldV2Component {
+    /** Metadata definition of the field (type, key, options, styles, flags, etc.) */
+    field: MetaFieldConfig;
+    /** Parent FormGroup that contains the FormControl for this field */
+    form: FormGroup;
+    /**
+     * Page-level read-only flag.
+     * When true, the component renders ReadOnlyInputV2Component instead of editable controls.
+     */
+    readOnly: boolean;
+    /**
+     * Global disable flag (e.g. parent dialog toggles entire form disabled).
+     * This is merged with field-level disable configuration.
+     */
+    disableForm: boolean;
+    /** Used to manually trigger change detection for OnPush strategy */
+    private cdr;
+    /** Used to automatically unsubscribe from value/status streams on destroy */
+    private dr;
+    /** Translation service for validation and display labels */
+    private translate;
+    /**
+     * Exposed enum-like mapping of MetaFieldType for template usage.
+     * Keeps templates readable and avoids magic strings.
+     */
+    readonly MetaFieldType: Readonly<{
+        TEXT: "TEXT";
+        URL: "URL";
+        NUMBER: "NUMBER";
+        TIMEPERIOD: "TIMEPERIOD";
+        CURRENCY: "CURRENCY";
+        TEXT_AREA: "TEXT_AREA";
+        SS_OPTION: "SS_OPTION";
+        SS_OPTION_OBJECT_BASED: "SS_OPTION_OBJECT_BASED";
+        MS_OPTION: "MS_OPTION";
+        START_DUE_DATE: "START_DUE_DATE";
+        DATE: "DATE";
+        TEXT_EDITOR: "TEXT_EDITOR";
+        CHECKBOX: "CHECKBOX";
+        CHECKBOX_COLOR: "CHECKBOX_COLOR";
+        SWITCH: "SWITCH";
+        SELECT_BUTTON: "SELECT_BUTTON";
+        ASSIGN: "ASSIGN";
+        ASSIGN_ASSET: "ASSIGN_ASSET";
+        PASSWORD: "PASSWORD";
+        COLOR: "COLOR";
+        UPLOAD: "UPLOAD";
+        UPLOAD_DRAG_DROP: "UPLOAD_DRAG_DROP";
+        LINKS_DATA: "LINKS_DATA";
+        SLOT: "SLOT";
+    }>;
+    /** Control key resolved from MetaFieldConfig */
+    get key(): string;
+    /** Field type resolved from MetaFieldConfig */
+    get type(): MetaFieldType;
+    /** Column width class for grid layout (falls back to default if not provided) */
+    get colClass(): string;
+    ngOnInit(): void;
+    /** Human-friendly label defined in metadata (already localized key) */
+    userFriendlyMessage(): string | null;
+    /** Optional placeholder i18n key defined in metadata */
+    placeholderKey(): string | null;
+    /**
+     * Resolves final read-only state for this field:
+     * - page-level readOnly OR field-level readOnly
+     */
+    isReadOnly(): boolean;
+    /**
+     * Resolves final disabled state for this field:
+     * - page-level disable OR field-level disable
+     */
+    isDisabled(): boolean;
+    /** Shortcut to underlying FormControl */
+    ctrl(): _angular_forms.AbstractControl<any, any, any> | null;
+    /**
+     * Minimal value formatter for legacy read-only rendering.
+     * Kept intentionally simple to match V1 behavior.
+     */
+    displayValue(): any;
+    /**
+     * Determines whether validation error should be displayed.
+     * Errors are shown only after user interaction (touched or dirty).
+     */
+    showError(): boolean;
+    /**
+     * Maps control error object to a normalized error key.
+     * Supports:
+     * - Angular built-in validators
+     * - Phoenix custom validators
+     * - Submit-only async validators
+     */
+    errorKey(): string | null;
+    /**
+     * Resolves translated error message based on errorKey().
+     * This is the single place responsible for validation message UX.
+     */
+    errorText(): string;
+    /**
+     * Lightweight text formatter for simple read-only display use cases.
+     * This is used mainly for inline displays and summary UIs.
+     */
+    valueText(): string;
+    isCheckbox(): boolean;
+    onDateSelected(val: any): void;
+    onDateCleared(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormFieldV2Component, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaFormFieldV2Component, "phoenix-meta-form-field-v2", never, { "field": { "alias": "field"; "required": true; }; "form": { "alias": "form"; "required": true; }; "readOnly": { "alias": "readOnly"; "required": false; }; "disableForm": { "alias": "disableForm"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MetaFormGroupV2Component {
+    group: MetaFormGroupConfig;
+    form: FormGroup;
+    readOnly: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormGroupV2Component, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaFormGroupV2Component, "phoenix-meta-form-group-v2", never, { "group": { "alias": "group"; "required": true; }; "form": { "alias": "form"; "required": true; }; "readOnly": { "alias": "readOnly"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MetaFormButtonsV2Component {
+    /**
+     * Disabled state for Save button (usually: form invalid or readOnly or loading)
+     */
+    isDisabled: i0.InputSignal<boolean>;
+    /**
+     * Optional feature: "Create another" checkbox.
+     * If false => checkbox is not rendered.
+     */
+    isCreateAnother: i0.InputSignal<boolean>;
+    /**
+     * Loading indicator for Save button.
+     */
+    isLoading: i0.InputSignal<boolean>;
+    /**
+     * Emits when user clicks Save.
+     * Payload matches existing contract: { isAnother: boolean }
+     */
+    handleSave: EventEmitter<{
+        isAnother: boolean;
+    }>;
+    /**
+     * Emits when user clicks Cancel.
+     */
+    handleCancel: EventEmitter<"CANCEL">;
+    /**
+     * Local checkbox model (kept only in this component).
+     */
+    createAnother: boolean;
+    onSaveClick(): void;
+    onCancelClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormButtonsV2Component, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaFormButtonsV2Component, "phoenix-meta-form-buttons-v2", never, { "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "isCreateAnother": { "alias": "isCreateAnother"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; }, { "handleSave": "handleSave"; "handleCancel": "handleCancel"; }, never, never, true, never>;
+}
+
+type MetaAsyncExecutor = (url: string, body?: any) => Observable<any>;
 /**
- * Generated bundle index. Do not edit.
+ * You provide this from app (or phoenix-config) so V2 lib doesn't depend on CrudService directly.
+ * Example impl: (url, body) => this.crud.post(url, body)
  */
-/// <amd-module name="@fuentis/phoenix-ui" />
-export * from './public-api';
+declare const META_FORM_ASYNC_EXECUTOR: InjectionToken<MetaAsyncExecutor>;
+
+declare class MetaSubmitValidatorService {
+    /**
+     * Optional async executor abstraction used to perform server-side validation
+     * (e.g. uniqueness checks).
+     *
+     * If not provided, submit-only validators will be skipped gracefully.
+     */
+    private executor?;
+    /** Used to automatically clean up subscriptions when the service is destroyed */
+    private dr;
+    constructor(
+    /**
+     * Optional async executor abstraction used to perform server-side validation
+     * (e.g. uniqueness checks).
+     *
+     * If not provided, submit-only validators will be skipped gracefully.
+     */
+    executor?: MetaAsyncExecutor | undefined);
+    /**
+     * Registers submit-only validators on the given form.
+     *
+     * - Attaches validator metadata to the form instance (via Symbols)
+     * - Cleans up any previous subscriptions
+     * - Subscribes to valueChanges in order to auto-clear submit-only errors
+     *   when the user modifies the field after a failed submit
+     */
+    register(form: FormGroup, validators: MetaSubmitValidatorConfig[] | null | undefined): void;
+    /**
+     * Executes submit-only validators.
+     *
+     * Flow:
+     * 1) Mark all controls as touched/dirty so sync validation messages become visible
+     * 2) If form is sync-invalid, skip async validation
+     * 3) Clear previous submit-only errors
+     * 4) Execute async validators sequentially
+     * 5) Apply mapped errors back to controls
+     *
+     * Returns:
+     * - true  → form is valid (sync + submit-only async)
+     * - false → at least one submit-only validator failed
+     */
+    run(form: FormGroup): Promise<boolean>;
+    /**
+     * Removes a specific submit-only error from the control without
+     * touching other validation errors.
+     */
+    private removeError;
+    /**
+     * Clears submit-only errors for all controls involved in submit validators.
+     * This does NOT trigger updateValueAndValidity to avoid unnecessary re-validation.
+     */
+    private clearSubmitErrors;
+    /**
+     * Marks all form controls as touched and dirty.
+     * This is used on submit to make validation errors visible to the user.
+     */
+    private markAllTouchedOnSubmit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaSubmitValidatorService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetaSubmitValidatorService>;
+}
+
+export { ActionTypes, ActionsComponent, CardComponent, ContexObjectComponent, ControlType, GroupsFormComponent, InnerHeaderComponent, META_FORM_ASYNC_EXECUTOR, MetaFormButtonsComponent, MetaFormButtonsV2Component, MetaFormComponent, MetaFormFieldV2Component, MetaFormGroupV2Component, MetaFormService, MetaFormV2Component, MetaSubmitValidatorService, ObjectItemDialogComponent, QuickPickComponent, QuickPickSidePanelComponent, SearchBarComponent, ShellComponent, SidebarComponent, SidebarItemComponent, SimpleButtonType, StatusBarComponent, StatusColType, StatusHeaderComponent, StatusTooltipType, TableComponent, TopbarComponent, UserComponent, tableActionType, tableButtonContext, tableButtonFormat, tableColumnType, tableFilterType, tableSelectionType };
+export type { Action, ActionButton, Actions, AllActionValues, AssignExtra, ColumnTypeMap, ConfirmationMode, ContextObjectConfig, ContextObjectTag, InitialSortMeta, MetaAsyncExecutor, MetaFieldConfig, MetaFieldType, MetaFormControls, MetaFormGroupConfig, MetaFormV2Config, MetaOption, MetaSubmitValidatorConfig, MetaValidators, RegisteredActionEnums, Severity, ShellConfig, ShellTheme, SidebarItem, SortMeta, SortOrder, SortRequest, SortResponse, StatusAttribute, StatusBarConfig, StatusTooltipItem, TabAction, TableAction, TableColumn, TableConfiguration, TopbarFooterConfig, TopbarItem, TopbarModuleGroup, TopbarModuleItem, TypingConfirmationConfig, UniqueValidationResponse, UrlConfig, User, cardConfig };