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 i0 from '@angular/core';
import { TemplateRef, InjectionToken, Injector, OnInit, AfterViewInit, OnDestroy, ElementRef, EventEmitter, ChangeDetectorRef, QueryList, OnChanges, SimpleChanges, AfterContentInit, NgZone, ViewContainerRef, Provider } from '@angular/core';
import * as _angular_cdk_overlay from '@angular/cdk/overlay';
import { OverlayRef, Overlay, BlockScrollStrategy, ConnectedPosition } from '@angular/cdk/overlay';
import { ControlValueAccessor, Validator, FormControl, AbstractControl, ValidationErrors, NgControl } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
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';
import * as ngx_tw from 'ngx-tw';
import { AnimationEvent } from '@angular/animations';

declare class TwNotificationData {
    type?: TwNotificationType;
    title?: string;
    text?: string;
    template?: TemplateRef<any>;
    templateContext?: any;
    autoClose?: boolean;
    autoCloseTimeout?: number;
    position?: {
        top: number;
        right: number;
    };
    animation?: {
        fadeOut: number;
        fadeIn: number;
    };
    classes?: {
        [key in TwNotificationClasses]: string;
    };
}
type TwNotificationType = 'warning' | 'info' | 'success' | 'danger';
type TwNotificationClasses = 'container' | 'card' | 'success' | 'info' | 'warning' | 'danger' | 'svg' | 'button';
interface TwNotificationConfig {
    type?: TwNotificationType;
    position?: {
        top: number;
        right: number;
    };
    animation?: {
        fadeOut: number;
        fadeIn: number;
    };
    autoClose?: boolean;
    autoCloseTimeout?: number;
    classes: {
        [key in TwNotificationClasses]: string;
    };
}
declare const defaultTwNotificationConfig: TwNotificationConfig;
declare const TW_NOTIFICATION_CONFIG_TOKEN: InjectionToken<unknown>;

type AlertType = TwNotificationType;
interface IAlert {
    title: string;
    description?: string;
    type: AlertType;
    duration: number;
    icon?: string;
    iconColor?: string;
    showActions?: boolean;
    secondaryActionText?: string;
    primaryActionText?: string;
}

declare class TwNotificationRef {
    private readonly overlay;
    constructor(overlay: OverlayRef);
    close(): void;
    isVisible(): HTMLElement;
    getPosition(): DOMRect;
}

declare class TwNotification {
    private overlay;
    private parentInjector;
    private notificationConfig;
    private lastNotification;
    constructor(overlay: Overlay, parentInjector: Injector, notificationConfig?: TwNotificationConfig);
    show(data: TwNotificationData): TwNotificationRef;
    getPositionStrategy(): _angular_cdk_overlay.GlobalPositionStrategy;
    getPosition(): string;
    getInjector(data: TwNotificationData, notificationRef: TwNotificationRef, parentInjector: Injector): i0.DestroyableInjector;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwNotification, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TwNotification>;
}

declare class TwAlertService {
    private readonly _twNotification;
    private _alert$;
    private _alertsContainerOverlay?;
    constructor(_twNotification: TwNotification);
    /**
     *
     * @deprecated This method is deprecated use TwNotification.show() instead
     */
    info({ title, description, icon, iconColor, duration, showActions, primaryActionText, secondaryActionText, }: {
        title: string;
        description?: string;
        icon?: string | null;
        iconColor?: string | null;
        duration?: number;
        showActions?: boolean;
        secondaryActionText?: string | null;
        primaryActionText?: string | null;
    }): void;
    /**
     *
     * @deprecated This method is deprecated use TwNotification.show() instead
     */
    warning({ title, description, icon, iconColor, duration, showActions, primaryActionText, secondaryActionText, }: {
        title: string;
        description?: string;
        icon?: string | null;
        iconColor?: string | null;
        duration?: number;
        showActions?: boolean;
        secondaryActionText?: string | null;
        primaryActionText?: string | null;
    }): void;
    /**
     *
     * @deprecated This method is deprecated use TwNotification.show() instead
     */
    error({ title, description, icon, iconColor, duration, showActions, primaryActionText, secondaryActionText, }: {
        title: string;
        description?: string;
        icon?: string | null;
        iconColor?: string | null;
        duration?: number;
        showActions?: boolean;
        secondaryActionText?: string | null;
        primaryActionText?: string | null;
    }): void;
    private notify;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwAlertService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TwAlertService>;
}

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;
}

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

declare class TwAutocomplete<T = any> implements OnInit, AfterViewInit, OnDestroy, ControlValueAccessor, Validator, InputField {
    elementRef: ElementRef;
    private overlay;
    private cdr;
    iconSuffix?: string;
    iconSuffixClass?: string;
    iconPrefix?: string;
    iconPrefixClass?: string;
    twClass?: string;
    name: string;
    label: string;
    set maxLength(value: number | undefined);
    get maxLength(): number | undefined;
    private _maxLength?;
    set minLength(value: number | undefined);
    get minLength(): number | undefined;
    private _minLength?;
    set required(value: string | boolean);
    get required(): string | boolean;
    private _required;
    set pattern(value: string | RegExp);
    get pattern(): string | RegExp;
    private _pattern;
    placeholder: string;
    set disabled(value: boolean);
    get disabled(): boolean;
    inputType: InputTypes;
    color?: ColorTypes;
    showLabel: boolean;
    multiline: boolean;
    _value?: T;
    get value(): T | undefined;
    set value(val: T | undefined);
    private _minFieldSize;
    private resizeObserver?;
    set suggestions(value: SuggestionsType<T>);
    get suggestions(): SuggestionsType<T>;
    get suggestionsLoading(): boolean;
    set displayFactory(value: ((item: any) => {
        key: string;
        text: string;
    }) | undefined);
    get displayFactory(): ((item: any) => {
        key: string;
        text: string;
    }) | undefined;
    optionTemplate: TemplateRef<any> | null;
    set filterFn(fn: (value: string, item: any) => boolean);
    get filterFn(): (value: string, item: any) => boolean;
    get minFieldSize(): number;
    selectionChanged: EventEmitter<any>;
    searchControl: FormControl<string | null>;
    get filteredSuggestions(): T[];
    blockScrollStrategy: BlockScrollStrategy;
    positions: ConnectedPosition[];
    onChange: ((value: any) => void)[];
    onTouched: (() => void)[];
    autoCompleteManager: AutoCompleteManager<T>;
    constructor(elementRef: ElementRef, overlay: Overlay, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    updateValidators(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    selectSuggestion(suggestion: any): void;
    writeValue(value: any): void;
    propagateOnchange(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwAutocomplete<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwAutocomplete<any>, "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; }; "value": { "alias": "value"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; "displayFactory": { "alias": "displayFactory"; "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>;
    autoCompleteDisplayFactory: ((item: any) => {
        key: string;
        text: string;
    }) | undefined;
    autoCompleteOptionTemplate: TemplateRef<any> | null;
    autoCompleteFilterFn: ((value: string, item: any) => boolean) | undefined;
    set autoCompleteSuggestions(value: SuggestionsType<any>);
    get autoCompleteSuggestions(): SuggestionsType<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; }; "autoCompleteDisplayFactory": { "alias": "autoCompleteDisplayFactory"; "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[] | undefined;
    set dataSource(value: T[] | undefined);
    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 TwExpanderModul