import * as i0 from '@angular/core';
import { ElementRef, QueryList, EventEmitter, OnInit, OnDestroy, ChangeDetectorRef, AfterContentInit, TemplateRef, AfterViewInit, PipeTransform } from '@angular/core';
import * as i33 from 'ngx-bootstrap/dropdown';
import { BsDropdownContainerComponent } from 'ngx-bootstrap/dropdown';
import * as i3 from '@angular/common';
import { WeekDay, DatePipe } from '@angular/common';
import * as i26 from '@angular/forms';
import { ControlValueAccessor, NgControl } from '@angular/forms';
import moment from 'moment';
import { SelectItem, SelectColor } from '@sowatech/shared/@types';
import * as i36 from '@sowatech/shared/utilities';
import { I18nService } from '@sowatech/shared/utilities';
import { LoggerService } from '@sowatech/shared/logger';
import { UserPropertiesStorageService } from '@sowatech/shared/user-properties-storage';
import { IBoxDefaultConfig } from '@sowatech/shared/shared-config';
import * as i4 from '@sowatech/shared/template';
import * as i5 from '@sowatech/shared/layout';
import * as i30 from 'ng-keyboard-shortcuts';
import { ShortcutInput } from 'ng-keyboard-shortcuts';
import * as i35 from '@ng-select/ng-select';
import { NgSelectComponent } from '@ng-select/ng-select';
import * as i31 from 'ngx-quill';
import { QuillModules, QuillEditorComponent, QuillModule } from 'ngx-quill';
import * as i28 from 'ngx-mask';
import * as i29 from '@sowatech/shared/no-double-click';

