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

declare class CclUiComponents {
    static ɵfac: i0.ɵɵFactoryDeclaration<CclUiComponents, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CclUiComponents, "ccl-ui-components", never, {}, {}, never, never, true, never>;
}

declare class ButtonComponent {
    variant: 'primary' | 'secondary' | 'tertiary' | 'destructive';
    size: 'sm' | 'md' | 'lg';
    appearance: 'solid' | 'outline';
    shape: 'square' | 'rounded' | 'pill';
    disabled: boolean;
    loading: boolean;
    ariaLabel?: string;
    ariaDescribedBy?: string;
    ariaExpanded?: boolean;
    ariaPressed?: boolean;
    clicked: EventEmitter<void>;
    onKeydown(event: KeyboardEvent): void;
    onClick(): void;
    get buttonClasses(): string;
    get ariaAttributes(): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "ccl-button", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; }; "ariaExpanded": { "alias": "ariaExpanded"; "required": false; }; "ariaPressed": { "alias": "ariaPressed"; "required": false; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
}

declare class InputComponent implements ControlValueAccessor {
    type: 'text' | 'password' | 'number' | 'email';
    label: string;
    placeholder: string;
    disabled: boolean;
    readonly: boolean;
    error: boolean;
    errorMessage: string;
    helperText: string;
    required: boolean;
    ariaLabel?: string;
    ariaDescribedBy?: string;
    minLength?: number;
    maxLength?: number;
    /** Native `min` attribute (e.g. number, date, time inputs). */
    min?: string | number;
    /** Native `max` attribute (e.g. number, date, time inputs). */
    max?: string | number;
    valueChange: EventEmitter<string>;
    id: string;
    value: string;
    private onChange;
    private onTouched;
    writeValue(value: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    get inputId(): string;
    get labelId(): string;
    get hintId(): string;
    get errorId(): string;
    get describedBy(): string | undefined;
    get ariaAttributes(): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "ccl-input", never, { "type": { "alias": "type"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "error": { "alias": "error"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

interface DataTableColumn {
    id: string;
    label: string;
    width?: string;
    template?: TemplateRef<unknown>;
    className?: string | ((row: Record<string, any>) => string);
    style?: Record<string, string> | ((row: Record<string, any>) => Record<string, string>);
    onClick?: (row: Record<string, any>, value: any) => void;
    link?: (row: Record<string, any>) => string;
    sortable?: boolean;
    accessor?: (row: Record<string, any>) => unknown;
    groupable?: boolean;
    parentHeader?: string;
    colspan?: number;
    align?: 'left' | 'center' | 'right';
    borders?: {
        left?: boolean;
        right?: boolean;
        top?: boolean;
        bottom?: boolean;
    };
}
declare class DataTableComponent {
    columns: DataTableColumn[];
    rows: Record<string, unknown>[];
    striped: boolean;
    bordered: boolean;
    compact: boolean;
    clientSort: boolean;
    groupBy?: string;
    groupCollapsible: boolean;
    groupHeaderTemplate?: TemplateRef<unknown>;
    sortChange: EventEmitter<{
        id: string;
        direction: "asc" | "desc" | "";
    }>;
    groupToggle: EventEmitter<{
        groupKey: string;
        expanded: boolean;
    }>;
    sortId: string;
    sortDirection: 'asc' | 'desc' | '';
    expandedGroups: Set<string>;
    handleClick(col: DataTableColumn, row: any, value: any): void;
    getClass(col: DataTableColumn, row: any): string;
    getStyle(col: DataTableColumn, row: any): Record<string, string>;
    onHeaderClick(col: DataTableColumn): void;
    get rowsToRender(): Record<string, unknown>[];
    get groupedRows(): Array<{
        isGroup: boolean;
        groupKey?: string;
        groupValue?: any;
        rows?: Record<string, unknown>[];
    }>;
    toggleGroup(groupKey: string): void;
    isGroupExpanded(groupKey: string): boolean;
    get parentHeaders(): Array<{
        label: string;
        colspan: number;
        startIndex: number;
    }>;
    getParentHeaderAt(index: number): {
        label: string;
        colspan: number;
        startIndex: number;
    } | undefined;
    getHeaderBorderClasses(col: DataTableColumn): string;
    getCellBorderClasses(col: DataTableColumn): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataTableComponent, "ccl-datatable", never, { "columns": { "alias": "columns"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "bordered": { "alias": "bordered"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "clientSort": { "alias": "clientSort"; "required": false; }; "groupBy": { "alias": "groupBy"; "required": false; }; "groupCollapsible": { "alias": "groupCollapsible"; "required": false; }; "groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; }; }, { "sortChange": "sortChange"; "groupToggle": "groupToggle"; }, never, never, true, never>;
}

declare class ModalComponent implements AfterViewInit, OnChanges {
    isOpen: boolean;
    title: string | TemplateRef<unknown> | null;
    size: 'sm' | 'md' | 'lg';
    ariaLabel?: string;
    hideCloseButton: boolean;
    disableCloseButton: boolean;
    closed: EventEmitter<void>;
    modalContent?: ElementRef<HTMLElement>;
    closeButton?: ElementRef<HTMLButtonElement>;
    private previousActiveElement?;
    ngAfterViewInit(): void;
    onKeydown(event: KeyboardEvent): void;
    ngOnChanges(): void;
    private setupFocusManagement;
    private restoreFocus;
    close(): void;
    onOverlayClick(event: MouseEvent): void;
    private _modalId;
    get modalId(): string;
    get titleId(): string;
    get ariaAttributes(): {
        [key: string]: any;
    };
    get isStringTitle(): boolean;
    get stringTitle(): string;
    get templateTitle(): TemplateRef<unknown> | null;
    get hasTitle(): boolean;
    private isTemplateRefTitle;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "ccl-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "title": { "alias": "title"; "required": false; }; "size": { "alias": "size"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "hideCloseButton": { "alias": "hideCloseButton"; "required": false; }; "disableCloseButton": { "alias": "disableCloseButton"; "required": false; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
}

declare class ToastComponent implements OnInit, OnDestroy {
    variant: 'info' | 'success' | 'warning' | 'error';
    message: string;
    title?: string;
    duration: number;
    dismissible: boolean;
    position: 'top-right' | 'top-left' | 'top-center' | 'bottom-right' | 'bottom-left' | 'bottom-center';
    animation: 'slide' | 'fade' | 'none';
    showProgress: boolean;
    pauseOnHover: boolean;
    ariaLive: 'polite' | 'assertive' | 'off';
    role: 'alert' | 'status' | 'log';
    closed: EventEmitter<void>;
    private timer?;
    private progressTimer?;
    progress: number;
    isVisible: boolean;
    isExiting: boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    close(): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    getDefaultIcon(): string;
    private _toastId;
    get toastId(): string;
    get ariaAttributes(): {
        [key: string]: any;
    };
    get shouldAnnounce(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "ccl-toast", never, { "variant": { "alias": "variant"; "required": false; }; "message": { "alias": "message"; "required": false; }; "title": { "alias": "title"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "position": { "alias": "position"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; "showProgress": { "alias": "showProgress"; "required": false; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; }; "ariaLive": { "alias": "ariaLive"; "required": false; }; "role": { "alias": "role"; "required": false; }; }, { "closed": "closed"; }, never, never, true, never>;
}

declare class AlertComponent {
    variant: 'info' | 'success' | 'warning' | 'error';
    message: string;
    title?: string;
    dismissible: boolean;
    showIcon: boolean;
    icon?: string;
    closed: EventEmitter<void>;
    close(): void;
    getDefaultIcon(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "ccl-alert", never, { "variant": { "alias": "variant"; "required": false; }; "message": { "alias": "message"; "required": false; }; "title": { "alias": "title"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, { "closed": "closed"; }, never, never, true, never>;
}

declare class PaginationComponent implements OnInit {
    currentPage: number;
    totalPages?: number;
    totalItems?: number;
    pageSize: number;
    pageSizeOptions: number[];
    variant: 'numbers' | 'load-more' | 'infinite-scroll' | 'detailed';
    showFirstLast: boolean;
    prevButtonTemplate?: TemplateRef<unknown>;
    nextButtonTemplate?: TemplateRef<unknown>;
    pageChange: EventEmitter<number>;
    pageSizeChange: EventEmitter<number>;
    ngOnInit(): void;
    goToPage(page: number): void;
    nextPage(): void;
    prevPage(): void;
    loadMore(): void;
    onScroll(): void;
    get pages(): number[];
    get totalPagesResolved(): number | undefined;
    get rangeStart(): number | undefined;
    get rangeEnd(): number | undefined;
    onPageSizeChange(newSize: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "ccl-pagination", never, { "currentPage": { "alias": "currentPage"; "required": false; }; "totalPages": { "alias": "totalPages"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "showFirstLast": { "alias": "showFirstLast"; "required": false; }; "prevButtonTemplate": { "alias": "prevButtonTemplate"; "required": false; }; "nextButtonTemplate": { "alias": "nextButtonTemplate"; "required": false; }; }, { "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
}

declare class SearchbarComponent implements AfterViewInit, OnDestroy {
    placeholder: string;
    value: string;
    debounce: number;
    clearable: boolean;
    disabled: boolean;
    showIcon: boolean;
    searchIcon?: TemplateRef<unknown>;
    clearIcon?: TemplateRef<unknown>;
    onSearch: EventEmitter<string>;
    inputEl: ElementRef<HTMLInputElement>;
    private timeoutId;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    handleInput(event: Event): void;
    handleEnter(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchbarComponent, "ccl-searchbar", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "debounce": { "alias": "debounce"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "searchIcon": { "alias": "searchIcon"; "required": false; }; "clearIcon": { "alias": "clearIcon"; "required": false; }; }, { "onSearch": "onSearch"; }, never, never, true, never>;
}

declare class DateFieldComponent implements ControlValueAccessor, OnInit {
    value: Date | null;
    minDate?: Date;
    maxDate?: Date;
    disabled: boolean;
    required: boolean;
    showTime: boolean;
    onChange: EventEmitter<Date | null>;
    inputEl: ElementRef<HTMLInputElement>;
    errorMessage: string;
    onTouched: () => void;
    private onChangeFn;
    ngOnInit(): void;
    writeValue(value: Date | null): void;
    registerOnChange(fn: (val: Date | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    getInputValue(): string;
    getMinDateString(): string;
    getMaxDateString(): string;
    onDateInput(event: Event): void;
    clear(): void;
    onBlur(): void;
    onKeydown(event: KeyboardEvent): void;
    onInputClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateFieldComponent, "ccl-datefield", never, { "value": { "alias": "value"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; }, { "onChange": "onChange"; }, never, never, true, never>;
}

interface DateRangeValue {
    start: Date | null;
    end: Date | null;
}
declare class DateRangeFieldComponent implements OnInit {
    label: string;
    disabled: boolean;
    minSelectableDate?: Date;
    maxSelectableDate?: Date;
    startDate: Date | null;
    endDate: Date | null;
    displayTemplate?: TemplateRef<{
        range: DateRangeValue;
    }>;
    rangeChange: EventEmitter<DateRangeValue>;
    startPicker: ElementRef<HTMLInputElement>;
    endPicker: ElementRef<HTMLInputElement>;
    ngOnInit(): void;
    openStartPicker(event?: Event): void;
    openEndPicker(event?: Event): void;
    onStartDateChange(event: Event): void;
    onEndDateChange(event: Event): void;
    clearRange(): void;
    formatDisplay(date: Date | null): string;
    getRangeText(): string;
    getMinDateString(): string;
    getMaxDateString(): string;
    private emitChange;
    private clampDate;
    private stripTime;
    private toInputValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangeFieldComponent, "ccl-date-range-field", never, { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "minSelectableDate": { "alias": "minSelectableDate"; "required": false; }; "maxSelectableDate": { "alias": "maxSelectableDate"; "required": false; }; "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "displayTemplate": { "alias": "displayTemplate"; "required": false; }; }, { "rangeChange": "rangeChange"; }, never, never, true, never>;
}

declare class CustomDateFieldComponent implements ControlValueAccessor, OnChanges {
    value: Date | null;
    minDate?: Date;
    maxDate?: Date;
    disabled: boolean;
    required: boolean;
    placeholder: string;
    displayFormat: string;
    showTime: boolean;
    valueChange: EventEmitter<Date | null>;
    nativePicker: ElementRef<HTMLInputElement>;
    displayValue: string;
    errorMessage: string;
    private onChangeFn;
    private onTouchedFn;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: Date | null): void;
    registerOnChange(fn: (val: Date | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onTextInput(event: Event): void;
    openNativePicker(event?: Event): void;
    onNativeChange(event: Event): void;
    clear(): void;
    onWrapperClick(event: MouseEvent): void;
    onIconClick(event: Event): void;
    onClearClick(event: Event): void;
    onBlur(): void;
    getMinDateString(): string;
    getMaxDateString(): string;
    private setValue;
    private updateDisplayValue;
    private formatDate;
    private parseFormattedValue;
    private buildFormatRegex;
    private isWithinBounds;
    private stripTime;
    private toInputValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomDateFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomDateFieldComponent, "ccl-custom-datefield", never, { "value": { "alias": "value"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class FormFieldWrapperComponent implements AfterContentInit, AfterViewInit {
    private cdr;
    label: string;
    required: boolean;
    hint: string;
    error: string;
    state: 'default' | 'error' | 'success' | 'disabled';
    for: string;
    inputElement?: ElementRef<HTMLInputElement>;
    private _uniqueId;
    constructor(cdr: ChangeDetectorRef);
    get fieldId(): string;
    get hintId(): string;
    get errorId(): string;
    get describedBy(): string;
    get isErrorState(): boolean;
    get isSuccessState(): boolean;
    get isDisabledState(): boolean;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    private updateInputAttributes;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldWrapperComponent, "ccl-form-field-wrapper", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "error": { "alias": "error"; "required": false; }; "state": { "alias": "state"; "required": false; }; "for": { "alias": "for"; "required": false; }; }, {}, ["inputElement"], ["*"], true, never>;
}

interface SelectOption {
    value: string;
    label: string;
    disabled?: boolean;
}
declare class SelectComponent implements ControlValueAccessor {
    options: SelectOption[];
    placeholder: string;
    disabled: boolean;
    readonly: boolean;
    error: boolean;
    errorMessage: string;
    helperText: string;
    multiple: boolean;
    size?: number;
    filterIcon?: TemplateRef<unknown>;
    showPrefixIcon: boolean;
    prefixIcon?: TemplateRef<unknown>;
    iconBackground: 'none' | 'rounded' | 'square';
    selectionChange: EventEmitter<string | string[]>;
    id: string;
    selectedValue: string | string[];
    private onChange;
    private onTouched;
    writeValue(value: string | string[]): void;
    registerOnChange(fn: (value: string | string[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onSelectionChange(event: Event): void;
    isSelected(value: string): boolean;
    clearSelection(): void;
    onContainerClick(event: Event): void;
    /**
     * Simulate user click sequence (mousedown → mouseup → click)
     * Works for most browsers that block programmatic open()
     */
    private simulateUserClick;
    private getSelectElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "ccl-select", never, { "options": { "alias": "options"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "error": { "alias": "error"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "size": { "alias": "size"; "required": false; }; "filterIcon": { "alias": "filterIcon"; "required": false; }; "showPrefixIcon": { "alias": "showPrefixIcon"; "required": false; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; }; "iconBackground": { "alias": "iconBackground"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
}

declare class TextareaComponent implements ControlValueAccessor, OnInit {
    value: string;
    placeholder: string;
    disabled: boolean;
    readonly: boolean;
    error: boolean;
    errorMessage: string;
    helperText: string;
    rows: number;
    cols?: number;
    maxLength?: number;
    minLength?: number;
    resize: 'none' | 'both' | 'horizontal' | 'vertical';
    valueChange: EventEmitter<string>;
    id: string;
    private onChange;
    private onTouched;
    ngOnInit(): void;
    writeValue(value: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextareaComponent, "ccl-textarea", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "error": { "alias": "error"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "resize": { "alias": "resize"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

type BadgeVariant = 'default' | 'success' | 'error' | 'warning' | 'info' | 'custom';
type BadgeSize = 'sm' | 'md' | 'lg';
type BadgeShape = 'rounded' | 'pill' | 'square';
declare class BadgeComponent implements ControlValueAccessor {
    variant: BadgeVariant;
    label: string;
    icon: string;
    dismissible: boolean;
    count: number | null;
    clickable: boolean;
    size: BadgeSize;
    shape: BadgeShape;
    customColor: string;
    disabled: boolean;
    onDismiss: EventEmitter<void>;
    onClick: EventEmitter<void>;
    private onChange;
    private onTouched;
    writeValue(value: any): void;
    registerOnChange(fn: (value: any) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onBadgeClick(): void;
    onDismissClick(event: Event): void;
    onKeydown(event: KeyboardEvent): void;
    onDismissKeydown(event: KeyboardEvent): void;
    get displayText(): string;
    get isInteractive(): boolean;
    get role(): string;
    get ariaLabel(): string;
    get tabIndex(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeComponent, "ccl-badge", never, { "variant": { "alias": "variant"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "count": { "alias": "count"; "required": false; }; "clickable": { "alias": "clickable"; "required": false; }; "size": { "alias": "size"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "customColor": { "alias": "customColor"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onDismiss": "onDismiss"; "onClick": "onClick"; }, never, never, true, never>;
}

type LoadingVariant = 'spinner' | 'bar' | 'pulse';
type LoadingSize = 'sm' | 'md' | 'lg';
declare class LoadingComponent {
    variant: LoadingVariant;
    size: LoadingSize;
    animated: boolean;
    label: string;
    get role(): string;
    get ariaLabel(): string;
    get cssClasses(): string;
    get spinnerClasses(): string;
    get barClasses(): string;
    get pulseClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingComponent, "ccl-loading", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
}

interface DropdownOption {
    value: any;
    label: string;
    disabled?: boolean;
    selected?: boolean;
}
declare class DropdownComponent implements AfterViewInit, OnDestroy {
    private static currentlyOpenDropdown;
    options: DropdownOption[];
    placeholder: string;
    searchable: boolean;
    multiple: boolean;
    disabled: boolean;
    showCheckboxes: boolean;
    maxHeight: string;
    width: string;
    customTemplate?: TemplateRef<unknown>;
    filterIcon: boolean;
    searchPlaceholder: string;
    customClass: string;
    filterIconContent: string;
    searchIconContent: string;
    arrowIconContent: string;
    filterIconTemplate?: TemplateRef<unknown>;
    searchIconTemplate?: TemplateRef<unknown>;
    arrowIconTemplate?: TemplateRef<unknown>;
    selectionChange: EventEmitter<any>;
    searchChange: EventEmitter<string>;
    dropdownTrigger: ElementRef;
    dropdownMenu: ElementRef;
    dropdownContainer: ElementRef;
    isOpen: boolean;
    searchTerm: string;
    filteredOptions: DropdownOption[];
    private documentCaptureListener?;
    private isToggling;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(): void;
    toggleDropdown(event?: Event): void;
    closeDropdown(): void;
    onSearchChange(): void;
    private filterOptions;
    selectOption(option: DropdownOption): void;
    getDisplayText(): string;
    getSelectedCount(): number;
    private focusSearch;
    private registerAsOpen;
    private unregisterAsOpen;
    private registerDocumentCaptureListener;
    private removeDocumentCaptureListener;
    onDocumentClick(event: Event): void;
    private handleDocumentInteraction;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "ccl-dropdown", never, { "options": { "alias": "options"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showCheckboxes": { "alias": "showCheckboxes"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "width": { "alias": "width"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; "filterIcon": { "alias": "filterIcon"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "filterIconContent": { "alias": "filterIconContent"; "required": false; }; "searchIconContent": { "alias": "searchIconContent"; "required": false; }; "arrowIconContent": { "alias": "arrowIconContent"; "required": false; }; "filterIconTemplate": { "alias": "filterIconTemplate"; "required": false; }; "searchIconTemplate": { "alias": "searchIconTemplate"; "required": false; }; "arrowIconTemplate": { "alias": "arrowIconTemplate"; "required": false; }; }, { "selectionChange": "selectionChange"; "searchChange": "searchChange"; }, never, never, true, never>;
}

export { AlertComponent, BadgeComponent, ButtonComponent, CclUiComponents, CustomDateFieldComponent, DataTableComponent, DateFieldComponent, DateRangeFieldComponent, DropdownComponent, FormFieldWrapperComponent, InputComponent, LoadingComponent, ModalComponent, PaginationComponent, SearchbarComponent, SelectComponent, TextareaComponent, ToastComponent };
export type { BadgeShape, BadgeSize, BadgeVariant, DataTableColumn, DateRangeValue, DropdownOption, LoadingSize, LoadingVariant, SelectOption };