@fuentis/phoenix-ui 0.0.9-alpha.67 → 0.0.9-alpha.671

package/index.d.ts

@@ -1,5 +1,1743 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, ElementRef, OnChanges, SimpleChanges, QueryList, OnDestroy, TemplateRef, 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 { 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;
+    readonly defaultIncidentUrl = "https://fuentis.atlassian.net/servicedesk/customer/portal/1";
+    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;
+    openIncidentReport(): 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;
+        tooltip?: 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 {
+    /** Optional field caption shown as "Label:". Omit for a label-less info line. */
+    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;
+    /** Same-tab in-app navigation for a LINK: when set, the link uses routerLink
+     *  (no target=_blank, no external icon) instead of opening a new tab. */
+    routerLink?: any[] | 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",
+    RANGE = "range"
+}
+
+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;
+    /**
+     * Optional namespace for the persisted state keys (filters/columns), e.g. the
+     * current user id. Scopes state per user so a shared machine does not leak one
+     * user's filters/columns to another. Empty/omitted = unscoped (legacy).
+     */
+    stateKeyPrefix?: 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[];
+    /**
+     * Optional "type switcher" band, rendered as a separate header row ABOVE the
+     * caption (opt-in — present only when set). A rounded pill group that flips
+     * the table between sibling record types (e.g. Business Processes / Resources)
+     * without crowding the caption's own actions, which stay where they always
+     * are. Clicking a pill fires the ordinary `actionClick` carrying that tab
+     * (`type: tableActionType.TAB`); the host swaps the data/config and updates
+     * `activeKey`.
+     */
+    typeSwitch?: TableTypeSwitch;
+    /** 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;
+    /**
+     * Message shown when the table has no rows. An i18n key (translated) or plain
+     * text; falls back to the generic "NO_RESULTS_FOUND" when unset.
+     */
+    emptyMessage?: string;
+    /** 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;
+    /**
+     * Disables all column sorting: no sort icons, no click-to-sort, and no initial
+     * fallback sort — rows render in the exact order they arrive. For lists whose
+     * order is meaningful (config-driven tables that pre-order their own data).
+     */
+    disableSort?: boolean;
+    /**
+     * Fit-to-content height: the table grows to its rows (no fixed viewport height,
+     * no virtual scroll) and only starts scrolling once it exceeds `scrollHeight`,
+     * which acts as a max-height. Best for short config lists that shouldn't leave
+     * a large empty area below the rows.
+     */
+    autoHeight?: boolean;
+    /**
+     * Override virtual scrolling. By default the table virtualises whenever it is
+     * NOT `autoHeight` (fixed/fill height). Set `false` to keep a fixed, scrollable
+     * body WITHOUT virtualisation — required for tables with expandable rows, since
+     * virtual scroll assumes a fixed row height and a variable-height expanded row
+     * breaks its scroll math (scrolling snaps back to the top). Leave undefined for
+     * the default behaviour.
+     */
+    virtualScroll?: boolean;
+    /**
+     * Enables drag-to-reorder rows via a handle column; the table emits
+     * `rowReorder` with the new order. Pair with `autoHeight` (reorder does not
+     * work with virtual scroll) and `disableSort`.
+     */
+    reorderable?: boolean;
+    /**
+     * Fill the available flex height: the table expands to fill its (flex) parent
+     * and the body scrolls internally only when the rows exceed that space — the
+     * page never grows a scrollbar. Needs an unbroken flex-height parent chain.
+     * Mutually exclusive with `autoHeight`; `scrollHeight` is ignored.
+     */
+    fillHeight?: boolean;
+    /**
+     * Row density. Defaults to compact (`small`). Set `false` for taller,
+     * roomier rows (better for lists with wrapping text).
+     */
+    dense?: boolean;
+    /**
+     * Optional per-row inline style, e.g. a danger background for rows that fail a
+     * check. Returns a style object (or null) for each row.
+     */
+    rowStyle?: (row: any) => {
+        [key: string]: string;
+    } | null;
+    /** 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;
+}
+/** Config for the optional {@link TableConfiguration.typeSwitch} band. */
+interface TableTypeSwitch {
+    /** Pills to render, left to right. `badgeCount` shows as a count bubble. */
+    tabs: TabAction[];
+    /** `key` of the currently selected tab. */
+    activeKey: string;
+}
+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 cell HTML renderer. Receives the raw cell value and the row. */
+    customRenderer?: (value: any, rowData?: any) => string;
+    /**
+     * LIST_TAG only: read the badge label from this field of each item (for
+     * arrays of objects). Omit for arrays of primitives.
+     */
+    tagLabel?: string;
+    /**
+     * LIST_TAG only: how many badges to show before collapsing the rest into a
+     * "+N" badge that opens a popover. Omit to show all.
+     */
+    tagMax?: number;
+    /** LIST_TAG only: p-badge severity for the item badges. Default 'warn'. */
+    tagSeverity?: 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;
+    private SORT_KEY;
+    /** When stale filter values are detected, holds the remaining valid values per key. */
+    filterValidValues: Record<string, any[]> | null;
+    /**
+     * 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;
+    /**
+     * Filters passed down to table-caption.
+     * Identical to `filters`, except range filters get their numeric bounds
+     * (min/max) derived from the actual dataset so the slider reflects the
+     * real values present in the table. Explicit min/max in config still win.
+     */
+    computedFilters: any;
+    actionClick: EventEmitter<any>;
+    rowSelection: EventEmitter<any>;
+    checkBoxSelection: EventEmitter<any>;
+    saveColumns: EventEmitter<string[]>;
+    /** Emits the full data array in its new order after a drag reorder. */
+    rowReorder: EventEmitter<any[]>;
+    /**
+     * Optional expandable-row content, projected as
+     * `<ng-template #rowExpansion let-row>…</ng-template>`. When present, a toggler
+     * column is shown and each row can expand to render this template.
+     */
+    rowExpansionTpl?: TemplateRef<any>;
+    /** Host class so `:host(.fill)` can make the table fill its flex parent. */
+    get fillHost(): boolean;
+    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 getValidFilterValues;
+    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;
+    /**
+     * Rebuild `computedFilters` from `filters`, deriving numeric bounds
+     * (min/max) for every range filter from the current dataset.
+     * An explicitly configured min/max always wins over the data-derived value.
+     */
+    private enrichRangeFilters;
+    /**
+     * Min/max numeric bounds for a field across originalData.
+     * Falls back to [0, 100] when no numeric values are present.
+     */
+    private computeDataBounds;
+    /**
+     * 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;
+    /**
+     * Bound to p-table [rowSelectable]: a row whose `canSelect` is false cannot be selected — its
+     * checkbox is disabled and the header "select all" skips it, so bulk actions never include it.
+     */
+    isRowSelectable(event: any): boolean;
+    /**
+     * Some tables allow click on first N columns to open details.
+     */
+    isColumnClickable(columnIndex: number): boolean;
+    /** Labels currently shown in the overflow popover. */
+    overflowTags: string[];
+    /** Badge severity for the overflow popover (matches the column). */
+    overflowSeverity: string;
+    /** Badge label for one list item (string item, or `col.tagLabel` field). */
+    tagLabelOf(item: any, col: any): string;
+    /** The first `tagMax` items (all of them when `tagMax` is unset). */
+    visibleTags(list: any[], col: any): any[];
+    /** How many items are hidden behind the "+N" badge. */
+    tagOverflowCount(list: any[], col: any): number;
+    /** PrimeNG has already reordered `tableData` in place; emit the new order. */
+    onRowReorder(_event: any): void;
+    /** Colspan for the expanded row's single cell — spans every visible column. */
+    get expansionColspan(): number;
+    /** Open the overflow popover with the hidden items' labels. */
+    openTagOverflow(event: Event, panel: any, list: any[], col: any): void;
+    /**
+     * 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"; "rowReorder": "rowReorder"; }, ["rowExpansionTpl"], 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;
+    /** Optional neutral tag shown in the identity line next to name/code
+     *  (e.g. a Resource type or a Recovery-gap category). */
+    tag?: {
+        icon?: string;
+        text?: string;
+        variant?: string;
+        tooltip?: string;
+    };
+    description?: {
+        label: string;
+        value: any;
+        icon?: string;
+        type?: StatusColType;
+        dateFormat?: string;
+        /** Optional info popover for this context line: an ⓘ that opens a list
+         *  (e.g. related-resource names behind a count). */
+        popoverList?: string[];
+        popoverTitle?: 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: i0.InputSignal<string>;
+    data: i0.InputSignal<any[]>;
+    columns: i0.InputSignal<any[]>;
+    tableConfiguration: i0.InputSignal<any>;
+    widthClass: i0.InputSignal<string>;
+    isFullScreen: i0.InputSignal<boolean>;
+    filters: i0.Signal<any[]>;
+    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;
+    createDynamicFilters(data: any[], fields: any[], defaultFilterType?: string): any[];
+    toDisplay(val: any): string;
+    /**
+     * Extracts a displayable value from an object or primitive.
+     * - Prefers object.name, then object.label, object.value, or object.title.
+     * - Falls back to JSON stringification for objects without display fields.
+     * - Returns primitive values as-is.
+     */
+    extractItemNameOrValue(item: any): any;
+    getNestedValue(obj: any, path: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuickPickSidePanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuickPickSidePanelComponent, "phoenix-quick-pick-sidepanel", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "tableConfiguration": { "alias": "tableConfiguration"; "required": false; "isSignal": true; }; "widthClass": { "alias": "widthClass"; "required": false; "isSignal": true; }; "isFullScreen": { "alias": "isFullScreen"; "required": false; "isSignal": true; }; "panelState": { "alias": "panelState"; "required": false; }; }, { "panelStateChange": "panelStateChange"; "onRowClick": "onRowClick"; "lazyLoadData": "lazyLoadData"; "handlePanelFullScreen": "handlePanelFullScreen"; }, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Remove the data-table's persisted UI state (filters, selected columns, sort)
+ * from localStorage. Call this on logout so a user's saved table views do not
+ * carry over into the next login on a shared machine.
+ *
+ * @param userPrefix When the app persists state user-scoped
+ *   (`tableConfiguration.stateKeyPrefix`, e.g. the user id), pass the SAME value
+ *   to clear only that user's state — other users' saved views on this browser
+ *   stay intact. Omit to clear all persisted table state on this browser.
  */
-/// <amd-module name="@fuentis/phoenix-ui" />
-export * from './public-api';
+declare function clearPersistedTableState(userPrefix?: string): void;
+
+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;
+    /**
+     * Per-field validation message overrides, keyed by error type (e.g.
+     * `{ required: 'CONTINUITY.VALIDATION.GAP_TITLE_REQUIRED' }`). The value is an
+     * i18n key (translated) or plain text; when set for the active error it wins
+     * over the generic message.
+     */
+    errorMessages?: Record<string, string>;
+    style: {
+        colWidth: string;
+        /**
+         * When true, this field forces a hard line break: it starts a brand new
+         * grid row regardless of how much space is left in the current row
+         * (i.e. regardless of whether colWidths in the current row sum to 12).
+         * Default (unset/false): fields keep flowing/wrapping into the current
+         * row as space allows (existing behavior).
+         */
+        newRow?: boolean;
+    };
+}
+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;
+/**
+ * V2 form host. Signal-based (OnPush): inputs are `input()` signals, the
+ * template-facing structure (`hasControls`/`isGrouped`/`groupedControls`/
+ * `controlRows`) is `computed()` (so `splitControlsIntoRows` runs only when the
+ * config changes, not on every CD pass), and `expandedGroupIds` is a signal.
+ *
+ * Reactive forms aren't signal-native, so control building stays imperative: the
+ * first build runs synchronously in `ngOnInit` (controls exist before first
+ * paint), and an `effect()` re-runs the same build when `config`/`form`/`readOnly`
+ * change — with the same change-detection semantics the old `ngOnChanges` had.
+ */
+declare class MetaFormV2Component implements OnInit, OnDestroy {
+    /** Form instance created/owned by the parent (dialog/page). */
+    readonly form: i0.InputSignal<FormGroup<any>>;
+    /** V2 metadata/config (controls, initialValues, submitValidators, setupDependencies). */
+    readonly config: i0.InputSignal<MetaFormV2Config>;
+    /** Page-level readOnly state (rendering + "enter edit mode" behavior). */
+    readonly readOnly: i0.InputSignal<boolean>;
+    /** Optional layout customization for the inner content wrapper. */
+    readonly contentStyle: i0.InputSignal<Record<string, any> | null>;
+    /** Optional class name(s) for the inner content wrapper. */
+    readonly contentClass: i0.InputSignal<string | null>;
+    private fb;
+    private submitValidator;
+    private translate;
+    /** Signature of the current schema (key+type only) to detect real schema changes. */
+    private lastSignature;
+    /** Cleanup from setupDependencies; called on schema change or destroy. */
+    private depCleanup?;
+    /** Previous input references, to reproduce the old SimpleChanges semantics. */
+    private prevConfig;
+    private prevForm;
+    private prevReadOnly;
+    private initialized;
+    /** PrimeNG Accordion opened-panel ids. */
+    readonly expandedGroupIds: i0.WritableSignal<string[]>;
+    readonly hasControls: i0.Signal<boolean>;
+    /** Heuristic: grouped config has "ctrl" on the first element. */
+    readonly isGrouped: i0.Signal<boolean>;
+    readonly groupedControls: i0.Signal<any[]>;
+    readonly flatControls: i0.Signal<any[]>;
+    /** Flat schema split into rows, honoring `style.newRow` hard breaks. */
+    readonly controlRows: i0.Signal<any[][]>;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Ensures controls, patches initial values, wires validators/dependencies and
+     * initializes accordion state — only when config/form/readOnly actually change
+     * (same early-exit the old ngOnChanges had).
+     */
+    private rebuild;
+    /** Normalizes PrimeNG Accordion value into a stable string[]. */
+    onAccordionValueChange(v: AccordionValue): void;
+    private normalizeAccordionValue;
+    /** TrackBy for group rendering. */
+    groupTrack(g: any, idx: number): any;
+    /** Group id as a string (matches the accordion `value` type). */
+    panelValue(g: any): string;
+    /** Marks & validates ONLY controls that already have meaningful values. */
+    private touchAndValidateOnlyFilledControls;
+    /** What counts as a "meaningful" value (non-empty string/number/boolean/array/object). */
+    private hasMeaningfulValue;
+    /** "Visible invalid" = invalid AND interacted with (touched/dirty). */
+    private isVisibleInvalid;
+    private groupHasVisibleInvalid;
+    /** Expands groups with visible-invalid controls, preserving user-expanded ones. */
+    private expandVisibleInvalidGroupsUnion;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormV2Component, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaFormV2Component, "phoenix-meta-form-v2", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "contentStyle": { "alias": "contentStyle"; "required": false; "isSignal": true; }; "contentClass": { "alias": "contentClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders one meta field. Signal-based (OnPush): every template-facing value is a
+ * `computed()` so it is memoized and recomputed only when its inputs actually
+ * change — instead of a plain method re-running on every change-detection pass.
+ * Control state (value/status) is bridged into a signal (`controlTick`), so the
+ * error helpers stay reactive without a manual `markForCheck()`.
+ */
+declare class MetaFormFieldV2Component {
+    /** Metadata definition of the field (type, key, options, styles, flags, etc.) */
+    readonly field: i0.InputSignal<MetaFieldConfig>;
+    /** Parent FormGroup that contains the FormControl for this field. */
+    readonly form: i0.InputSignal<FormGroup<any>>;
+    /** Page-level read-only flag (renders the read-only view). */
+    readonly readOnly: i0.InputSignal<boolean>;
+    /** Global disable flag (merged with the field-level disable config). */
+    readonly disableForm: i0.InputSignal<boolean>;
+    private translate;
+    /** Enum-like map for the template `@switch`. */
+    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";
+    }>;
+    readonly key: i0.Signal<string>;
+    readonly type: i0.Signal<MetaFieldType>;
+    readonly colClass: i0.Signal<string>;
+    readonly userFriendlyMessage: i0.Signal<string | null>;
+    readonly placeholderKey: i0.Signal<string | null>;
+    readonly isReadOnly: i0.Signal<boolean>;
+    readonly isDisabled: i0.Signal<boolean>;
+    readonly isCheckbox: i0.Signal<boolean>;
+    /** The underlying FormControl for this field (recomputed if form/key change). */
+    readonly ctrl: i0.Signal<AbstractControl<any, any, any> | null>;
+    /**
+     * Bridge the current control's value/status stream into a signal so the error
+     * helpers below recompute reactively (reactive forms aren't signal-native yet).
+     * Re-subscribes when the control identity changes.
+     */
+    private readonly controlTick;
+    /** Bumped for silent (emitEvent:false) programmatic writes, e.g. the date field. */
+    private readonly manualTick;
+    /** Track the active language so translated error text refreshes on lang change. */
+    private readonly lang;
+    /** Show validation only after interaction (touched/dirty). */
+    readonly showError: i0.Signal<boolean>;
+    /** Normalized error key for the current control. */
+    readonly errorKey: i0.Signal<string | null>;
+    /** Translated validation message (the single place that owns error UX text). */
+    readonly errorText: i0.Signal<string>;
+    /** Minimal value formatter for legacy read-only rendering (not used in template). */
+    displayValue(): any;
+    /** Lightweight text formatter for simple read-only/summary display. */
+    valueText(): string;
+    onDateSelected(val: any): void;
+    onDateCleared(): void;
+    /**
+     * Re-anchor the (body-appended) datepicker overlay to its input in viewport
+     * space. PrimeNG positions the body overlay with the page scroll added, so on
+     * a scrolled page — e.g. a modal opened after scrolling down — the panel drops
+     * by roughly the scroll amount. Pinning it `fixed` at the input's viewport
+     * rect keeps it correct regardless of scroll, and flips it up when there is
+     * not enough room below.
+     */
+    onDateShow(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaFormFieldV2Component, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaFormFieldV2Component, "phoenix-meta-form-field-v2", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "disableForm": { "alias": "disableForm"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MetaFormGroupV2Component {
+    group: MetaFormGroupConfig;
+    form: FormGroup;
+    readOnly: boolean;
+    /** Group's fields split into row chunks, honoring `style.newRow` hard breaks. */
+    get rows(): any[][];
+    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>;
+/**
+ * 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)
+ */
+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, clearPersistedTableState, 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, TableTypeSwitch, TopbarFooterConfig, TopbarItem, TopbarModuleGroup, TopbarModuleItem, TypingConfirmationConfig, UniqueValidationResponse, UrlConfig, User, cardConfig };