@synerity/ui/index.d.ts

A comprehensive Angular UI component library with 70+ components including forms, data display, navigation, and utility components. All components feature enhanced SCSS styling with nested selectors and modern architecture.

import * as i0 from '@angular/core';
import { EventEmitter, OnInit, OnDestroy, ElementRef, OnChanges, ChangeDetectorRef, SimpleChanges, AfterViewInit, QueryList, TemplateRef, Renderer2 } from '@angular/core';
import { ControlValueAccessor } from '@angular/forms';

declare class Button implements ControlValueAccessor {
    variant: 'primary' | 'secondary' | 'outline' | 'ghost' | 'danger';
    size: 'sm' | 'md' | 'lg';
    disabled: boolean;
    loading: boolean;
    type: 'button' | 'submit' | 'reset';
    fullWidth: boolean;
    icon: string | null;
    iconPosition: 'left' | 'right';
    click: EventEmitter<MouseEvent>;
    private _value;
    private onChange;
    private onTouched;
    get value(): boolean;
    set value(val: boolean);
    onButtonClick(event: MouseEvent): void;
    writeValue(value: boolean): void;
    registerOnChange(fn: (value: boolean) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    get buttonClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<Button, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Button, "sui-button", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "type": { "alias": "type"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; }, { "click": "click"; }, never, ["*"], true, never>;
}

declare class InputText implements ControlValueAccessor, OnInit, OnDestroy {
    placeholder: string;
    disabled: boolean;
    readonly: boolean;
    required: boolean;
    size: 'sm' | 'md' | 'lg';
    variant: 'default' | 'filled' | 'outlined';
    validationState: 'none' | 'valid' | 'invalid';
    errorMessage: string;
    helperText: string;
    label: string;
    type: 'text' | 'email' | 'password' | 'tel' | 'url';
    maxlength: number | null;
    minlength: number | null;
    pattern: string | null;
    autocomplete: string | null;
    autofocus: boolean;
    spellcheck: boolean;
    prefix: string | null;
    suffix: string | null;
    clearable: boolean;
    showPasswordToggle: boolean;
    blur: EventEmitter<FocusEvent>;
    focus: EventEmitter<FocusEvent>;
    input: EventEmitter<Event>;
    clear: EventEmitter<void>;
    private _value;
    private onChange;
    private onTouched;
    private _showPassword;
    private _focused;
    get value(): string;
    set value(val: string);
    get showPassword(): boolean;
    get focused(): boolean;
    get inputType(): string;
    ngOnInit(): void;
    ngOnDestroy(): void;
    onInput(event: Event): void;
    onBlur(event: FocusEvent): void;
    onFocus(event: FocusEvent): void;
    onClear(): void;
    togglePasswordVisibility(): void;
    writeValue(value: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    get inputClasses(): string;
    get containerClasses(): string;
    get hasValue(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputText, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputText, "sui-input-text", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "validationState": { "alias": "validationState"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "label": { "alias": "label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "spellcheck": { "alias": "spellcheck"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "showPasswordToggle": { "alias": "showPasswordToggle"; "required": false; }; }, { "blur": "blur"; "focus": "focus"; "input": "input"; "clear": "clear"; }, never, never, true, never>;
}

declare class Card {
    variant: 'default' | 'outlined' | 'elevated' | 'filled';
    size: 'sm' | 'md' | 'lg';
    clickable: boolean;
    disabled: boolean;
    header: string;
    subheader: string;
    showHeader: boolean;
    showFooter: boolean;
    loading: boolean;
    hoverable: boolean;
    borderless: boolean;
    click: EventEmitter<MouseEvent>;
    headerClick: EventEmitter<MouseEvent>;
    onCardClick(event: MouseEvent): void;
    onHeaderClick(event: MouseEvent): void;
    get cardClasses(): string;
    get headerClasses(): string;
    get subheaderClasses(): string;
    get contentClasses(): string;
    get footerClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<Card, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Card, "sui-card", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "clickable": { "alias": "clickable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "header": { "alias": "header"; "required": false; }; "subheader": { "alias": "subheader"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "hoverable": { "alias": "hoverable"; "required": false; }; "borderless": { "alias": "borderless"; "required": false; }; }, { "click": "click"; "headerClick": "headerClick"; }, never, ["*", "[slot=footer]"], true, never>;
}

declare class AutoComplete implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    inputId: string;
    placeholder: string;
    minLength: number;
    options: Array<string | {
        label: string;
        value: unknown;
    }>;
    change: EventEmitter<unknown>;
    value: unknown;
    term: string;
    open: boolean;
    activeIndex: number;
    private onChange;
    private onTouched;
    writeValue(obj: unknown): void;
    registerOnChange(fn: (val: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onFocus(): void;
    onBlur(): void;
    onKeyDown(event: KeyboardEvent): void;
    select(item: string | {
        label: string;
        value: unknown;
    }): void;
    clear(): void;
    get filtered(): Array<string | {
        label: string;
        value: unknown;
    }>;
    displayItem(item: string | {
        label: string;
        value: unknown;
    }): string;
    resolveValue(item: string | {
        label: string;
        value: unknown;
    }): unknown;
    displayValue(val: unknown): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoComplete, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AutoComplete, "sui-auto-complete", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

interface CaptchaChallenge {
    question: string;
    answer: string;
    type: 'math' | 'text' | 'image';
}
declare class Captcha implements OnInit {
    type: 'math' | 'text' | 'image';
    difficulty: 'easy' | 'medium' | 'hard';
    disabled: boolean;
    style: any;
    styleClass: string;
    refreshButton: boolean;
    customChallenge?: CaptchaChallenge;
    onVerify: EventEmitter<boolean>;
    onRefresh: EventEmitter<void>;
    currentChallenge: CaptchaChallenge | null;
    userAnswer: string;
    isVerified: boolean;
    isError: boolean;
    errorMessage: string;
    ngOnInit(): void;
    generateChallenge(): void;
    verifyAnswer(): void;
    onInputChange(value: string): void;
    onKeyPress(event: KeyboardEvent): void;
    refresh(): void;
    private generateMathChallenge;
    private generateTextChallenge;
    private generateImageChallenge;
    private scrambleWord;
    private resetState;
    getCaptchaClass(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<Captcha, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Captcha, "sui-captcha", never, { "type": { "alias": "type"; "required": false; }; "difficulty": { "alias": "difficulty"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "refreshButton": { "alias": "refreshButton"; "required": false; }; "customChallenge": { "alias": "customChallenge"; "required": false; }; }, { "onVerify": "onVerify"; "onRefresh": "onRefresh"; }, never, never, true, never>;
}

declare class CascadeSelect implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    levelsPlaceholder: string[];
    options: Array<{
        label: string;
        value?: unknown;
        children?: any[];
    }>;
    change: EventEmitter<unknown>;
    path: Array<{
        label: string;
        value?: unknown;
        children?: any[];
    } | null>;
    value: unknown;
    private onChange;
    private onTouched;
    writeValue(val: unknown): void;
    registerOnChange(fn: (val: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    levelOptions(level: number): Array<{
        label: string;
        value?: unknown;
        children?: any[];
    }>;
    onSelect(level: number, idx: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CascadeSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CascadeSelect, "sui-cascade-select", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "levelsPlaceholder": { "alias": "levelsPlaceholder"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class Checkbox implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    value: unknown;
    inputId: string;
    cssClass: string;
    change: EventEmitter<boolean>;
    checked: boolean;
    private onChange;
    private onTouched;
    writeValue(value: boolean): void;
    registerOnChange(fn: (val: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInputChange(event: Event): void;
    onInputBlur(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Checkbox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Checkbox, "sui-checkbox", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

declare class ColorPicker implements ControlValueAccessor, OnDestroy {
    value: string;
    format: 'hex' | 'rgb' | 'hsl';
    inline: boolean;
    disabled: boolean;
    size: 'small' | 'medium' | 'large';
    style: any;
    styleClass: string;
    onChange: EventEmitter<string>;
    onSelect: EventEmitter<string>;
    colorInput: ElementRef;
    colorPicker: ElementRef;
    colorPickerContainer: ElementRef;
    visible: boolean;
    private documentClickListener;
    private onValueChange;
    private onTouched;
    ngOnDestroy(): void;
    toggle(): void;
    onColorChange(event: Event): void;
    onColorSelect(color: string): void;
    private bindDocumentClickListener;
    private unbindDocumentClickListener;
    getColorPickerClass(): string;
    getColorPickerStyle(): any;
    getPreviewStyle(): any;
    isVisible(): boolean;
    isDisabled(): boolean;
    isInline(): boolean;
    writeValue(value: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColorPicker, "sui-color-picker", never, { "value": { "alias": "value"; "required": false; }; "format": { "alias": "format"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, { "onChange": "onChange"; "onSelect": "onSelect"; }, never, never, true, never>;
}

interface DatePickerConfig {
    format: string;
    minDate?: Date;
    maxDate?: Date;
    disabledDates?: Date[];
    disabledDays?: number[];
    firstDayOfWeek?: number;
    showWeekNumbers?: boolean;
    showTodayButton?: boolean;
    showClearButton?: boolean;
    showTime?: boolean;
    timeFormat?: '12' | '24';
    placeholder?: string;
    size?: 'small' | 'medium' | 'large';
    variant?: 'default' | 'compact' | 'inline';
    theme?: 'light' | 'dark';
}
declare class DatePicker implements ControlValueAccessor, OnDestroy, OnInit, OnChanges {
    private cdr;
    value: Date | null;
    rangeValue: {
        start: Date | null;
        end: Date | null;
    } | null;
    placeholder: string;
    disabled: boolean;
    readonly: boolean;
    required: boolean;
    variant: 'dropdown' | 'inline' | 'range';
    size: 'normal' | 'compact';
    theme: 'light' | 'dark';
    minDate: Date | null;
    maxDate: Date | null;
    disabledDates: Date[];
    disabledDays: number[];
    firstDayOfWeek: number;
    showWeekNumbers: boolean;
    showTodayButton: boolean;
    showClearButton: boolean;
    showTime: boolean;
    timeFormat: '12' | '24';
    dateFormat: string;
    timeFormatString: string;
    style: any;
    styleClass: string;
    onChange: EventEmitter<Date | {
        start: Date | null;
        end: Date | null;
    } | null>;
    onSelect: EventEmitter<Date | {
        start: Date | null;
        end: Date | null;
    } | null>;
    onOpen: EventEmitter<void>;
    onClose: EventEmitter<void>;
    onFocus: EventEmitter<void>;
    onBlur: EventEmitter<void>;
    triggerElement: ElementRef;
    calendarPanel: ElementRef;
    dateInput: ElementRef;
    isOpen: boolean;
    isFocused: boolean;
    currentView: 'calendar' | 'months' | 'years';
    currentMonth: number;
    currentYear: number;
    rangeStart: Date | null;
    rangeEnd: Date | null;
    rangeHoverDate: Date | null;
    selectedTime: {
        hours: number;
        minutes: number;
    };
    private calendarZIndex;
    private calendarElement;
    weekDays: string[];
    monthNames: string[];
    yearRange: number[];
    private documentClickListener;
    private windowResizeListener;
    private windowScrollListener;
    private escapeKeyListener;
    private calendarClickHandler;
    private isSelectingDate;
    private onValueChange;
    private onTouched;
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    toggle(): void;
    open(): void;
    close(): void;
    selectDate(date: Date, event?: Event): void;
    selectToday(): void;
    handleRangeSelection(date: Date): void;
    clear(event?: Event): void;
    previousMonth(): void;
    nextMonth(): void;
    goToMonth(month: number): void;
    goToYear(year: number): void;
    getCalendarDays(): any[];
    getMonthNames(): string[];
    getYearRange(): number[];
    isDateDisabled(date: Date): boolean;
    isSameDay(date1: Date, date2: Date): boolean;
    getWeekNumber(date: Date): number;
    getDisplayValue(): string;
    formatTime(date: Date): string;
    onInputFocus(): void;
    onInputBlur(): void;
    onInputChange(event: Event): void;
    onTimeFormatChange(event: Event): void;
    onKeyDown(event: KeyboardEvent): void;
    getComponentClass(): string;
    getTriggerClass(): string;
    getCalendarClass(): string;
    getCalendarStyle(): any;
    private createCalendarInBody;
    private removeCalendarFromBody;
    private renderCalendarContent;
    private bindCalendarEvents;
    private ensureGlobalStyles;
    private initializeYearRange;
    private updateCurrentDate;
    private positionCalendar;
    private bindEventListeners;
    private cleanupEventListeners;
    writeValue(value: Date | null | {
        start: Date | null;
        end: Date | null;
    } | null): void;
    registerOnChange(fn: (value: any) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatePicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatePicker, "sui-date-picker", never, { "value": { "alias": "value"; "required": false; }; "rangeValue": { "alias": "rangeValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabledDates": { "alias": "disabledDates"; "required": false; }; "disabledDays": { "alias": "disabledDays"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "timeFormat": { "alias": "timeFormat"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "timeFormatString": { "alias": "timeFormatString"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, { "onChange": "onChange"; "onSelect": "onSelect"; "onOpen": "onOpen"; "onClose": "onClose"; "onFocus": "onFocus"; "onBlur": "onBlur"; }, never, never, true, never>;
}

declare class Editor implements OnInit, OnDestroy, OnChanges {
    private cdr;
    value: string;
    placeholder: string;
    disabled: boolean;
    readonly: boolean;
    height: string;
    showToolbar: boolean;
    theme: 'light' | 'dark';
    style: any;
    styleClass: string;
    onChange: EventEmitter<string>;
    onFocus: EventEmitter<void>;
    onBlur: EventEmitter<void>;
    editorElement: ElementRef;
    private isFocused;
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    setEditorContent(): void;
    onContentChange(): void;
    onFocusHandler(): void;
    onBlurHandler(): void;
    onKeyDown(event: KeyboardEvent): void;
    onPaste(event: ClipboardEvent): void;
    execCommand(command: string, value?: string): void;
    isFormatActive(format: string): boolean;
    insertLink(): void;
    insertImage(): void;
    insertCode(): void;
    insertText(html: string): void;
    onHeadingChange(event: Event): void;
    getEditorClass(): string;
    getEditorStyle(): any;
    isDisabled(): boolean;
    isReadonly(): boolean;
    hasToolbar(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<Editor, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Editor, "sui-editor", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "height": { "alias": "height"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, { "onChange": "onChange"; "onFocus": "onFocus"; "onBlur": "onBlur"; }, never, never, true, never>;
}

declare class FloatLabel {
    label: string;
    for: string;
    required: boolean;
    style: any;
    styleClass: string;
    inputElement: ElementRef;
    isFocused: boolean;
    hasValue: boolean;
    onFocus(): void;
    onBlur(): void;
    onInput(): void;
    private checkValue;
    getFloatLabelClass(): string;
    getFloatLabelStyle(): any;
    getLabelText(): string;
    getForAttribute(): string;
    isRequired(): boolean;
    isFocusedOrHasValue(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatLabel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FloatLabel, "sui-float-label", never, { "label": { "alias": "label"; "required": false; }; "for": { "alias": "for"; "required": false; }; "required": { "alias": "required"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class IconField implements AfterViewInit {
    private elementRef;
    icon: string;
    position: 'left' | 'right';
    size: 'small' | 'normal' | 'large';
    style: any;
    styleClass: string;
    constructor(elementRef: ElementRef);
    ngAfterViewInit(): void;
    private applyInputPadding;
    getPaddingValue(): string;
    getIconFieldClass(): string;
    getIconFieldStyle(): any;
    getIconClass(): string;
    hasIcon(): boolean;
    getIcon(): string;
    isLeftPosition(): boolean;
    isRightPosition(): boolean;
    getSize(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconField, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconField, "sui-icon-field", never, { "icon": { "alias": "icon"; "required": false; }; "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class IftLabel {
    condition: boolean;
    trueLabel: string;
    falseLabel: string;
    style: any;
    styleClass: string;
    getLabelClass(): string;
    getLabelStyle(): any;
    getDisplayLabel(): string;
    hasTrueLabel(): boolean;
    hasFalseLabel(): boolean;
    shouldShowTrue(): boolean;
    shouldShowFalse(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IftLabel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IftLabel, "sui-ift-label", never, { "condition": { "alias": "condition"; "required": false; }; "trueLabel": { "alias": "trueLabel"; "required": false; }; "falseLabel": { "alias": "falseLabel"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IftaLabel {
    condition: boolean;
    trueLabel: string;
    falseLabel: string;
    altLabel: string;
    style: any;
    styleClass: string;
    getIftaLabelClass(): string;
    getIftaLabelStyle(): any;
    getDisplayLabel(): string;
    hasTrueLabel(): boolean;
    hasFalseLabel(): boolean;
    hasAltLabel(): boolean;
    shouldShowTrue(): boolean;
    shouldShowFalse(): boolean;
    shouldShowAlt(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IftaLabel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IftaLabel, "sui-ifta-label", never, { "condition": { "alias": "condition"; "required": false; }; "trueLabel": { "alias": "trueLabel"; "required": false; }; "falseLabel": { "alias": "falseLabel"; "required": false; }; "altLabel": { "alias": "altLabel"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class InputGroup {
    size: 'small' | 'normal' | 'large';
    disabled: boolean;
    style: any;
    styleClass: string;
    getInputGroupClass(): string;
    getInputGroupStyle(): any;
    getSize(): string;
    isDisabled(): boolean;
    isSmall(): boolean;
    isNormal(): boolean;
    isLarge(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputGroup, "sui-input-group", never, { "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class InputMask implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    inputId: string;
    placeholder: string;
    mask: string;
    maskPlaceholder: string;
    change: EventEmitter<string>;
    rawValue: string;
    viewValue: string;
    private onChange;
    private onTouched;
    ngOnInit(): void;
    writeValue(value: string): void;
    registerOnChange(fn: (val: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    private stripLiterals;
    private applyMask;
    private fits;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputMask, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputMask, "sui-input-mask", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "maskPlaceholder": { "alias": "maskPlaceholder"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class InputNumber implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    inputId: string;
    min: number | null;
    max: number | null;
    step: number;
    placeholder: string;
    change: EventEmitter<number | null>;
    value: number | null;
    private onChange;
    private onTouched;
    writeValue(value: number | null): void;
    registerOnChange(fn: (val: number | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    increment(): void;
    decrement(): void;
    private updateValue;
    private clamp;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputNumber, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputNumber, "sui-input-number", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class InputOtp implements ControlValueAccessor {
    length: number;
    disabled: boolean;
    name: string;
    inputType: 'text' | 'tel';
    numericOnly: boolean;
    change: EventEmitter<string>;
    complete: EventEmitter<string>;
    inputs: QueryList<ElementRef<HTMLInputElement>>;
    values: string[];
    private onChange;
    private onTouched;
    ngOnInit(): void;
    writeValue(value: string): void;
    registerOnChange(fn: (val: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event, index: number): void;
    onKeyDown(event: KeyboardEvent, index: number): void;
    onPaste(event: ClipboardEvent): void;
    onBlur(): void;
    private emitValue;
    private focusIndex;
    private ensureLength;
    private resetValues;
    private isComplete;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputOtp, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputOtp, "sui-input-otp", never, { "length": { "alias": "length"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputType": { "alias": "inputType"; "required": false; }; "numericOnly": { "alias": "numericOnly"; "required": false; }; }, { "change": "change"; "complete": "complete"; }, never, never, true, never>;
}

declare class KeyFilter implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    inputId: string;
    placeholder: string;
    pattern: 'int' | 'num' | 'alpha' | 'alphanum' | string;
    change: EventEmitter<string>;
    value: string;
    private onChange;
    private onTouched;
    writeValue(value: string): void;
    registerOnChange(fn: (val: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    onKeyDown(event: KeyboardEvent): void;
    private resolveRegex;
    static ɵfac: i0.ɵɵFactoryDeclaration<KeyFilter, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KeyFilter, "sui-key-filter", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class Knob {
    value: number;
    min: number;
    max: number;
    step: number;
    size: number;
    strokeWidth: number;
    disabled: boolean;
    readonly: boolean;
    showValue: boolean;
    style: any;
    styleClass: string;
    label: string;
    unit: string;
    showTicks: boolean;
    tickCount: number;
    onChange: EventEmitter<number>;
    knobElement: ElementRef;
    isDragging: boolean;
    startAngle: number;
    startValue: number;
    onMouseDown(event: MouseEvent): void;
    onMouseMove(event: MouseEvent): void;
    onMouseUp(): void;
    onTouchStart(event: TouchEvent): void;
    onTouchMove(event: TouchEvent): void;
    onTouchEnd(): void;
    private startDragging;
    private updateValue;
    private stopDragging;
    private getAngle;
    getKnobClass(): string;
    getKnobStyle(): any;
    getProgressStyle(): any;
    getDisplayValue(): string;
    isDisabled(): boolean;
    isReadonly(): boolean;
    shouldShowValue(): boolean;
    getIndicatorStyle(): any;
    getTickMarks(): Array<{
        x1: number;
        y1: number;
        x2: number;
        y2: number;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<Knob, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Knob, "sui-knob", never, { "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "size": { "alias": "size"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "label": { "alias": "label"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; "showTicks": { "alias": "showTicks"; "required": false; }; "tickCount": { "alias": "tickCount"; "required": false; }; }, { "onChange": "onChange"; }, never, never, true, never>;
}

declare class Listbox implements ControlValueAccessor {
    disabled: boolean;
    options: Array<{
        label: string;
        value: unknown;
        disabled?: boolean;
    }>;
    change: EventEmitter<unknown>;
    value: unknown;
    activeIndex: number;
    private onChange;
    private onTouched;
    writeValue(obj: unknown): void;
    registerOnChange(fn: (val: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    isSelected(opt: {
        value: unknown;
    }): boolean;
    select(opt: {
        label: string;
        value: unknown;
        disabled?: boolean;
    }, index: number): void;
    onKeyDown(event: KeyboardEvent): void;
    private moveActive;
    static ɵfac: i0.ɵɵFactoryDeclaration<Listbox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Listbox, "sui-listbox", never, { "disabled": { "alias": "disabled"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class Password implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    inputId: string;
    placeholder: string;
    minLength: number | null;
    toggleMask: boolean;
    change: EventEmitter<string>;
    value: string;
    show: boolean;
    private onChange;
    private onTouched;
    writeValue(value: string): void;
    registerOnChange(fn: (val: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    toggleVisibility(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Password, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Password, "sui-password", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "toggleMask": { "alias": "toggleMask"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class RadioButton implements ControlValueAccessor {
    name: string;
    disabled: boolean;
    value: unknown;
    inputId: string;
    change: EventEmitter<unknown>;
    private _modelValue;
    private onChange;
    private onTouched;
    get checked(): boolean;
    writeValue(obj: unknown): void;
    registerOnChange(fn: (val: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInputChange(): void;
    onInputBlur(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButton, "sui-radio-button", never, { "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class Rating implements ControlValueAccessor {
    disabled: boolean;
    readonly: boolean;
    max: number;
    allowClear: boolean;
    change: EventEmitter<number>;
    value: number;
    hoverIndex: number;
    private onChange;
    private onTouched;
    get stars(): number[];
    writeValue(val: number): void;
    registerOnChange(fn: (val: number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    setValue(star: number): void;
    onKeyDown(event: KeyboardEvent): void;
    onMouseEnter(star: number): void;
    onMouseLeave(): void;
    onBlur(): void;
    isFilled(star: number): boolean;
    private clamp;
    static ɵfac: i0.ɵɵFactoryDeclaration<Rating, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Rating, "sui-rating", never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "max": { "alias": "max"; "required": false; }; "allowClear": { "alias": "allowClear"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class Select implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    inputId: string;
    placeholder: string | null;
    options: Array<{
        label: string;
        value: unknown;
        disabled?: boolean;
    }>;
    searchable: boolean;
    clearable: boolean;
    multiple: boolean;
    selectAll: boolean;
    maxDisplayItems: number;
    showSelectedCount: boolean;
    searchPlaceholder: string;
    noResultsText: string;
    loading: boolean;
    change: EventEmitter<unknown>;
    dropdown: ElementRef;
    searchInput: ElementRef;
    value: unknown;
    searchTerm: string;
    isOpen: boolean;
    focusedIndex: number;
    private onChange;
    private onTouched;
    writeValue(obj: unknown): void;
    registerOnChange(fn: (val: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onSelectChange(event: Event): void;
    onBlur(): void;
    onSearchInput(event: Event): void;
    clearSelection(): void;
    get filteredOptions(): Array<{
        label: string;
        value: unknown;
        disabled?: boolean;
    }>;
    isOptionSelected(optionValue: unknown): boolean;
    hasValue(): boolean;
    toggleDropdown(): void;
    closeDropdown(): void;
    onOptionClick(option: {
        label: string;
        value: unknown;
        disabled?: boolean;
    }): void;
    removeSelectedItem(value: unknown): void;
    selectAllOptions(): void;
    clearAllOptions(): void;
    get selectedOptions(): Array<{
        label: string;
        value: unknown;
        disabled?: boolean;
    }>;
    get displayText(): string;
    get isAllSelected(): boolean;
    get isPartiallySelected(): boolean;
    onKeyDown(event: KeyboardEvent): void;
    onDocumentClick(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Select, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Select, "sui-select", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "options": { "alias": "options"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "selectAll": { "alias": "selectAll"; "required": false; }; "maxDisplayItems": { "alias": "maxDisplayItems"; "required": false; }; "showSelectedCount": { "alias": "showSelectedCount"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "noResultsText": { "alias": "noResultsText"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class SelectButton implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    options: Array<{
        label: string;
        value: unknown;
        disabled?: boolean;
    }>;
    change: EventEmitter<unknown>;
    value: unknown;
    private onChange;
    private onTouched;
    writeValue(obj: unknown): void;
    registerOnChange(fn: (val: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onOptionClick(option: {
        label: string;
        value: unknown;
        disabled?: boolean;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectButton, "sui-select-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class Slider implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    inputId: string;
    min: number;
    max: number;
    step: number;
    change: EventEmitter<number>;
    value: number;
    private onChange;
    private onTouched;
    writeValue(value: number): void;
    registerOnChange(fn: (val: number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    private clamp;
    static ɵfac: i0.ɵɵFactoryDeclaration<Slider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Slider, "sui-slider", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class Textarea implements ControlValueAccessor, AfterViewInit {
    disabled: boolean;
    name: string;
    inputId: string;
    placeholder: string;
    rows: number;
    autosize: boolean;
    change: EventEmitter<string>;
    textareaRef: ElementRef<HTMLTextAreaElement>;
    value: string;
    private onChange;
    private onTouched;
    ngAfterViewInit(): void;
    writeValue(value: string): void;
    registerOnChange(fn: (val: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    private adjustHeight;
    static ɵfac: i0.ɵɵFactoryDeclaration<Textarea, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Textarea, "sui-textarea", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "autosize": { "alias": "autosize"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class ToggleButton implements ControlValueAccessor {
    disabled: boolean;
    multiple: boolean;
    options: Array<{
        label: string;
        value: unknown;
        icon?: string;
    }>;
    size: 'sm' | 'md' | 'lg';
    variant: 'default' | 'success' | 'warning' | 'danger' | 'purple';
    style: 'default' | 'outline' | 'ghost';
    shape: 'default' | 'rounded' | 'pill';
    change: EventEmitter<unknown>;
    value: unknown | unknown[];
    private onChange;
    private onTouched;
    writeValue(val: unknown | unknown[]): void;
    registerOnChange(fn: (val: unknown | unknown[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    select(option: {
        label: string;
        value: unknown;
        icon?: string;
    }): void;
    isSelected(option: {
        label: string;
        value: unknown;
        icon?: string;
    }): boolean;
    getGroupClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButton, "sui-toggle-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "options": { "alias": "options"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "style": { "alias": "style"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class ToggleSwitch implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    inputId: string;
    change: EventEmitter<boolean>;
    checked: boolean;
    private onChange;
    private onTouched;
    writeValue(value: boolean): void;
    registerOnChange(fn: (val: boolean) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    toggle(): void;
    onBlur(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleSwitch, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleSwitch, "sui-toggle-switch", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class TreeSelect implements ControlValueAccessor {
    disabled: boolean;
    name: string;
    placeholder: string;
    options: Array<{
        label: string;
        value?: unknown;
        children?: any[];
    }>;
    change: EventEmitter<unknown>;
    value: unknown;
    open: boolean;
    private onChange;
    private onTouched;
    writeValue(val: unknown): void;
    registerOnChange(fn: (val: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    toggle(): void;
    select(item: {
        label: string;
        value?: unknown;
        children?: any[];
    }): void;
    onBlur(): void;
    displayValue(): string;
    private findInTree;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeSelect, "sui-tree-select", never, { "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class SpeedDial {
    disabled: boolean;
    direction: 'up' | 'down' | 'left' | 'right';
    items: Array<{
        label?: string;
        icon?: string;
        command?: () => void;
        disabled?: boolean;
    }>;
    buttonIcon: string;
    buttonLabel: string;
    itemClick: EventEmitter<{
        label?: string;
        icon?: string;
        command?: () => void;
        disabled?: boolean;
    }>;
    open: boolean;
    toggle(): void;
    onItemClick(item: {
        label?: string;
        icon?: string;
        command?: () => void;
        disabled?: boolean;
    }): void;
    getDirectionClass(): string;
    getItemsContainerClass(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpeedDial, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpeedDial, "sui-speed-dial", never, { "disabled": { "alias": "disabled"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "items": { "alias": "items"; "required": false; }; "buttonIcon": { "alias": "buttonIcon"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
}

declare class SplitButton {
    disabled: boolean;
    label: string;
    icon: string;
    items: Array<{
        label?: string;
        icon?: string;
        command?: () => void;
        disabled?: boolean;
        separator?: boolean;
    }>;
    buttonStyle: 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'help' | 'danger';
    onClick: EventEmitter<void>;
    itemClick: EventEmitter<{
        label?: string;
        icon?: string;
        command?: () => void;
        disabled?: boolean;
        separator?: boolean;
    }>;
    open: boolean;
    onMainClick(): void;
    onItemClick(item: {
        label?: string;
        icon?: string;
        command?: () => void;
        disabled?: boolean;
        separator?: boolean;
    }): void;
    toggleDropdown(): void;
    getButtonClass(): string;
    getMainButtonClasses(): string;
    getDropdownButtonClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SplitButton, "sui-split-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "items": { "alias": "items"; "required": false; }; "buttonStyle": { "alias": "buttonStyle"; "required": false; }; }, { "onClick": "onClick"; "itemClick": "itemClick"; }, never, never, true, never>;
}

declare class DataView {
    value: any[];
    layout: 'list' | 'grid';
    paginator: boolean;
    rows: number;
    first: number;
    totalRecords: number;
    emptyMessage: string;
    itemTemplate: TemplateRef<any> | null;
    onPage: EventEmitter<any>;
    onLazyLoad: EventEmitter<any>;
    get paginatedValue(): any[];
    onPageChange(event: any): void;
    getLayoutClass(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataView, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataView, "sui-data-view", never, { "value": { "alias": "value"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "paginator": { "alias": "paginator"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "first": { "alias": "first"; "required": false; }; "totalRecords": { "alias": "totalRecords"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; }, { "onPage": "onPage"; "onLazyLoad": "onLazyLoad"; }, never, ["*", "*"], true, never>;
}

declare class OrderList {
    value: any[];
    header: string;
    listStyle: a