ngx-tw/index.d.ts

A comprehensive Angular component library built with Tailwind CSS, providing a modern and customizable set of UI components for Angular applications.

import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import * as _angular_cdk_overlay from '@angular/cdk/overlay';
import { Overlay, BlockScrollStrategy, ConnectedPosition } from '@angular/cdk/overlay';
import * as i0 from '@angular/core';
import { OnInit, ViewContainerRef, TemplateRef, ChangeDetectorRef, ElementRef, EventEmitter, AfterViewInit, QueryList, OnChanges, SimpleChanges, AfterContentInit, OnDestroy, NgZone } from '@angular/core';
import { ControlValueAccessor, FormControl, NgControl } from '@angular/forms';
import { Dialog, DialogConfig, DialogRef } from '@angular/cdk/dialog';
export { DIALOG_DATA, DialogRef } from '@angular/cdk/dialog';
import { ComponentType } from '@angular/cdk/portal';
import { CdkAccordionItem, CdkAccordion } from '@angular/cdk/accordion';
import { HttpClient } from '@angular/common/http';
import * as i1 from '@angular/common';
import { CdkMenuTrigger } from '@angular/cdk/menu';
import { LiveAnnouncer } from '@angular/cdk/a11y';
import { NavigationExtras, Router, ActivatedRoute } from '@angular/router';
import { DataSource } from '@angular/cdk/table';

type AlertType = 'info' | 'error' | 'warning';
interface IAlert {
    title: string;
    description?: string;
    type: AlertType;
    duration: number;
    icon?: string;
    iconColor?: string;
    showActions?: boolean;
    secondaryActionText?: string;
    primaryActionText?: string;
}

declare class TwAlertService {
    private readonly _overlay;
    private _alert$;
    private _alertsContainerOverlay?;
    constructor(_overlay: Overlay);
    info({ title, description, icon, iconColor, duration, showActions, primaryActionText, secondaryActionText, }: {
        title: string;
        description?: string | null;
        icon?: string | null;
        iconColor?: string | null;
        duration?: number;
        showActions?: boolean;
        secondaryActionText?: string | null;
        primaryActionText?: string | null;
    }): void;
    warning({ title, description, icon, iconColor, duration, showActions, primaryActionText, secondaryActionText, }: {
        title: string;
        description?: string | null;
        icon?: string | null;
        iconColor?: string | null;
        duration?: number;
        showActions?: boolean;
        secondaryActionText?: string | null;
        primaryActionText?: string | null;
    }): void;
    error({ title, description, icon, iconColor, duration, showActions, primaryActionText, secondaryActionText, }: {
        title: string;
        description?: string | null;
        icon?: string | null;
        iconColor?: string | null;
        duration?: number;
        showActions?: boolean;
        secondaryActionText?: string | null;
        primaryActionText?: string | null;
    }): void;
    private notify;
    private _createContainer;
    clearContainer(): void;
    get alerts(): rxjs.Observable<IAlert | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwAlertService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TwAlertService>;
}

