danarakca-design-system 1.0.0

package/types/danarakca-design-system.d.ts

@@ -0,0 +1,991 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, OnInit, OnChanges, TemplateRef, QueryList, ChangeDetectorRef, ElementRef, OnDestroy, AfterViewInit, SimpleChanges, AfterContentInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ChangeEvent } from '@ckeditor/ckeditor5-angular';
+import { ClassicEditor, EditorConfig } from 'ckeditor5';
+import { SafeHtml } from '@angular/platform-browser';
+
+type KeuButtonVariant = 'primary' | 'primary-tinted' | 'primary-outline' | 'accent' | 'accent-tinted' | 'accent-outline' | 'success' | 'success-tinted' | 'success-outline' | 'danger' | 'danger-tinted' | 'danger-outline' | 'neutral-outline' | 'ghost';
+type KeuButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type KeuBadgeVariant = 'primary' | 'accent' | 'success' | 'danger' | 'neutral' | 'white';
+declare class KeuButtonComponent {
+    variant: KeuButtonVariant;
+    size: KeuButtonSize;
+    disabled: boolean;
+    loading: boolean;
+    block: boolean;
+    pill: boolean;
+    iconOnly: boolean;
+    leadingIcon: string;
+    trailingIcon: string;
+    showBadge: boolean;
+    badge: string | number | null;
+    badgeVariant: KeuBadgeVariant;
+    type: 'button' | 'submit' | 'reset';
+    clicked: EventEmitter<MouseEvent>;
+    get hostClasses(): string;
+    handleClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuButtonComponent, "keu-button", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "block": { "alias": "block"; "required": false; }; "pill": { "alias": "pill"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; "showBadge": { "alias": "showBadge"; "required": false; }; "badge": { "alias": "badge"; "required": false; }; "badgeVariant": { "alias": "badgeVariant"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+}
+
+type KeuLinkColor = 'blue' | 'white' | 'black';
+type KeuLinkSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+declare class KeuLinkComponent {
+    href: string;
+    color: KeuLinkColor;
+    size: KeuLinkSize;
+    showIcon: boolean;
+    target: '_blank' | '_self' | '_parent' | '_top';
+    disabled: boolean;
+    get hostClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuLinkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuLinkComponent, "keu-link", never, { "href": { "alias": "href"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "target": { "alias": "target"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class KeuContainerDirective {
+    /** Fluid = lebar penuh tanpa max-width */
+    fluid: boolean;
+    get hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeuContainerDirective, "[keuContainer]", never, { "fluid": { "alias": "fluid"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuRowAlign = 'start' | 'center' | 'end' | 'stretch';
+type KeuRowJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+declare class KeuRowDirective {
+    align: KeuRowAlign;
+    justify: KeuRowJustify;
+    noGutter: boolean;
+    get hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuRowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeuRowDirective, "[keuRow]", never, { "align": { "alias": "align"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "noGutter": { "alias": "noGutter"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuColSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'auto';
+declare class KeuColDirective {
+    /** Jumlah kolom default (semua breakpoint) */
+    span: KeuColSpan;
+    /** Override per breakpoint */
+    xs: KeuColSpan | null;
+    sm: KeuColSpan | null;
+    md: KeuColSpan | null;
+    lg: KeuColSpan | null;
+    xl: KeuColSpan | null;
+    get hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuColDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeuColDirective, "[keuCol]", never, { "span": { "alias": "span"; "required": false; }; "xs": { "alias": "xs"; "required": false; }; "sm": { "alias": "sm"; "required": false; }; "md": { "alias": "md"; "required": false; }; "lg": { "alias": "lg"; "required": false; }; "xl": { "alias": "xl"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuDividerOrientation = 'horizontal' | 'vertical';
+type KeuDividerPadding = '0' | '16' | '24' | '32';
+declare class KeuDividerComponent {
+    orientation: KeuDividerOrientation;
+    padding: KeuDividerPadding;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuDividerComponent, "keu-divider", never, { "orientation": { "alias": "orientation"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuInputState = 'default' | 'success' | 'error';
+type KeuInputVariant = 'outline' | 'filled';
+declare class KeuInputComponent implements ControlValueAccessor {
+    label: string;
+    placeholder: string;
+    helperText: string;
+    state: KeuInputState;
+    stateMessage: string;
+    variant: KeuInputVariant;
+    type: string;
+    disabled: boolean;
+    leadingIcon: string;
+    trailingIcon: string;
+    value: string;
+    private onChange;
+    private onTouched;
+    writeValue(val: string): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuInputComponent, "keu-input", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "state": { "alias": "state"; "required": false; }; "stateMessage": { "alias": "stateMessage"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KeuSelectComponent implements ControlValueAccessor {
+    label: string;
+    placeholder: string;
+    helperText: string;
+    disabled: boolean;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    value: string;
+    private onChange;
+    private onTouched;
+    writeValue(val: string): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onSelectChange(event: Event): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuSelectComponent, "keu-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KeuTextareaComponent implements ControlValueAccessor {
+    label: string;
+    placeholder: string;
+    helperText: string;
+    disabled: boolean;
+    rows: number;
+    value: string;
+    private onChange;
+    private onTouched;
+    writeValue(val: string): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuTextareaComponent, "keu-textarea", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KeuRichtextComponent implements ControlValueAccessor {
+    label: string;
+    placeholder: string;
+    helperText: string;
+    disabled: boolean;
+    height: number;
+    value: string;
+    Editor: typeof ClassicEditor;
+    editorConfig: EditorConfig;
+    private onChange;
+    private onTouched;
+    ngOnInit(): void;
+    writeValue(val: string): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onEditorChange(event: ChangeEvent): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuRichtextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuRichtextComponent, "keu-richtext", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuIconNode = [string, Record<string, string | number>][];
+
+type ExtraIcons = Record<string, KeuIconNode>;
+declare class KeuIconComponent implements OnInit, OnChanges {
+    name: string;
+    size: number;
+    color: string;
+    stroke: number;
+    /** Extra icons not in the built-in registry */
+    extraIcons: ExtraIcons;
+    svgContent: SafeHtml;
+    private readonly sanitizer;
+    private readonly cdr;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private render;
+    private buildSvg;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuIconComponent, "keu-icon", never, { "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "stroke": { "alias": "stroke"; "required": false; }; "extraIcons": { "alias": "extraIcons"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuChipVariant = 'default' | 'primary' | 'accent' | 'success' | 'danger' | 'outlined';
+type KeuChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type KeuChipShape = 'pill' | 'label';
+declare class KeuChipComponent {
+    variant: KeuChipVariant;
+    size: KeuChipSize;
+    shape: KeuChipShape;
+    icon: string;
+    closable: boolean;
+    disabled: boolean;
+    closed: EventEmitter<void>;
+    get hostClasses(): string;
+    get iconSize(): number;
+    get closeIconSize(): number;
+    handleClose(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuChipComponent, "keu-chip", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+type KeuToggleSize = 'sm' | 'md';
+declare class KeuToggleComponent implements ControlValueAccessor {
+    size: KeuToggleSize;
+    disabled: boolean;
+    label: string;
+    description: string;
+    checked: boolean;
+    changed: EventEmitter<boolean>;
+    private onChange;
+    private onTouched;
+    get hostClasses(): string;
+    toggle(): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (val: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuToggleComponent, "keu-toggle", never, { "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+type KeuBadgeStatus = 'unread' | 'read' | 'neutral' | 'information';
+declare class KeuBadgeComponent {
+    variant: KeuBadgeStatus;
+    value: string | number | null;
+    get hostClasses(): string;
+    get displayValue(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuBadgeComponent, "keu-badge", never, { "variant": { "alias": "variant"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuPaginationShape = 'square' | 'circle';
+type KeuPaginationSize = 'sm' | 'md';
+declare class KeuPaginationComponent {
+    totalPages: number;
+    currentPage: number;
+    shape: KeuPaginationShape;
+    size: KeuPaginationSize;
+    maxVisible: number;
+    pageChange: EventEmitter<number>;
+    get hostClasses(): string;
+    get pages(): (number | '...')[];
+    get canPrev(): boolean;
+    get canNext(): boolean;
+    goToPage(page: number | '...'): void;
+    prev(): void;
+    next(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuPaginationComponent, "keu-pagination", never, { "totalPages": { "alias": "totalPages"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "size": { "alias": "size"; "required": false; }; "maxVisible": { "alias": "maxVisible"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+type KeuSortDirection = 'asc' | 'desc' | null;
+interface KeuColumnDef {
+    key: string;
+    header: string;
+    sortable?: boolean;
+    width?: string;
+    align?: 'left' | 'center' | 'right';
+}
+interface KeuSortEvent {
+    column: string;
+    direction: KeuSortDirection;
+}
+declare class KeuCellDirective {
+    templateRef: TemplateRef<any>;
+    columnKey: string;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeuCellDirective, "[keuCell]", never, { "columnKey": { "alias": "keuCell"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class KeuHeaderCellDirective {
+    templateRef: TemplateRef<any>;
+    columnKey: string;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuHeaderCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeuHeaderCellDirective, "[keuHeaderCell]", never, { "columnKey": { "alias": "keuHeaderCell"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class KeuTableEmptyDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuTableEmptyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeuTableEmptyDirective, "[keuTableEmpty]", never, {}, {}, never, never, true, never>;
+}
+declare class KeuTableComponent {
+    columns: KeuColumnDef[];
+    data: any[];
+    selectable: boolean;
+    striped: boolean;
+    hoverable: boolean;
+    bordered: boolean;
+    compact: boolean;
+    emptyText: string;
+    loading: boolean;
+    stickyHeader: boolean;
+    paginated: boolean;
+    pageSize: number;
+    currentPage: number;
+    pageSizes: number[];
+    paginationShape: KeuPaginationShape;
+    sortChange: EventEmitter<KeuSortEvent>;
+    selectionChange: EventEmitter<any[]>;
+    rowClick: EventEmitter<{
+        row: any;
+        index: number;
+    }>;
+    pageChange: EventEmitter<{
+        page: number;
+        pageSize: number;
+    }>;
+    cellTemplates: QueryList<KeuCellDirective>;
+    headerCellTemplates: QueryList<KeuHeaderCellDirective>;
+    emptyTemplate?: KeuTableEmptyDirective;
+    sortColumn: string | null;
+    sortDirection: KeuSortDirection;
+    selectedRows: Set<number>;
+    allSelected: boolean;
+    get tableClasses(): string;
+    getCellTemplate(key: string): TemplateRef<any> | null;
+    getHeaderCellTemplate(key: string): TemplateRef<any> | null;
+    onSort(column: KeuColumnDef): void;
+    toggleAll(): void;
+    toggleRow(index: number): void;
+    isRowSelected(index: number): boolean;
+    onRowClick(row: any, index: number): void;
+    trackByIndex(index: number): number;
+    get totalPages(): number;
+    get paginatedData(): any[];
+    get paginationStart(): number;
+    get paginationEnd(): number;
+    onPageChange(page: number): void;
+    onPageSizeChange(event: Event): void;
+    private emitSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuTableComponent, "keu-table", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "hoverable": { "alias": "hoverable"; "required": false; }; "bordered": { "alias": "bordered"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "paginated": { "alias": "paginated"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "pageSizes": { "alias": "pageSizes"; "required": false; }; "paginationShape": { "alias": "paginationShape"; "required": false; }; }, { "sortChange": "sortChange"; "selectionChange": "selectionChange"; "rowClick": "rowClick"; "pageChange": "pageChange"; }, ["emptyTemplate", "cellTemplates", "headerCellTemplates"], never, true, never>;
+}
+
+type KeuCheckboxLayout = 'block' | 'inline';
+declare class KeuCheckboxComponent implements ControlValueAccessor {
+    private cdr;
+    label: string;
+    description: string;
+    disabled: boolean;
+    indeterminate: boolean;
+    layout: KeuCheckboxLayout;
+    checked: boolean;
+    checkedChange: EventEmitter<boolean>;
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef);
+    get hostClasses(): string;
+    toggle(): void;
+    onKeydown(event: KeyboardEvent): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuCheckboxComponent, "keu-checkbox", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
+}
+
+type KeuRadioLayout = 'block' | 'inline';
+declare class KeuRadioComponent implements ControlValueAccessor {
+    private cdr;
+    label: string;
+    description: string;
+    disabled: boolean;
+    layout: KeuRadioLayout;
+    checked: boolean;
+    value: any;
+    name: string;
+    checkedChange: EventEmitter<boolean>;
+    valueSelect: EventEmitter<any>;
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef);
+    get hostClasses(): string;
+    select(): void;
+    onKeydown(event: KeyboardEvent): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuRadioComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuRadioComponent, "keu-radio", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "checkedChange": "checkedChange"; "valueSelect": "valueSelect"; }, never, never, true, never>;
+}
+
+type KeuAlertVariant = 'default' | 'warning' | 'danger' | 'success';
+declare class KeuAlertComponent {
+    variant: KeuAlertVariant;
+    title: string;
+    content: string;
+    dismissible: boolean;
+    dismissed: EventEmitter<void>;
+    visible: boolean;
+    get hostClasses(): string;
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuAlertComponent, "keu-alert", never, { "variant": { "alias": "variant"; "required": false; }; "title": { "alias": "title"; "required": false; }; "content": { "alias": "content"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+
+type KeuAvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type KeuAvatarStatus = 'available' | 'away' | 'busy' | 'offline' | 'none';
+declare class KeuAvatarComponent {
+    src: string;
+    alt: string;
+    initials: string;
+    size: KeuAvatarSize;
+    status: KeuAvatarStatus;
+    get hostClasses(): string;
+    get statusClasses(): string;
+    get showFallback(): boolean;
+    onImageError(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuAvatarComponent, "keu-avatar", never, { "src": { "alias": "src"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; "initials": { "alias": "initials"; "required": false; }; "size": { "alias": "size"; "required": false; }; "status": { "alias": "status"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KeuAvatarGroupComponent {
+    size: KeuAvatarSize;
+    overflow: number;
+    get hostClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuAvatarGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuAvatarGroupComponent, "keu-avatar-group", never, { "size": { "alias": "size"; "required": false; }; "overflow": { "alias": "overflow"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+type KeuBreadcrumbSeparator = 'chevron' | 'slash';
+type KeuBreadcrumbSize = 'sm' | 'md';
+type KeuBreadcrumbActiveStyle = 'text' | 'pill';
+interface KeuBreadcrumbItem {
+    label: string;
+    url?: string;
+    icon?: 'home';
+    collapsed?: boolean;
+}
+declare class KeuBreadcrumbComponent {
+    items: KeuBreadcrumbItem[];
+    separator: KeuBreadcrumbSeparator;
+    size: KeuBreadcrumbSize;
+    activeStyle: KeuBreadcrumbActiveStyle;
+    itemClick: EventEmitter<KeuBreadcrumbItem>;
+    get hostClasses(): string;
+    isLast(index: number): boolean;
+    onItemClick(item: KeuBreadcrumbItem, event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuBreadcrumbComponent, "keu-breadcrumb", never, { "items": { "alias": "items"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; "size": { "alias": "size"; "required": false; }; "activeStyle": { "alias": "activeStyle"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}
+
+interface KeuButtonGroupItem {
+    label: string;
+    value: string | number;
+    badge?: number | string;
+}
+type KeuButtonGroupVariant = 'button' | 'chip';
+declare class KeuButtonGroupComponent {
+    items: KeuButtonGroupItem[];
+    value: string | number;
+    variant: KeuButtonGroupVariant;
+    scrollable: boolean;
+    valueChange: EventEmitter<string | number>;
+    scrollContainer: ElementRef<HTMLElement>;
+    get hostClasses(): string;
+    select(item: KeuButtonGroupItem): void;
+    isActive(item: KeuButtonGroupItem): boolean;
+    scrollLeft(): void;
+    scrollRight(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuButtonGroupComponent, "keu-button-group", never, { "items": { "alias": "items"; "required": false; }; "value": { "alias": "value"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+type KeuSliderLabelMode = 'none' | 'below' | 'tooltip';
+interface KeuSliderValue {
+    low: number;
+    high: number;
+}
+declare class KeuSliderComponent implements ControlValueAccessor {
+    private cdr;
+    min: number;
+    max: number;
+    step: number;
+    low: number;
+    high: number;
+    range: boolean;
+    labelMode: KeuSliderLabelMode;
+    disabled: boolean;
+    formatLabel: (value: number) => string;
+    valueChange: EventEmitter<KeuSliderValue>;
+    trackRef: ElementRef<HTMLDivElement>;
+    private dragging;
+    private onChange;
+    private onTouched;
+    get lowPercent(): number;
+    get highPercent(): number;
+    get fillLeft(): string;
+    get fillWidth(): string;
+    get hostClasses(): string;
+    onThumbDown(event: MouseEvent | TouchEvent, thumb: 'low' | 'high'): void;
+    onTrackClick(event: MouseEvent): void;
+    private onMove;
+    private getValueFromEvent;
+    private snapToStep;
+    private emitValue;
+    writeValue(val: KeuSliderValue | null): void;
+    registerOnChange(fn: (val: KeuSliderValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuSliderComponent, "keu-slider", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "low": { "alias": "low"; "required": false; }; "high": { "alias": "high"; "required": false; }; "range": { "alias": "range"; "required": false; }; "labelMode": { "alias": "labelMode"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "formatLabel": { "alias": "formatLabel"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+type KeuDatePickerMode = 'single' | 'range';
+interface KeuDateRange {
+    start: Date | null;
+    end: Date | null;
+}
+interface KeuCalendarDay {
+    date: Date;
+    day: number;
+    currentMonth: boolean;
+    today: boolean;
+    selected: boolean;
+    inRange: boolean;
+    rangeStart: boolean;
+    rangeEnd: boolean;
+    disabled: boolean;
+}
+declare class KeuDatepickerComponent implements ControlValueAccessor {
+    private cdr;
+    private elRef;
+    mode: KeuDatePickerMode;
+    inline: boolean;
+    disabled: boolean;
+    locale: string;
+    placeholder: string;
+    label: string;
+    dateFormat: string;
+    minDate: Date | null;
+    maxDate: Date | null;
+    disabledDates: Date[];
+    disabledDays: number[];
+    showTodayButton: boolean;
+    clearable: boolean;
+    dateChange: EventEmitter<Date | null>;
+    rangeChange: EventEmitter<KeuDateRange>;
+    viewDate: Date;
+    selectedDate: Date | null;
+    rangeStart: Date | null;
+    rangeEnd: Date | null;
+    hoverDate: Date | null;
+    showPicker: boolean;
+    dropdownOpen: boolean;
+    private onChange;
+    private onTouched;
+    onDocClick(event: MouseEvent): void;
+    toggleDropdown(): void;
+    get inputDisplayValue(): string;
+    private formatDate;
+    readonly weekDays: string[];
+    readonly monthNames: string[];
+    get yearRange(): number[];
+    togglePicker(): void;
+    selectMonth(monthIndex: number): void;
+    selectYear(year: number): void;
+    prevPickerYear(): void;
+    nextPickerYear(): void;
+    get monthYearLabel(): string;
+    get monthLabel(): string;
+    get weeks(): KeuCalendarDay[][];
+    private buildDay;
+    selectDay(day: KeuCalendarDay): void;
+    onDayHover(day: KeuCalendarDay): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    private isSameDay;
+    private isDaySelected;
+    private isDayDisabled;
+    private isDayInRange;
+    getDayClasses(day: KeuCalendarDay): string;
+    trackByWeek(index: number): number;
+    trackByDay(_: number, day: KeuCalendarDay): number;
+    goToToday(): void;
+    clearSelection(): void;
+    writeValue(val: Date | KeuDateRange | null): void;
+    registerOnChange(fn: (val: Date | KeuDateRange | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuDatepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuDatepickerComponent, "keu-datepicker", never, { "mode": { "alias": "mode"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabledDates": { "alias": "disabledDates"; "required": false; }; "disabledDays": { "alias": "disabledDays"; "required": false; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; }, { "dateChange": "dateChange"; "rangeChange": "rangeChange"; }, never, never, true, never>;
+}
+
+type KeuTooltipPosition = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right';
+type KeuTooltipTheme = 'light' | 'dark';
+type KeuTooltipTrigger = 'hover' | 'click';
+declare class KeuTooltipComponent implements OnDestroy {
+    private cdr;
+    private elRef;
+    text: string;
+    tooltipTitle: string;
+    description: string;
+    position: KeuTooltipPosition;
+    theme: KeuTooltipTheme;
+    trigger: KeuTooltipTrigger;
+    disabled: boolean;
+    showDelay: number;
+    hideDelay: number;
+    open: boolean;
+    private _visible;
+    private showTimer;
+    private hideTimer;
+    get isVisible(): boolean;
+    get isRich(): boolean;
+    get tooltipClasses(): string;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    onDocClick(event: MouseEvent): void;
+    ngOnDestroy(): void;
+    private clearTimers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuTooltipComponent, "keu-tooltip", never, { "text": { "alias": "text"; "required": false; }; "tooltipTitle": { "alias": "tooltipTitle"; "required": false; }; "description": { "alias": "description"; "required": false; }; "position": { "alias": "position"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showDelay": { "alias": "showDelay"; "required": false; }; "hideDelay": { "alias": "hideDelay"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface KeuTabItem {
+    label: string;
+    value: string;
+    badge?: string | number;
+    icon?: string;
+    disabled?: boolean;
+}
+type KeuTabVariant = 'underline' | 'pill' | 'boxed';
+type KeuTabSize = 'sm' | 'md' | 'lg';
+declare class KeuTabsComponent implements AfterViewInit, OnChanges {
+    private cdr;
+    tabs: KeuTabItem[];
+    activeTab: string;
+    variant: KeuTabVariant;
+    size: KeuTabSize;
+    fullWidth: boolean;
+    disabled: boolean;
+    iconOnly: boolean;
+    tabChange: EventEmitter<string>;
+    tabBtns: QueryList<ElementRef<HTMLButtonElement>>;
+    indicatorStyle: {
+        [key: string]: string;
+    };
+    private initialized;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    selectTab(tab: KeuTabItem): void;
+    private updateIndicator;
+    get hostClasses(): string;
+    getTabClasses(tab: KeuTabItem): string;
+    trackByTab(_: number, tab: KeuTabItem): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuTabsComponent, "keu-tabs", never, { "tabs": { "alias": "tabs"; "required": false; }; "activeTab": { "alias": "activeTab"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; }, { "tabChange": "tabChange"; }, never, never, true, never>;
+}
+
+type KeuProgressBarLabelMode = 'none' | 'right' | 'bottom' | 'top-floating' | 'bottom-floating';
+type KeuProgressBarSize = 'sm' | 'md' | 'lg';
+type KeuProgressBarVariant = 'primary' | 'success' | 'danger' | 'accent';
+declare class KeuProgressBarComponent {
+    value: number;
+    max: number;
+    label: KeuProgressBarLabelMode;
+    size: KeuProgressBarSize;
+    variant: KeuProgressBarVariant;
+    showDot: boolean;
+    animated: boolean;
+    striped: boolean;
+    get percentage(): number;
+    get hostClasses(): string;
+    get fillStyle(): {
+        [key: string]: string;
+    };
+    get floatingStyle(): {
+        [key: string]: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuProgressBarComponent, "keu-progress-bar", never, { "value": { "alias": "value"; "required": false; }; "max": { "alias": "max"; "required": false; }; "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "showDot": { "alias": "showDot"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuProgressCircleMode = 'circle' | 'half';
+type KeuProgressCircleSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+declare class KeuProgressCircleComponent {
+    value: number;
+    max: number;
+    mode: KeuProgressCircleMode;
+    size: KeuProgressCircleSize;
+    label: string;
+    showValue: boolean;
+    private readonly gradientId;
+    get percentage(): number;
+    get svgSize(): number;
+    get strokeWidth(): number;
+    get radius(): number;
+    get center(): number;
+    get circumference(): number;
+    get dashOffset(): number;
+    get halfCircumference(): number;
+    get halfDashOffset(): number;
+    get halfViewBox(): string;
+    get halfSvgHeight(): number;
+    get halfArcPath(): string;
+    get halfArcLength(): number;
+    get halfArcDashOffset(): number;
+    get gradId(): string;
+    get valueFontSize(): number;
+    get labelFontSize(): number;
+    get hostClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuProgressCircleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuProgressCircleComponent, "keu-progress-circle", never, { "value": { "alias": "value"; "required": false; }; "max": { "alias": "max"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "size": { "alias": "size"; "required": false; }; "label": { "alias": "label"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type KeuRatingSize = 'sm' | 'md' | 'lg';
+declare class KeuRatingComponent implements ControlValueAccessor {
+    /** Current rating value (supports half values like 3.5) */
+    value: number;
+    /** Maximum number of stars */
+    max: number;
+    /** Component size */
+    size: KeuRatingSize;
+    /** Read-only display mode */
+    readonly: boolean;
+    /** Disabled state */
+    disabled: boolean;
+    /** Allow half-star selection */
+    allowHalf: boolean;
+    /** Color of filled stars */
+    color: string;
+    /** Color of empty stars */
+    emptyColor: string;
+    /** Emitted when user clicks a star */
+    valueChange: EventEmitter<number>;
+    hoverValue: number;
+    private onChange;
+    private onTouched;
+    get stars(): number[];
+    get isInteractive(): boolean;
+    getStarFill(star: number): 'full' | 'half' | 'empty';
+    onStarClick(star: number, event: Event): void;
+    onStarHover(star: number, event: MouseEvent): void;
+    onStarLeave(): void;
+    writeValue(val: number): void;
+    registerOnChange(fn: (val: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuRatingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuRatingComponent, "keu-rating", never, { "value": { "alias": "value"; "required": false; }; "max": { "alias": "max"; "required": false; }; "size": { "alias": "size"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "allowHalf": { "alias": "allowHalf"; "required": false; }; "color": { "alias": "color"; "required": false; }; "emptyColor": { "alias": "emptyColor"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+interface KeuSidebarTab {
+    id: string;
+    icon: string;
+    label: string;
+}
+declare class KeuSidebarPanelDirective {
+    templateRef: TemplateRef<unknown>;
+    id: string;
+    constructor(templateRef: TemplateRef<unknown>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuSidebarPanelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeuSidebarPanelDirective, "[keuSidebarPanel]", never, { "id": { "alias": "keuSidebarPanel"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class KeuSidebarComponent implements AfterContentInit {
+    /** Tab definitions */
+    tabs: KeuSidebarTab[];
+    /** Currently active tab id */
+    activeTab: string;
+    /** Title shown in panel header (defaults to active tab label) */
+    title: string;
+    /** Whether the panel content is visible */
+    open: boolean;
+    /** Position */
+    position: 'left' | 'right';
+    /** Emits when active tab changes */
+    activeTabChange: EventEmitter<string>;
+    /** Emits when panel is closed via × button */
+    closed: EventEmitter<void>;
+    /** Emits when open state changes */
+    openChange: EventEmitter<boolean>;
+    panels: QueryList<KeuSidebarPanelDirective>;
+    private panelMap;
+    ngAfterContentInit(): void;
+    private buildPanelMap;
+    get activePanel(): TemplateRef<unknown> | null;
+    get displayTitle(): string;
+    onTabClick(tab: KeuSidebarTab): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuSidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuSidebarComponent, "keu-sidebar", never, { "tabs": { "alias": "tabs"; "required": false; }; "activeTab": { "alias": "activeTab"; "required": false; }; "title": { "alias": "title"; "required": false; }; "open": { "alias": "open"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, { "activeTabChange": "activeTabChange"; "closed": "closed"; "openChange": "openChange"; }, ["panels"], never, true, never>;
+}
+
+type KeuModalVariant = 'dialog' | 'popup';
+type KeuModalIcon = 'warning' | 'success' | 'error' | 'info' | 'none';
+declare class KeuModalComponent {
+    /** Modal variant */
+    variant: KeuModalVariant;
+    /** Icon type displayed in the modal */
+    icon: KeuModalIcon;
+    /** Modal title */
+    title: string;
+    /** Modal description/body text */
+    description: string;
+    /** Whether the modal is visible */
+    visible: boolean;
+    /** Show close (×) button — typically for dialog variant */
+    showClose: boolean;
+    /** Primary (confirm) button text */
+    confirmText: string;
+    /** Cancel button text */
+    cancelText: string;
+    /** Show action buttons (dialog) */
+    showActions: boolean;
+    /** Close modal when clicking backdrop */
+    closeOnBackdrop: boolean;
+    /** Render inline without backdrop (for docs/preview) */
+    inline: boolean;
+    /** Custom padding for the body section, e.g. '24px 32px'. Overrides default. */
+    bodyPadding?: string;
+    /** Emitted when confirm button is clicked */
+    confirm: EventEmitter<void>;
+    /** Emitted when cancel button or close button is clicked */
+    cancel: EventEmitter<void>;
+    /** Emitted when modal visibility changes */
+    visibleChange: EventEmitter<boolean>;
+    get iconName(): string;
+    get iconColorClass(): string;
+    onConfirm(): void;
+    onCancel(): void;
+    onBackdropClick(): void;
+    onContentClick(event: Event): void;
+    private close;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuModalComponent, "keu-modal", never, { "variant": { "alias": "variant"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "confirmText": { "alias": "confirmText"; "required": false; }; "cancelText": { "alias": "cancelText"; "required": false; }; "showActions": { "alias": "showActions"; "required": false; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "bodyPadding": { "alias": "bodyPadding"; "required": false; }; }, { "confirm": "confirm"; "cancel": "cancel"; "visibleChange": "visibleChange"; }, never, ["*"], true, never>;
+}
+
+interface KeuDropdownOption {
+    value: string;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+}
+declare class KeuDropdownComponent implements ControlValueAccessor {
+    private cdr;
+    private el;
+    label: string;
+    placeholder: string;
+    helperText: string;
+    disabled: boolean;
+    searchable: boolean;
+    searchPlaceholder: string;
+    options: KeuDropdownOption[];
+    valueChange: EventEmitter<string>;
+    isOpen: boolean;
+    value: string;
+    searchQuery: string;
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef, el: ElementRef);
+    get selectedOption(): KeuDropdownOption | undefined;
+    get filteredOptions(): KeuDropdownOption[];
+    get displayLabel(): string;
+    toggle(): void;
+    select(option: KeuDropdownOption): void;
+    onDocumentClick(event: Event): void;
+    onEscape(): void;
+    writeValue(val: string): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuDropdownComponent, "keu-dropdown", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+interface KeuTreeNode {
+    value: string;
+    label: string;
+    children?: KeuTreeNode[];
+    disabled?: boolean;
+}
+type KeuTreeSelectMode = 'single' | 'multiple';
+declare class KeuTreeSelectComponent implements ControlValueAccessor {
+    private cdr;
+    private el;
+    label: string;
+    placeholder: string;
+    helperText: string;
+    disabled: boolean;
+    searchable: boolean;
+    searchPlaceholder: string;
+    mode: KeuTreeSelectMode;
+    nodes: KeuTreeNode[];
+    valueChange: EventEmitter<string[]>;
+    isOpen: boolean;
+    searchQuery: string;
+    selectedValues: string[];
+    expandedNodes: Set<string>;
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef, el: ElementRef);
+    get triggerLabel(): string;
+    get selectedChips(): Array<{
+        value: string;
+        label: string;
+    }>;
+    private findLabel;
+    toggleExpand(node: KeuTreeNode, event: Event): void;
+    isExpanded(node: KeuTreeNode): boolean;
+    hasChildren(node: KeuTreeNode): boolean;
+    isSelected(value: string): boolean;
+    isIndeterminate(node: KeuTreeNode): boolean;
+    isAllSelected(node: KeuTreeNode): boolean;
+    private getLeafValues;
+    private getAllDescendantValues;
+    toggleNode(node: KeuTreeNode): void;
+    removeChip(value: string, event: Event): void;
+    matchesSearch(node: KeuTreeNode): boolean;
+    get filteredNodes(): KeuTreeNode[];
+    private filterNodes;
+    shouldShowNode(node: KeuTreeNode): boolean;
+    toggle(): void;
+    onDocumentClick(event: Event): void;
+    onEscape(): void;
+    writeValue(val: string[]): void;
+    registerOnChange(fn: (val: string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuTreeSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuTreeSelectComponent, "keu-tree-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+interface KeuAutocompleteOption {
+    value: string;
+    label: string;
+    sublabel?: string;
+    avatar?: string;
+    icon?: string;
+}
+type KeuAutocompleteMode = 'single' | 'multiple';
+declare class KeuAutocompleteComponent implements ControlValueAccessor {
+    private cdr;
+    private el;
+    label: string;
+    placeholder: string;
+    helperText: string;
+    disabled: boolean;
+    mode: KeuAutocompleteMode;
+    trailingIcon: string;
+    options: KeuAutocompleteOption[];
+    minChars: number;
+    valueChange: EventEmitter<string[]>;
+    search: EventEmitter<string>;
+    isOpen: boolean;
+    query: string;
+    selectedValues: string[];
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef, el: ElementRef);
+    get filteredOptions(): KeuAutocompleteOption[];
+    get selectedOptions(): KeuAutocompleteOption[];
+    isSelected(value: string): boolean;
+    onInputChange(): void;
+    onInputFocus(): void;
+    select(option: KeuAutocompleteOption): void;
+    removeSelected(value: string, event: Event): void;
+    clearQuery(): void;
+    onDocumentClick(event: Event): void;
+    onEscape(): void;
+    writeValue(val: string[]): void;
+    registerOnChange(fn: (val: string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeuAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KeuAutocompleteComponent, "keu-autocomplete", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; "options": { "alias": "options"; "required": false; }; "minChars": { "alias": "minChars"; "required": false; }; }, { "valueChange": "valueChange"; "search": "search"; }, never, never, true, never>;
+}
+
+export { KeuAlertComponent, KeuAutocompleteComponent, KeuAvatarComponent, KeuAvatarGroupComponent, KeuBadgeComponent, KeuBreadcrumbComponent, KeuButtonComponent, KeuButtonGroupComponent, KeuCellDirective, KeuCheckboxComponent, KeuChipComponent, KeuColDirective, KeuContainerDirective, KeuDatepickerComponent, KeuDividerComponent, KeuDropdownComponent, KeuHeaderCellDirective, KeuIconComponent, KeuInputComponent, KeuLinkComponent, KeuModalComponent, KeuPaginationComponent, KeuProgressBarComponent, KeuProgressCircleComponent, KeuRadioComponent, KeuRatingComponent, KeuRichtextComponent, KeuRowDirective, KeuSelectComponent, KeuSidebarComponent, KeuSidebarPanelDirective, KeuSliderComponent, KeuTableComponent, KeuTableEmptyDirective, KeuTabsComponent, KeuTextareaComponent, KeuToggleComponent, KeuTooltipComponent, KeuTreeSelectComponent };
+export type { KeuAlertVariant, KeuAutocompleteMode, KeuAutocompleteOption, KeuAvatarSize, KeuAvatarStatus, KeuBadgeStatus, KeuBadgeVariant, KeuBreadcrumbActiveStyle, KeuBreadcrumbItem, KeuBreadcrumbSeparator, KeuBreadcrumbSize, KeuButtonGroupItem, KeuButtonGroupVariant, KeuButtonSize, KeuButtonVariant, KeuCheckboxLayout, KeuChipShape, KeuChipSize, KeuChipVariant, KeuColSpan, KeuColumnDef, KeuDatePickerMode, KeuDateRange, KeuDividerOrientation, KeuDividerPadding, KeuDropdownOption, KeuInputState, KeuInputVariant, KeuLinkColor, KeuLinkSize, KeuModalIcon, KeuModalVariant, KeuPaginationShape, KeuPaginationSize, KeuProgressBarLabelMode, KeuProgressBarSize, KeuProgressBarVariant, KeuProgressCircleMode, KeuProgressCircleSize, KeuRadioLayout, KeuRatingSize, KeuRowAlign, KeuRowJustify, KeuSidebarTab, KeuSliderLabelMode, KeuSliderValue, KeuSortDirection, KeuSortEvent, KeuTabItem, KeuTabSize, KeuTabVariant, KeuToggleSize, KeuTooltipPosition, KeuTooltipTheme, KeuTooltipTrigger, KeuTreeNode, KeuTreeSelectMode };