type InputSize$1 = 'small' | 'medium' | 'large';
declare class DropDownContainerComponent {
    dropdown: BsDropdownContainerComponent;
    inputContainer: ElementRef<HTMLElement>;
    childDropdowns: QueryList<DropDownContainerComponent>;
    container: string;
    alignContent: 'left' | 'right';
    width: string;
    disableClickPropagation: boolean;
    inputSize: InputSize$1;
    tabindex: number | string | null;
    /**
     * Kann gesetzt werden um den Dropdown automatisch zu schließen sobald man außerhalb des Dropdowns klickt.
     * ToggleCollapse/Expand funktionieren nicht, wenn closeWhenClickOutside aktiviert ist.
     */
    closeWhenClickOutside: boolean;
    value: string;
    values: string[];
    set displayValue(value: string | string[]);
    get collapsed(): boolean;
    set collapsed(value: boolean);
    allowClear: boolean;
    onClear: EventEmitter<void>;
    onShow: EventEmitter<void>;
    toggleCollapse(isGoingToOpen: boolean): void;
    collapse(): void;
    collapseAndFocus(): void;
    expand(): void;
    clear(eventData: Event): void;
    collapseChildDropdowns(): void;
    onKeyDown(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropDownContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropDownContainerComponent, "swt-dropdown-container", never, { "container": { "alias": "container"; "required": false; }; "alignContent": { "alias": "alignContent"; "required": false; }; "width": { "alias": "width"; "required": false; }; "disableClickPropagation": { "alias": "disableClickPropagation"; "required": false; }; "inputSize": { "alias": "inputSize"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "closeWhenClickOutside": { "alias": "closeWhenClickOutside"; "required": false; }; "displayValue": { "alias": "displayValue"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "allowClear": { "alias": "allowClear"; "required": false; }; }, { "onClear": "onClear"; "onShow": "onShow"; }, ["childDropdowns"], ["[dropdown-input]", "*"], false, never>;
}

declare class SwtDatePickerComponent implements ControlValueAccessor, OnInit {
    constructor();
    ngOnInit(): void;
    modusYear: boolean;
    set markedDays(value: Date[]);
    get markedDays(): Date[];
    private _markedDays;
    calendarWeekVisible: boolean;
    private _firstDayOfWeek;
    get firstDayOfWeek(): WeekDay;
    set firstDayOfWeek(value: WeekDay);
    get lastDayOfWeek(): WeekDay;
    readonly DisplayModus: typeof DisplayModus;
    private startDate;
    private endDate;
    currentMonth: number;
    private currentYear;
    weeks: DatePickerWeekViewModel[];
    daysOfWeek: string[];
    displayModus: DisplayModus;
    yearAuswahl: number[][];
    private yearInCenterView;
    private innerValue;
    private onTouchedCallback;
    private onChangeCallback;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    get value(): string | Date;
    set value(v: string | Date);
    refresh(): void;
    writeValue(v: string | Date): void;
    private valueType;
    valueChange: EventEmitter<string | Date>;
    monthChanged: EventEmitter<{
        startDay: Date;
        endDay: Date;
    }>;
    select(date: Date): void;
    get currentMonthAndYear(): Date;
    next(): void;
    previous(): void;
    private goToSelectedDate;
    private displayNextMonth;
    private displayNextYears;
    private displayPreviousMonth;
    private displayPreviousYears;
    /**
     * Berechnet Start- und Enddatum der Ansicht neu
     */
    private refreshStartEndDate;
    private buildMonth;
    private buildWeek;
    today(): void;
    setYear(pickedYear: number): void;
    setModusYear(): void;
    fillYearAuswahlArray(): void;
    getStartDate(): Date;
    getEndDate(): Date;
    private setDaysOfWeek;
    private toIsoWeekday;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtDatePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtDatePickerComponent, "swt-date-picker", never, { "modusYear": { "alias": "modusYear"; "required": false; }; "markedDays": { "alias": "markedDays"; "required": false; }; "calendarWeekVisible": { "alias": "calendarWeekVisible"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; }, { "valueChange": "change"; "monthChanged": "monthChanged"; }, never, never, false, never>;
}
declare class DatePickerWeekViewModel {
    weekNumber: number;
    days: DatePickerDayViewModel[];
    constructor(weekNumber: number, days?: DatePickerDayViewModel[]);
}
declare class DatePickerDayViewModel {
    currentMoment: moment.Moment;
    constructor(currentMoment: moment.Moment, currentMonth: number, valueMoment: moment.Moment, valueChange: EventEmitter<string | Date>, markedDays: moment.Moment[]);
    isCurrentMonth: boolean;
    isToday: boolean;
    isSelected: boolean;
    isMarked: boolean;
    get currentDate(): Date;
    get cssClass(): string;
}
declare enum DisplayModus {
    Years = 0,
    Days = 1
}

/**
 * - number: Letzten x Tage bis zum gewählten Tag
 * - 'day', 'currentday': Tag
 * - 'currentmonth': Monat + Jahr
 * - 'currentmonthwithoutyear': Datum => Monat
 * - 'currentquarter': Quartal + Jahr
 * - 'currentyear': Jahr
 * - 'interval': Tag bis Tag
 * - 'calendarweek': Kalenderwoche + Jahr
 * - 'monthinterval': Monat bis Monat + Jahr
 */
type TIntervalSelectType = number | 'day' | 'currentday' | 'currentmonth' | 'currentquarter' | 'currentyear' | 'interval' | 'currentmonthwithoutyear' | 'calendarweek' | 'monthinterval';
declare class DateInterval {
    constructor(start?: string | Date, end?: string | Date);
    start: string;
    end: string;
    get startMoment(): moment.Moment;
    get endMoment(): moment.Moment;
    get startDate(): Date;
    get endDate(): Date;
    setStart(d: string | Date): any;
    setStart(m: moment.Moment): any;
    setEnd(d: string | Date): any;
    setEnd(m: moment.Moment): any;
}

declare class DateRange {
    constructor(start?: string | Date, end?: string | Date, maxDuration?: number);
    static createFromDateRange(from: DateRange, maxDuration?: number): DateRange;
    private _start?;
    set start(val: string);
    get start(): string | undefined;
    private _end?;
    set end(val: string);
    get end(): string | undefined;
    readonly maxDurationInDays?: number;
    get isValid(): boolean;
    isDefined(): boolean;
    hasValidOrder(): boolean;
    durationMaxisNotExceeded(): boolean;
    setStart(value: string | Date): void;
    setEnd(value: string | Date): void;
}

declare class SwtDateRangePickerComponent {
    private i18n;
    stopPropagation(evt: Event): void;
    set inputInterval(val: DateInterval);
    set maxDurationInDays(val: number);
    newInterval: EventEmitter<DateInterval>;
    currentRange: DateRange;
    errortext?: string;
    submitInterval(): void;
    getError(range: DateRange): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtDateRangePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtDateRangePickerComponent, "swt-date-range-picker", never, { "inputInterval": { "alias": "inputInterval"; "required": false; }; "maxDurationInDays": { "alias": "maxDurationInDays"; "required": false; }; }, { "newInterval": "newInterval"; }, never, never, false, never>;
}

declare class SwtPopoverComponent {
    title: string;
    private placement;
    set setPlacement(value: 'top' | 'bottom' | 'left' | 'right');
    private trigger;
    set setTrigger(value: 'click' | 'hover' | 'focus' | 'manual');
    private target;
    set setTarget(value: HTMLElement);
    private oldEvent;
    private popoverElement;
    private arrowElement;
    arrow: HTMLElement;
    set arrowRef(ref: ElementRef);
    set popoverRef(ref: ElementRef);
    private setArrowStyle;
    private currentEventListener;
    private removeEventListener;
    private addEventListener;
    private get triggerEventName();
    get display(): string;
    visible: boolean;
    show(target?: HTMLElement): void;
    hide(): void;
    private calculatePosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtPopoverComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtPopoverComponent, "swt-popover", never, { "title": { "alias": "title"; "required": false; }; "setPlacement": { "alias": "placement"; "required": false; }; "setTrigger": { "alias": "trigger"; "required": false; }; "setTarget": { "alias": "target"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class SwtDateIntervalStoreHelper {
    private loggerService;
    private storage;
    constructor(loggerService: LoggerService, storage: UserPropertiesStorageService);
    clearStorage(storeKey: string): void;
    loadFromStorage(storeKey: string, maxDurationInDays?: number): DateIntervalStoredData;
    saveToStorage(storeKey: string, start: string, end: string, intervalSelectType: TIntervalSelectType): void;
    private selectedDateKey;
    private selectedFromDateKey;
    private selectedItemValueKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtDateIntervalStoreHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SwtDateIntervalStoreHelper>;
}
declare class DateIntervalStoredData {
    constructor(start: string, end: string, intervalSelectType: TIntervalSelectType, maxDurationInDays?: number);
    start: string;
    end: string;
    intervalSelectType: TIntervalSelectType;
    private maxDurationInDays?;
    get isValid(): boolean;
    private hasValidDates;
    private isDefined;
    private hasValidOrder;
    private durationMaxisNotExceeded;
}

type InputSize = 'small' | 'medium' | 'large';
declare class SwtDateIntervalComponent implements OnInit, OnDestroy {
    private storeHelper;
    private i18n;
    private changeDetectorRef;
    constructor(storeHelper: SwtDateIntervalStoreHelper, i18n: I18nService, changeDetectorRef: ChangeDetectorRef);
    storeKey: string;
    set setintervalValues(values: Array<TIntervalSelectType>);
    private _selectedDate?;
    get selectedDate(): Date | string | undefined;
    get selectedDateAsString(): string | undefined;
    set setSelectedDate(value: Date | string);
    maxDurationInDays: number;
    delimiter: string;
    inputSize: InputSize;
    changeEventEmitter: EventEmitter<DateInterval>;
    swtcontainer: DropDownContainerComponent;
    swtFromcontainer: DropDownContainerComponent;
    swtDropdownContainerContainer: string;
    private readonly subscriptions;
    private onInitCalled;
    ngOnInit(): void;
    ngOnDestroy(): void;
    currentInterval: DateInterval;
    intervalSelectType: TIntervalSelectType;
    selectItems: Array<SelectItem>;
    setIntervalSelectType(value: TIntervalSelectType): void;
    newIntervalFromRangePicker(val: DateInterval, container: DropDownContainerComponent): void;
    onIntervalChange(): void;
    selectedMonth: TMonthIndex;
    selectedFromMonth: TMonthIndex;
    selectedFromQuarter: Quarters;
    selectedYear: number;
    selectedCalendarWeek: number;
    onMonthYearChange(): void;
    private initQuarter;
    updateQuarter(): void;
    selectedYearAdd(addYear: number): void;
    calendarWeekAdd(increment: number): void;
    isFirstCalendarWeekOfYear: boolean;
    isLastCalendarWeekOfYear: boolean;
    private recalcIsFirstOrLastWeek;
    onCalendarWeekChange(): void;
    fixCalendarWeek(): void;
    startEndError: boolean;
    fromDatePickerVisible: boolean;
    datepickervisible: boolean;
    monthvisible: boolean;
    fromMonthVisible: boolean;
    yearvisible: boolean;
    calendarweekVisible: boolean;
    intervalVisible: boolean;
    currentmonthyearvisible: boolean;
    quarterSelectorVisible: boolean;
    isInChange: boolean;
    months: Array<SelectItem>;
    readonly quarters: SelectItem[];
    calendarWeeks: Array<SelectItem>;
    refreshCalendarWeeks(): void;
    private detectChanges;
    private setSelectItemsValues;
    private getIntervalTypeSelectItemText;
    private oldInterval;
    private setCurrentInterval;
    private updateSelectedDateProperties;
    private getSelectedYearByInterval;
    private saveToStorage;
    private refreshControlVisibility;
    onInputChange(eventData: Event | string | Date, collapseContainer?: DropDownContainerComponent): void;
    private hasDatePicker;
    useBrowserDateInput(): boolean;
    private hasMonthSelect;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtDateIntervalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtDateIntervalComponent, "swt-date-interval", never, { "storeKey": { "alias": "store-key"; "required": false; }; "setintervalValues": { "alias": "selectItems"; "required": false; }; "setSelectedDate": { "alias": "selectedDate"; "required": false; }; "maxDurationInDays": { "alias": "maxDurationInDays"; "required": false; }; "delimiter": { "alias": "delimiter"; "required": false; }; "inputSize": { "alias": "inputSize"; "required": false; }; "swtDropdownContainerContainer": { "alias": "swtDropdownContainerContainer"; "required": false; }; }, { "changeEventEmitter": "change"; }, never, never, false, never>;
}
declare enum TMonthIndex {
    jan = 0,
    feb = 1,
    mar = 2,
    apr = 3,
    may = 4,
    jun = 5,
    jul = 6,
    aug = 7,
    sep = 8,
    oct = 9,
    nov = 10,
    dec = 11
}
declare enum Quarters {
    I = 0,
    II = 1,
    III = 2,
    IV = 3
}

declare class RatingIconsComponent {
    private logger;
    constructor(logger: LoggerService);
    iconCssClass: string;
    emptyIconCssClass: string;
    set rating(value: number);
    set maxRating(value: number);
    _rating: number;
    _maxRating: number;
    fullArray: number[];
    emptyArray: number[];
    private refreshArrays;
    static ɵfac: i0.ɵɵFactoryDeclaration<RatingIconsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RatingIconsComponent, "rating-icons", never, { "iconCssClass": { "alias": "iconCssClass"; "required": false; }; "emptyIconCssClass": { "alias": "emptyIconCssClass"; "required": false; }; "rating": { "alias": "rating"; "required": false; }; "maxRating": { "alias": "maxRating"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LoadingIndicatorComponent implements AfterContentInit {
    text: string;
    spinnerSize: string;
    minHeight: string;
    private set loadingContainerRef(value);
    private loadingContainer;
    visible: boolean;
    topdistance: string;
    constructor();
    ngAfterContentInit(): void;
    private recalcPosition;
    show(): void;
    hide(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingIndicatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingIndicatorComponent, "loading-indicator", never, { "text": { "alias": "text"; "required": false; }; "spinnerSize": { "alias": "spinnerSize"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare enum State {
    open = "open",
    collapsed = "collapsed"
}
declare class IBoxComponent implements OnInit {
    private logger;
    private config;
    private userPropStorageService;
    stateChange: EventEmitter<State>;
    heading: string;
    collapsable: boolean;
    collapsed: boolean;
    headingHidden: boolean;
    label: string;
    contentHeadingClass: string;
    storeKey?: string;
    saveState?: boolean;
    constructor(logger: LoggerService, config: IBoxDefaultConfig, userPropStorageService: UserPropertiesStorageService);
    toggleCollapse(event: MouseEvent): void;
    ngOnInit(): void;
    private get key();
    private get defaultKey();
    static ɵfac: i0.ɵɵFactoryDeclaration<IBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IBoxComponent, "ibox", never, { "heading": { "alias": "heading"; "required": false; }; "collapsable": { "alias": "collapsable"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "headingHidden": { "alias": "headingHidden"; "required": false; }; "label": { "alias": "label"; "required": false; }; "contentHeadingClass": { "alias": "contentHeadingClass"; "required": false; }; "storeKey": { "alias": "store-key"; "required": false; }; "saveState": { "alias": "saveState"; "required": false; }; }, { "stateChange": "stateChange"; }, never, ["*", "[ibox-heading]", "[ibox-title-info]", "[ibox-tools]", "[ibox-content-heading]"], false, never>;
}

declare abstract class IBoxTemplateBase {
    component: IBoxComponent;
    content: TemplateRef<unknown>;
    content_heading: TemplateRef<unknown>;
    content_titleInfo: TemplateRef<unknown>;
    content_tools: TemplateRef<unknown>;
    content_contentHeading: TemplateRef<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IBoxTemplateBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IBoxTemplateBase, never, never, { "component": { "alias": "component"; "required": false; }; "content": { "alias": "content"; "required": false; }; "content_heading": { "alias": "content_heading"; "required": false; }; "content_titleInfo": { "alias": "content_titleInfo"; "required": false; }; "content_tools": { "alias": "content_tools"; "required": false; }; "content_contentHeading": { "alias": "content_contentHeading"; "required": false; }; }, {}, never, never, true, never>;
}
declare class IBoxSneatComponent extends IBoxTemplateBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<IBoxSneatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IBoxSneatComponent, "ibox-template-sneat", never, {}, {}, never, never, false, never>;
}
declare class IBoxInspiniaComponent extends IBoxTemplateBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<IBoxInspiniaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IBoxInspiniaComponent, "ibox-template-inspinia", never, {}, {}, never, never, false, never>;
}

declare class IBoxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IBoxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IBoxModule, [typeof IBoxComponent, typeof IBoxSneatComponent, typeof IBoxInspiniaComponent], [typeof i3.CommonModule, typeof i4.SwitchTemplateModule, typeof i5.LayoutModule], [typeof IBoxComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IBoxModule>;
}

declare class SwtCheckboxWrapper {
    sizePixel: number;
    checkBoxFocused: boolean;
    get fontSize(): string;
    get boxSize(): string;
    set contentChild(value: ElementRef<HTMLInputElement>);
    checkBoxControl: HTMLInputElement;
    onFocusCheckbox(): void;
    onUnfocusCheckbox(): void;
    get isChecked(): boolean;
    toggleCheckbox(): void;
    get isIntermediate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtCheckboxWrapper, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtCheckboxWrapper, "swt-checkbox-wrapper", never, { "sizePixel": { "alias": "size"; "required": false; }; }, {}, ["contentChild"], ["*"], false, never>;
}

declare class SwtCheckboxComponent implements ControlValueAccessor, AfterViewInit {
    private changeDetectorRef;
    constructor(changeDetectorRef: ChangeDetectorRef);
    activeChangeDetectionHack: boolean;
    size: number;
    get boxSize(): string;
    id: i0.InputSignal<string>;
    checkBox: HTMLInputElement;
    ngAfterViewInit(): void;
    swtCheckboxWrapper: SwtCheckboxWrapper;
    set checkBoxRef(value: ElementRef);
    private innerValue;
    private onTouchedCallback;
    private onChangeCallback;
    onFocusCheckbox(): void;
    onUnfocusCheckbox(): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onBlur(): void;
    get value(): boolean;
    set value(v: boolean);
    writeValue(v: boolean): void;
    valueChanged(event: any): void;
    refreshBindings(): void;
    protected toggleCheckbox(event: Event): void;
    valueChange: EventEmitter<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtCheckboxComponent, "swt-checkbox", never, { "activeChangeDetectionHack": { "alias": "activeChangeDetectionHack"; "required": false; }; "size": { "alias": "size"; "required": false; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "valueChange": "change"; }, never, never, false, never>;
}

declare class WizardStepComponent {
    step: WizardStep;
    set setIdent(value: string);
    set setName(value: string);
    /** @deprecated title sorgt für einen Tooltip auf dem ganzen Wizard Step */
    set setTitle(value: string);
    set setNumber(value: string);
    set setCanFinish(value: boolean);
    set setLast(value: boolean);
    set setFirst(value: boolean);
    set canCancel(value: boolean);
    set leaveStepToNextCallback(v: () => boolean | Promise<boolean>);
    static ɵfac: i0.ɵɵFactoryDeclaration<WizardStepComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WizardStepComponent, "swt-wizard-step", never, { "setIdent": { "alias": "ident"; "required": false; }; "setName": { "alias": "name"; "required": false; }; "setTitle": { "alias": "title"; "required": false; }; "setNumber": { "alias": "number"; "required": false; }; "setCanFinish": { "alias": "canFinish"; "required": false; }; "setLast": { "alias": "last"; "required": false; }; "setFirst": { "alias": "first"; "required": false; }; "canCancel": { "alias": "canCancel"; "required": false; }; "leaveStepToNextCallback": { "alias": "leaveStepToNextCallback"; "required": false; }; }, {}, never, ["*"], false, never>;
}
declare class WizardStep {
    constructor(title: string);
    title: string;
    ident: string;
    number?: string;
    get class(): string;
    disabled: boolean;
    current: boolean;
    done: boolean;
    hidden: boolean;
    error: boolean;
    private _first;
    set first(value: boolean);
    get first(): boolean;
    private _last;
    set last(value: boolean);
    get last(): boolean;
    canFinish: boolean;
    canLeaveToNext: boolean;
    canLeaveToPrevious: boolean;
    canCancel: boolean;
    /** Callback, ob man den Step verlassen darf. Wird bei Click auf "Weiter" abgefragt. */
    leaveStepToNextCallback: () => boolean | Promise<boolean>;
}

declare class WizardComponent implements AfterContentInit {
    shortcuts: ShortcutInput[];
    wizardStepComponents: QueryList<WizardStepComponent>;
    ngAfterContentInit(): void;
    tabclass: string;
    autoReset: boolean;
    /** `@Input` mit 'title' sorgt für einen tooltip, also besser 'heading' benutzen */
    title: string;
    get heading(): string;
    set heading(value: string);
    subTitle: string;
    onAfterReset: EventEmitter<void>;
    onBeforeLeaveStepToNext: EventEmitter<WizardStep>;
    onBeforeLeaveStepToPrevious: EventEmitter<WizardStep>;
    onAfterLeaveStep: EventEmitter<WizardStep>;
    onBeforeEnterStep: EventEmitter<WizardStep>;
    onAfterEnterStep: EventEmitter<WizardStep>;
    onStepChanged: EventEmitter<WizardStep>;
    onBeforeFinished: EventEmitter<WizardStep>;
    onAfterFinished: EventEmitter<WizardStep>;
    onCanceled: EventEmitter<void>;
    steps: Array<WizardStep>;
    private initSteps;
    private setStepDefaults;
    reset(): void;
    private setFirstStep;
    set firstStep(firstStep: WizardStep);
    get firstStep(): WizardStep;
    private setCurrentStep;
    set currentStep(currentStep: WizardStep);
    get currentStep(): WizardStep;
    setLastSteps(lastSteps: WizardStep[]): void;
    getNextStep(): WizardStep;
    getPreviousStep(): WizardStep;
    goto(gotoStep: WizardStep): Promise<void>;
    next(targetStep?: WizardStep): Promise<void>;
    previous(enteredStep?: WizardStep): void;
    private leftStep;
    private enterStep;
    finish(): void;
    cancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WizardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WizardComponent, "swt-wizard", never, { "tabclass": { "alias": "tabclass"; "required": false; }; "autoReset": { "alias": "autoReset"; "required": false; }; "title": { "alias": "title"; "required": false; }; "heading": { "alias": "heading"; "required": false; }; "subTitle": { "alias": "subTitle"; "required": false; }; }, { "onAfterReset": "onAfterReset"; "onBeforeLeaveStepToNext": "onBeforeLeaveStepToNext"; "onBeforeLeaveStepToPrevious": "onBeforeLeaveStepToPrevious"; "onAfterLeaveStep": "onAfterLeaveStep"; "onBeforeEnterStep": "onBeforeEnterStep"; "onAfterEnterStep": "onAfterEnterStep"; "onStepChanged": "onStepChanged"; "onBeforeFinished": "onBeforeFinished"; "onAfterFinished": "onAfterFinished"; "onCanceled": "onCanceled"; }, ["wizardStepComponents"], ["*"], false, never>;
}

declare class DebounceDirective implements OnInit {
    model: NgControl;
    private readonly destroyRef;
    onDebounce: EventEmitter<any>;
    debounceTime: number;
    private isFirstChange;
    constructor(model: NgControl);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DebounceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DebounceDirective, "[ngModel][debounce]", never, { "debounceTime": { "alias": "debounce"; "required": false; }; }, { "onDebounce": "onDebounce"; }, never, never, false, never>;
}

declare abstract class SwtLruComponentBase {
    htmlInputSearch: ElementRef;
    htmlSelectItems: QueryList<ElementRef>;
    component: LRUComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtLruComponentBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SwtLruComponentBase, never, never, { "component": { "alias": "component"; "required": false; }; }, {}, never, never, true, never>;
}
declare class SwtLruInspiniaComponent extends SwtLruComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtLruInspiniaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtLruInspiniaComponent, "swt-lru-inspinia", never, {}, {}, never, never, false, never>;
}
declare class SwtLruSneatComponent extends SwtLruComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtLruSneatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtLruSneatComponent, "swt-lru-sneat", never, {}, {}, never, never, false, never>;
}

declare class LRUComponent implements OnInit {
    private storage;
    constructor(storage: UserPropertiesStorageService);
    template: QueryList<SwtLruComponentBase>;
    selectedId: EventEmitter<number>;
    selectedName: EventEmitter<string>;
    valueChange: EventEmitter<string>;
    private get htmlInputSearch();
    private get htmlSelectItems();
    private inputValue;
    get value(): string;
    set value(value: string);
    key: string;
    inputMaxLength: number;
    stopEventPropagation: boolean;
    filterMethod: 'includes' | 'startswith';
    set inputSelectItems(selectItems: SelectItem[]);
    private _cssClass;
    set cssClass(value: string);
    get cssClass(): string;
    id: string;
    focusLost: EventEmitter<void>;
    inputGroupCss: string;
    /**
     * @deprecated Use the 'value' two-way-binding instead
     */
    set preSetText(text: string);
    savedIds: number[];
    selectItems: SelectItem[];
    originalSelectItems: SelectItem[];
    inputFocused: boolean;
    listFocused: boolean;
    showList: boolean;
    private focusedItem;
    ngOnInit(): void;
    storageKey(): string;
    onKeydown(event: KeyboardEvent): void;
    filterSelectItems(): void;
    select(itemValue?: number): void;
    refresh(): void;
    reorderSelectItems(): void;
    onInputFocus(): void;
    onListFocus(): void;
    onInputFocusLost(): void;
    onListFocusLost(): void;
    private updateShowList;
    clearInput(): void;
    private getFocusedElement;
    private setSelectedText;
    private removeItemFromArray;
    private loadFromStorage;
    private saveToStorage;
    private addToBeginning;
    static ɵfac: i0.ɵɵFactoryDeclaration<LRUComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LRUComponent, "swt-lru", never, { "value": { "alias": "value"; "required": false; }; "key": { "alias": "key"; "required": false; }; "inputMaxLength": { "alias": "inputMaxLength"; "required": false; }; "stopEventPropagation": { "alias": "stopEventPropagation"; "required": false; }; "filterMethod": { "alias": "filter-method"; "required": false; }; "inputSelectItems": { "alias": "inputSelectItems"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "id": { "alias": "id"; "required": false; }; "preSetText": { "alias": "preSetText"; "required": false; }; }, { "selectedId": "selectedId"; "selectedName": "selectedName"; "valueChange": "valueChange"; "focusLost": "focusLost"; }, never, never, false, never>;
}

type VALUE = any;
declare class MultiLRUComponent implements OnInit, OnDestroy {
    ngSelect: NgSelectComponent;
    selectedValues: EventEmitter<VALUE[]>;
    selectedTexts: EventEmitter<string[]>;
    valueChange: EventEmitter<string[]>;
    focusLost: EventEmitter<void>;
    protected readonly nameSignal: i0.WritableSignal<string>;
    get name(): string;
    set name(value: string);
    private _textValues;
    /**Text der SelectItems */
    get value(): string[];
    set value(value: string[]);
    inputSelectItems: SelectItem[];
    inputSelectItemsFn: (searchTerm: string) => Promise<SelectItem[]>;
    multiple: boolean;
    addTag: boolean;
    maxSelectedItems: number;
    inputMaxLength: number;
    filterMethod: 'includes' | 'startswith';
    cssClass: string;
    fieldText: string;
    id: string;
    private loadingCounter;
    private readonly subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    onSelectChanged(): void;
    onSearch(searchTerm: string): Promise<void>;
    filterFunction: (term: string, item: SelectItem) => boolean;
    protected loading: i0.WritableSignal<boolean>;
    private showLoading;
    private hideLoading;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiLRUComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiLRUComponent, "multi-lru", never, { "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "inputSelectItems": { "alias": "inputSelectItems"; "required": false; }; "inputSelectItemsFn": { "alias": "inputSelectItemsFn"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "addTag": { "alias": "addTag"; "required": false; }; "maxSelectedItems": { "alias": "maxSelectedItems"; "required": false; }; "inputMaxLength": { "alias": "inputMaxLength"; "required": false; }; "filterMethod": { "alias": "filter-method"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "fieldText": { "alias": "fieldText"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "selectedValues": "selectedValues"; "selectedTexts": "selectedTexts"; "valueChange": "valueChange"; "focusLost": "focusLost"; }, never, never, false, never>;
}

declare class ToolBarContainerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolBarContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolBarContainerComponent, "toolbar-container", never, {}, {}, never, ["*"], false, never>;
}

declare class UlNavTabs implements AfterContentInit, OnDestroy {
    cssClasses: any;
    pills: boolean;
    stacked: boolean;
    justified: boolean;
    private readonly config;
    get ngClassValue(): string;
    changed: EventEmitter<string>;
    private navtabsRef;
    private get navtabs();
    private get navTabsItems();
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    contentChange(): void;
    private tabsWithSubscriptions;
    private initTabs;
    private unsubscribeTabs;
    private onNavTabClick;
    private onNavTabKeyDown;
    private activeTabId;
    setActive(id: string): void;
    getActive(): string;
    isActive(id: string): boolean;
    /** In Bs3 wird die active Klasse direkt auf dem LI-Element gesetzt. In Bs5 wird sie auf dem A-Element gesetzt */
    private getActiveClassHtmlElement;
    private getNavStackedCssClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<UlNavTabs, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UlNavTabs, "ul-nav-tabs", never, { "cssClasses": { "alias": "class"; "required": false; }; "pills": { "alias": "pills"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "justified": { "alias": "justified"; "required": false; }; }, { "changed": "changed"; }, never, ["*"], false, never>;
}

declare class SwtDateInputComponent implements ControlValueAccessor, OnInit, OnDestroy {
    private datePipe;
    locale: string;
    private i18n;
    constructor(datePipe: DatePipe, locale: string, i18n: I18nService);
    private subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private valueType;
    errorMessage: string;
    isValid: boolean;
    languageIso: string;
    private momentFormat;
    private alternativeMomentFormat;
    private dateIsoFormat;
    dateString: string;
    dateInputError: DateInputError;
    private pattern;
    placeholder: string;
    dateFormat: string;
    name: any;
    autofocus: any;
    required: boolean;
    class: any;
    width: number;
    maxDate: Date;
    minDate: Date;
    showErrorMessage: boolean;
    id: string;
    dateError: EventEmitter<DateInputError>;
    focusLost: EventEmitter<void>;
    private setTranslationProps;
    transformDateToString(date: Date): string;
    transformStringToDate(dateString: string): Date;
    transformStringToMoment(dateString: string): moment.Moment;
    dateMoment: moment.Moment;
    private onTouchedCallback;
    private onChangeCallback;
    get dateValue(): string;
    set dateValue(v: string);
    private resetErrorMessage;
    onBlur(): void;
    writeValue(value: DateIso | Date): void;
    private isIsoFormat;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onKeyDown(event: KeyboardEvent): void;
    private checkValidation;
    private checkDateIntervallisValid;
    checkForMaxDateError(maxDateMoment: moment.Moment, dateMoment: moment.Moment): DateInputError;
    private checkForMinDateError;
    private checkForDateIntervallError;
    private getErrorMessage;
    private checkDateIsValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtDateInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtDateInputComponent, "swt-date-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "name": { "alias": "name"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "required": { "alias": "required"; "required": false; }; "class": { "alias": "class"; "required": false; }; "width": { "alias": "width"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "showErrorMessage": { "alias": "showErrorMessage"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "dateError": "dateError"; "focusLost": "focusLost"; }, never, never, false, never>;
}
declare enum DateInputError {
    None = 0,
    DateInvalidError = 1,
    MinDateError = 2,
    MaxDateError = 3,
    DateIntervallError = 4
}
type DateIso = string;

declare class SwtColorPickerService {
    getColorFromSelectColorsOrEmptyColor(hexColor: string, colors: SelectColor[]): SelectColor;
    isSelectedColor(hexColor: string, colors: SelectColor[]): boolean;
    hexColorIsValid(hexColor: string): boolean;
    getEmptySelectColor(hexColor?: string): SelectColor;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtColorPickerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SwtColorPickerService>;
}

declare class ColorPickerConfiguration {
    returnHexCode?: boolean;
    emptyText?: string;
    allowOnlyColorsFromSelect?: boolean;
}

declare class SwtColorPickerComponent implements ControlValueAccessor, OnInit {
    private elementRef;
    private colorPickerService;
    input: Element;
    required: boolean;
    set _selectColors(value: SelectColor[]);
    set _config(value: ColorPickerConfiguration);
    get emptyText(): string;
    get value(): string;
    set value(v: string);
    selectColors: SelectColor[];
    showColors: boolean;
    selectedColor: SelectColor;
    config: ColorPickerConfiguration;
    private innerValue;
    constructor(elementRef: ElementRef, colorPickerService: SwtColorPickerService);
    ngOnInit(): void;
    onDocumentClick(event: MouseEvent): void;
    writeValue(value: string): void;
    changeValue(selectedColor: SelectColor): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    changeColor(hexColor: string): void;
    changeColorManual(hexColor: string): void;
    hexColorIsValid(hexColor: string): boolean;
    toggleColors(): void;
    private initConfigDefaults;
    private setSelectedColor;
    private onChangeCallback;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtColorPickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtColorPickerComponent, "swt-color-picker", never, { "required": { "alias": "required"; "required": false; }; "_selectColors": { "alias": "selectColors"; "required": false; }; "_config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SWTHighlightSearch implements PipeTransform {
    transform(value: any, args: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SWTHighlightSearch, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SWTHighlightSearch, "highlight", false>;
}

interface IQuillConfiguration {
    /**
        default: 'html'
     */
    format?: 'html' | 'object' | 'text' | 'json';
    /**
        default: 'snow'
     */
    theme?: 'snow' | 'bubble';
    readOnly?: boolean;
    toolbar?: QuillToolbarDefaultType | IQuillToolbarConfiguration;
    /**
     *wird nur benötigt, falls standard modules/toolbar nicht ausreicht
     */
    modules?: QuillModules;
}
/**
 *manuelles einstellen der Toolbar
 */
interface IQuillToolbarConfiguration {
    clean?: boolean;
    decorators?: QuillDecorator[];
    quotes?: QuillQuote[];
    headers?: QuillHeader[];
    lists?: QuillList[];
    scripts?: QuillScript[];
    directions?: QuillDirection[];
    sizes?: QuillSize[];
    colors?: string[];
    backgrounds?: string[];
    fonts?: string[];
    aligns?: QuillAlign[];
}
/**
 * reduced: decorators, lists, sizes, colors, backgrounds, aligns
 *
 * full: decorators, quotes, headers, lists, scripts, directions, sizes, colors, backgrounds, fonts, aligns
 */
type QuillToolbarDefaultType = 'reduced' | 'full';
type QuillDecorator = 'bold' | 'italic' | 'underline' | 'strike';
type QuillQuote = 'blockquote';
type QuillHeader = 1 | 2 | number[];
type QuillList = 'ordered' | 'bullet';
type QuillScript = 'sub' | 'super';
type QuillDirection = 'rtl';
type QuillSize = '10px' | false | '18px' | '32px';
type QuillAlign = false | 'center' | 'right' | 'justify';

declare const SWT_QUILL_EDITOR_VALUE_ACCESSOR: any;
declare class SwtQuillEditorComponent implements OnInit, ControlValueAccessor {
    private logger;
    constructor(logger: LoggerService);
    private _config;
    get config(): IQuillConfiguration;
    set config(config: IQuillConfiguration);
    name: string;
    maxLength: number;
    minLength: number;
    required: boolean;
    placeholder: string;
    textbox: QuillEditorComponent;
    ngOnInit(): void;
    private innerValue;
    get value(): string;
    set value(v: string);
    private onTouchedCallback;
    private onChangeCallback;
    writeValue(v: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    private configureQuillInlineStyles;
    quillModules: QuillModule;
    private setQuillModules;
    private getQuillToolbar;
    private prepareConfig;
    getDefaultQuillToolbar(defaultType: QuillToolbarDefaultType): IQuillToolbarConfiguration;
    static getReducedQuillToolbar(): IQuillToolbarConfiguration;
    static getFullQuillToolbar(): IQuillToolbarConfiguration;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtQuillEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtQuillEditorComponent, "swt-quill-editor", never, { "config": { "alias": "config"; "required": false; }; "name": { "alias": "name"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "required": { "alias": "required"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DomChangeDirective implements OnDestroy {
    private elementRef;
    private changes;
    domChange: EventEmitter<any>;
    constructor(elementRef: ElementRef);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DomChangeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DomChangeDirective, "[domChange]", never, {}, { "domChange": "domChange"; }, never, never, false, never>;
}

declare class LoadingDirective {
    private readonly loadingIndicator;
    private readonly changeDetector;
    constructor();
    /** Wenn `true`, wird der `loading-indicator` angezeigt */
    readonly loading: i0.InputSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LoadingDirective, "loading-indicator[loading]", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare abstract class SwtDateIntervalComponentBase {
    component: SwtDateIntervalComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtDateIntervalComponentBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SwtDateIntervalComponentBase, never, never, { "component": { "alias": "component"; "required": false; }; }, {}, never, never, true, never>;
}
declare class SwtDateIntervalInspiniaComponent extends SwtDateIntervalComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtDateIntervalInspiniaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtDateIntervalInspiniaComponent, "swt-date-interval-inspinia", never, {}, {}, never, never, false, never>;
}
declare class SwtDateIntervalSneatComponent extends SwtDateIntervalComponentBase {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtDateIntervalSneatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwtDateIntervalSneatComponent, "swt-date-interval-sneat", never, {}, {}, never, never, false, never>;
}

declare const QuillModuleForRoot: i0.ModuleWithProviders<QuillModule>;
declare class SwtControlsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SwtControlsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SwtControlsModule, [typeof DropDownContainerComponent, typeof SwtDatePickerComponent, typeof SwtDateRangePickerComponent, typeof SwtDateInputComponent, typeof SwtPopoverComponent, typeof SwtColorPickerComponent, typeof RatingIconsComponent, typeof ToolBarContainerComponent, typeof WizardComponent, typeof WizardStepComponent, typeof DebounceDirective, typeof SWTHighlightSearch, typeof SwtQuillEditorComponent, typeof UlNavTabs, typeof DomChangeDirective, typeof SwtCheckboxWrapper, typeof SwtCheckboxComponent, typeof LRUComponent, typeof SwtLruSneatComponent, typeof SwtLruInspiniaComponent, typeof MultiLRUComponent, typeof LoadingIndicatorComponent, typeof LoadingDirective, typeof SwtDateIntervalComponent, typeof SwtDateIntervalSneatComponent, typeof SwtDateIntervalInspiniaComponent], [typeof i3.CommonModule, typeof i26.FormsModule, typeof i4.SwitchTemplateModule, typeof i28.NgxMaskDirective, typeof i28.NgxMaskPipe, typeof i29.NoDblClickModule, typeof i30.KeyboardShortcutsModule, typeof i31.QuillModule, typeof IBoxModule, typeof i33.BsDropdownModule, typeof i5.LayoutModule, typeof i35.NgSelectModule, typeof i36.NgSelectAriaLabelDirective], [typeof DropDownContainerComponent, typeof SwtDatePickerComponent, typeof SwtDateRangePickerComponent, typeof SwtPopoverComponent, typeof SwtColorPickerComponent, typeof SwtDateInputComponent, typeof RatingIconsComponent, typeof LoadingIndicatorComponent, typeof LoadingDirective, typeof SwtCheckboxWrapper, typeof SwtCheckboxComponent, typeof WizardComponent, typeof WizardStepComponent, typeof DebounceDirective, typeof LRUComponent, typeof MultiLRUComponent, typeof ToolBarContainerComponent, typeof SwtQuillEditorComponent, typeof UlNavTabs, typeof DomChangeDirective, typeof IBoxModule, typeof SwtDateIntervalComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SwtControlsModule>;
}

export { ColorPickerConfiguration, DateInterval, DebounceDirective, DomChangeDirective, DropDownContainerComponent, IBoxComponent, IBoxModule, LRUComponent, LoadingDirective, LoadingIndicatorComponent, MultiLRUComponent, QuillModuleForRoot, RatingIconsComponent, SWTHighlightSearch, SWT_QUILL_EDITOR_VALUE_ACCESSOR, SwtCheckboxComponent, SwtCheckboxWrapper, SwtColorPickerComponent, SwtControlsModule, SwtDateInputComponent, SwtDateIntervalComponent, SwtDateIntervalStoreHelper, SwtDatePickerComponent, SwtDateRangePickerComponent, SwtPopoverComponent, SwtQuillEditorComponent, ToolBarContainerComponent, UlNavTabs, WizardComponent, WizardStep, WizardStepComponent };
export type { IQuillConfiguration, IQuillToolbarConfiguration, QuillAlign, QuillDecorator, QuillDirection, QuillHeader, QuillList, QuillQuote, QuillScript, QuillSize, QuillToolbarDefaultType };