declare class TwAlerts implements OnInit {
    private readonly _alertService;
    private readonly _cd;
    private static _notificationRef;
    alertsContainer?: ViewContainerRef;
    alertTemplate?: TemplateRef<any>;
    private _subscribed;
    private _embeddedViewRefs;
    private _subsciption$$?;
    constructor(_alertService: TwAlertService, _cd: ChangeDetectorRef);
    ngOnDestroy(): void;
    ngOnInit(): void;
    withDefaults(notification: IAlert): IAlert;
    getDisplayedIcon(type: AlertType): "hero:information-circle" | "hero:exclamation-circle" | "hero:exclamation-triangle";
    getDisplayedIconColor(type: AlertType): "bg-blue-100 text-blue-500" | "bg-red-100 text-red-500" | "bg-yellow-100 text-yellow-500";
    private render;
    close(notificationRef: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwAlerts, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwAlerts, "tw-alerts", never, {}, {}, never, never, true, never>;
}

type ColorTypes = 'primary' | 'accent' | 'danger';

type InputTypes = 'text' | 'password' | 'email' | 'color' | 'date' | 'email' | 'number' | 'month' | 'search' | 'tel' | 'time' | 'url' | 'week';
interface InputField {
    iconSuffix?: string;
    iconSuffixClass?: string;
    iconPrefix?: string;
    iconPrefixClass?: string;
    twClass?: string;
    name: string;
    label: string;
    maxLength?: number;
    minLength?: number;
    required: string | boolean;
    pattern: string | RegExp;
    placeholder: string;
    disabled: boolean;
    inputType: InputTypes;
    color?: ColorTypes;
    showLabel: boolean;
    multiline: boolean;
}

declare class AutoCompleteManager<T> {
    private valueChangeObservable;
    filteredSuggestions: T[];
    filterFn: (value: string, item: T) => boolean;
    keyFactory: ((item: T) => {
        key: string;
        value: string;
    }) | undefined;
    isOpen: boolean;
    disabled: boolean;
    private _suggestions;
    set suggestions(value: T[] | Observable<T[]>);
    get suggestions(): T[] | Observable<T[]>;
    constructor(valueChangeObservable: Observable<string>);
    init(): void;
    filterSuggestions(value: string): Observable<T[]>;
    getDisplayText(item: any): string;
    openDropdown(): void;
    closeDropdown(): void;
    selectSuggestion(suggestion: any): boolean;
}

declare class TwAutocomplete implements OnInit, ControlValueAccessor, InputField {
    elementRef: ElementRef;
    private overlay;
    iconSuffix?: string;
    iconSuffixClass?: string;
    iconPrefix?: string;
    iconPrefixClass?: string;
    twClass?: string;
    name: string;
    label: string;
    maxLength?: number;
    minLength?: number;
    required: string | boolean;
    pattern: string | RegExp;
    placeholder: string;
    set disabled(value: boolean);
    get disabled(): boolean;
    inputType: InputTypes;
    color?: ColorTypes;
    showLabel: boolean;
    multiline: boolean;
    set suggestions(value: any[] | Observable<any[]>);
    get suggestions(): any[] | Observable<any[]>;
    set keyFactory(value: ((item: any) => {
        key: string;
        value: string;
    }) | undefined);
    get keyFactory(): ((item: any) => {
        key: string;
        value: string;
    }) | undefined;
    optionTemplate: TemplateRef<any> | null;
    set filterFn(fn: (value: string, item: any) => boolean);
    get filterFn(): (value: string, item: any) => boolean;
    selectionChanged: EventEmitter<any>;
    searchControl: FormControl<any>;
    get filteredSuggestions(): unknown[];
    blockScrollStrategy: BlockScrollStrategy;
    positions: ConnectedPosition[];
    onChange: (value: any) => void;
    onTouched: () => void;
    autoCompleteManager: AutoCompleteManager<unknown>;
    constructor(elementRef: ElementRef, overlay: Overlay);
    ngOnInit(): void;
    selectSuggestion(suggestion: any): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwAutocomplete, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwAutocomplete, "tw-autocomplete", never, { "iconSuffix": { "alias": "iconSuffix"; "required": false; }; "iconSuffixClass": { "alias": "iconSuffixClass"; "required": false; }; "iconPrefix": { "alias": "iconPrefix"; "required": false; }; "iconPrefixClass": { "alias": "iconPrefixClass"; "required": false; }; "twClass": { "alias": "twClass"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "required": { "alias": "required"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "inputType": { "alias": "inputType"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; "keyFactory": { "alias": "keyFactory"; "required": false; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; }, { "selectionChanged": "selectionChanged"; }, never, never, true, never>;
}

declare class TwButtonGroupItem {
    value: any;
    disabled: boolean;
    content: TemplateRef<any> | null;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TwButtonGroupItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwButtonGroupItem, "tw-btn-group-item", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class TwButtonGroup implements AfterViewInit {
    children?: QueryList<TwButtonGroupItem>;
    selectedIndexChange: EventEmitter<number>;
    itemSelected: EventEmitter<{
        selectedIndex: number;
        selectedValue: any;
    }>;
    selectedIndex: number;
    orientation: 'vertical' | 'horizontal';
    constructor();
    ngAfterViewInit(): void;
    changeSelection(index: number, value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwButtonGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwButtonGroup, "tw-btn-group", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "itemSelected": "itemSelected"; }, ["children"], never, true, never>;
}

type ButtonType = 'basic' | 'outlined' | 'filled';
type RoundedTypes = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | 'full';
interface TwButtonInterface {
    /**
     * The type fo the button : basic, outlined, filled
     * @default basic
     */
    type?: ButtonType;
    /**
     * @default md
     */
    rounded?: RoundedTypes;
    color?: ColorTypes;
    isSubmit?: boolean;
    disabled?: boolean;
    twClass?: string;
    title?: string;
    href?: string;
    target?: string;
}

declare class TwButtonIcon implements OnInit, TwButtonInterface {
    type?: ButtonType;
    color?: ColorTypes;
    isSubmit?: boolean;
    twClass?: string;
    disabled?: boolean;
    title?: string;
    svgIcon?: string;
    svgIconSize: number;
    href?: string;
    target?: string;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwButtonIcon, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwButtonIcon, "tw-button-icon", never, { "type": { "alias": "type"; "required": false; }; "color": { "alias": "color"; "required": false; }; "isSubmit": { "alias": "isSubmit"; "required": false; }; "twClass": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "title": { "alias": "title"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; "svgIconSize": { "alias": "svgIconSize"; "required": false; }; "href": { "alias": "href"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TwButton implements TwButtonInterface {
    type?: ButtonType;
    isSubmit?: boolean;
    rounded?: RoundedTypes;
    disabled?: boolean;
    color?: ColorTypes;
    twClass?: string;
    title?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwButton, "tw-button", never, { "type": { "alias": "type"; "required": false; }; "isSubmit": { "alias": "isSubmit"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; "twClass": { "alias": "twClass"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface CalendarDate {
    date: Date;
    isCurrentMonth: boolean;
    isToday: boolean;
    isSelected: boolean;
    isInRange: boolean;
    isRangeStart: boolean;
    isRangeEnd: boolean;
    isDisabled: boolean;
}
declare class TwCalendar implements OnInit, OnChanges {
    selectedDate: Date | null;
    rangeStart: Date | null;
    rangeEnd: Date | null;
    minDate: Date | null;
    maxDate: Date | null;
    isRange: boolean;
    displayDate: Date;
    dateSelected: EventEmitter<Date>;
    rangeSelected: EventEmitter<{
        start: Date;
        end: Date | null;
    }>;
    currentDate: Date;
    calendarDates: CalendarDate[];
    viewMode: 'days' | 'months' | 'years';
    years: number[];
    yearRangeStart: number;
    weekdays: string[];
    months: string[];
    get currentMonthName(): string;
    get currentYear(): number;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    generateCalendarDates(): void;
    createCalendarDate(date: Date, isCurrentMonth: boolean): CalendarDate;
    isDateDisabled(date: Date): boolean;
    getStartOfDay(date: Date): Date;
    getEndOfDay(date: Date): Date;
    selectDate(date: CalendarDate): void;
    unSelectAllOtherDates(date: CalendarDate): void;
    changeMonth(delta: number): void;
    changeYear(delta: number): void;
    switchView(mode: 'days' | 'months' | 'years'): void;
    generateYearRange(): void;
    isYearDisabled(year: number): boolean;
    isMonthDisabled(monthIndex: number): boolean;
    selectMonth(monthIndex: number): void;
    selectYear(year: number): void;
    changeYearRange(delta: number): void;
    isPrevMonthDisabled(): boolean;
    isNextMonthDisabled(): boolean;
    isPrevYearDisabled(): boolean;
    isNextYearDisabled(): boolean;
    isPrevYearRangeDisabled(): boolean;
    isNextYearRangeDisabled(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwCalendar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwCalendar, "tw-calendar", never, { "selectedDate": { "alias": "selectedDate"; "required": false; }; "rangeStart": { "alias": "rangeStart"; "required": false; }; "rangeEnd": { "alias": "rangeEnd"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "isRange": { "alias": "isRange"; "required": false; }; "displayDate": { "alias": "displayDate"; "required": false; }; }, { "dateSelected": "dateSelected"; "rangeSelected": "rangeSelected"; }, never, never, true, never>;
}

interface TwChipInterface {
    label: string;
    image?: string;
    isDeletable?: boolean;
}

declare class TwChipItem implements TwChipInterface {
    label: string;
    image?: string | undefined;
    isDeletable?: boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwChipItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwChipItem, "tw-chip-item", never, { "label": { "alias": "label"; "required": true; }; "image": { "alias": "image"; "required": false; }; "isDeletable": { "alias": "isDeletable"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TwChipList implements AfterViewInit, ControlValueAccessor {
    elementRef: ElementRef;
    private _cd;
    children?: QueryList<TwChipItem>;
    iconSuffix?: string;
    iconSuffixClass?: string;
    iconPrefix?: string;
    iconPrefixClass?: string;
    color?: ColorTypes;
    keyCodeSeperator?: string;
    isEditable: boolean;
    allowUnknownItemInsertion: boolean;
    placeholder: string;
    newContentTransformer: (text: string) => TwChipInterface;
    itemRemoved: EventEmitter<{
        chip: TwChipInterface;
        index: number;
    }>;
    newItemContent?: ElementRef<HTMLDivElement>;
    autoCompleteKeyFactory: ((item: any) => {
        key: string;
        value: string;
    }) | undefined;
    autoCompleteOptionTemplate: TemplateRef<any> | null;
    autoCompleteFilterFn: ((value: string, item: any) => boolean) | undefined;
    set autoCompleteSuggestions(value: any[] | Observable<any[]>);
    get autoCompleteSuggestions(): any[] | Observable<any[]>;
    positions: _angular_cdk_overlay.ConnectedPosition[];
    chipItems: TwChipItem[];
    _onChange: ((value: any) => void)[];
    _onTouched: (() => void)[];
    blockScrollStrategy: BlockScrollStrategy;
    get filteredSuggestions(): any[] | undefined;
    autoCompleteManager?: AutoCompleteManager<any>;
    private _autoCompleteSuggestions?;
    constructor(elementRef: ElementRef, _cd: ChangeDetectorRef, overlay: Overlay);
    ngAfterViewInit(): void;
    contentKeydown(event: KeyboardEvent): void;
    removeItem(index: number): void;
    selectSuggestion(suggestion: any): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onChange(value: any): void;
    onTouched(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwChipList, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwChipList, "tw-chip-list", never, { "iconSuffix": { "alias": "iconSuffix"; "required": false; }; "iconSuffixClass": { "alias": "iconSuffixClass"; "required": false; }; "iconPrefix": { "alias": "iconPrefix"; "required": false; }; "iconPrefixClass": { "alias": "iconPrefixClass"; "required": false; }; "color": { "alias": "color"; "required": false; }; "keyCodeSeperator": { "alias": "keyCodeSeperator"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "allowUnknownItemInsertion": { "alias": "allowUnknownItemInsertion"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "newContentTransformer": { "alias": "newContentTransformer"; "required": false; }; "autoCompleteKeyFactory": { "alias": "autoCompleteKeyFactory"; "required": false; }; "autoCompleteOptionTemplate": { "alias": "autoCompleteOptionTemplate"; "required": false; }; "autoCompleteFilterFn": { "alias": "autoCompleteFilterFn"; "required": false; }; "autoCompleteSuggestions": { "alias": "autoCompleteSuggestions"; "required": false; }; "chipItems": { "alias": "chipItems"; "required": false; }; }, { "itemRemoved": "itemRemoved"; }, ["children"], never, true, never>;
}

declare class TwChip implements TwChipInterface {
    label: string;
    image?: string | undefined;
    isDeletable?: boolean | undefined;
    twClass?: string;
    deleteItem: EventEmitter<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwChip, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwChip, "tw-chip", never, { "label": { "alias": "label"; "required": true; }; "image": { "alias": "image"; "required": false; }; "isDeletable": { "alias": "isDeletable"; "required": false; }; "twClass": { "alias": "twClass"; "required": false; }; }, { "deleteItem": "deleteItem"; }, never, never, true, never>;
}

interface MaskConfig {
    mask: string | RegExp[];
    guide?: boolean;
    placeholderChar?: string;
    keepCharPositions?: boolean;
    showMask?: boolean;
}
interface MaskedInputField extends InputField {
    maskConfig: MaskConfig;
    allowAlphanumeric?: boolean;
    validator?: (value: string) => boolean | string;
}

interface DateRange {
    start: Date;
    end: Date | null;
    preset?: string;
}
declare class TwDateRangePicker implements OnInit, ControlValueAccessor {
    elementRef: ElementRef;
    isOpen: boolean;
    startDate: Date | null;
    endDate: Date | null;
    minDate: Date | null;
    maxDate: Date | null;
    disabled: boolean;
    isMobileView: boolean;
    dateRangeChange: EventEmitter<DateRange>;
    openChanged: EventEmitter<boolean>;
    dateRange: DateRange;
    private originalRange;
    startDateModel: string;
    endDateModel: string;
    selectedPreset: string;
    leftCalendarDate: Date;
    rightCalendarDate: Date;
    dateMaskConfig: MaskConfig;
    presets: {
        id: string;
        label: string;
    }[];
    positions: _angular_cdk_overlay.ConnectedPosition[];
    blockScrollStrategy: BlockScrollStrategy;
    get isValid(): boolean | null;
    onChange: (value: DateRange) => void;
    onTouched: () => void;
    constructor(elementRef: ElementRef, overlay: Overlay);
    ngOnInit(): void;
    checkMobileView(): void;
    writeValue(value: DateRange | null): void;
    registerOnChange(fn: (value: DateRange) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    toggleOpen(): void;
    closeDropdown(): void;
    onRangeSelected(range: {
        start: Date;
        end: Date | null;
    }): void;
    onRightCalendarChange(date: Date): void;
    onLeftCalendarChange(date: Date): void;
    selectPreset(presetId: string): void;
    applySelection(): void;
    cancelSelection(): void;
    formatDate(date: Date | null): string;
    formatDateRangeDisplay(): string;
    parseInputDate(dateStr: string): Date | null;
    validateDate: (dateType: "start" | "end") => (value: string) => boolean | string;
    checkDateInterval(date: Date): string | true;
    onStartDateInput(value: string): void;
    onEndDateInput(value: string): void;
    formatDateForInput(date: Date | null): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwDateRangePicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwDateRangePicker, "tw-date-range-picker", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dateRange": { "alias": "dateRange"; "required": false; }; }, { "dateRangeChange": "dateRangeChange"; "openChanged": "openChanged"; }, never, never, true, never>;
}

declare class TwDialog {
    private readonly _dialog;
    constructor(_dialog: Dialog);
    open<R = unknown, C = unknown, D = unknown>(component: ComponentType<C>, dialogConfig?: DialogConfig<D, DialogRef<R, C>>): rxjs.Observable<R | undefined>;
    openWithRef<R = unknown, C = unknown, D = unknown>(component: ComponentType<C>, dialogConfig?: DialogConfig<D, DialogRef<R, C>>): DialogRef<R, C>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwDialog, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TwDialog>;
}

declare class TwExpanderContent {
    content?: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwExpanderContent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwExpanderContent, "tw-expander-content", never, {}, {}, never, ["*"], true, never>;
}

declare class TwExpanderHeader {
    showIcon: boolean;
    hideDivider: boolean;
    content?: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwExpanderHeader, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwExpanderHeader, "tw-expander-header", never, { "showIcon": { "alias": "showIcon"; "required": false; }; "hideDivider": { "alias": "hideDivider"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class TwExpanderItem implements AfterContentInit {
    expanded: boolean;
    expandedChange: EventEmitter<any>;
    opened: EventEmitter<any>;
    closed: EventEmitter<any>;
    header: TwExpanderHeader;
    content: TwExpanderContent;
    expanderItem?: CdkAccordionItem;
    private _parent?;
    ngAfterContentInit(): void;
    set parent(value: TwExpanderGroup | undefined);
    get parent(): TwExpanderGroup | undefined;
    calculateHeight(elt: HTMLElement): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwExpanderItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwExpanderItem, "tw-expander", never, { "expanded": { "alias": "expanded"; "required": false; }; }, { "expandedChange": "expanded"; "opened": "opened"; "closed": "closed"; }, ["header", "content"], never, true, never>;
}

declare class TwExpanderGroup implements AfterContentInit {
    multi: boolean;
    expanderGroup?: CdkAccordion;
    expanderItems?: QueryList<TwExpanderItem>;
    ngAfterContentInit(): void;
    closeAll(): void;
    openAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwExpanderGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwExpanderGroup, "tw-expander-group", never, { "multi": { "alias": "multi"; "required": false; }; }, {}, ["expanderItems"], ["*"], true, never>;
}

declare class TwExpanderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TwExpanderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TwExpanderModule, never, [typeof TwExpanderItem, typeof TwExpanderContent, typeof TwExpanderHeader, typeof TwExpanderGroup], [typeof TwExpanderItem, typeof TwExpanderContent, typeof TwExpanderHeader, typeof TwExpanderGroup]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TwExpanderModule>;
}

declare class TwIcon implements AfterViewInit, OnDestroy {
    private readonly _host;
    private readonly _httpClient;
    private static ICON_REGISTRY;
    private _retrievalSubscription$?;
    private _svgIcon?;
    private _size;
    set size(value: number);
    get size(): number;
    set svgIcon(value: string | undefined);
    get svgIcon(): string | undefined;
    constructor(_host: ElementRef<HTMLElement>, _httpClient: HttpClient);
    ngAfterViewInit(): void;
    private _setStyles;
    private _setIcon;
    ngOnDestroy(): void;
    private _retriveIcon;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwIcon, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwIcon, "tw-icon", never, { "size": { "alias": "size"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class TwInputField implements ControlValueAccessor, InputField {
    private readonly _ngControl?;
    iconSuffix?: string;
    iconSuffixClass?: string;
    iconPrefix?: string;
    iconPrefixClass?: string;
    twClass?: string;
    name: string;
    label: string;
    value?: string;
    maxLength?: number;
    minLength?: number;
    required: string | boolean;
    pattern: string | RegExp;
    placeholder: string;
    disabled: boolean;
    inputType: InputTypes;
    color?: ColorTypes;
    showLabel: boolean;
    multiline: boolean;
    private _onChangeFns;
    private _onTouchedFns;
    get errors(): string | null;
    constructor(_ngControl?: NgControl | undefined);
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    ngOnInit(): void;
    onChange(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwInputField, [{ optional: true; self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwInputField, "tw-input-field", never, { "iconSuffix": { "alias": "iconSuffix"; "required": false; }; "iconSuffixClass": { "alias": "iconSuffixClass"; "required": false; }; "iconPrefix": { "alias": "iconPrefix"; "required": false; }; "iconPrefixClass": { "alias": "iconPrefixClass"; "required": false; }; "twClass": { "alias": "twClass"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "required": { "alias": "required"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "inputType": { "alias": "inputType"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "multiline": { "alias": "multiline"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TwMaskedInput implements ControlValueAccessor, MaskedInputField, OnInit {
    private readonly _ngControl?;
    multiline: boolean;
    iconSuffix?: string;
    iconSuffixClass?: string;
    iconPrefix?: string;
    iconPrefixClass?: string;
    twClass?: string;
    name: string;
    label: string;
    value?: string;
    maxLength?: number;
    minLength?: number;
    required: string | boolean;
    pattern: string | RegExp;
    placeholder: string;
    disabled: boolean;
    inputType: InputTypes;
    color?: ColorTypes;
    showLabel: boolean;
    maskConfig: MaskConfig;
    allowAlphanumeric: boolean;
    validator?: (rawValue: string) => boolean | string;
    inputElement: ElementRef;
    private _onChangeFns;
    private _onTouchedFns;
    private _maskedValue;
    private _validationError;
    get errors(): string | null;
    constructor(_ngControl?: NgControl | undefined);
    ngOnInit(): void;
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    onChange(event: Event): void;
    /**
     * Extracts the raw value from the masked input
     */
    private extractRawValue;
    /**
     * Applies the mask to the input value
     */
    private applyMask;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwMaskedInput, [{ optional: true; self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwMaskedInput, "tw-masked-input", never, { "multiline": { "alias": "multiline"; "required": false; }; "iconSuffix": { "alias": "iconSuffix"; "required": false; }; "iconSuffixClass": { "alias": "iconSuffixClass"; "required": false; }; "iconPrefix": { "alias": "iconPrefix"; "required": false; }; "iconPrefixClass": { "alias": "iconPrefixClass"; "required": false; }; "twClass": { "alias": "twClass"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "required": { "alias": "required"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "inputType": { "alias": "inputType"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "maskConfig": { "alias": "maskConfig"; "required": false; }; "allowAlphanumeric": { "alias": "allowAlphanumeric"; "required": false; }; "validator": { "alias": "validator"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TwMenuItemDirective {
    template: TemplateRef<any>;
    menu?: TwMenu | string;
    disabled: boolean;
    type: 'check' | 'radio' | 'classic';
    get triggerMenu(): TemplateRef<unknown> | undefined;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<TwMenuItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TwMenuItemDirective, "[twMenuItem]", never, { "menu": { "alias": "twMenuItem"; "required": false; }; "disabled": { "alias": "twMenuItemDisabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TwMenu {
    menuTemplate?: TemplateRef<unknown>;
    menuItems?: QueryList<TwMenuItemDirective>;
    panelWidth?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwMenu, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwMenu, "tw-menu", never, { "panelWidth": { "alias": "panelWidth"; "required": false; }; }, {}, ["menuItems"], never, true, never>;
}

type TwMenuTriggerPositions = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
declare class TwMenuTriggerDirective extends CdkMenuTrigger {
    private readonly _cd;
    constructor(_cd: ChangeDetectorRef);
    menu: TwMenu;
    set position(value: TwMenuTriggerPositions);
    onClick(event: Event): void;
    ngAfterContentInit(): void;
    private _getPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwMenuTriggerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TwMenuTriggerDirective, "[twMenuTriggerFor]", never, { "menu": { "alias": "twMenuTriggerFor"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TwMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TwMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TwMenuModule, never, [typeof i1.CommonModule, typeof TwMenuTriggerDirective, typeof TwMenu, typeof TwMenuItemDirective], [typeof TwMenuTriggerDirective, typeof TwMenu, typeof TwMenuItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TwMenuModule>;
}

declare class TwStickyContentHeader {
    top: number;
    zIndex: number;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwStickyContentHeader, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwStickyContentHeader, "tw-sticky-content-header", never, { "top": { "alias": "top"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/** Event object emitted by MatOption when selected or deselected. */
declare class OptionSelectionChange<T = any> {
    /** Reference to the option that emitted the event. */
    source: TwOption<T>;
    /** Whether the change in the option's value was a result of a user action. */
    isUserInput: boolean;
    /** Content element */
    innerHTML: string | null;
    constructor(
    /** Reference to the option that emitted the event. */
    source: TwOption<T>, 
    /** Whether the change in the option's value was a result of a user action. */
    isUserInput?: boolean, 
    /** Content element */
    innerHTML?: string | null);
}
declare class TwOption<T = any> implements OnInit {
    private readonly element;
    selected: boolean;
    active: boolean;
    value: any;
    disabled: boolean;
    id: string;
    textOnly: boolean | string;
    useSelectedIndicator: boolean;
    indicator: 'left' | 'right' | null;
    readonly onSelectionChange: EventEmitter<OptionSelectionChange<T>>;
    contentElement: ElementRef;
    constructor(element: ElementRef<HTMLElement>);
    ngOnInit(): void;
    /** Emits the selection change event. */
    private _emitSelectionChangeEvent;
    /** Selects the option. */
    select(isUserInput?: boolean): void;
    deselect(isUserInput?: boolean): void;
    /**
     * This method sets display styles on the option to make it appear
     * active. This is used by the ActiveDescendantKeyManager so key
     * events will display the proper options as active on arrow key events.
     */
    setActiveStyles(): void;
    /**
     * This method removes display styles on the option that made it appear
     * active. This is used by the ActiveDescendantKeyManager so key
     * events will display the proper options as active on arrow key events.
     */
    setInactiveStyles(): void;
    /** Gets the label to be used when determining whether the option should be focused. */
    getLabel(): string;
    getInnerHTML(forceHTML?: boolean): string | null;
    /**
     * `Selects the option while indicating the selection came from the user. Used to
     * determine if the select's view -> model callback should be invoked.`
     */
    selectViaInteraction(): void;
    scrollIntoView(): void;
    setActiveStylesWithDelay(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwOption<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwOption<any>, "tw-option", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "textOnly": { "alias": "textOnly"; "required": false; }; "useSelectedIndicator": { "alias": "useSelectedIndicator"; "required": false; }; "indicator": { "alias": "indicator"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, never, ["*"], true, never>;
}

declare class TwSelect implements ControlValueAccessor, OnInit, AfterContentInit {
    cdr: ChangeDetectorRef;
    elementRef: ElementRef;
    overlay: Overlay;
    private readonly zone;
    private readonly liveAnnouncer;
    placeholder: string;
    disabled: boolean;
    id: string;
    compareWith: (o1: any, o2: any) => boolean;
    get value(): any;
    set value(newValue: any);
    arrowContainer: ElementRef<HTMLDivElement>;
    inputContainer: ElementRef<HTMLDivElement>;
    trigger: ElementRef;
    options: QueryList<TwOption>;
    color?: ColorTypes;
    twClass?: string;
    inputSticky: boolean;
    get htmlValue(): string | null;
    onChange: (value: any) => void;
    onTouched: () => void;
    innerValue: any;
    wasTouched: boolean;
    isOpen: boolean;
    overlayWidth: string;
    private _keyManager;
    _scrollStrategy: BlockScrollStrategy;
    positions: ConnectedPosition[];
    /** Combined stream of all of the child options' change events. */
    readonly optionSelectionChanges: Observable<OptionSelectionChange>;
    constructor(cdr: ChangeDetectorRef, elementRef: ElementRef, overlay: Overlay, zone: NgZone, liveAnnouncer: LiveAnnouncer);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(isDisabled: boolean): void;
    openPanel(): void;
    closePanel(): void;
    backdropClick(): void;
    selectOption(newValue: any, innerHTML: string | null, touched: boolean, forceUpdate?: boolean): void;
    onSelect(source: TwOption, isUserInput: boolean, innerHTML: string | null): void;
    handleKeydown(event: KeyboardEvent): void;
    private _handleClosedKeydown;
    /** Handles keyboard events when the selected is open. */
    private _handleOpenKeydown;
    private _initKeyManager;
    private _updateKeyManagerActiveItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwSelect, "tw-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "value": { "alias": "value"; "required": false; }; "color": { "alias": "color"; "required": false; }; "twClass": { "alias": "twClass"; "required": false; }; "inputSticky": { "alias": "inputSticky"; "required": false; }; }, {}, ["options"], ["[arrow-icon]", "input", "tw-option", "*"], true, never>;
}

declare class TwTabItem {
    label?: string;
    route?: {
        path: string[];
        extras?: NavigationExtras;
    };
    content?: TemplateRef<any>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TwTabItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwTabItem, "tw-tab", never, { "label": { "alias": "label"; "required": false; }; "route": { "alias": "route"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class TwTabGroup implements AfterViewInit {
    private readonly _cd;
    private readonly _router;
    private readonly _activatedRoute;
    children?: QueryList<TwTabItem>;
    selectedIndex: number;
    color?: ColorTypes;
    behavior?: 'default' | 'router';
    selectionChanged: EventEmitter<number>;
    get currentContent(): TemplateRef<any> | null;
    constructor(_cd: ChangeDetectorRef, _router: Router, _activatedRoute: ActivatedRoute);
    ngAfterViewInit(): void;
    navigate(route?: {
        path: string[];
        extras?: NavigationExtras;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwTabGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwTabGroup, "tw-tab-group", never, { "color": { "alias": "color"; "required": false; }; "behavior": { "alias": "behavior"; "required": false; }; }, { "selectionChanged": "selectionChanged"; }, ["children"], never, true, never>;
}

declare class TwHeaderCellDefDirective {
    template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<TwHeaderCellDefDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TwHeaderCellDefDirective, "[twHeaderCellDef]", never, {}, {}, never, never, true, never>;
}
declare class TwCellDefDirective<T> {
    template: TemplateRef<T>;
    constructor(template: TemplateRef<T>);
    static ɵfac: i0.ɵɵFactoryDeclaration<TwCellDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TwCellDefDirective<any>, "[twCellDef]", never, {}, {}, never, never, true, never>;
}
declare class TwRowDefDirective<T> {
    template: TemplateRef<T>;
    displayColumns: string[];
    getLink?: (row: T) => string[];
    constructor(template: TemplateRef<T>);
    static ɵfac: i0.ɵɵFactoryDeclaration<TwRowDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TwRowDefDirective<any>, "[twRowDef]", never, { "displayColumns": { "alias": "twRowDefDisplayColumns"; "required": true; }; "getLink": { "alias": "twRowDefLink"; "required": false; }; }, {}, never, never, true, never>;
}
declare class TwColumnDefDirective<T> {
    name: string;
    headerCellDef?: TwHeaderCellDefDirective;
    cellDef?: TwCellDefDirective<T | {
        $implicit: T;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwColumnDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TwColumnDefDirective<any>, "[twColumnDef]", never, { "name": { "alias": "twColumnDef"; "required": true; }; }, {}, ["headerCellDef", "cellDef"], never, true, never>;
}
declare const TwTableColumnRowDefinitions: (typeof TwHeaderCellDefDirective | typeof TwColumnDefDirective)[];

interface ITableQueryChange {
    pageIndex: number;
    pageSize: number;
    searchTerm?: string;
}
declare class TwTable<T> implements OnDestroy, AfterViewInit {
    private readonly _route;
    private _dataSource?;
    get dataSource(): T[];
    set dataSource(value: T[]);
    dataLoading?: boolean;
    displayCheckbox: boolean;
    displayPagination: boolean;
    displayEmptyTemplate: boolean;
    totalItemsCount: number;
    pageSizes: number[];
    itemClick: EventEmitter<T>;
    queryChange: EventEmitter<ITableQueryChange>;
    columnDefs?: QueryList<TwColumnDefDirective<T>>;
    rowDef?: TwRowDefDirective<T>;
    _selectedPageSize: number;
    get selectedPageSize(): number;
    set selectedPageSize(value: number);
    internalSource?: DataSource<T>;
    private _pageNumber;
    get displayColumns(): string[];
    get columns(): TwColumnDefDirective<T>[];
    get totalPagesCount(): number;
    get pageNumber(): number;
    private set pageNumber(value);
    get querySnapshot(): ITableQueryChange;
    private _queryParamSubscription$$?;
    private _currentSearchTerm?;
    private _initializedParams;
    constructor(_route: ActivatedRoute);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    moveNext(): void;
    movePrevious(): void;
    changePageSize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwTable<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwTable<any>, "tw-table", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "dataLoading": { "alias": "dataLoading"; "required": false; }; "displayCheckbox": { "alias": "displayCheckbox"; "required": false; }; "displayPagination": { "alias": "displayPagination"; "required": false; }; "displayEmptyTemplate": { "alias": "displayEmptyTemplate"; "required": false; }; "totalItemsCount": { "alias": "totalItemsCount"; "required": false; }; "pageSizes": { "alias": "pageSizes"; "required": false; }; "selectedPageSize": { "alias": "selectedPageSize"; "required": false; }; }, { "itemClick": "itemClick"; "queryChange": "queryChange"; }, ["rowDef", "columnDefs"], ["*"], true, never>;
}

declare class TwTableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TwTableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TwTableModule, never, [typeof TwTable, typeof TwColumnDefDirective, typeof TwHeaderCellDefDirective, typeof TwCellDefDirective, typeof TwRowDefDirective], [typeof TwTable, typeof TwColumnDefDirective, typeof TwHeaderCellDefDirective, typeof TwCellDefDirective, typeof TwRowDefDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TwTableModule>;
}

declare class TwToolbar {
    header?: string;
    toolbarIcon?: string;
    hideActions: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TwToolbar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwToolbar, "tw-toolbar", never, { "header": { "alias": "header"; "required": false; }; "toolbarIcon": { "alias": "toolbarIcon"; "required": false; }; "hideActions": { "alias": "hideActions"; "required": false; }; }, {}, never, ["[subHeader]"], true, never>;
}

declare class TwSwitch implements ControlValueAccessor {
    label?: string;
    twClass?: string;
    toggleChange: EventEmitter<boolean>;
    disabled: boolean;
    color?: ColorTypes;
    value: boolean;
    private _alternateValues;
    private _onChangeFns;
    private _onTouchedFns;
    constructor();
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    ngOnInit(): void;
    onChange(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwSwitch, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwSwitch, "tw-switch", never, { "label": { "alias": "label"; "required": false; }; "twClass": { "alias": "twClass"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "toggleChange": "toggleChange"; }, never, never, true, never>;
}

declare class TwSpinner {
    color?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwSpinner, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwSpinner, "tw-spinner", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TwSkeletonComponent {
    private host;
    width?: string;
    height?: string;
    className?: string;
    template: TemplateRef<any> | null;
    constructor(host: ElementRef<HTMLElement>);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwSkeletonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwSkeletonComponent, "tw-skeleton-rect", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TwSkeletonDirective implements OnChanges {
    private tpl;
    private vcr;
    isLoading: boolean;
    size: number;
    template: TemplateRef<any> | null;
    width: string;
    height: string;
    className?: string;
    constructor(tpl: TemplateRef<any>, vcr: ViewContainerRef);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwSkeletonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TwSkeletonDirective, "[twSkeleton]", never, { "isLoading": { "alias": "twSkeleton"; "required": false; }; "size": { "alias": "twSkeletonRepeat"; "required": false; }; "template": { "alias": "twSkeletonTemplate"; "required": false; }; "width": { "alias": "twSkeletonWidth"; "required": true; }; "height": { "alias": "twSkeletonHeight"; "required": true; }; "className": { "alias": "twSkeletonClassName"; "required": false; }; }, {}, never, never, true, never>;
}

declare class NgxTwModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTwModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxTwModule, never, [typeof TwButton, typeof TwButtonGroup, typeof TwExpanderModule, typeof TwStickyContentHeader, typeof TwInputField, typeof TwMaskedInput, typeof TwMenuModule, typeof TwSelect, typeof TwStickyContentHeader, typeof TwTabGroup, typeof TwTabItem, typeof TwTableModule, typeof TwToolbar, typeof TwSwitch, typeof TwOption, typeof TwChip, typeof TwChipList, typeof TwSpinner, typeof TwAlerts, typeof TwSkeletonComponent, typeof TwSkeletonDirective, typeof TwAutocomplete, typeof TwChipItem, typeof TwDateRangePicker, typeof TwCalendar], [typeof TwButton, typeof TwButtonGroup, typeof TwExpanderModule, typeof TwStickyContentHeader, typeof TwInputField, typeof TwMaskedInput, typeof TwMenuModule, typeof TwSelect, typeof TwStickyContentHeader, typeof TwTabGroup, typeof TwTabItem, typeof TwTableModule, typeof TwToolbar, typeof TwSwitch, typeof TwOption, typeof TwChip, typeof TwChipList, typeof TwSpinner, typeof TwAlerts, typeof TwSkeletonComponent, typeof TwSkeletonDirective, typeof TwAutocomplete, typeof TwChipItem, typeof TwDateRangePicker, typeof TwCalendar]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxTwModule>;
}

export { NgxTwModule, OptionSelectionChange, TwAlertService, TwAlerts, TwAutocomplete, TwButton, TwButtonGroup, TwButtonGroupItem, TwButtonIcon, TwCalendar, TwCellDefDirective, TwChip, TwChipItem, TwChipList, TwColumnDefDirective, TwDateRangePicker, TwDialog, TwExpanderContent, TwExpanderGroup, TwExpanderHeader, TwExpanderItem, TwExpanderModule, TwHeaderCellDefDirective, TwIcon, TwInputField, TwMaskedInput, TwMenu, TwMenuItemDirective, TwMenuModule, TwMenuTriggerDirective, TwOption, TwRowDefDirective, TwSelect, TwSkeletonComponent, TwSkeletonDirective, TwSpinner, TwStickyContentHeader, TwSwitch, TwTabGroup, TwTabItem, TwTable, TwTableColumnRowDefinitions, TwTableModule, TwToolbar };
export type { AlertType, CalendarDate, DateRange, IAlert, ITableQueryChange, MaskConfig, MaskedInputField, TwChipInterface };