@verisoft/ui-core 20.1.0 → 20.1.2

package/index.d.ts

@@ -0,0 +1,1126 @@
+import * as i0 from '@angular/core';
+import { SimpleChanges, EventEmitter, QueryList, InjectionToken, OnInit, OnChanges, OnDestroy, AfterViewInit, ChangeDetectorRef, ViewChild, InputSignal, Type, TemplateRef, Signal, PipeTransform } from '@angular/core';
+import * as _verisoft_core from '@verisoft/core';
+import { FilterEvent, LazyLoadEvent, RequestParams, DatasourceType, Sort, SortDirectionType } from '@verisoft/core';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, Subject } from 'rxjs';
+import { NgControl, ControlValueAccessor, FormControl, FormGroup, ValidatorFn, AbstractControl, ValidationErrors } from '@angular/forms';
+import { CanDeactivate, ActivatedRoute, Router, Params } from '@angular/router';
+import { Store } from '@ngrx/store';
+import { SafeHtml } from '@angular/platform-browser';
+
+declare function setComponentProperties<TComponent>(component: TComponent, value: Partial<TComponent>, firstChange?: boolean): void;
+
+declare enum ControlSeverity {
+    success = "success",
+    info = "info",
+    warning = "warning",
+    danger = "danger",
+    help = "help",
+    primary = "primary",
+    secondary = "secondary",
+    contrast = "contrast"
+}
+declare enum GovControlSeverity {
+    primary = "primary",
+    secondary = "secondary",
+    neutral = "neutral",
+    error = "error",
+    success = "success",
+    warning = "warning"
+}
+declare enum GovButtonType {
+    solid = "solid",
+    outlined = "outlined",
+    base = "base",
+    link = "link"
+}
+declare enum IconPosition {
+    left = "left",
+    right = "right"
+}
+declare enum SlotPosition {
+    top = "top",
+    bottom = "bottom"
+}
+declare enum Position {
+    top = "top",
+    bottom = "bottom",
+    left = "left",
+    right = "right"
+}
+declare enum FieldSize {
+    small = "small",
+    medium = "medium",
+    large = "large",
+    xl = "xl"
+}
+declare enum FieldAlign {
+    left = "left",
+    center = "center",
+    right = "right"
+}
+declare enum FieldType {
+    text = "text",
+    number = "number",
+    password = "password",
+    search = "search",
+    date = "date"
+}
+declare enum LayoutType {
+    horizontal = "horizontal",
+    vertical = "vertical"
+}
+type ControlSeverityType = keyof typeof ControlSeverity;
+type GovControlSeverityType = keyof typeof GovControlSeverity;
+type GovButtonTypeType = keyof typeof GovButtonType;
+type IconPositionType = keyof typeof IconPosition;
+type SlotPositionType = keyof typeof SlotPosition;
+type PositionType = keyof typeof Position;
+type FieldSizeType = keyof typeof FieldSize;
+type FieldAlignType = keyof typeof FieldAlign;
+type FieldTypeType = keyof typeof FieldType;
+type LayoutTypeType = keyof typeof LayoutType;
+
+declare const DEFAULT_DEBOUNCE_TIME = 300;
+declare const DEFAULT_PAGINATION: number[];
+declare const MAX_COLUMN_CHAR_COUNT = 30;
+
+interface DataSourceComponentModel<TEntity> {
+    ngOnChanges?: (changes: SimpleChanges) => void;
+    lazy: boolean;
+    loading: boolean;
+    filter: boolean;
+    options: TEntity[] | undefined;
+    optionValue: string | undefined;
+    optionLabel: string | undefined;
+    showed: EventEmitter<any>;
+    cleared: EventEmitter<any>;
+    filtered: EventEmitter<FilterEvent>;
+    lazyLoad: EventEmitter<LazyLoadEvent>;
+}
+declare function setDataToArray<T>(targetArray: (T | undefined)[] | undefined, data: T[], offset?: number, total?: number | undefined, defaultItem?: T | undefined): (T | undefined)[];
+type ExtendedRequestType<T> = RequestParams<T> & {
+    useNewData: boolean;
+};
+
+declare function isFilterEmpty<T>(filter: Partial<T> | undefined): boolean;
+
+interface NotificableProperty {
+    propertyChanged: Observable<unknown>;
+}
+
+declare function queryListChanged<TEntity>(list: QueryList<TEntity>): rxjs.Observable<TEntity[]>;
+
+interface CommonIcons {
+    add: string;
+    minus: string;
+    delete: string;
+    filter: string;
+    download: string;
+    save: string;
+    print: string;
+    edit: string;
+    settings: string;
+    house: string;
+    calendar: string;
+    chevronRight: string;
+    chevronLeft: string;
+    chevronDown: string;
+    chevronUp: string;
+    checkbox: string;
+    warning: string;
+    search: string;
+    action: string;
+    user: string;
+    logout: string;
+    crossCircle: string;
+    infoCircle: string;
+    cross: string;
+    arrowLeft: string;
+    arrowRight: string;
+    questionCircle: string;
+    checkCircle: string;
+    sitemap: string;
+    check: string;
+    envelope: string;
+    loader: string;
+}
+
+declare function downloadText(filename: string, text: string, mimeType?: string | undefined): void;
+declare function downloadFile(filename: string, blob: Blob): void;
+
+interface PreventUnsavedChangesCore {
+    canDeactivate: () => Observable<boolean> | Promise<boolean> | boolean;
+}
+
+interface ActionButton extends NotificableProperty {
+    disabled: boolean;
+    toolTip?: string;
+    id?: string;
+    icon?: string;
+    outlined: boolean;
+    raised: boolean;
+    severity?: ControlSeverityType;
+    label?: string;
+    size?: FieldSizeType;
+    click: EventEmitter<MouseEvent>;
+}
+
+declare const ACTION_BUTTON_GROUP_COMPONENT_TOKEN: InjectionToken<ActionButtonGroupCore>;
+interface ActionButtonGroupCore {
+    maxItems: number;
+    maxItemsMobile: number;
+    items: ActionButton[];
+    menuIconPos: IconPositionType;
+    menuIcon: string;
+    label?: string;
+}
+
+declare abstract class BaseInputControls<T> {
+    value?: T | null;
+    readonly ngControl?: NgControl;
+    readonly label?: string;
+    readonly required: boolean;
+}
+
+declare class BaseFormInputComponent implements BaseInputControls<any>, ControlValueAccessor, OnInit {
+    private readonly control;
+    readonly ngControl?: NgControl;
+    readonly errorService: _verisoft_core.ErrorProvider;
+    formControl: FormControl;
+    constructor(control: NgControl);
+    label?: string;
+    required: boolean;
+    readonly: boolean;
+    disabled: boolean;
+    tooltip: string;
+    formDisplay: 'flex' | 'block';
+    clearable: boolean;
+    placeholder?: string;
+    testId?: string;
+    inputId: string;
+    selectionChanged: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    ngOnInit(): void;
+    isRequired(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFormInputComponent, "ng-component", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "formDisplay": { "alias": "formDisplay"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "testId": { "alias": "testId"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ScreenSizeService {
+    isMobileBlock: BehaviorSubject<boolean>;
+    prevState: boolean;
+    constructor();
+    checkScreenSize(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenSizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenSizeService>;
+}
+
+declare class DialogService {
+    showEvent: EventEmitter<ExtendedDialogData>;
+    closeEvent: EventEmitter<null>;
+    showDialog<TInputs, TOutputs>(data: ExtendedDialogData<TInputs, TOutputs>): void;
+    private mapInputAndOutpus;
+    closeModal(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}
+
+declare class PreventUnsavedChangesDirective implements CanDeactivate<PreventUnsavedChangesCore> {
+    private dialogService;
+    private translateService;
+    private readonly Icons;
+    canDeactivate(component: PreventUnsavedChangesCore): Observable<boolean> | Promise<boolean> | boolean;
+    showConfirmationDialog(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventUnsavedChangesDirective, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PreventUnsavedChangesDirective>;
+}
+
+declare class TableService {
+    readonly reload: i0.WritableSignal<symbol | TableSignal>;
+    /**
+     * If name is set, reload a specific table with the set`[tableName]`
+     *
+     * If name is NOT set, reload all tables in the current DOM
+     * */
+    forceReload(name?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableService>;
+}
+
+interface BaseFormCore {
+    label?: string;
+    required: boolean;
+    readonly: boolean;
+    tooltip: string;
+    formDisplay: 'flex' | 'block';
+    clearable: boolean;
+    placeholder?: string;
+    testId?: string;
+}
+interface BaseFormDirectiveCore<T> {
+    initialData: T | any;
+}
+interface FormState {
+    dirty: boolean;
+    valid: boolean;
+}
+declare function isFormStateEqual(current: FormState, other: FormState): boolean;
+
+declare abstract class BaseFormDirective<T extends object> implements OnInit, OnChanges, OnDestroy, AfterViewInit, PreventUnsavedChangesCore {
+    data: T | any;
+    dataChange: EventEmitter<T>;
+    statusChange: EventEmitter<FormState>;
+    formSubmit: EventEmitter<T>;
+    formClear: EventEmitter<void>;
+    formDestroyed$: Subject<void>;
+    keys: {
+        key: string;
+        alias?: string;
+        type?: string;
+        readOnly: string;
+    }[];
+    formGroup: FormGroup;
+    cd: ChangeDetectorRef;
+    valueInitialization: boolean;
+    lastState: FormState;
+    guardViewChild: ViewChild;
+    formSubmitted: boolean;
+    protected guard: PreventUnsavedChangesDirective;
+    unloadHandler(event: BeforeUnloadEvent): void;
+    canDeactivate(): Observable<boolean> | Promise<boolean> | boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    abstract createFormGroup(): FormGroup;
+    createCompleteData(): T;
+    submit(): void;
+    clear(): void;
+    private initializeFormGroup;
+    private initValueChanges;
+    private initStatusChanges;
+    private createAndEmitIfFormStateChanged;
+    protected applyChanges(data: T, changes: Partial<T>): T;
+    protected toModel(data: T): Partial<T>;
+    protected fromModel(data: T): T;
+    private recursiveObjectAttributesTransformation;
+    private recursiveObjectAttributesTraversal;
+    private transformEmptyStringToNullStringFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFormDirective<any>, "[v-baseForm]", never, { "data": { "alias": "data"; "required": false; }; }, { "dataChange": "dataChange"; "statusChange": "statusChange"; "formSubmit": "formSubmit"; "formClear": "formClear"; }, never, never, true, never>;
+}
+
+declare abstract class UnsubscribeComponent implements OnDestroy {
+    destroyed$: Subject<void>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnsubscribeComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UnsubscribeComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class DetailStoreDirective extends UnsubscribeComponent implements OnInit, AfterViewInit, OnDestroy {
+    form: BaseFormDirective<any>;
+    detailsRepository: string;
+    autoBind: boolean;
+    detailId: string | number | undefined;
+    ngrxFeatureKey: string;
+    destroyForm: boolean;
+    readonly: boolean;
+    readonlyControlNames: string[];
+    store: Store<any>;
+    cdr: ChangeDetectorRef;
+    route: ActivatedRoute;
+    private itemCache;
+    private loaded;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private initForm;
+    private listenFormState;
+    private listenFormChange;
+    private listenFormStatusChange;
+    private handleValidation;
+    private handleBackendValidation;
+    private dispatchErrors;
+    private normalizePropertyNames;
+    private isStateChanged;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DetailStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DetailStoreDirective, "[v-useDetailStore]", ["useDetailStore"], { "form": { "alias": "form"; "required": true; }; "detailsRepository": { "alias": "detailsRepository"; "required": true; }; "autoBind": { "alias": "autoBind"; "required": false; }; "detailId": { "alias": "detailId"; "required": false; }; "ngrxFeatureKey": { "alias": "ngrxFeatureKey"; "required": true; }; "destroyForm": { "alias": "destroyForm"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "readonlyControlNames": { "alias": "readonlyControlNames"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const MENU_TOKEN: InjectionToken<MenuItem[]>;
+declare const LOGO_ROUTER_ROUTE: InjectionToken<string>;
+declare const SIDE_MENU_COMPONENT_TOKEN: InjectionToken<SideMenuCore>;
+declare const SIDE_MENU_STATE_TOKEN: InjectionToken<SideMenuState>;
+interface SideMenuState {
+    expanded: string[];
+    minimalized: boolean;
+}
+interface MenuItem {
+    id?: string;
+    label?: string | undefined;
+    icon?: string;
+    expanded?: boolean;
+    data?: MenuItemData;
+    tooltip?: string;
+    url?: string;
+    visible?: boolean | Observable<boolean>;
+    type?: string;
+    children?: MenuItem[];
+    routerLink?: any;
+    class?: string;
+    command?: Function;
+}
+type ExtendableType = {
+    [key: string]: string | number | boolean | string[] | number[] | boolean[] | undefined;
+};
+interface MenuItemData extends ExtendableType {
+    roles?: string[];
+    permissions?: string[];
+}
+interface SideMenuModuleConfig {
+    items?: MenuItem[];
+}
+interface SideMenuCore {
+    items: MenuItem[];
+    logoUrl: string;
+    userName: string;
+    userRole: any | any[] | undefined;
+}
+
+declare class SideMenuService {
+    private _menuItems;
+    private stateToken;
+    menuItems$: Observable<MenuItem[]>;
+    menuMinimalized: boolean;
+    setMenu(items: MenuItem[]): void;
+    saveMinimalizedState(minimalized: boolean): void;
+    saveExpandedState(item: MenuItem): void;
+    private resetSidemenuState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SideMenuService>;
+}
+
+declare class SideMenuProviderService {
+    readonly menu: MenuItem[];
+    readonly menuService: SideMenuService;
+    constructor(menu: MenuItem[] | undefined, menuService: SideMenuService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideMenuProviderService, [{ optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SideMenuProviderService>;
+}
+
+declare class MenuServiceDirective extends UnsubscribeComponent implements AfterViewInit {
+    private readonly menuService;
+    private readonly cdr;
+    private readonly sideMenu;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuServiceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuServiceDirective, "v-side-menu[useMenuService]", ["useMenuService"], {}, {}, never, never, true, never>;
+}
+
+declare const BREADCRUMB_COMPONENT_TOKEN: InjectionToken<BreadcrumbCore>;
+interface BreadcrumbCore {
+    items: MenuItem[];
+    homeRoute: string;
+    useHomeRoute: boolean;
+}
+interface Breadcrumb {
+    label: string;
+    routerLink?: string;
+    url?: string;
+    active?: boolean;
+    activatedRoute?: ActivatedRoute;
+}
+
+declare class BreadcrumbService {
+    routeChange: EventEmitter<Breadcrumb>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
+}
+
+declare class BreadcrumbCoreComponent extends UnsubscribeComponent implements BreadcrumbCore, OnInit {
+    items: MenuItem[];
+    homeRoute: string;
+    useHomeRoute: boolean;
+    static readonly ROUTE_DATA_BREADCRUMB = "breadcrumb";
+    static readonly ROUTE_DATA_BREADCRUMB_URL = "breadcrumb_url";
+    static readonly ROUTE_DATA_NO_BREADCRUMB_ROUTE = "breadcrumb_no_route";
+    static readonly BREADCRUMB_HIDE = "breadcrumb_hide";
+    readonly home: {
+        icon: string;
+        routerLink: string;
+    };
+    router: Router;
+    activatedRoute: ActivatedRoute;
+    breadcrumbService: BreadcrumbService;
+    cdr: ChangeDetectorRef;
+    ngOnInit(): void;
+    private initBreadcrumbsCreation;
+    private initRouteChangeListen;
+    private createBreadcrumbs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbCoreComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbCoreComponent, never, never, { "items": { "alias": "items"; "required": false; }; "homeRoute": { "alias": "homeRoute"; "required": false; }; "useHomeRoute": { "alias": "useHomeRoute"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const BUTTON_COMPONENT_TOKEN: InjectionToken<ButtonCore>;
+interface ButtonCore {
+    label?: string;
+    icon?: string;
+    badge?: string;
+    iconPos: IconPositionType;
+    rounded: boolean;
+    outlined: boolean;
+    raised: boolean;
+    severity?: ControlSeverityType;
+    routerLink: any[];
+    size: FieldSizeType | undefined;
+    queryParams?: Params;
+}
+
+declare const DROPDOWN_BUTTON_COMPONENT_TOKEN: InjectionToken<DropdownButtonCore>;
+interface DropdownButtonCore {
+    label: InputSignal<string | undefined>;
+    icon: InputSignal<string | undefined>;
+    rounded: InputSignal<boolean | undefined>;
+    outlined: InputSignal<boolean | undefined>;
+    raised: InputSignal<boolean | undefined>;
+    severity: InputSignal<ControlSeverityType | undefined>;
+    size: InputSignal<FieldSizeType | undefined>;
+    items: InputSignal<MenuItem[] | undefined>;
+}
+
+declare const CALENDAR_COMPONENT_TOKEN: InjectionToken<CalendarCore>;
+interface CalendarCore extends BaseFormCore {
+    maxDate: Date;
+    icon: string;
+    minDate: Date;
+    header: string;
+    footer: string;
+    floatLabel: string | undefined;
+    selectionMode: "single" | "multiple" | "range" | undefined;
+}
+
+declare const CHECKBOX_COMPONENT_TOKEN: InjectionToken<CheckboxCore>;
+interface CheckboxCore extends BaseFormCore {
+    indeterminate: InputSignal<boolean>;
+}
+
+declare const CONFIRM_DIALOG_COMPONENT_TOKEN: InjectionToken<object>;
+type ConfirmDialogCore = object;
+interface DialogData {
+    title?: string;
+    headerIcon?: string;
+    severity?: ControlSeverityType;
+    showCancelButton?: boolean;
+    buttonOrder?: 'confirm-cancel' | 'cancel-confirm';
+    confirmButtonText?: string;
+    confirmButtonFn?: () => void;
+    cancelButtonFn?: () => void;
+    cancelButtonText?: string;
+    innerHTML?: string | SafeHtml;
+    data?: unknown;
+    componentType?: Type<unknown>;
+    closable?: boolean;
+    width?: string;
+    height?: string;
+}
+interface ExtendedDialogData<TInputs = any, TOutputs = any> extends DialogData {
+    data?: TInputs & TOutputs;
+}
+
+declare const DROPDOWN_COMPONENT_TOKEN: InjectionToken<DropdownCore<any>>;
+interface DropdownCore<T> extends DataSourceComponentModel<T>, BaseFormCore {
+    dropdownIcon?: string;
+    floatLabel?: string;
+    editable: boolean;
+    forceMinWidth: boolean;
+    showFilter: boolean;
+    localSearch: boolean;
+}
+
+type ExtendedComponent<TComponent> = Partial<TComponent> & {
+    [key: string]: (value: any) => void;
+};
+
+interface GenericFieldDefinition {
+    validator?: ValidatorFn[];
+    type?: GenericFieldTypeType;
+    label?: string;
+    floatLabel?: boolean;
+    name: string;
+    optionLabel?: string;
+    optionValue?: string;
+    options?: unknown[];
+    value?: unknown;
+    testId?: string;
+    size?: FieldSizeType;
+    readonly?: boolean;
+    datasource?: DatasourceType<any>;
+    filterField?: string;
+    showFilter?: boolean;
+    localSearch?: boolean;
+}
+declare enum GenericFieldType {
+    'dropdown' = "dropdown",
+    'checkbox' = "checkbox",
+    'simplecheckbox' = "simplecheckbox",
+    'calendar' = "calendar",
+    'multiselect' = "multiselect",
+    'text' = "text"
+}
+type GenericFieldTypeType = keyof typeof GenericFieldType;
+
+declare const FILTER_COMPONENT_TOKEN: InjectionToken<FilterCore>;
+interface FilterCore extends ControlValueAccessor {
+    fields: GenericFieldDefinition[];
+    title?: string;
+    fulltextFieldName: string;
+    showFulltext: boolean;
+    showFilters: boolean;
+    autoBind: boolean;
+    debounceTime?: number;
+}
+
+declare const FORM_FIELD_COMPONENT_TOKEN: InjectionToken<FormFieldCore>;
+interface FormFieldCore {
+    ngControl?: NgControl;
+    label?: string;
+    tooltip?: string;
+    required: boolean;
+    testId?: string;
+    display: 'flex' | 'block';
+}
+
+declare const GENERIC_FIELD_COMPONENT_TOKEN: InjectionToken<GenericFieldCore<any>>;
+interface GenericFieldCore<T> extends DataSourceComponentModel<T>, BaseFormCore {
+}
+
+declare const HEADER_COMPONENT_TOKEN: InjectionToken<HeaderCore>;
+declare const SETTINGS_MENU: InjectionToken<MenuItem[]>;
+interface HeaderCore {
+    title: string;
+    userName: string;
+    logoUrl: string;
+    userRole: any | any[] | undefined;
+    menuRef: HTMLDivElement;
+}
+
+declare const INPUT_GROUP_COMPONENT_TOKEN: InjectionToken<InputGroupCore>;
+interface InputGroupItem {
+    icon?: string;
+    text?: string;
+    position: IconPositionType;
+}
+interface InputGroupCore extends BaseFormCore {
+    items: InputGroupItem[];
+}
+
+declare const LOADER_COMPONENT_TOKEN: InjectionToken<object>;
+type LoaderCore = object;
+
+declare const MULTISELECT_COMPONENT_TOKEN: InjectionToken<MultiselectCore<any>>;
+interface MultiselectCore<T> extends DataSourceComponentModel<T>, BaseFormCore {
+    dropdownIcon?: string;
+    floatLabel?: string;
+    editable: boolean;
+}
+
+declare const NUMBER_INPUT_COMPONENT_TOKEN: InjectionToken<NumberInputCore>;
+interface NumberInputCore extends BaseFormCore {
+    mode: string;
+    currency: string;
+    min: number;
+    max: number;
+    step: number;
+}
+
+declare const PAGE_HEADER_COMPONENT_TOKEN: InjectionToken<PageHeaderCore>;
+interface PageHeaderCore {
+    title: string;
+    subtitle: string | undefined;
+    showBackButton: boolean | undefined;
+}
+
+declare class PageHeaderService {
+    pageHeader: EventEmitter<PageHeaderCore>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageHeaderService>;
+}
+
+declare class PageHeaderCoreComponent extends UnsubscribeComponent implements OnInit {
+    readonly router: Router;
+    readonly cdr: ChangeDetectorRef;
+    readonly headerService: PageHeaderService;
+    title: string;
+    subtitle: string | undefined;
+    showBackButton: boolean;
+    size: FieldSizeType;
+    constructor(router: Router, cdr: ChangeDetectorRef, headerService: PageHeaderService);
+    ngOnInit(): void;
+    protected locationBack(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderCoreComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageHeaderCoreComponent, never, never, { "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "showBackButton": { "alias": "showBackButton"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const PASSWORD_COMPONENT_TOKEN: InjectionToken<PasswordCore>;
+declare enum PasswordStrength {
+    None = 0,
+    Low = 1,
+    Medium = 2,
+    High = 3,
+    Superb = 4
+}
+interface PasswordCore extends BaseFormCore {
+    toggleMask: boolean;
+    feedback: boolean;
+}
+interface PasswordValidationItem {
+    severity: 'success' | 'error';
+    validationLabel: string;
+    validationFn: (x: string) => boolean;
+}
+
+declare const RADIOBUTTON_COMPONENT_TOKEN: InjectionToken<RadiobuttonCore<any>>;
+interface RadioButtonItem<T> {
+    id: string;
+    value: T;
+}
+interface RadiobuttonCore<T> extends BaseFormCore {
+    radioGroupName: string;
+    items: RadioButtonItem<T>[];
+}
+
+declare const SECTION_COMPONENT_TOKEN: InjectionToken<SectionCore>;
+interface SectionCore {
+    title: string;
+    showContent: boolean;
+    backgroundColor: string;
+}
+
+declare const SLIDER_COMPONENT_TOKEN: InjectionToken<SliderCore>;
+interface SliderCore extends BaseFormCore {
+    step: number;
+    min: number;
+    max: number;
+    range: boolean;
+}
+
+declare const SNACKBAR_COMPONENT_TOKEN: InjectionToken<object>;
+type SnackbarCore = object;
+
+declare const STEPPER_COMPONENT_TOKEN: InjectionToken<StepperCore>;
+interface StepperItem {
+    header: string;
+    template?: TemplateRef<any>;
+    annotation?: string;
+    prefix?: string;
+}
+interface StepperCore {
+    items: StepperItem[];
+    layout: LayoutTypeType;
+    activeIndexChange: EventEmitter<number>;
+    size: FieldSizeType | undefined;
+    icon: string;
+    prefix: string;
+    annotation: string;
+    label: string;
+}
+
+declare const SWITCH_COMPONENT_TOKEN: InjectionToken<BaseFormCore>;
+type SwitchCore = BaseFormCore;
+
+declare const TAB_VIEW_COMPONENT_TOKEN: InjectionToken<TabViewCore>;
+interface TabViewItemCore {
+    title: string;
+    url?: string;
+    icon?: string;
+    disabled?: boolean;
+    content?: string;
+    contentTemplate?: TemplateRef<unknown>;
+}
+interface TabViewCore {
+    items: TabViewItemCore[];
+    useRouting: boolean;
+    activeIndex: number;
+    activeIndexChange: EventEmitter<number>;
+    url?: string;
+}
+
+declare const TABLE_COMPONENT_TOKEN: InjectionToken<TableCore<any>>;
+declare const TABLE_COLUMN_PROVIDER: InjectionToken<unknown>;
+declare enum TableSelectionMode {
+    single = "single",
+    multiple = "multiple"
+}
+declare enum TableButtonSeverity {
+    success = "success",
+    info = "info",
+    warning = "warning",
+    danger = "danger",
+    help = "help",
+    primary = "primary",
+    secondary = "secondary",
+    contrast = "contrast"
+}
+declare enum ColumnVisibility {
+    visible = "visible",
+    hidden = "hidden",
+    default = "default"
+}
+type TableSelectionModeType = keyof typeof TableSelectionMode;
+type TableButtonSeverityType = keyof typeof TableButtonSeverity;
+type ColumnVisibilityType = keyof typeof ColumnVisibility;
+interface TableCore<T> {
+    sorters: Sort[];
+    columns: ColumnDefinition<T>[];
+    data: T[];
+    total: number;
+    filter: Partial<T> | undefined;
+    loading: boolean;
+    scrollable: boolean;
+    pageSize: number;
+    currentPage: number;
+    showPaginator: boolean;
+    sortMultiple: boolean;
+    lazy: boolean;
+    selection: T[];
+    selectionMode: TableSelectionModeType | undefined;
+    showPageSizePicker: boolean;
+    entityKey: string | undefined;
+    selectionChange: EventEmitter<T[]>;
+    lazyLoad: EventEmitter<LazyLoadEvent>;
+    maximumColumnLength: number;
+    disableCustomClicks: boolean;
+}
+interface TableSignal {
+    name: string;
+    symbol: symbol;
+}
+interface ActionColumnsDefinition<T> {
+    severity?: TableButtonSeverity;
+    title?: string;
+    icon?: string;
+    tooltip?: string;
+    rounded?: boolean;
+    outlined?: boolean;
+    raised?: boolean;
+    badge?: string;
+    visible?: (row: T) => boolean;
+    routerLink?: (row: T) => string;
+    queryParams?: Params;
+    disabled?: boolean | ((row: T) => boolean);
+    onClick?: (row: T, event?: MouseEvent) => void;
+}
+interface ColumnProvider<T> {
+    getDefinition(): ColumnDefinition<T>;
+    index: number;
+}
+interface ColumnDefinition<T, _KEY = keyof T> {
+    id: string;
+    value?: (row: T, index?: number) => string;
+    headerName?: ((columnId: string, index?: number) => string) | string;
+    icon?: string | ((row?: T | undefined) => string);
+    type?: string;
+    sortable?: boolean;
+    format?: (row: T) => string;
+    routerLink?: (row: T) => string | string;
+    queryParams?: Params;
+    columnClass?: string;
+    template?: TemplateRef<{
+        $implicit: T;
+    }>;
+    actions?: ActionColumnsDefinition<T>[];
+    textAlign?: FieldAlignType;
+    width?: string | number;
+    forceVisibility?: ColumnVisibilityType;
+    visible?: boolean;
+}
+declare function LinkRenderer<T>(text: string, href: string): (row: T, index: number | undefined) => string;
+declare function routerRenderer<T>(link: string, text: string): (row: T, index?: number | undefined) => {
+    text: string;
+    link: string;
+};
+declare function Renderer<T>(fnc: (row: T) => string): (row: T) => string;
+declare class ColumnModel<T> {
+    readonly configuration: ColumnDefinition<T>;
+    sortDirection: SortDirectionType | undefined;
+    columnClass?: string;
+    queryParams?: Params;
+    routerLink?: (row: T) => string | string;
+    valueGetter: (row: T, index: number) => string;
+    headerGetter: (columnId: string, index: number) => string | string;
+    template?: TemplateRef<{
+        $implicit: T;
+    }>;
+    actions?: ActionColumnsDefinition<T>[];
+    sortable?: boolean;
+    id: string;
+    format: Function;
+    textAlign?: FieldAlignType;
+    width: string | undefined;
+    forceVisibility: ColumnVisibilityType;
+    visible: boolean;
+    constructor(configuration: ColumnDefinition<T>);
+}
+declare class RowModel<T> {
+    row: T;
+    index?: number;
+    id: number | string;
+    selected: boolean;
+    marked?: boolean;
+    focused?: boolean;
+    expanded: boolean;
+    fnc?: void;
+    customRoute: string | undefined;
+    constructor(row: T, selected: boolean, expanded: boolean, marked?: boolean, index?: number, fnc?: void, customRoute?: string, entityKey?: string);
+}
+
+declare class TableColumnDirective<T> implements ColumnProvider<T> {
+    template: TemplateRef<{
+        $implicit: T;
+    }>;
+    index: number;
+    id: string;
+    columnClass: string;
+    sortable: boolean;
+    routerLink: (row: T) => string;
+    queryParams: Params;
+    headerName: ((column: string, index?: number) => string) | string;
+    width: string | number | undefined;
+    textAlign: FieldAlignType;
+    format: (row: T) => string;
+    forceVisibility: ColumnVisibilityType;
+    visible: boolean;
+    getDefinition(): ColumnDefinition<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableColumnDirective<any>, "v-table-column", never, { "index": { "alias": "index"; "required": false; }; "id": { "alias": "id"; "required": false; }; "columnClass": { "alias": "columnClass"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "headerName": { "alias": "headerName"; "required": false; }; "width": { "alias": "width"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; "format": { "alias": "format"; "required": false; }; "forceVisibility": { "alias": "forceVisibility"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, ["template"], never, true, never>;
+}
+
+declare class ColumnConfiguration<TEntity> {
+    private id;
+    private column;
+    constructor(id: string | keyof TEntity);
+    headerName(headerName: string | ((columnId: string, index?: number) => string)): this;
+    sortable(sortable: boolean): this;
+    columnClass(columnClass: string): this;
+    valueFunction(value: (row: TEntity, index?: number) => string): this;
+    type(type: string): this;
+    build(): ColumnDefinition<TEntity>;
+}
+
+declare class TableBuilder<TEntity> {
+    private columns;
+    addColumn(id: string | keyof TEntity, config?: (v: ColumnConfiguration<TEntity>) => void): TableBuilder<TEntity>;
+    addTextColumn(id: string | keyof TEntity, config?: (v: ColumnConfiguration<TEntity>) => void): TableBuilder<TEntity>;
+    addNumberColumn(id: string | keyof TEntity, config?: (v: ColumnConfiguration<TEntity>) => void): TableBuilder<TEntity>;
+    addDateColumn(id: string | keyof TEntity, config?: (v: ColumnConfiguration<TEntity>) => void): TableBuilder<TEntity>;
+    addBooleanColumn(id: string, config?: (v: ColumnConfiguration<TEntity>) => void): TableBuilder<TEntity>;
+    addEnumColumn(id: string | keyof TEntity, config?: (v: ColumnConfiguration<TEntity>) => void): TableBuilder<TEntity>;
+    build(): ColumnDefinition<TEntity>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBuilder<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableBuilder<any>>;
+}
+
+declare const TABLE_FILTER_COMPONENT_TOKEN: InjectionToken<TableFilterCore<any>>;
+interface FilterDefinition {
+    optionLabel: string;
+    label: string;
+    optionValue?: string;
+    url?: string;
+    filterType?: 'dropdown' | 'checkbox' | 'calendar' | 'multiselect';
+    initialValue?: any;
+}
+interface TableFilterCore<T> extends BaseFormDirectiveCore<T> {
+    filterDefinitions: FilterDefinition[];
+    title: string;
+    hideSearch?: boolean;
+    debounceTime?: number;
+}
+
+declare const TEXTAREA_COMPONENT_TOKEN: InjectionToken<TextareaCore>;
+interface TextareaCore extends BaseFormCore {
+    rows: number;
+    cols: number;
+    autoResize: boolean;
+    floatLabel: string | undefined;
+}
+
+declare const TEXTFIELD_COMPONENT_TOKEN: InjectionToken<TextfieldCore>;
+interface TextfieldCore extends BaseFormCore {
+    size: FieldSizeType | undefined;
+    type: FieldTypeType;
+    floatLabel: boolean;
+}
+
+declare const TOOLTIP_COMPONENT_TOKEN: InjectionToken<TooltipCore>;
+interface TooltipCore {
+    color: Signal<ControlSeverityType | undefined>;
+    position: Signal<PositionType | undefined>;
+    size: Signal<FieldSizeType | undefined>;
+    tooltipText: Signal<string | undefined>;
+}
+
+declare const ICONS_COMPONENT_TOKEN: InjectionToken<IconsCore>;
+type IconLibraryType = 'native' | 'bootstrap';
+interface IconsCore {
+    library: InputSignal<IconLibraryType>;
+    name: InputSignal<string>;
+    size: InputSignal<FieldSizeType | undefined>;
+    severity: InputSignal<ControlSeverityType | undefined>;
+    class: InputSignal<string | undefined>;
+}
+
+declare abstract class IconsComponent implements IconsCore {
+    library: i0.InputSignal<IconLibraryType>;
+    name: i0.InputSignal<string>;
+    size: i0.InputSignal<"small" | "medium" | "large" | "xl" | undefined>;
+    severity: i0.InputSignal<"success" | "info" | "warning" | "danger" | "help" | "primary" | "secondary" | "contrast" | undefined>;
+    class: i0.InputSignal<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconsComponent, "ng-component", never, { "library": { "alias": "library"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const TAG_COMPONENT_TOKEN: InjectionToken<TagCore>;
+type TagVariant = 'bold' | 'subtle';
+interface TagCore {
+    label: InputSignal<string | undefined>;
+    severity: InputSignal<ControlSeverityType | undefined>;
+    variant: InputSignal<TagVariant>;
+    size: InputSignal<FieldSizeType>;
+}
+
+declare class DatasourceDirective<T> extends UnsubscribeComponent implements OnChanges, OnInit {
+    datasource: DatasourceType<T>;
+    autoBind: boolean;
+    loadingText: string;
+    filterField: string | undefined;
+    transformFn?: (data: T) => unknown;
+    extraFilter: any;
+    get activeComponent(): DataSourceComponentModel<T>;
+    private httpClient;
+    private baseUrl;
+    private changeDetectorRef;
+    private isAllDataLoaded;
+    private parameters$;
+    private lastParameter;
+    private dropdownComponent;
+    private multiSelectComponent;
+    private genericField;
+    private dataSourceService?;
+    private loadingPlaceholderItem;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private isDataForRequestLoaded;
+    private setDataToControl;
+    private changeComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatasourceDirective<any>, "v-dropdown[useDatasource], v-multiselect[useDatasource], v-generic-field[useDatasource]", never, { "datasource": { "alias": "datasource"; "required": false; }; "autoBind": { "alias": "autoBind"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "filterField": { "alias": "filterField"; "required": false; }; "transformFn": { "alias": "transformFn"; "required": false; }; "extraFilter": { "alias": "extraFilter"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TableDatasourceDirective<T> extends UnsubscribeComponent implements OnInit, OnChanges {
+    protected readonly store: Store<any>;
+    autoBind: boolean;
+    tableName: string;
+    debounceTime: number;
+    datasource: DatasourceType<T>;
+    extraFilter: any;
+    transformFn?: (data: T) => unknown;
+    private tableComponent;
+    private changeDetectorRef;
+    private httpClient;
+    private baseUrl;
+    private dataSourceService?;
+    private parameters$;
+    params$: rxjs.Observable<Partial<ExtendedRequestType<T>>>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    reload(): void;
+    private changeComponent;
+    private setDataToControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDatasourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableDatasourceDirective<any>, "v-table[useDatasource]", ["useDatasource"], { "autoBind": { "alias": "autoBind"; "required": false; }; "tableName": { "alias": "tableName"; "required": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; "datasource": { "alias": "datasource"; "required": false; }; "extraFilter": { "alias": "extraFilter"; "required": false; }; "transformFn": { "alias": "transformFn"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ButtonShortCutDirective {
+    shortCutFn?: () => void;
+    shortCutKey: string;
+    private keyMap;
+    onKeyDown(event: KeyboardEvent): void;
+    onKeyUp(event: KeyboardEvent): void;
+    private checkShortcut;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonShortCutDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonShortCutDirective, "v-button[useShortCut]", ["useShortCut"], { "shortCutFn": { "alias": "shortCutFn"; "required": false; }; "shortCutKey": { "alias": "shortCutKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TableFilterDirective<T> implements OnChanges, OnDestroy {
+    filterComponent: FilterCore;
+    private filterChange$;
+    private subscription;
+    private tableComponent;
+    private changeDetectorRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    private onFilterChange;
+    ngOnDestroy(): void;
+    private unRegister;
+    private register;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFilterDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFilterDirective<any>, "v-table[useFilter]", ["tableFilterDirective"], { "filterComponent": { "alias": "filterComponent"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+type ErrorCodesFn = (value?: any) => string;
+declare const ErrorCodesFns: {
+    [key: string]: ErrorCodesFn;
+};
+
+type ErrorValue = {
+    key: string;
+    value: string;
+} | null;
+declare function getFirstErrorFromControl<T extends AbstractControl>(control: T): ErrorValue;
+declare function getFirstError(errors: ValidationErrors): ErrorValue;
+
+declare class ErrorPipe implements PipeTransform {
+    transform(errors: ValidationErrors | undefined | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ErrorPipe, "error", true>;
+}
+
+declare class WarningPipe implements PipeTransform {
+    transform(warnings: ValidationErrors | undefined | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WarningPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<WarningPipe, "warning", true>;
+}
+
+type WarningCodesFn = (value?: any) => string;
+declare const WarningCodesFns: {
+    [key: string]: WarningCodesFn;
+};
+
+declare class KeyOrFunctionPipe implements PipeTransform {
+    transform(keyOrFn: any, row: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyOrFunctionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KeyOrFunctionPipe, "keyOrFn", true>;
+}
+
+declare class EnumToListPipe implements PipeTransform {
+    transform(data: any): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumToListPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumToListPipe, "enumToList", true>;
+}
+
+declare class Format {
+    static concatArray(value: any[], itemFormatter?: Function, delimeter?: string): string;
+    static czechDate(value: Date | string): string;
+    static date(value: Date | string): string;
+    static dateAndTime(value: Date | string): string;
+    static convertToUserLocaleDate(value?: Date | string): string;
+    static bool(value: boolean): "Yes" | "No";
+    static boolWithIcon(value: boolean): "<span>✓</span>" | "<span>⨯</span>";
+}
+
+export { ACTION_BUTTON_GROUP_COMPONENT_TOKEN, BREADCRUMB_COMPONENT_TOKEN, BUTTON_COMPONENT_TOKEN, BaseFormDirective, BaseFormInputComponent, BaseInputControls, BreadcrumbCoreComponent, BreadcrumbService, ButtonShortCutDirective, CALENDAR_COMPONENT_TOKEN, CHECKBOX_COMPONENT_TOKEN, CONFIRM_DIALOG_COMPONENT_TOKEN, ColumnConfiguration, ColumnModel, ColumnVisibility, ControlSeverity, DEFAULT_DEBOUNCE_TIME, DEFAULT_PAGINATION, DROPDOWN_BUTTON_COMPONENT_TOKEN, DROPDOWN_COMPONENT_TOKEN, DatasourceDirective, DetailStoreDirective, DialogService, EnumToListPipe, ErrorCodesFns, ErrorPipe, FILTER_COMPONENT_TOKEN, FORM_FIELD_COMPONENT_TOKEN, FieldAlign, FieldSize, FieldType, Format, GENERIC_FIELD_COMPONENT_TOKEN, GenericFieldType, GovButtonType, GovControlSeverity, HEADER_COMPONENT_TOKEN, ICONS_COMPONENT_TOKEN, INPUT_GROUP_COMPONENT_TOKEN, IconPosition, IconsComponent, KeyOrFunctionPipe, LOADER_COMPONENT_TOKEN, LOGO_ROUTER_ROUTE, LayoutType, LinkRenderer, MAX_COLUMN_CHAR_COUNT, MENU_TOKEN, MULTISELECT_COMPONENT_TOKEN, MenuServiceDirective, NUMBER_INPUT_COMPONENT_TOKEN, PAGE_HEADER_COMPONENT_TOKEN, PASSWORD_COMPONENT_TOKEN, PageHeaderCoreComponent, PageHeaderService, PasswordStrength, Position, PreventUnsavedChangesDirective, RADIOBUTTON_COMPONENT_TOKEN, Renderer, RowModel, SECTION_COMPONENT_TOKEN, SETTINGS_MENU, SIDE_MENU_COMPONENT_TOKEN, SIDE_MENU_STATE_TOKEN, SLIDER_COMPONENT_TOKEN, SNACKBAR_COMPONENT_TOKEN, STEPPER_COMPONENT_TOKEN, SWITCH_COMPONENT_TOKEN, ScreenSizeService, SideMenuProviderService, SideMenuService, SlotPosition, TABLE_COLUMN_PROVIDER, TABLE_COMPONENT_TOKEN, TABLE_FILTER_COMPONENT_TOKEN, TAB_VIEW_COMPONENT_TOKEN, TAG_COMPONENT_TOKEN, TEXTAREA_COMPONENT_TOKEN, TEXTFIELD_COMPONENT_TOKEN, TOOLTIP_COMPONENT_TOKEN, TableBuilder, TableButtonSeverity, TableColumnDirective, TableDatasourceDirective, TableFilterDirective, TableSelectionMode, TableService, UnsubscribeComponent, WarningCodesFns, WarningPipe, downloadFile, downloadText, getFirstError, getFirstErrorFromControl, isFilterEmpty, isFormStateEqual, queryListChanged, routerRenderer, setComponentProperties, setDataToArray };
+export type { ActionButton, ActionButtonGroupCore, ActionColumnsDefinition, BaseFormCore, BaseFormDirectiveCore, Breadcrumb, BreadcrumbCore, ButtonCore, CalendarCore, CheckboxCore, ColumnDefinition, ColumnProvider, ColumnVisibilityType, CommonIcons, ConfirmDialogCore, ControlSeverityType, DataSourceComponentModel, DialogData, DropdownButtonCore, DropdownCore, ExtendedComponent, ExtendedDialogData, ExtendedRequestType, FieldAlignType, FieldSizeType, FieldTypeType, FilterCore, FilterDefinition, FormFieldCore, FormState, GenericFieldCore, GenericFieldDefinition, GenericFieldTypeType, GovButtonTypeType, GovControlSeverityType, HeaderCore, IconLibraryType, IconPositionType, IconsCore, InputGroupCore, InputGroupItem, LayoutTypeType, LoaderCore, MenuItem, MenuItemData, MultiselectCore, NotificableProperty, NumberInputCore, PageHeaderCore, PasswordCore, PasswordValidationItem, PositionType, PreventUnsavedChangesCore, RadioButtonItem, RadiobuttonCore, SectionCore, SideMenuCore, SideMenuModuleConfig, SideMenuState, SliderCore, SlotPositionType, SnackbarCore, StepperCore, StepperItem, SwitchCore, TabViewCore, TabViewItemCore, TableButtonSeverityType, TableCore, TableFilterCore, TableSelectionModeType, TableSignal, TagCore, TagVariant, TextareaCore, TextfieldCore, TooltipCore };