/*
   jQWidgets TypeScript definitions

   Copyright (c) 2011-2024 jQWidgets.
   License: https://jqwidgets.com/license/
*/

interface JQueryStatic {
    jqx: any;
}

declare var generatedata: any;
declare var jqx: any;

declare module jqwidgets {
    export function createInstance(selector: string, widgetName: string, params?: any): any;
    
    export class widget
    {
        constructor(selector: string, options?: Object);
        refresh(): void;
        destroy(): void;
        getInstance(): any;
        addEventHandler(event: string, funcEventHandler: (any: any) => void): void;
        removeEventHandler(event: string): void;
        setOptions(params?: any): any;
    }


    export interface BarGaugeLabelsFont {
        // BarGaugeLabelsFont properties
        color?: string;
        size?: number | string;
        family?: string;
    }// BarGaugeLabelsFont

    export interface BarGaugeLabels {
        // BarGaugeLabels properties
        connectorColor?: string;
        connectorWidth?: number;
        font?: BarGaugeLabelsFont;
        formatFunction?: (value: number, index?: number) => string;
        indent?: number;
        precision?: number;
        visible?: boolean;
    }// BarGaugeLabels

    export interface BarGaugeTextFont {
        // BarGaugeTextFont properties
        color?: string;
        family?: string;
        opacity?: number;
        size?: number | string;
        weight?: number;
    }// BarGaugeTextFont

    export interface BarGaugeTitleMargin {
        // BarGaugeTitleMargin properties
        bottom?: number;
        left?: number;
        right?: number;
        top?: number;
    }// BarGaugeTitleMargin

    export interface BarGaugeTitleSubtitle {
        // BarGaugeTitleSubtitle properties
        text?: string;
        font?: BarGaugeTextFont;
    }// BarGaugeTitleSubtitle

    export interface BarGaugeTitle {
        // BarGaugeTitle properties
        text?: string;
        font?: BarGaugeTextFont;
        horizontalAlignment?: string;
        margin?: BarGaugeTitleMargin;
        subtitle?: BarGaugeTitleSubtitle;
        verticalAlignment?: string;
    }// BarGaugeTitle

    export interface BarGaugeTooltip {
        // BarGaugeTooltip properties
        classname?: string;
        formatFunction?: (value: string, index?: number, color?: string) => string;
        visible?: boolean;
        precision?: number;
    }// BarGaugeTooltip

    export interface BarGaugeCustomColorScheme {
        // BarGaugeCustomColorScheme properties
        name: string;
        colors: Array<string>;
    }// BarGaugeCustomColorScheme

    export interface BarGaugeOptions {
        // BarGaugeOptions properties
        animationDuration?: number;
        backgroundColor?: string;
        barSpacing?: number;
        baseValue?: number;
        colorScheme?: string;
        customColorScheme?: BarGaugeCustomColorScheme;
        disabled?: boolean;
        endAngle?: number;
        formatFunction?: (value: number, index?: number, color?: string) => string;
        height?: string | number;
        labels?: BarGaugeLabels;
        max?: number | string;
        min?: number;
        relativeInnerRadius?: number | string;
        rendered?: () => void;
        startAngle?: number;
        title?: BarGaugeTitle;
        tooltip?: BarGaugeTooltip;
        useGradient?: boolean;
        values?: Array<number>;
        width?: string | number;
    }// BarGaugeOptions

    export interface jqxBarGauge extends widget, BarGaugeOptions {

        // jqxBarGauge functions
        refresh(): void;
        render(): void;
        val(value: Array<number>): Array<number>;
    }// jqxBarGauge

    export interface BulletChartLabelsFormatFunction {
        // BulletChartLabelsFormatFunction properties
        value?: string;
        position?: string;
    }// BulletChartLabelsFormatFunction

    export interface BulletChartTooltipFormatFunction {
        // BulletChartTooltipFormatFunction properties
        pointerValue?: number;
        targetValue?: number;
    }// BulletChartTooltipFormatFunction

    export interface BulletChartPointer {
        // BulletChartPointer properties
        value?: number;
        label?: string;
        size?: number | string;
        color?: string;
    }// BulletChartPointer

    export interface BulletChartRanges {
        // BulletChartRanges properties
        startValue: number;
        endValue: number;
        opacity?: number;
        color?: string;
    }// BulletChartRanges

    export interface BulletChartTicks {
        // BulletChartTicks properties
        position?: string;
        interval?: number;
        size?: number | string;
    }// BulletChartTicks

    export interface BulletChartOptions {
        // BulletChartOptions properties
        animationDuration?: number;
        barSize?: number | string;
        description?: string;
        disabled?: boolean;
        height?: string | number;
        labelsFormat?: string;
        labelsFormatFunction?: (value?: BulletChartLabelsFormatFunction['value'], position?: BulletChartLabelsFormatFunction['position']) => any;
        orientation?: string;
        pointer?: BulletChartPointer;
        rtl?: boolean;
        ranges?: Array<BulletChartRanges>;
        showTooltip?: boolean;
        target?: BulletChartPointer;
        ticks?: BulletChartTicks;
        title?: string;
        tooltipFormatFunction?: (pointerValue?: BulletChartTooltipFormatFunction['pointerValue'], targetValue?: BulletChartTooltipFormatFunction['targetValue']) => string;
        width?: string | number;
    }// BulletChartOptions

    export interface jqxBulletChart extends widget, BulletChartOptions {

        // jqxBulletChart functions
        destroy(): void;
        render(): void;
        refresh(): void;
        val(value: number): number;
    }// jqxBulletChart

    export interface ButtonGroupOptions {
        // ButtonGroupOptions properties
        disabled?: boolean;
        enableHover?: boolean;
        mode?: string;
        rtl?: boolean;
        template?: string;
        theme?: string;
    }// ButtonGroupOptions

    export interface jqxButtonGroup extends widget, ButtonGroupOptions {

        // jqxButtonGroup functions
        disableAt(index: number): void;
        disable(): void;
        destroy(): void;
        enable(): void;
        enableAt(index: number): void;
        getSelection(): any;
        render(): void;
        setSelection(index: number): void;
    }// jqxButtonGroup

    export interface ButtonOptions {
        // ButtonOptions properties
        disabled?: boolean;
        height?: number | string;
        imgSrc?: string;
        imgWidth?: number | string;
        imgHeight?: number | string;
        imgPosition?: string;
        roundedCorners?: string;
        rtl?: boolean;
        enableDefault?: boolean;
        cursor?: boolean;
        textPosition?: string;
        textImageRelation?: string;
        theme?: string;
        template?: string;
        width?: number | string;
        value?: string;
    }// ButtonOptions

    export interface jqxButton extends widget, ButtonOptions {

        // jqxButton functions
        destroy(): void;
        focus(): void;
        render(): void;
        val(value: string): string;
    }// jqxButton

    export interface CalendarOptions {
        // CalendarOptions properties
        backText?: string;
        columnHeaderHeight?: number;
        clearString?: string;
        culture?: string;
        dayNameFormat?: string;
        disabled?: boolean;
        enableWeekend?: boolean;
        enableViews?: boolean;
        enableOtherMonthDays?: boolean;
        enableFastNavigation?: boolean;
        enableHover?: boolean;
        enableAutoNavigation?: boolean;
        enableTooltips?: boolean;
        forwardText?: string;
        firstDayOfWeek?: number;
        height?: string | number;
        min?: any;
        max?: any;
        navigationDelay?: number;
        rowHeaderWidth?: number | string;
        readOnly?: boolean;
        restrictedDates?: Array<Date>;
        rtl?: boolean;
        stepMonths?: number;
        showWeekNumbers?: boolean;
        showDayNames?: boolean;
        showOtherMonthDays?: boolean;
        showFooter?: boolean;
        selectionMode?: string;
        specialDates?: Array<any>;
        theme?: string;
        titleHeight?: number;
        titleFormat?: string;
        todayString?: string;
        value?: Date;
        width?: string | number;
    }// CalendarOptions

    export interface jqxCalendar extends widget, CalendarOptions {

        // jqxCalendar functions
        clear(): void;
        destroy(): void;
        focus(): void;
        addSpecialDate(date: any, specialDateClass: any, text: any): void;
        getMinDate(): any;
        getMaxDate(): any;
        getDate(): any;
        getRange(): any;
        navigateForward(months: number): void;
        navigateBackward(months: number): void;
        render(): void;
        refresh(): void;
        setMinDate(date: any): void;
        setMaxDate(date: any): void;
        setDate(date: any): void;
        setRange(date: any, date2: any): void;
        today(): void;
        val(value: Date | string, value2: Date | string): Date | string;
    }// jqxCalendar

    export interface ChartDraw {
        // ChartDraw properties
        renderer?: any;
        rect?: any;
    }// ChartDraw

    export interface ChartDrawBefore {
        // ChartDrawBefore properties
        renderer?: any;
        rect?: any;
    }// ChartDrawBefore

    export interface ChartOffset {
        // ChartOffset properties
        x: number;
        y: number;
    }// ChartOffset

    export interface ChartRect {
        // ChartRect properties
        x: number;
        y: number;
        width: number | string;
        height: number | string;
    }// ChartRect

    export interface ChartPadding {
        // ChartPadding properties
        left: number;
        right: number;
        top: number;
        bottom: number;
    }// ChartPadding

    export interface ChartTickMarks {
        // ChartTickMarks properties
        visible?: any;
        color?: string;
        step?: number;
        dashStyle?: string;
        lineWidth?: number;
        size?: number | string;
        interval?: any;
        custom?: Array<ChartCustomOffset>;
    }// ChartTickMarks

    export interface ChartGridLines {
        // ChartGridLines properties
        visible?: any;
        color?: string;
        step?: number;
        dashStyle?: string;
        lineWidth?: number;
        interval?: any;
        custom?: Array<ChartCustomOffset>;
    }// ChartGridLines

    export interface ChartAxisLine {
        // ChartAxisLine properties
        visible?: any;
        color?: string;
        dashStyle?: string;
        lineWidth?: number;
    }// ChartAxisLine

    export interface ChartCustomOffset {
        // ChartCustomOffset properties
        value?: any;
        offset?: number;
    }// ChartCustomOffset

    export interface ChartAxisLabels {
        // ChartAxisLabels properties
        visible?: any;
        class?: string;
        step?: number;
        angle?: number;
        rotationPoint?: string;
        horizontalAlignment?: string;
        verticalAlignment?: string;
        offset?: ChartOffset;
        custom?: Array<ChartCustomOffset>;
        formatSettings?: ChartFormatSettings;
        formatFunction?: (value: any, itemIndex?: number, serieIndex?: number, groupIndex?: number, xAxisValue?: any, xAxis?: ChartXAxis) => string;
        autoRotate?: boolean;
    }// ChartAxisLabels

    export interface ChartFormatSettings {
        // ChartFormatSettings properties
        prefix?: string;
        sufix?: string;
        decimalSeparator?: string;
        thousandsSeparator?: string;
        decimalPlaces?: number;
        negativeWithBrackets?: boolean;
        dateFormat?: string;
    }// ChartFormatSettings

    export interface ChartSeriesLabels {
        // ChartSeriesLabels properties
        visible?: boolean;
        class?: string;
        angle?: number;
        horizontalAlignment?: string;
        verticalAlignment?: string;
        offset?: ChartOffset;
        backgroundColor?: string;
        backgroundOpacity?: number;
        borderColor?: string;
        borderOpacity?: number;
        padding?: ChartPadding;
        linesEnabled?: boolean;
        linesAngles?: boolean;
        autoRotate?: boolean;
        radius?: any;
    }// ChartSeriesLabels

    export interface ChartAxisTitle {
        // ChartAxisTitle properties
        visible?: boolean;
        text?: string;
        class?: string;
        horizontalAlignment?: string;
        verticalAlignment?: string;
        angle?: number;
        rotationPoint?: string;
        offset?: ChartOffset;
    }// ChartAxisTitle

    export interface ChartColorBand {
        // ChartColorBand properties
        minValue?: number;
        maxValue?: number;
        fillColor?: string;
        opacity?: number;
        lineColor?: string;
        lineWidth?: number;
        dashStyle?: string;
    }// ChartColorBand

    export interface ChartXAxis {
        // ChartXAxis properties
        visible?: boolean;
        unitInterval?: number;
        dataField?: string;
        displayText?: string;
        type?: string;
        baseUnit?: string;
        valuesOnTicks?: boolean;
        dateFormat?: string;
        axisSize?: number | string;
        customDraw?: boolean;
        flip?: boolean;
        position?: string;
        padding?: ChartPadding;
        title?: ChartAxisTitle;
        tickMarks?: ChartTickMarks;
        gridLines?: ChartGridLines;
        line?: ChartAxisLine;
        labels?: ChartAxisLabels;
        logarithmicScale?: boolean;
        logarithmicScaleBase?: number;
        minValue?: any;
        maxValue?: any;
        bands?: Array<ChartColorBand>;
        alternatingBackgroundColor?: string;
        alternatingBackgroundColor2?: string;
        alternatingBackgroundOpacity?: number;
        formatSettings?: any;
        formatFunction?: any;
        toolTipFormatSettings?: ChartFormatSettings;
        toolTipFormatFunction?: any;
        rangeSelector?: any;
        textRotationAngle?: number;
    }// ChartXAxis

    export interface ChartSerie {
        // ChartSerie properties
        dataField?: string;
        displayText?: string;
        dataFieldFrom?: string;
        displayTextFrom?: string;
        dataFieldTo?: string;
        displayTextTo?: string;
        dataFieldOpen?: string;
        displayTextOpen?: string;
        dataFieldLow?: string;
        displayTextLow?: string;
        dataFieldHigh?: string;
        displayTextHigh?: string;
        dataFieldClose?: string;
        displayTextClose?: string;
        lineWidth?: number;
        dashStyle?: string;
        symbolType?: string;
        symbolSize?: number;
        symbolSizeSelected?: number;
        emptyPointsDisplay?: string;
        linesUnselectMode?: string;
        opacity?: number;
        useGradientColors?: boolean;
        greyScale?: boolean;
        lineColor?: string;
        lineColorSelected?: string;
        fillColor?: string;
        fillColorSelected?: string;
        lineColorSymbol?: string;
        lineColorSymbolSelected?: string;
        fillColorSymbol?: string;
        fillColorSymbolSelected?: string;
        fillColorAlt?: string;
        fillColorAltSelected?: string;
        colorFunction?: (dataValue: any, itemIndex?: number, serie?: any, group?: any) => any;
        labels?: ChartSeriesLabels;
        formatSettings?: ChartFormatSettings;
        formatFunction?: (value: any, itemIndex?: number, serieIndex?: number, groupIndex?: number, xAxisValue?: any, xAxis?: ChartXAxis) => string;
        legendFormatSettings?: ChartFormatSettings;
        legendFormatFunction?: (value: any, itemIndex?: number, serieIndex?: number, groupIndex?: number, xAxisValue?: any, xAxis?: ChartXAxis) => string;
        legendLineColor?: string;
        legnedFillColor?: string;
        toolTipFormatSettings?: ChartFormatSettings;
        toolTipFormatFunction?: (value: any, itemIndex?: number, serieIndex?: number, groupIndex?: number, xAxisValue?: any, xAxis?: ChartXAxis) => string;
        toolTipLineColor?: string;
        toolTipBackground?: string;
        toolTipClass?: string;
        radius?: any;
        innerRadius?: any;
        startAngle?: number;
        endAngle?: number;
        offsetX?: number;
        offsetY?: number;
        hiddenPointsDisplay?: boolean;
        enableSeriesToggle?: boolean;
        enableSelection?: boolean;
        radiusDataField?: string;
        minRadius?: any;
        maxRadius?: any;
        summary?: string;
        labelRadius?: any;
        initialAngle?: number;
        centerOffset?: number;
    }// ChartSerie

    export interface ChartValueAxis {
        // ChartValueAxis properties
        visible?: boolean;
        flip?: boolean;
        position?: string;
        axisSize?: any;
        minValue?: number;
        maxValue?: number;
        baselineValue?: number;
        logarithmicScale?: boolean;
        logarithmicScaleBase?: number;
        valuesOnTicks?: boolean;
        unitInterval?: number;
        title?: ChartAxisTitle;
        labels?: ChartAxisLabels;
        gridLines?: ChartGridLines;
        tickMarks?: ChartTickMarks;
        padding?: ChartPadding;
        bands?: Array<ChartColorBand>;
        alternatingBackgroundColor?: string;
        alternatingBackgroundColor2?: string;
        alternatingBackgroundOpacity?: number;
        toolTipFormatSettings?: ChartFormatSettings;
        formatFunction?: any;
    }// ChartValueAxis

    export interface ChartSeriesGroup {
        // ChartSeriesGroup properties
        type: string;
        orientation?: string;
        valueAxis?: ChartValueAxis;
        series: Array<ChartSerie>;
        formatSettings?: ChartFormatSettings;
        toolTipFormatFunction?: any;
        columnsGapPercent?: number;
        seriesGapPercent?: number;
        columnsMinWidth?: number;
        columnsMaxWidth?: number;
        columnsTopWidthPercent?: number;
        columnsBottomWidthPercent?: number;
        skipOverlappingPoints?: boolean;
        polar?: boolean;
        spider?: boolean;
        radius?: any;
        startAngle?: number;
        endAngle?: number;
        offsetX?: number;
        offsetY?: number;
        source?: any;
        xAxis?: ChartXAxis;
        colorScheme?: string;
        showLabels?: boolean;
        alignEndPointsWithIntervals?: boolean;
        annotations?: any;
    }// ChartSeriesGroup

    export interface ChartLegendLayout {
        // ChartLegendLayout properties
        left: number;
        top: number;
        width: number | string;
        height: number | string;
        flow: string;
    }// ChartLegendLayout

    export interface ChartOptions {
        // ChartOptions properties
        title?: string;
        description?: string;
        source?: any;
        showBorderLine?: boolean;
        borderLineColor?: string;
        borderLineWidth?: number;
        backgroundColor?: string;
        backgroundImage?: string;
        showLegend?: boolean;
        legendLayout?: ChartLegendLayout;
        padding?: ChartPadding;
        titlePadding?: ChartPadding;
        colorScheme?: string;
        greyScale?: boolean;
        showToolTips?: boolean;
        toolTipShowDelay?: number;
        toolTipHideDelay?: number;
        toolTipMoveDuration?: number;
        drawBefore?: (renderer?: ChartDrawBefore['renderer'], rect?: ChartDrawBefore['rect']) => void;
        draw?: (renderer?: ChartDraw['renderer'], rect?: ChartDraw['rect']) => void;
        rtl?: boolean;
        enableCrosshairs?: boolean;
        crosshairsColor?: string;
        crosshairsDashStyle?: string;
        crosshairsLineWidth?: number;
        columnSeriesOverlap?: boolean;
        enabled?: boolean;
        enableAnimations?: boolean;
        animationDuration?: number;
        enableAxisTextAnimation?: boolean;
        renderEngine?: string;
        xAxis?: ChartXAxis;
        valueAxis?: ChartValueAxis;
        categoryAxis?: any;
        seriesGroups: Array<ChartSeriesGroup>;
    }// ChartOptions

    export interface jqxChart extends widget, ChartOptions {

        // jqxChart functions
        getInstance(): any;
        refresh(): void;
        update(): void;
        destroy(): void;
        addColorScheme(schemeName: string, colors: Array<string>): void;
        removeColorScheme(schemeName: string): void;
        getItemsCount(groupIndex: number, serieIndex: number): number;
        getItemCoord(groupIndex: number, serieIndex: number, itemIndex: number): any;
        getXAxisRect(groupIndex: number): ChartRect;
        getXAxisLabels(groupIndex: number): Array<any>;
        getValueAxisRect(groupIndex: number): ChartRect;
        getValueAxisLabels(groupIndex: number): Array<any>;
        getColorScheme(colorScheme: string): Array<string>;
        hideSerie(groupIndex: number, serieIndex: number, itemIndex?: number): void;
        showSerie(groupIndex: number, serieIndex: number, itemIndex?: number): void;
        hideToolTip(hideDelay: number): void;
        showToolTip(groupIndex: number, serieIndex: number, itemIndex: number, showDelay?: number, hideDelay?: number): void;
        saveAsJPEG(fileName: string, exportServerUrl?: string): void;
        saveAsPNG(fileName: string, exportServerUrl?: string): void;
        saveAsPDF(fileName: string, exportServerUrl?: string): void;
        getXAxisValue(offset: number, groupIndex: number): any;
        getValueAxisValue(offset: number, groupIndex: number): any;
    }// jqxChart

    export interface CheckBoxOptions {
        // CheckBoxOptions properties
        animationShowDelay?: number;
        animationHideDelay?: number;
        boxSize?: number | string;
        checked?: boolean | null;
        disabled?: boolean;
        enableContainerClick?: boolean;
        groupName?: string;
        height?: number | string;
        hasThreeStates?: boolean;
        locked?: boolean;
        rtl?: boolean;
        theme?: string;
        width?: number | string;
    }// CheckBoxOptions

    export interface jqxCheckBox extends widget, CheckBoxOptions {

        // jqxCheckBox functions
        check(): void;
        disable(): void;
        destroy(): void;
        enable(): void;
        focus(): void;
        indeterminate(): void;
        render(): void;
        toggle(): void;
        uncheck(): void;
        val(value: boolean): boolean;
    }// jqxCheckBox

    export interface ColorPickerOptions {
        // ColorPickerOptions properties
        color?: string;
        colorMode?: string;
        disabled?: boolean;
        height?: string | number;
        showTransparent?: boolean;
        width?: string | number;
    }// ColorPickerOptions

    export interface jqxColorPicker extends widget, ColorPickerOptions {

        // jqxColorPicker functions
        getColor(): any;
        setColor(color: any): void;
    }// jqxColorPicker

    export interface ComboBoxRenderer {
        // ComboBoxRenderer properties
        index?: number;
        label?: number | string;
        value?: number | string;
    }// ComboBoxRenderer

    export interface ComboBoxRenderSelectedItem {
        // ComboBoxRenderSelectedItem properties
        index?: number;
        item?: any;
    }// ComboBoxRenderSelectedItem

    export interface ComboBoxSearch {
        // ComboBoxSearch properties
        searchString?: string;
    }// ComboBoxSearch

    export interface ComboBoxValidateSelection {
        // ComboBoxValidateSelection properties
        itemValue?: string;
    }// ComboBoxValidateSelection

    export interface ComboBoxOptions {
        // ComboBoxOptions properties
        animationType?: string;
        autoComplete?: boolean;
        autoOpen?: boolean;
        autoItemsHeight?: boolean;
        autoDropDownHeight?: boolean;
        closeDelay?: number;
        checkboxes?: boolean;
        disabled?: boolean;
        displayMember?: string;
        dropDownHorizontalAlignment?: string;
        dropDownVerticalAlignment?: string;
        dropDownHeight?: number | string;
        dropDownWidth?: number | string;
        enableHover?: boolean;
        enableSelection?: boolean;
        enableBrowserBoundsDetection?: boolean;
        height?: string | number;
        itemHeight?: number;
        multiSelect?: boolean;
        minLength?: number;
        openDelay?: number;
        popupZIndex?: number;
        placeHolder?: string;
        remoteAutoComplete?: boolean;
        remoteAutoCompleteDelay?: number;
        renderer?: (index?: ComboBoxRenderer['index'], label?: ComboBoxRenderer['label'], value?: ComboBoxRenderer['value']) => string;
        renderSelectedItem?: (index?: ComboBoxRenderSelectedItem['index'], item?: ComboBoxRenderSelectedItem['item']) => string;
        rtl?: boolean;
        selectedIndex?: number;
        showArrow?: boolean;
        showCloseButtons?: boolean;
        searchMode?: string;
        search?: (searchString?: ComboBoxSearch['searchString']) => void;
        source?: any;
        scrollBarSize?: number | string;
        template?: string;
        theme?: string;
        validateSelection?: (itemValue?: ComboBoxValidateSelection['itemValue']) => boolean;
        valueMember?: string;
        width?: string | number;
    }// ComboBoxOptions

    export interface jqxComboBox extends widget, ComboBoxOptions {

        // jqxComboBox functions
        addItem(item: any): boolean;
        clearSelection(): void;
        clear(): void;
        close(): void;
        checkIndex(index: number): void;
        checkItem(item: any): void;
        checkAll(): void;
        destroy(): void;
        disableItem(item: any): void;
        disableAt(index: number): void;
        enableItem(item: any): void;
        enableAt(index: number): void;
        ensureVisible(index: number): void;
        focus(): void;
        getItem(index: number): any;
        getItemByValue(value: string): any;
        getVisibleItems(): Array<any>;
        getItems(): Array<any>;
        getCheckedItems(): Array<any>;
        getSelectedItem(): any;
        getSelectedItems(): Array<any>;
        getSelectedIndex(): number;
        insertAt(item: any, index: number): boolean;
        isOpened(): boolean;
        indeterminateIndex(index: number): void;
        indeterminateItem(item: any): void;
        loadFromSelect(selectTagId: string): void;
        open(): void;
        removeItem(item: any): boolean;
        removeAt(index: number): boolean;
        selectIndex(index: number): void;
        selectItem(item: any): void;
        searchString(): string;
        updateItem(item: any, itemValue: string): void;
        updateAt(item: any, index: any): void;
        unselectIndex(index: number): void;
        unselectItem(item: any): void;
        uncheckIndex(index: number): void;
        uncheckItem(item: any): void;
        uncheckAll(): void;
        val(value: string): string;
    }// jqxComboBox

    export interface ComplexInputOptions {
        // ComplexInputOptions properties
        decimalNotation?: string;
        disabled?: boolean;
        height?: string | number;
        placeHolder?: string;
        roundedCorners?: boolean;
        rtl?: boolean;
        spinButtons?: boolean;
        spinButtonsStep?: number;
        template?: string;
        theme?: string;
        value?: string;
        width?: string | number;
    }// ComplexInputOptions

    export interface jqxComplexInput extends widget, ComplexInputOptions {

        // jqxComplexInput functions
        destroy(): void;
        getDecimalNotation(part: string, decimalNotation: string): string;
        getReal(complexnumber: number): number;
        getImaginary(complexnumber: number): number;
        render(): void;
        refresh(): void;
        val(value: any): string;
    }// jqxComplexInput

    export interface DataTableColumns {
        // DataTableColumns properties
        text: string;
        dataField: string;
        displayField?: string;
        sortable?: boolean;
        filterable?: boolean;
        hidden?: boolean;
        columnGroup ?: string;
        autoCellHeight?: boolean;
        renderer?: (text:string, align?:string, height?: string | number) => string;
        rendered?: (element:any, align?:string, height?: string | number) => boolean;
        cellsRenderer?: (row:number, column?:any, value?: any, rowData?:any) => string;
        columnType?: string;
        validation?: (cell:number, value?:any) => any;
        initEditor?: (row:number, cellValue?:any, editor?:any, cellText?:string, width?:string | number, height?:string | number) => void;
        createEditor?: (row:number, cellValue?:any, editor?:any, cellText?:string, width?:string | number, height?:string | number) => void;
        getEditorValue?: (row:number, cellValue?:any, editor?:any) => void;
        cellsFormat?: string;
        aggregates?: Array<any>;
        aggregatesRenderer?: (aggregates?: any, column?: any, element?: any) => string;
        align?: string;
        cellsAlign?: string;
        width?: number | string;
        minWidth?: number | string;
        maxWidth?: number | string;
        resizable?: boolean;
        draggable?: boolean;
        editable?: boolean;
        className?: string;
        cellClassName?: any;
        pinned?: boolean;
    }// DataTableColumns

    export interface DataTableColumnGroups {
        // DataTableColumnGroups properties
        text?: string;
        parentGroup?: string;
        align?: string;
        name?: string;
    }// DataTableColumnGroups

    export interface DataTableGroupsRenderer {
        // DataTableGroupsRenderer properties
        value?: string;
        rowdata?: any;
        level?: number;
    }// DataTableGroupsRenderer

    export interface DataTableInitRowDetails {
        // DataTableInitRowDetails properties
        id?: number;
        row?: number;
        element?: any;
        rowinfo?: any;
    }// DataTableInitRowDetails

    export interface DataTableRenderToolbar {
        // DataTableRenderToolbar properties
        toolbar?: any;
    }// DataTableRenderToolbar

    export interface DataTableRenderStatusBar {
        // DataTableRenderStatusBar properties
        statusbar?: any;
    }// DataTableRenderStatusBar

    export interface DataTableEditSettings {
        // DataTableEditSettings properties
        saveOnPageChange?: boolean;
        saveOnBlur?: boolean;
        saveOnSelectionChange?: boolean;
        cancelOnEsc?: boolean;
        saveOnEnter?: boolean;
        editSingleCell?: boolean;
        editOnDoubleClick?: boolean;
        editOnF2?: boolean;
    }// DataTableEditSettings

    export interface DataTableExportSettings {
        // DataTableExportSettings properties
        columnsHeader?: boolean;
        hiddenColumns?: boolean;
        serverURL?: any;
        characterSet?: any;
        recordsInView?: boolean;
        fileName?: string;
    }// DataTableExportSettings

    export interface DataTableOptions {
        // DataTableOptions properties
        altRows?: boolean;
        autoRowHeight?: boolean;
        aggregatesHeight?: number;
        autoShowLoadElement?: boolean;
        columnsHeight?: number;
        columns?: Array<DataTableColumns>;
        columnGroups?: Array<DataTableColumnGroups>;
        columnsResize?: boolean;
        columnsReorder?: boolean;
        disabled?: boolean;
        editable?: boolean;
        editSettings?: DataTableEditSettings;
        exportSettings?: DataTableExportSettings;
        enableHover?: boolean;
        enableBrowserSelection?: boolean;
        filterable?: boolean;
        filterHeight?: number;
        filterMode?: string;
        groups?: Array<any>;
        groupsRenderer?: (value?:DataTableGroupsRenderer['value'], rowData?:DataTableGroupsRenderer['rowdata'], level?:DataTableGroupsRenderer['level']) => string;
        height?: number | string;
        initRowDetails?: (id?:DataTableInitRowDetails['id'], row?:DataTableInitRowDetails['row'], element?:DataTableInitRowDetails['element'], rowInfo?:DataTableInitRowDetails['rowinfo']) => void;
        incrementalSearch?: boolean;
        localization?: any;
        pagerHeight?: number;
        pageSize?: number;
        pageSizeOptions?: Array<string | number>;
        pageable?: boolean;
        pagerPosition?: string;
        pagerMode?: string;
        pagerButtonsCount?: number;
        pagerRenderer?: () => any;
        ready?: () => void;
        rowDetails?: boolean;
        renderToolbar?: (toolbar?:DataTableRenderToolbar['toolbar']) => void;
        renderStatusBar?: (statusbar?:DataTableRenderStatusBar['statusbar']) => void;
        rendering?: () => void;
        rendered?: () => void;
        rtl?: boolean;
        source?: any;
        sortable?: boolean;
        showAggregates?: boolean;
        showToolbar?: boolean;
        showStatusbar?: boolean;
        enableSanitizeAll?: boolean;
        statusBarHeight?: number;
        scrollBarSize?: number | string;
        selectionMode?: string;
        serverProcessing?: boolean;
        showHeader?: boolean;
        theme?: string;
        toolbarHeight?: number;
        width?: string | number;
    }// DataTableOptions

    export interface jqxDataTable extends widget, DataTableOptions {

        // jqxDataTable functions
        addRow(rowIndex: number, rowData: any, rowPosition: any): void;
        addFilter(dataField: string, filerGroup: any): void;
        applyFilters(): void;
        beginUpdate(): void;
        beginRowEdit(rowIndex: number): void;
        beginCellEdit(rowIndex: number, dataField: string): void;
        clearSelection(): void;
        clearFilters(): void;
        clear(): void;
        destroy(): void;
        deleteRow(rowIndex: number): void;
        endUpdate(): void;
        ensureRowVisible(rowIndex: number): void;
        endRowEdit(rowIndex: number, cancelChanges: boolean): void;
        endCellEdit(rowIndex: number, dataField: string): void;
        exportData(exportDataType: any): any;
        focus(): void;
        getColumnProperty(dataField: string, propertyName: string): any;
        goToPage(pageIndex: number): void;
        goToPrevPage(): void;
        goToNextPage(): void;
        getSelection(): Array<any>;
        getRows(): Array<any>;
        getView(): Array<any>;
        getCellValue(rowIndex: number, dataField: string): any;
        hideColumn(dataField: string): void;
        hideDetails(rowIndex: boolean): void;
        isBindingCompleted(): boolean;
        lockRow(rowIndex: number): void;
        refresh(): void;
        render(): void;
        removeFilter(dataField: string): void;
        scrollOffset(top: number, left: number): void;
        setColumnProperty(dataField: string, propertyName: string, propertyValue: any): void;
        showColumn(dataField: string): void;
        selectRow(rowIndex: number): void;
        showDetails(rowIndex: number): void;
        setCellValue(rowIndex: number, dataField: string, value: any): void;
        sortBy(dataField: string, sortOrder: any): void;
        updating(): boolean;
        updateBoundData(): void;
        unselectRow(rowIndex: number): void;
        updateRow(rowIndex: number, rowData: any): void;
        unlockRow(rowIndex: number): void;
    }// jqxDataTable

    export interface DateTimeInputOptions {
        // DateTimeInputOptions properties
        animationType?: string;
        allowNullDate?: boolean;
        allowKeyboardDelete?: boolean;
        clearString?: string;
        culture?: string;
        closeDelay?: number;
        closeCalendarAfterSelection?: boolean;
        dropDownHorizontalAlignment?: string;
        dropDownVerticalAlignment?: string;
        disabled?: boolean;
        enableBrowserBoundsDetection?: boolean;
        enableAbsoluteSelection?: boolean;
        editMode?: string;
        firstDayOfWeek?: number;
        formatString?: string;
        height?: string | number;
        min?: Date;
        max?: Date;
        openDelay?: number;
        placeHolder?: string;
        popupZIndex?: number;
        rtl?: boolean;
        readonly?: boolean;
        showFooter?: boolean;
        selectionMode?: string;
        showWeekNumbers?: boolean;
        showTimeButton?: boolean;
        showCalendarButton?: boolean;
        showDeleteButton?: boolean;
        theme?: string;
        template?: string;
        textAlign?: string;
        todayString?: string;
        value?: Date | null;
        width?: string | number;
        yearCutoff?: number;
    }// DateTimeInputOptions

    export interface jqxDateTimeInput extends widget, DateTimeInputOptions {

        // jqxDateTimeInput functions
        close(): void;
        destroy(): void;
        focus(): void;
        getRange(): any;
        getText(): string;
        getDate(): any;
        getMaxDate(): any;
        getMinDate(): any;
        open(): void;
        setRange(date: any, date2: any): void;
        setMinDate(date: any): void;
        setMaxDate(date: any): void;
        setDate(date: any): void;
        val(value: any, value2: any): any;
    }// jqxDateTimeInput

    export interface DockingCookieOptions {
        // DockingCookieOptions properties
        domain?: string;
        expires?: number;
    }// DockingCookieOptions

    export interface DockingOptions {
        // DockingOptions properties
        cookies?: boolean;
        cookieOptions?: DockingCookieOptions;
        disabled?: boolean;
        floatingWindowOpacity?: number;
        height?: number | string;
        keyboardNavigation?: boolean;
        mode?: string;
        orientation?: string;
        rtl?: boolean;
        theme?: string;
        width?: number | string;
        windowsMode?: object;
        windowsOffset?: number;
    }// DockingOptions

    export interface jqxDocking extends widget, DockingOptions {

        // jqxDocking functions
        addWindow(windowId: string, mode: any, panel: number, position: any): void;
        closeWindow(windowId: string): void;
        collapseWindow(windowId: string): void;
        destroy(): void;
        disableWindowResize(windowId: string): void;
        disable(): void;
        exportLayout(): string;
        enable(): void;
        expandWindow(windowId: string): void;
        enableWindowResize(windowId: string): void;
        focus(): void;
        hideAllCloseButtons(): void;
        hideAllCollapseButtons(): void;
        hideCollapseButton(windowId: string): void;
        hideCloseButton(windowId: string): void;
        importLayout(Json: string): void;
        move(windowId: string, panel: number, position: number): void;
        pinWindow(windowId: string): void;
        setWindowMode(windowId: string, mode: any): void;
        showCloseButton(windowId: string): void;
        showCollapseButton(windowId: string): void;
        setWindowPosition(windowId: string, top: any, left: number): void;
        showAllCloseButtons(): void;
        showAllCollapseButtons(): void;
        unpinWindow(windowId: string): void;
    }// jqxDocking

    export interface DockingLayoutLayout {
        // DockingLayoutLayout properties
        type: string;
        alignment?: string;
        allowClose?: boolean;
        allowPin?: boolean;
        allowUnpin?: boolean;
        contentContainer?: string;
        height?: number | string;
        initContent?: () => void;
        minHeight?: number | string;
        minWidth?: number | string;
        orientation?: string;
        pinnedHeight?: number | string;
        pinnedWidth?: number | string;
        position?: DockingLayoutLayoutPosition;
        selected?: boolean;
        title?: string;
        unpinnedHeight?: number | string;
        unpinnedWidth?: number | string;
        width?: number | string;
        items?: Array<DockingLayoutLayout>;
    }// DockingLayoutLayout

    export interface DockingLayoutLayoutPosition {
        // DockingLayoutLayoutPosition properties
        x: number;
        y: number;
    }// DockingLayoutLayoutPosition

    export interface DockingLayoutOptions {
        // DockingLayoutOptions properties
        contextMenu?: boolean;
        height?: string | number;
        layout?: Array<DockingLayoutLayout>;
        minGroupHeight?: number | string;
        minGroupWidth?: number | string;
        resizable?: boolean;
        rtl?: boolean;
        theme?: string;
        width?: string | number;
    }// DockingLayoutOptions

    export interface jqxDockingLayout extends widget, DockingLayoutOptions {

        // jqxDockingLayout functions
        addFloatGroup(width: number | string, height: number | string, position: DockingLayoutLayoutPosition, panelType: string, title: string, content: string, initContent: any): void;
        destroy(): void;
        loadLayout(layout: any): void;
        refresh(): void;
        render(): void;
        saveLayout(): any;
    }// jqxDockingLayout

    export interface DockPanelOptions {
        // DockPanelOptions properties
        disabled?: boolean;
        height?: string | number;
        lastchildfill?: boolean;
        width?: string | number;
    }// DockPanelOptions

    export interface jqxDockPanel extends widget, DockPanelOptions {

        // jqxDockPanel functions
        refresh(): void;
    }// jqxDockPanel

    export interface DragDropOnDrag {
        // DragDropOnDrag properties
        data?: any;
        position?: object;
    }// DragDropOnDrag

    export interface DragDropOnDragStart {
        // DragDropOnDragStart properties
        position?: object;
    }// DragDropOnDragStart

    export interface DragDropOnTargetDrop {
        // DragDropOnTargetDrop properties
        data?: any;
    }// DragDropOnTargetDrop

    export interface DragDropOnDropTargetLeave {
        // DragDropOnDropTargetLeave properties
        data?: any;
    }// DragDropOnDropTargetLeave

    export interface DragDropOptions {
        // DragDropOptions properties
        appendTo?: string;
        disabled?: boolean;
        distance?: number;
        data?: any;
        dropAction?: string;
        dropTarget?: any;
        dragZIndex?: number;
        feedback?: string;
        initFeedback?: (feedback?:any) => void;
        opacity?: number;
        onDragEnd?: () => void;
        onDrag?: (data?: DragDropOnDrag['data'], position?: DragDropOnDrag['position']) => void;
        onDragStart?: (position?: DragDropOnDragStart['position']) => void;
        onTargetDrop?: (data?: DragDropOnTargetDrop['data']) => void;
        onDropTargetEnter?: () => void;
        onDropTargetLeave?: (data?: DragDropOnDropTargetLeave['data']) => void;
        restricter?: string | object;
        revert?: boolean;
        revertDuration?: number;
        tolerance?: string;
    }// DragDropOptions

    export interface jqxDragDrop extends widget, DragDropOptions {

        // jqxDragDrop functions

    }// jqxDragDrop

    export interface DrawOptions {
        // DrawOptions properties
        renderEngine?: string;
    }// DrawOptions

    export interface jqxDraw extends widget, DrawOptions {

        // jqxDraw functions
        attr(element: any, attributes: any): void;
        circle(cx: number, cy: number, r: number, attributes: any): any;
        clear(): void;
        getAttr(element: any, attributes: any): string;
        getSize(): any;
        line(x1: number, y1: number, x2: number, y2: number, attributes: any): any;
        measureText(text: string, angle: number, attributes: any): any;
        on(element: any, event: string, func: any): void;
        off(element: any, event: string, func: any): void;
        path(path: string, attributes: any): any;
        pieslice(cx: number, xy: number, innerRadius: any, outerRadius: any, fromAngle: number, endAngle: number, centerOffset: number, attributes: any): any;
        refresh(): void;
        rect(x: number, y: number, width: number | string, height: number | string, attributes: any): any;
        saveAsJPEG(image: string, url: string): void;
        saveAsPNG(image: string, url: string): void;
        text(text: string, x: number, y: number, width: number | string, height: number | string, angle: number, attributes: any, clip: boolean, halign: string, valign: string, rotateAround: string): any;
    }// jqxDraw

    export interface DropDownButtonOptions {
        // DropDownButtonOptions properties
        animationType?: string;
        arrowSize?: number;
        autoOpen?: boolean;
        closeDelay?: number;
        disabled?: boolean;
        dropDownHorizontalAlignment?: string;
        dropDownVerticalAlignment?: string;
        dropDownWidth?: number | string;
        enableBrowserBoundsDetection?: boolean;
        height?: string | number;
        initContent?: () => void;
        openDelay?: number;
        popupZIndex?: number;
        rtl?: boolean;
        template?: string;
        theme?: string;
        width?: string | number;
    }// DropDownButtonOptions

    export interface jqxDropDownButton extends widget, DropDownButtonOptions {

        // jqxDropDownButton functions
        close(): void;
        destroy(): void;
        focus(): void;
        getContent(): any;
        isOpened(): boolean;
        open(): void;
        setContent(content: string): void;
    }// jqxDropDownButton

    export interface DropDownListItem {
        // DropDownListItem properties
        label?: string;
        value?: any;
        disabled?: boolean;
        checked?: any;
        hasThreeStates?: boolean;
        html?: string;
        group?: string;
    }// DropDownListItem

    export interface DropDownListRenderer {
        // DropDownListRenderer properties
        index?: number;
        label?: string;
        value?: string;
    }// DropDownListRenderer

    export interface DropDownListSelectionRenderer {
        // DropDownListSelectionRenderer properties
        element?: any;
        index?: number;
        label?: string;
        value?: any;
    }// DropDownListSelectionRenderer

    export interface DropDownListOptions {
        // DropDownListOptions properties
        autoOpen?: boolean;
        autoDropDownHeight?: boolean;
        animationType?: string;
        checkboxes?: boolean;
        closeDelay?: number;
        disabled?: boolean;
        displayMember?: string;
        dropDownHorizontalAlignment?: string;
        dropDownVerticalAlignment?: string;
        dropDownHeight?: number | string;
        dropDownWidth?: number | string;
        enableSelection?: boolean;
        enableBrowserBoundsDetection?: boolean;
        enableHover?: boolean;
        filterable?: boolean;
        filterHeight?: number;
        filterDelay?: number;
        filterPlaceHolder?: string;
        height?: number | string;
        incrementalSearch?: boolean;
        incrementalSearchDelay?: number;
        itemHeight?: number;
        openDelay?: number;
        placeHolder?: string;
        popupZIndex?: number;
        rtl?: boolean;
        renderer?: (index?: DropDownListRenderer['index'], label?: DropDownListRenderer['label'], value?: DropDownListRenderer['value']) => string;
        selectionRenderer?: (element?: DropDownListSelectionRenderer['element'], index?: DropDownListSelectionRenderer['index'], label?: DropDownListSelectionRenderer['label'], value?: DropDownListSelectionRenderer['value']) => string;
        searchMode?: string;
        source?: Array<any>;
        selectedIndex?: number;
        scrollBarSize?: number;
        theme?: string;
        template?: string;
        valueMember?: string;
        width?: number | string;
    }// DropDownListOptions

    export interface jqxDropDownList extends widget, DropDownListOptions {

        // jqxDropDownList functions
        addItem(item: DropDownListItem): boolean;
        clearSelection(): void;
        clear(): void;
        close(): void;
        checkIndex(index: number): void;
        checkItem(item: any): void;
        checkAll(): void;
        clearFilter(): void;
        destroy(): void;
        disableItem(item: any): void;
        disableAt(index: number): void;
        enableItem(item: any): void;
        enableAt(index: number): void;
        ensureVisible(index: number): void;
        focus(): void;
        getItem(index: number): DropDownListItem;
        getItemByValue(itemValue: string): DropDownListItem;
        getItems(): Array<DropDownListItem>;
        getCheckedItems(): Array<DropDownListItem>;
        getSelectedItem(): DropDownListItem;
        getSelectedIndex(): number;
        insertAt(item: DropDownListItem, index: number): void;
        isOpened(): boolean;
        indeterminateIndex(index: number): void;
        indeterminateItem(item: any): void;
        loadFromSelect(arg: string): void;
        open(): void;
        removeItem(item: any): void;
        removeAt(index: number): void;
        selectIndex(index: number): void;
        selectItem(item: DropDownListItem): void;
        setContent(content: string): void;
        updateItem(newItem: DropDownListItem, item: any): void;
        updateAt(item: DropDownListItem, index: number): void;
        unselectIndex(index: number): void;
        unselectItem(item: any): void;
        uncheckIndex(index: number): void;
        uncheckItem(item: any): void;
        uncheckAll(): void;
        val(value: string): string;
    }// jqxDropDownList

    export interface EditorLocalization {
        // EditorLocalization properties
        bold?: string;
        italic?: string;
        underline?: string;
        format?: string;
        size?: number | string;
        font?: string;
        html?: string;
        color?: string;
        background?: string;
        left?: string;
        center?: string;
        right?: string;
        outdent?: string;
        indent?: string;
        ul?: string;
        ol?: string;
        image?: string;
        link?: string;
        clean?: string;
    }// EditorLocalization

    export interface EditorCreateCommand {
        // EditorCreateCommand properties
        name?: string;
    }// EditorCreateCommand

    export interface EditorOptions {
        // EditorOptions properties
        createCommand?: (name:EditorCreateCommand['name']) => void;
        disabled?: boolean;
        editable?: boolean;
        height?: string  | number;
        lineBreak?: string;
        localization?: EditorLocalization;
        pasteMode?: string;
        rtl?: boolean;
        stylesheets?: Array<any>;
        theme?: string;
        toolbarPosition?: string;
        tools?: string;
        width?: string | number;
    }// EditorOptions

    export interface jqxEditor extends widget, EditorOptions {

        // jqxEditor functions
        destroy(): void;
        focus(): void;
        print(): void;
        setMode(mode: boolean): void;
        val(value: string): string;
    }// jqxEditor

    export interface ExpanderOptions {
        // ExpanderOptions properties
        animationType?: string;
        arrowPosition?: string;
        collapseAnimationDuration?: number;
        disabled?: boolean;
        expanded?: boolean;
        expandAnimationDuration?: number;
        height?: number | string;
        headerPosition?: string;
        initContent?: () => void;
        rtl?: boolean;
        showArrow?: boolean;
        theme?: string;
        toggleMode?: string;
        width?: number | string;
    }// ExpanderOptions

    export interface jqxExpander extends widget, ExpanderOptions {

        // jqxExpander functions
        collapse(): void;
        disable(): void;
        destroy(): void;
        enable(): void;
        expand(): void;
        focus(): void;
        getContent(): string;
        getHeaderContent(): string;
        invalidate(): void;
        refresh(): void;
        render(): void;
        setHeaderContent(headerContent: string): void;
        setContent(content: string): void;
    }// jqxExpander

    export interface FileUploadLocalization {
        // FileUploadLocalization properties
        browseButton?: string;
        uploadButton?: string;
        cancelButton?: string;
        uploadFileTooltip?: string;
        cancelFileTooltip?: string;
    }// FileUploadLocalization

    export interface FileUploadRenderFiles {
        // FileUploadRenderFiles properties
        fileName?: string;
    }// FileUploadRenderFiles

    export interface FileUploadOptions {
        // FileUploadOptions properties
        autoUpload?: boolean;
        accept?: string;
        browseTemplate?: string;
        cancelTemplate?: string;
        disabled?: boolean;
        fileInputName?: string;
        height?: number | string;
        localization?: FileUploadLocalization;
        multipleFilesUpload?: boolean;
        renderFiles?: (filename:FileUploadRenderFiles['fileName']) => void;
        rtl?: boolean;
        theme?: string;
        uploadUrl?: string;
        uploadTemplate?: string;
        width?: string | number;
    }// FileUploadOptions

    export interface jqxFileUpload extends widget, FileUploadOptions {

        // jqxFileUpload functions
        browse(): void;
        cancelFile(fileIndex: number): void;
        cancelAll(): void;
        destroy(): void;
        render(): void;
        refresh(): void;
        uploadFile(fileIndex: number): void;
        uploadAll(): void;
    }// jqxFileUpload

    export interface FormPadding {
        // FormPadding properties
        left: number | string;
        right: number | string;
        top: number | string;
        bottom: number | string;
    }// FormPadding

    export interface FormTemplateItem {
        // FormTemplateItem properties
        name?: string;
        text?: string;
        type?: string;
        bind?: string;
        submit?: boolean;
        required?: boolean;
        requiredPosition?: string;
        info?: string;
        infoPosition?: string;
        component?: string;
        init?: (value: any) => void;
        label?: string;
        labelPosition?: string;
        labelAlign?: string;
        align?: string;
        valign?: string;
        labelValign?: string;
        height?: number | string;
        rowHeight?: number | string;
        width?: number | string;
        columnWidth?: number | string;
        labelWidth?: number | string;
        labelHeight?: number | string;
        padding?: FormPadding;
        labelPadding?: FormPadding;
        columns?: Array<FormTemplateItem>;
        optionsLayout?: string;
        options?: Array<any>;
    }// FormTemplateItem

    export interface FormOptions {
        // FormOptions properties
        padding?: FormPadding;
        backgroundColor?: string;
        borderColor?: string;
        value?: any;
        template: Array<FormTemplateItem>;
    }// FormOptions

    export interface jqxForm extends widget, FormOptions {

        // jqxForm functions
        getInstance(): any;
        refresh(): void;
        destroy(): void;
        hideComponent(name: string): void;
        showComponent(name: string): void;
        val(value?: any): any;
        submit(action?: string, target?: string, method?: string): void;
        getComponentByName(name?: string): any;
    }// jqxForm

    export interface FormattedInputOptions {
        // FormattedInputOptions properties
        disabled?: boolean;
        decimalNotation?: string;
        dropDown?: boolean;
        dropDownWidth?: number | string;
        height?: number | string;
        min?: number | string;
        max?: number | string;
        placeHolder?: string;
        popupZIndex?: number;
        roundedCorners?: boolean;
        rtl?: boolean;
        radix?: number | string;
        spinButtons?: boolean;
        spinButtonsStep?: number;
        template?: string;
        theme?: string;
        upperCase?: boolean;
        value?: any;
        width?: number | string;
    }// FormattedInputOptions

    export interface jqxFormattedInput extends widget, FormattedInputOptions {

        // jqxFormattedInput functions
        close(): void;
        destroy(): void;
        focus(): void;
        open(): void;
        render(): void;
        refresh(): void;
        selectAll(): void;
        selectFirst(): void;
        selectLast(): void;
        val(value: number | string): any;
    }// jqxFormattedInput

    export interface GaugeStyle {
        // GaugeStyle properties
        fill?: string;
        stroke?: string;
    }// GaugeStyle

    export interface GaugeBorder {
        // GaugeBorder properties
        size?: number | string;
        visible?: boolean;
        style?: GaugeStyle;
        showGradient?: boolean;
    }// GaugeBorder

    export interface GaugeCaption {
        // GaugeCaption properties
        value?: string;
        position?: string;
        offset?: Array<number>;
        visible?: boolean;
    }// GaugeCaption

    export interface GaugeCap {
        // GaugeCap properties
        size?: number | string;
        visible?: boolean;
        style?: GaugeStyle;
    }// GaugeCap

    export interface GaugeLabels {
        // GaugeLabels properties
        distance?: string;
        position?: string;
        interval?: number | string;
        offset?: Array<number>;
        visible?: boolean;
        formatValue?: (value?: number) => string;
    }// GaugeLabels

    export interface GaugePointer {
        // GaugePointer properties
        pointerType?: string;
        style?: GaugeStyle;
        width?: number | string;
        length?: number | string;
        visible?: boolean;
    }// GaugePointer

    export interface GaugeRanges {
        // GaugeRanges properties
        startValue: number | string;
        endValue: number | string;
        startWidth: number | string;
        endWidth: number | string;
        startDistance?: number | string;
        endDistance?: number | string;
        style: GaugeStyle;
    }// GaugeRanges

    export interface GaugeTicks {
        // GaugeTicks properties
        size: number | string;
        interval: number | string;
        visible?: boolean;
        style?: GaugeStyle;
    }// GaugeTicks

    export interface GaugeOptions {
        // GaugeOptions properties
        animationDuration?: string | number;
        border?: GaugeBorder;
        caption?: GaugeCaption;
        cap?: GaugeCap;
        colorScheme?: string;
        disabled?: boolean;
        easing?: string;
        endAngle?: number | string;
        height?: number | string;
        int64?: boolean;
        labels?: GaugeLabels;
        min?: number;
        max?: number | string;
        pointer?: GaugePointer;
        radius?: number | string;
        ranges?: Array<GaugeRanges>;
        startAngle?: number | string;
        showRanges?: boolean;
        styles?: GaugeStyle;
        ticksMajor?: GaugeTicks;
        ticksMinor?: GaugeTicks;
        ticksDistance?: string;
        value?: number;
        width?: number | string;
    }// GaugeOptions

    export interface jqxGauge extends widget, GaugeOptions {

        // jqxGauge functions
        disable(): void;
        enable(): void;
        val(value: number): number;
    }// jqxGauge

    export interface ValidationResult {
        // ValidationResult properties
        result: boolean;
        message?: string;
    }// ValidationResult

    export interface GridCharting {
        // GridCharting properties
        appendTo?: string;
        colorScheme?: string;
        dialog?: (width: number, height: number, header: string, position: any, enabled: boolean) => void;
        formatSettings?: any;
        ready?: any;
    }// GridCharting

    export interface GridColumn {
        // GridColumn properties
        text?: string;
        datafield?: string;
        displayfield?: string;
        threestatecheckbox?: boolean;
        sortable?: boolean;
        filterable?: boolean;
        filter?: (cellValue?: any, rowData?: any, dataField?: string, filterGroup?: any, defaultFilterResult?: any) => any;
        buttonclick?: (row: number) => void;
        hideable?: boolean;
        hidden?: boolean;
        groupable?: boolean;
        menu?: boolean;
        exportable?: boolean;
        columngroup?: string;
        enabletooltips?: boolean;
        columntype?: string;
        renderer?: (defaultText?: string, alignment?: string, height?: number) => string;
        rendered?: (columnHeaderElement?: any) => void;
        cellsrenderer?: (row?: number, columnfield?: string, value?: any, defaulthtml?: string, columnproperties?: any, rowdata?: any) => string;
        aggregatesrenderer?: (aggregates?: any, column?: any, element?: any, summaryData?: any)  => string;
        validation?: (cell?: any, value?: number) => any;
        createwidget?: (row: any, column: any, value: string, cellElement: any) => void;
        initwidget?: (row: number, column: string, value: string, cellElement: any) => void;
        createfilterwidget?: (column: any, htmlElement: HTMLElement, editor: any) => void;
        createfilterpanel?: (datafield: string, filterPanel: any) => void;
        initeditor?: (row: number, cellvalue: any, editor: any, celltext: any, pressedChar: string, callback: any) => void;
        createeditor?: (row: number, cellvalue: any, editor: any, celltext: any, cellwidth: any, cellheight: any) => void;
        destroyeditor?: (row: number, callback: any) => void;
        geteditorvalue?: (row: number, cellvalue:any, editor:any) => any;
        cellbeginedit?: (row: number, datafield: string, columntype: string, value: any) => boolean;
        cellendedit?: (row: number, datafield: string, columntype: string, oldvalue: any, newvalue: any) => boolean;
        cellvaluechanging?: (row: number, datafield: string, columntype: string, oldvalue: any, newvalue: any) => string | void;
        createeverpresentrowwidget?: (datafield: string, htmlElement: HTMLElement, popup: any, addRowCallback: any) => any;
        initeverpresentrowwidget?: (datafield: string, htmlElement: HTMLElement, popup: any) => void;
        reseteverpresentrowwidgetvalue?: (datafield: string, htmlElement: HTMLElement) => void;
        geteverpresentrowwidgetvalue?: (datafield: string, htmlElement: HTMLElement) => any;
        destroyeverpresentrowwidget?: (htmlElement: HTMLElement) => void;
        validateeverpresentrowwidgetvalue?: (datafield: string, value: any, rowValues: any) => boolean | object;
        cellsformat?: string;
        cellclassname?: any;
        aggregates?: any;
        align?: string;
        cellsalign?: string;
        width?: number | string;
        minwidth?: any;
        maxwidth?: any;
        resizable?: boolean;
        draggable?: boolean;
        editable?: boolean;
        classname?: string;
        pinned?: boolean;
        nullable?: boolean;
        filteritems?: any;
        filterdelay?: number;
        filtertype?: string;
        filtercondition?: string;
    }// GridColumn

    export interface GridSourceDataFields {
        // GridSourceDataFields properties
        name: string;
        type?: string;
        format?: string;
        map?: string;
        id?: string;
        text?: string;
        source?: Array<any>;
    }// GridSourceDataFields

    export interface GridSource {
        // GridSource properties
        url?: string;
        data?: any;
        localdata?: any;
        datatype?: string;
        type?: string;
        id?: string;
        root?: string;
        record?: string;
        datafields?: Array<GridSourceDataFields>;
        pagenum?: number;
        pagesize?: number;
        pager?: (pagenum?: number, pagesize?: number, oldpagenum?: number) => any;
        sortcolumn?: string;
        sortdirection?: string;
        sort?: (column?: any, direction?: any) => void;
        filter?: (filters?: any, recordsArray?: any) => void;
        addrow?: (rowid?: any, rowdata?: any, position?: any, commit?: boolean) => void;
        deleterow?: (rowid?: any, commit?: boolean) => void;
        updaterow?: (rowid?: any, newdata?: any, commit? : any) => void;
        processdata?: (data: any) => void;
        formatdata?: (data: any) => any;
        async?: boolean;
        totalrecords?: number;
        unboundmode?: boolean;
    }// GridSource

    export interface GridGetColumn {
        // GridGetColumn properties
        datafield?: string;
        displayfield?: string;
        text?: string;
        sortable?: boolean;
        filterable?: boolean;
        exportable?: boolean;
        editable?: boolean;
        groupable?: boolean;
        resizable?: boolean;
        draggable?: boolean;
        classname?: string;
        cellclassname?: any;
        width?: number | string;
        menu?: boolean;
    }// GridGetColumn

    export interface GridGetDataInformation {
        // GridGetDataInformation properties
        rowscount?: string;
        sortinformation?: any;
        sortcolumn?: any;
        sortdirection?: any;
        paginginformation?: any;
        pagenum?: any;
        pagesize?: any;
        pagescount?: any;
    }// GridGetDataInformation

    export interface GridGetSortInformation {
        // GridGetSortInformation properties
        sortcolumn?: string;
        sortdirection?: any;
    }// GridGetSortInformation

    export interface GridGetPagingInformation {
        // GridGetPagingInformation properties
        pagenum?: string;
        pagesize?: any;
        pagescount?: any;
    }// GridGetPagingInformation

    export interface GridDateNaming {
        // GridDateNaming properties
        names?: Array<string>;
        namesAbbr?: Array<string>;
        namesShort?: Array<string>;
    }// GridDateNaming

    export interface GridLocalizationobject {
        // GridLocalizationobject properties
        filterstringcomparisonoperators?: any;
        filternumericcomparisonoperators?: any;
        filterdatecomparisonoperators?: any;
        filterbooleancomparisonoperators?: any;
        pagergotopagestring?: string;
        pagershowrowsstring?: string;
        pagerrangestring?: string;
        pagernextbuttonstring?: string;
        pagerpreviousbuttonstring?: string;
        sortascendingstring?: string;
        sortdescendingstring?: string;
        sortremovestring?: string;
        firstDay?: number;
        percentsymbol?: string;
        currencysymbol?: string;
        currencysymbolposition?: string;
        decimalseparator?: string;
        thousandsseparator?: string;
        days?: GridDateNaming;
        months?: GridDateNaming;
        addrowstring?: string;
        updaterowstring?: string;
        deleterowstring?: string;
        resetrowstring?: string;
        everpresentrowplaceholder?: string;
        emptydatastring?: string;
    }// GridLocalizationobject

    export interface GridScrollPosition {
        // GridScrollPosition properties
        top?: number;
        left?: number;
    }// GridScrollPosition

    export interface GridGetGroup {
        // GridGetGroup properties
        group?: number;
        level?: number;
        expanded?: number;
        subgroups?: number;
        subrows?: number;
    }// GridGetGroup

    export interface GridGetCell {
        // GridGetCell properties
        value?: number;
        row?: number;
        column?: number;
    }// GridGetCell

    export interface GridGetSelectedCell {
        // GridGetSelectedCell properties
        rowindex?: number;
        datafield?: string;
    }// GridGetSelectedCell

    export interface GridGetStateColumns {
        // GridGetStateColumns properties
        width?: number | string;
        hidden?: boolean;
        index?: number;
        pinned?: boolean;
        groupable?: boolean;
        resizable?: boolean;
        draggable?: boolean;
        text?: string;
        align?: string;
        cellsalign?: string;
    }// GridGetStateColumns

    export interface GridGetState {
        // GridGetState properties
        width?: number | string;
        height?: number | string;
        pagenum?: number;
        pagesize?: number;
        pagesizeoptions?: Array<string>;
        sortcolumn?: any;
        sortdirection?: any;
        filters?: any;
        groups?: any;
        columns?: GridGetStateColumns;
    }// GridGetState

    export interface GridColumnmenuopening {
        // GridColumnmenuopening properties
        menu?: any;
        datafield?: any;
        height?: any;
    }// GridColumnmenuopening

    export interface GridColumnmenuclosing {
        // GridColumnmenuclosing properties
        menu?: any;
        datafield?: any;
        height?: any;
    }// GridColumnmenuclosing

    export interface GridCellhover {
        // GridCellhover properties
        cellhtmlElement?: any;
        x?: any;
        y?: any;
    }// GridCellhover

    export interface GridGroupsrenderer {
        // GridGroupsrenderer properties
        text?: string;
        group?: number;
        expanded?: boolean;
        data?: object;
    }// GridGroupsrenderer

    export interface GridGroupcolumnrenderer {
        // GridGroupcolumnrenderer properties
        text?: any;
    }// GridGroupcolumnrenderer

    export interface GridHandlekeyboardnavigation  {
        // GridHandlekeyboardnavigation  properties
        event?: any;
    }// GridHandlekeyboardnavigation 

    export interface GridScrollfeedback {
        // GridScrollfeedback properties
        row?: any;
    }// GridScrollfeedback

    export interface GridFilter {
        // GridFilter properties
        cellValue?: any;
        rowData?: any;
        dataField?: string;
        filterGroup?: any;
        defaultFilterResult?: boolean;
    }// GridFilter

    export interface GridRendertoolbar {
        // GridRendertoolbar properties
        toolbar?: any;
    }// GridRendertoolbar

    export interface GridRenderstatusbar {
        // GridRenderstatusbar properties
        statusbar?: any;
    }// GridRenderstatusbar

    export interface GridOptions {
        // GridOptions properties
        altrows?: boolean;
        altstart?: number;
        altstep?: number;
        autoshowloadelement?: boolean;
        autoshowfiltericon?: boolean;
        autoshowcolumnsmenubutton?: boolean;
        showcolumnlines?: boolean;
        showrowlines?: boolean;
        showcolumnheaderlines?: boolean;
        adaptive?: boolean;
        compact?: boolean;
        contextmenuitems?: any;
        contextmenuenabled?: any;
        contextmenuwidth?: any;
        contextmenuheight?: any;
        contextmenuitemclick?: any;
        adaptivewidth?: number;
        commandcolumn?: boolean;
        commandcolumnrenderer?: (row?: number, columnfield?: string, active?: any) => string;
        clipboard?: boolean;
        closeablegroups?: boolean;
        columnsmenuwidth?: number;
        columnmenuopening?: (menu?: GridColumnmenuopening['menu'], datafield?: GridColumnmenuopening['datafield'], height?: GridColumnmenuopening['height']) => boolean | void;
        columnmenuclosing?: (menu?: GridColumnmenuclosing['menu'], datafield?: GridColumnmenuclosing['datafield'], height?: GridColumnmenuclosing['height']) => boolean;
        cellhover?: (cellhtmlElement?: GridCellhover['cellhtmlElement'], x?: GridCellhover['x'], y?: GridCellhover['y']) => void;
        enablekeyboarddelete?: boolean;
        enableellipsis?: boolean;
        enablemousewheel?: boolean;
        enableanimations?: boolean;
        enabletooltips?: boolean;
        enablehover?: boolean;
        enablebrowserselection?: boolean;
        everpresentrowposition?: string;
        everpresentrowheight?: number;
        everpresentrowactions?: string;
        everpresentrowactionsmode?: string;
        filterrowheight?: number;
        filtermode?: string;
        groupsrenderer?: (text?: GridGroupsrenderer['text'], group?: GridGroupsrenderer['group'], expanded?: GridGroupsrenderer['expanded'], data?: GridGroupsrenderer['data']) => string;
        groupcolumnrenderer?: (text?: GridGroupcolumnrenderer['text']) => string;
        groupsexpandedbydefault?: boolean;
        handlekeyboardnavigation?: (event: GridHandlekeyboardnavigation['event']) => boolean;
        pagerrenderer?: () => any[];
        rtl?: boolean;
        showdefaultloadelement?: boolean;
        showfiltercolumnbackground?: boolean;
        showfiltermenuitems?: boolean;
        showpinnedcolumnbackground?: boolean;
        showsortcolumnbackground?: boolean;
        showsortmenuitems?: boolean;
        showgroupmenuitems?: boolean;
        showrowdetailscolumn?: boolean;
        showheader?: boolean;
        showgroupsheader?: boolean;
        showaggregates?: boolean;
        showgroupaggregates?: boolean;
        showeverpresentrow?: boolean;
        showfilterrow?: boolean;
        showemptyrow?: boolean;
        showstatusbar?: boolean;
        statusbarheight?: number;
        showtoolbar?: boolean;
        showfilterbar?: boolean;
        filterbarmode?: string;
        selectionmode?: string;
        updatefilterconditions?: (type?: string, defaultconditions?: any) => any;
        updatefilterpanel?: (filtertypedropdown1?: any, filtertypedropdown2?: any, filteroperatordropdown?: any, filterinputfield1?: any, filterinputfield2?: any, filterbutton?: any, clearbutton?: any, columnfilter?: any, filtertype?: any, filterconditions?: any) => any;
        theme?: string;
        toolbarheight?: number;
        autoheight?: boolean;
        autorowheight?: boolean;
        columnsheight?: number;
        deferreddatafields?: Array<string>;
        groupsheaderheight?: number;
        groupindentwidth?: number;
        height?: number | string;
        pagerheight?: number | string;
        rowsheight?: number;
        scrollbarsize?: number | string;
        scrollmode?: string;
        scrollfeedback?: (row: GridScrollfeedback['row']) => string;
        width?: string | number;
        autosavestate?: boolean;
        autoloadstate?: boolean;
        columns?: GridColumn[];
        enableSanitize?: boolean;
        cardview?: boolean;
        cardviewcolumns?: any;
        cardheight?: number;
        cardsize?: number;
        columngroups?: Array<any>;
        columnsmenu?: boolean;
        columnsresize?: boolean;
        columnsautoresize?: boolean;
        columnsreorder?: boolean;
        charting?: GridCharting;
        disabled?: boolean;
        editable?: boolean;
        batcheditable?: boolean;
        editmode?: string;
        filter?: (cellValue?: GridFilter['cellValue'], rowData?: GridFilter['rowData'], dataField?: GridFilter['dataField'], filterGroup?: GridFilter['filterGroup'], defaultFilterResult?: GridFilter['defaultFilterResult']) => any;
        filterable?: boolean;
        groupable?: boolean;
        groups?: Array<string>;
        horizontalscrollbarstep?: number;
        horizontalscrollbarlargestep?: number;
        initrowdetails?: (index?: number, parentElement?: any, gridElement?: any, datarecord?: any) => void;
        keyboardnavigation?: boolean;
        localization?: GridLocalizationobject;
        pagesize?: number;
        pagesizeoptions?: Array<number | string>;
        pagermode?: 'simple' | 'default' | 'material';
        pagerbuttonscount?: number;
        pageable?: boolean;
        autofill?: boolean;
        rowdetails?: boolean;
        rowdetailstemplate?: any;
        ready?: () => void;
        rendered?: (type: any) => void;
        renderstatusbar?: (statusbar?: GridRenderstatusbar['statusbar']) => void;
        rendertoolbar?: (toolbar?: GridRendertoolbar['toolbar']) => void;
        rendergridrows?: (params?: any) => any;
        sortable?: boolean;
        sortmode?: string;
        sortmodekey?: string;
        selectedrowindex?: number;
        selectedrowindexes?: Array<number>;
        source?: GridSource;
        sorttogglestates?: string;
        updatedelay?: number;
        virtualmode?: boolean;
        verticalscrollbarstep?: number;
        verticalscrollbarlargestep?: number;
    }// GridOptions

    export interface jqxGrid extends widget, GridOptions {

        // jqxGrid functions
        autoresizecolumns(type: string): void;
        autoresizecolumn(dataField: string, type: string): void;
        beginupdate(): void;
        clear(): void;
        createChart(type: string, dataSource: any): void;
        destroy(): void;
        endupdate(): void;
        ensurerowvisible(rowBoundIndex: number): void;
        focus(): void;
        getcolumnindex(dataField: string): number;
        getcolumn(dataField: string): GridGetColumn;
        getcolumnproperty(dataField: string, propertyName: string): any;
        getrowid(rowBoundIndex: number): string;
        getrowdata(rowBoundIndex: number): any;
        getrowdatabyid(rowID: string): any;
        getrowboundindexbyid(rowID: string): number;
        getrowboundindex(rowDisplayIndex: number): number;
        getrows(): Array<any>;
        getboundrows(): Array<any>;
        getdisplayrows(): Array<any>;
        getdatainformation(): GridGetDataInformation;
        getsortinformation(): GridGetSortInformation;
        getpaginginformation(): GridGetPagingInformation;
        hidecolumn(dataField: string): void;
        hideloadelement(): void;
        hiderowdetails(rowBoundIndex: number): void;
        iscolumnvisible(dataField: string): boolean;
        iscolumnpinned(dataField: string): boolean;
        localizestrings(localizationobject: GridLocalizationobject): void;
        pincolumn(dataField: string): void;
        refreshdata(): void;
        refresh(): void;
        render(): void;
        scrolloffset(top: number, left: number): void;
        scrollposition(): GridScrollPosition;
        showloadelement(): void;
        showrowdetails(rowBoundIndex: number): void;
        setcolumnindex(dataField: string, index: number): void;
        setcolumnproperty(dataField: string, propertyName: any, propertyValue: any): void;
        showcolumn(dataField: string): void;
        unpincolumn(dataField: string): void;
        updatebounddata(type: any): void;
        updating(): boolean;
        getsortcolumn(): string;
        removesort(): void;
        sortby(dataField: string, sortOrder: string): void;
        addgroup(dataField: string): void;
        cleargroups(): void;
        collapsegroup(group: number | string): void;
        collapseallgroups(): void;
        expandallgroups(): void;
        expandgroup(group: number | string): void;
        getrootgroupscount(): number;
        getgroup(groupIndex: number): GridGetGroup;
        insertgroup(groupIndex: number, dataField: string): void;
        iscolumngroupable(): boolean;
        removegroupat(groupIndex: number): void;
        removegroup(dataField: string): void;
        addfilter(dataField: string, filterGroup: any, refreshGrid: boolean): void;
        applyfilters(): void;
        clearfilters(): void;
        getfilterinformation(): any;
        getcolumnat(index: number): any;
        removefilter(dataField: string, refreshGrid: boolean): void;
        refreshfilterrow(): void;
        gotopage(pagenumber: number): void;
        gotoprevpage(): void;
        gotonextpage(): void;
        addrow(rowIds: any, data: any, rowPosition: any): void;
        begincelledit(rowBoundIndex: number, dataField: string): void;
        beginrowedit(rowBoundIndex: number): void;
        closemenu(): void;
        deleterow(rowIds: string | number | Array<number | string>): void;
        endcelledit(rowBoundIndex: number, dataField: string, confirmChanges: boolean): void;
        endrowedit(rowBoundIndex: number, confirmChanges: boolean): void;
        getcell(rowBoundIndex: number, datafield: string): GridGetCell;
        getcellatposition(left: number, top: number): GridGetCell;
        getcelltext(rowBoundIndex: number, dataField: string): string;
        getcelltextbyid(rowID: string, dataField: string): string;
        getcellvaluebyid(rowID: string, dataField: string): any;
        getcellvalue(rowBoundIndex: number, dataField: string): any;
        isBindingCompleted(): boolean;
        openmenu(dataField: string): void;
        setcellvalue(rowBoundIndex: number, dataField: string, value: any): void;
        setcellvaluebyid(rowID: string, dataField: string, value: any): void;
        showvalidationpopup(rowBoundIndex: number, dataField: string, validationMessage: string): void;
        updaterow(rowIds: string | number | Array<number | string>, data: any): void;
        clearselection(): void;
        getselectedrowindex(): number;
        getselectedrowindexes(): Array<number>;
        getselectedcell(): GridGetSelectedCell;
        getselectedcells(): Array<GridGetSelectedCell>;
        selectcell(rowBoundIndex: number, dataField: string): void;
        selectallrows(): void;
        selectrow(rowBoundIndex: number): void;
        unselectrow(rowBoundIndex: number): void;
        unselectcell(rowBoundIndex: number, dataField: string): void;
        getcolumnaggregateddata(dataField: string, aggregates: Array<any>): string;
        refreshaggregates(): void;
        renderaggregates(): void;
        exportdata(dataType: string, fileName: string, exportHeader: boolean, rows: Array<number>, exportHiddenColumns: boolean, serverURL: string, charSet: string): any;
        exportview(dataType: string, fileName: string): any;
        openColumnChooser(columns: any, header: string): void;
        getstate(): GridGetState;
        loadstate(stateobject: any): void;
        savestate(): GridGetState;
    }// jqxGrid

    export interface InputOptions {
        // InputOptions properties
        disabled?: boolean;
        dropDownWidth?: number | string;
        displayMember?: string;
        height?: string | number;
        items?: number;
        minLength?: number;
        maxLength?: number;
        opened?: boolean;
        placeHolder?: string;
        popupZIndex?: number;
        query?: string;
        renderer?: (itemValue?: string, inputValue?: string) => string;
        rtl?: boolean;
        searchMode?: string;
        source?: any;
        theme?: string;
        valueMember?: string;
        width?: string | number;
        value?: number | string;
    }// InputOptions

    export interface jqxInput extends widget, InputOptions {

        // jqxInput functions
        destroy(): void;
        focus(): void;
        selectAll(): void;
        val(value: number | string): string;
    }// jqxInput

    export interface KanbanColumns {
        // KanbanColumns properties
        text?: string;
        dataField?: string;
        maxItems?: number;
        collapsible?: boolean;
        collapseDirection?: string;
        headerElement?: any;
        collapsedHeaderElement?: any;
        iconClassName?: string;
    }// KanbanColumns

    export interface KanbanColumnRenderer {
        // KanbanColumnRenderer properties
        element?: any;
        collapsedElement?: any;
        column?: any;
    }// KanbanColumnRenderer

    export interface KanbanItemRenderer {
        // KanbanItemRenderer properties
        element?: any;
        item?: any;
        resource?: any;
    }// KanbanItemRenderer

    export interface KanbanSource {
        // KanbanSource properties
        id?: number;
        status?: string;
        text?: string;
        content?: any;
        tags?: string;
        color?: string;
        resourceId?: any;
        className?: string;
    }// KanbanSource

    export interface KanbanUpdateItem {
        // KanbanUpdateItem properties
        status?: string;
        text?: string;
        content?: any;
        tags?: string;
        color?: string;
        resourceId?: any;
        className?: string;
    }// KanbanUpdateItem

    export interface KanbanOptions {
        // KanbanOptions properties
        columnRenderer?: (element?: KanbanColumnRenderer['element'], collapsedElement?: KanbanColumnRenderer['collapsedElement'], column?: KanbanColumnRenderer['column']) => void;
        columns?: Array<KanbanColumns>;
        connectWith?: string;
        headerHeight?: number | string;
        headerWidth?: number;
        height?: string | number;
        itemRenderer?: (element?: KanbanItemRenderer['element'], item?: KanbanItemRenderer['item'], resource?: KanbanItemRenderer['resource']) => void;
        ready?: () => void;
        rtl?: boolean;
        source?: any;
        resources?: any;
        template?: string;
        templateContent?: any;
        theme?: string;
        width?: string | number;
    }// KanbanOptions

    export interface jqxKanban extends widget, KanbanOptions {

        // jqxKanban functions
        addItem(newItem: any): void;
        destroy(): void;
        getColumn(dataField: string): KanbanColumns;
        getColumnItems(dataField: string): Array<KanbanSource>;
        getItems(): KanbanSource;
        removeItem(itemId: string): void;
        updateItem(itemId: string, newContent: KanbanUpdateItem): void;
    }// jqxKanban

    export interface KnobChanging {
        // KnobChanging properties
        oldValue?: number;
        newValue?: number;
    }// KnobChanging

    export interface KnobLabelsFormatFunction {
        // KnobLabelsFormatFunction properties
        formatFunction?: (label: string | number) => string | number;
    }// KnobLabelsFormatFunction

    export interface KnobMarks {
        // KnobMarks properties
        colorProgress?: any;
        colorRemaining?: any;
        drawAboveProgressBar?: boolean;
        minorInterval?: number;
        majorInterval?: number;
        majorSize?: number | string;
        offset?: string;
        rotate?: boolean;
        size?: number | string;
        type?: string;
        thickness?: number;
        visible?: boolean;
    }// KnobMarks

    export interface KnobDial {
        // KnobDial properties
        innerRadius?: any;
        outerRadius?: any;
        style?: any;
        startAngle?: number;
        endAngle?: number;
    }// KnobDial

    export interface KnobLabels {
        // KnobLabels properties
        rotate?: any;
        offset?: number | string;
        visible?: boolean;
        step?: number;
        style?: any;
        formatFunction?: KnobLabelsFormatFunction['formatFunction'];
    }// KnobLabels

    export interface KnobProgressBar {
        // KnobProgressBar properties
        offset?: number | string;
        style?: any;
        size?: number | string;
        background?: any;
        ranges?: Array<any>;
    }// KnobProgressBar

    export interface KnobPointer {
        // KnobPointer properties
        offset?: number | string;
        type?: string;
        style?: any;
        size?: number | string;
        thickness?: number;
        visible?: boolean;
    }// KnobPointer

    export interface KnobSpinner {
        // KnobSpinner properties
        innerRadius?: any;
        outerRadius?: any;
        style?: any;
        marks?: KnobMarks;
    }// KnobSpinner

    export interface KnobStyle {
        // KnobStyle properties
        fill?: any;
        stroke?: string;
        strokeWidth?: number;
    }// KnobStyle

    export interface KnobOptions {
        // KnobOptions properties
        allowValueChangeOnClick?: boolean;
        allowValueChangeOnDrag?: boolean;
        allowValueChangeOnMouseWheel?: boolean;
        changing?: (oldValue: KnobChanging['oldValue'] | KnobChanging['oldValue'][], newValue: KnobChanging['newValue'] | KnobChanging['newValue'][]) => boolean;
        dragEndAngle?: number;
        dragStartAngle?: number;
        disabled?: boolean;
        dial?: KnobDial;
        endAngle?: number;
        height?: number | string;
        labels?: KnobLabels;
        marks?: KnobMarks;
        min?: number;
        max?: number;
        progressBar?: KnobProgressBar;
        pointer?: KnobPointer | KnobPointer[];
        pointerGrabAction?: string;
        rotation?: string;
        startAngle?: number;
        spinner?: KnobSpinner;
        styles?: KnobStyle;
        step?: number | string;
        snapToStep?: boolean;
        value?: any;
        width?: number | string;
    }// KnobOptions

    export interface jqxKnob extends widget, KnobOptions {

        // jqxKnob functions
        destroy(): void;
        val(value: number | string): number;
    }// jqxKnob

    export interface Layout {
        // Layout properties
        type: string;
        alignment?: string;
        allowClose?: boolean;
        allowPin?: boolean;
        allowUnpin?: boolean;
        contentContainer?: string;
        height?: number | string;
        initContent?: () => void;
        minHeight?: number | string;
        minWidth?: number | string;
        orientation?: string;
        pinnedHeight?: number | string;
        pinnedWidth?: number | string;
        selected?: boolean;
        title?: number | string;
        unpinnedHeight?: number | string;
        unpinnedWidth?: number | string;
        width?: number | string;
        items?: Array<Layout>;
    }// Layout

    export interface LayoutOptions {
        // LayoutOptions properties
        contextMenu?: boolean;
        height?: string | number;
        layout?: Array<Layout>;
        minGroupHeight?: number | string;
        minGroupWidth?: number | string;
        resizable?: boolean;
        rtl?: boolean;
        theme?: string;
        width?: string | number;
    }// LayoutOptions

    export interface jqxLayout extends widget, LayoutOptions {

        // jqxLayout functions
        destroy(): void;
        loadLayout(Layout: any): void;
        refresh(): void;
        render(): void;
        saveLayout(): any;
    }// jqxLayout

    export interface LinearGaugeRanges {
        // LinearGaugeRanges properties
        startValue?: number;
        endValue?: number;
        style?: any;
    }// LinearGaugeRanges

    export interface LinearGaugeBackground {
        // LinearGaugeBackground properties
        borderType?: string;
        borderRadius?: any;
        visible?: boolean;
        style?: any;
        showGradient?: boolean;
    }// LinearGaugeBackground

    export interface LinearGaugeLabels {
        // LinearGaugeLabels properties
        position?: string;
        style?: any;
        interval?: number;
        offset?: number;
        formatValue?: (value:any, position:string) => any;
        visible?: boolean;
    }// LinearGaugeLabels

    export interface LinearGaugePointer {
        // LinearGaugePointer properties
        pointerType?: string;
        style?: any;
        size?: number | string;
        offset?: number;
        visible?: boolean;
    }// LinearGaugePointer

    export interface LinearGaugeTicks {
        // LinearGaugeTicks properties
        size?: number | string;
        interval?: number;
        visible?: boolean;
        style?: any;
    }// LinearGaugeTicks

    export interface LinearGaugeOptions {
        // LinearGaugeOptions properties
        animationDuration?: number;
        background?: LinearGaugeBackground;
        colorScheme?: string;
        disabled?: boolean;
        easing?: string;
        height?: number | string;
        int64?: boolean;
        labels?: LinearGaugeLabels | LinearGaugeLabels[];
        min?: number;
        max?: number;
        orientation?: string;
        pointer?: LinearGaugePointer;
        rangesOffset?: number;
        rangeSize?: number | string;
        ranges?: Array<LinearGaugeRanges>;
        showRanges?: boolean;
        scaleStyle?: any;
        scaleLength?: number | string;
        ticksOffset?: Array<number | string>;
        ticksPosition?: string;
        ticksMinor?: LinearGaugeTicks;
        ticksMajor?: LinearGaugeTicks;
        value?: number;
        width?: number | string;
    }// LinearGaugeOptions

    export interface jqxLinearGauge extends widget, LinearGaugeOptions {

        // jqxLinearGauge functions
        disable(): void;
        enable(): void;
        val(value: number | string): number;
    }// jqxLinearGauge

    export interface LinkButtonOptions {
        // LinkButtonOptions properties
        disabled?: boolean;
        height?: string | number;
        rtl?: boolean;
        theme?: string;
        width?: string | number;
    }// LinkButtonOptions

    export interface jqxLinkButton extends widget, LinkButtonOptions {

    }// jqxLinkButton

    export interface ListBoxDragStart {
        // ListBoxDragStart properties
        item?: object;
    }// ListBoxDragStart

    export interface ListBoxDragEnd {
        // ListBoxDragEnd properties
        dragItem?: object;
        dropItem?: object;
    }// ListBoxDragEnd

    export interface ListBoxRenderer {
        // ListBoxRenderer properties
        index?: number;
        label?: string | number;
        value?: string | number;
    }// ListBoxRenderer

    export interface ListBoxOptions {
        // ListBoxOptions properties
        autoHeight?: boolean;
        allowDrag?: boolean;
        allowDrop?: boolean;
        checkboxes?: boolean;
        disabled?: boolean;
        displayMember?: number | string;
        dropAction?: string;
        dragStart?: (item:ListBoxDragStart['item']) => boolean;
        dragEnd?: (dragItem: ListBoxDragEnd['dragItem'], dropItem: ListBoxDragEnd['dropItem']) => boolean;
        enableHover?: boolean;
        enableSelection?: boolean;
        equalItemsWidth?: boolean;
        filterable?: boolean;
        filterHeight?: number;
        filterDelay?: number | string;
        filterPlaceHolder?: number | string;
        height?: string | number;
        hasThreeStates?: boolean;
        itemHeight?: number;
        incrementalSearch?: boolean;
        incrementalSearchDelay?: number | string;
        multiple?: boolean;
        multipleextended?: boolean;
        renderer?: (index: ListBoxRenderer['index'], label: ListBoxRenderer['label'], value: ListBoxRenderer['value']) => string;
        rendered?: () => any;
        rtl?: boolean;
        selectedIndex?: number | string;
        selectedIndexes?: any;
        source?: Array<any>;
        scrollBarSize?: number;
        searchMode?: string;
        theme?: string;
        valueMember?: number | string;
        width?: string | number;
    }// ListBoxOptions

    export interface jqxListBox extends widget, ListBoxOptions {

        // jqxListBox functions
        addItem(Item: any): boolean;
        beginUpdate(): void;
        clear(): void;
        clearSelection(): void;
        checkIndex(Index: number): void;
        checkItem(Item: any): void;
        checkAll(): void;
        clearFilter(): void;
        destroy(): void;
        disableItem(Item: any): void;
        disableAt(Index: number): void;
        enableItem(Item: any): void;
        enableAt(Index: number | string): void;
        ensureVisible(item: any): void;
        endUpdate(): void;
        focus(): void;
        getItems(): Array<any>;
        getSelectedItems(): Array<any>;
        getCheckedItems(): Array<any>;
        getItem(Index: number): any;
        getItemByValue(Item: any): any;
        getSelectedItem(): any;
        getSelectedIndex(): number;
        insertAt(Item: any, Index: number | string): void;
        invalidate(): void;
        indeterminateItem(Item: any): void;
        indeterminateIndex(Index: number): void;
        loadFromSelect(selector: string): void;
        removeItem(Item: any): void;
        removeAt(Index: number | string): void;
        render(): void;
        refresh(): void;
        selectItem(Item: any): void;
        selectIndex(Index: number | string): void;
        updateItem(Item: any, Value: number | string): void;
        updateAt(item: any, index: number | string): void;
        unselectIndex(index: number | string): void;
        unselectItem(item: any): void;
        uncheckIndex(index: number | string): void;
        uncheckItem(item: any): void;
        uncheckAll(): void;
        val(value: number | string): string;
    }// jqxListBox

    export interface ListMenuFilterCallback {
        // ListMenuFilterCallback properties
        text?: string;
        searchValue?: string | number;
    }// ListMenuFilterCallback

    export interface ListMenuOptions {
        // ListMenuOptions properties
        alwaysShowNavigationArrows?: boolean;
        animationType?: string;
        animationDuration?: number | string;
        autoSeparators?: boolean;
        backLabel?: number | string;
        disabled?: boolean;
        enableScrolling?: boolean;
        filterCallback?: (text:ListMenuFilterCallback['text'], searchValue:ListMenuFilterCallback['searchValue']) => boolean;
        height?: number | string;
        headerAnimationDuration?: number | string;
        placeHolder?: number | string;
        readOnly?: boolean;
        rtl?: boolean;
        roundedCorners?: boolean;
        showNavigationArrows?: boolean;
        showFilter?: boolean;
        showHeader?: boolean;
        showBackButton?: boolean;
        theme?: string;
        width?: string | number;
    }// ListMenuOptions

    export interface jqxListMenu extends widget, ListMenuOptions {

        // jqxListMenu functions
        back(): void;
        changePage(Item: any): void;
        destroy(): void;
    }// jqxListMenu

    export interface LoaderOptions {
        // LoaderOptions properties
        autoOpen?: boolean;
        height?: string | number;
        html?: string;
        isModal?: boolean;
        imagePosition?: string;
        rtl?: boolean;
        text?: number | string;
        textPosition?: string;
        theme?: string;
        width?: string | number;
    }// LoaderOptions

    export interface jqxLoader extends widget, LoaderOptions {

        // jqxLoader functions
        close(): void;
        open(left: number | string, top: number | string): void;
    }// jqxLoader

    export interface MaskedInputOptions {
        // MaskedInputOptions properties
        disabled?: boolean;
        height?: string | number;
        mask?: string;
        promptChar?: number | string;
        readOnly?: boolean;
        rtl?: boolean;
        theme?: string;
        textAlign?: string;
        value?: number | string;
        width?: string | number;
    }// MaskedInputOptions

    export interface jqxMaskedInput extends widget, MaskedInputOptions {

        // jqxMaskedInput functions
        clear(): void;
        destroy(): void;
        focus(): void;
        val(value: number | string): string;
    }// jqxMaskedInput

    export interface MenuOptions {
        // MenuOptions properties
        animationShowDuration?: number;
        animationHideDuration?: number;
        animationHideDelay?: number;
        animationShowDelay?: number;
        autoCloseInterval?: number;
        autoSizeMainItems?: boolean;
        autoCloseOnClick?: boolean;
        autoOpenPopup?: boolean;
        autoOpen?: boolean;
        autoCloseOnMouseLeave?: boolean;
        clickToOpen?: boolean;
        disabled?: boolean;
        enableHover?: boolean;
        easing?: string;
        height?: string | number;
        keyboardNavigation?: boolean;
        minimizeWidth?: number | string;
        mode?: string;
        popupZIndex?: number | string;
        rtl?: boolean;
        showTopLevelArrows?: boolean;
        source?: any;
        theme?: string;
        width?: string | number;
    }// MenuOptions

    export interface jqxMenu extends widget, MenuOptions {

        // jqxMenu functions
        closeItem(itemID: number | string): void;
        close(): void;
        disable(itemID: number | string, value: boolean): void;
        destroy(): void;
        focus(): void;
        minimize(): void;
        open(left: number, top: number): void;
        openItem(itemID: number | string): void;
        restore(): void;
        setItemOpenDirection(item: number | string, horizontaldirection: string, verticaldirection: string): void;
    }// jqxMenu

    export interface NavBarOptions {
        // NavBarOptions properties
        columns?: Array<string>;
        disabled?: boolean;
        height?: string | number;
        minimized?: boolean;
        minimizeButtonPosition?: string;
        minimizedHeight?: number | string;
        minimizedTitle?: number | string;
        orientation?: string;
        popupAnimationDelay?: number;
        rtl?: boolean;
        selection?: boolean;
        selectedItem?: number | string;
        theme?: string;
        width?: string | number;
    }// NavBarOptions

    export interface jqxNavBar extends widget, NavBarOptions {

        // jqxNavBar functions
        close(): void;
        destroy(): void;
        getSelectedIndex(): number;
        open(): void;
        selectAt(index: number | string): void;
    }// jqxNavBar

    export interface NavigationBarOptions {
        // NavigationBarOptions properties
        animationType?: string;
        arrowPosition?: string;
        collapseAnimationDuration?: number;
        disabled?: boolean;
        expandAnimationDuration?: number;
        expandMode?: string;
        expandedIndexes?: Array<number>;
        height?: string | number;
        initContent?: (index:number) => void;
        rtl?: boolean;
        showArrow?: boolean;
        theme?: string;
        toggleMode?: string;
        width?: string | number;
    }// NavigationBarOptions

    export interface jqxNavigationBar extends widget, NavigationBarOptions {

        // jqxNavigationBar functions
        add(header: number | string, content: number | string): void;
        collapseAt(index: number | string): void;
        disableAt(index: number | string): void;
        disable(): void;
        destroy(): void;
        expandAt(index: number | string): void;
        enableAt(index: number | string): void;
        enable(): void;
        focus(): void;
        getHeaderContentAt(index: number | string): string;
        getContentAt(index: number | string): string;
        hideArrowAt(index: number | string): void;
        invalidate(): void;
        insert(Index: number, header: number | string, content: number | string): void;
        refresh(): void;
        render(): void;
        remove(index: number | string): void;
        setContentAt(index: number, item: number | string): void;
        setHeaderContentAt(index: number, item: number | string): void;
        showArrowAt(index: number | string): void;
        update(index: number, header: number | string, content: number | string): void;
        val(value: number | string): string | number;
    }// jqxNavigationBar

    export interface NotificationIcon {
        // NotificationIcon properties
        width?: number | string;
        height?: number | string;
        url?: string;
        padding?: number | string;
    }// NotificationIcon

    export interface NotificationOptions {
        // NotificationOptions properties
        appendContainer?: string;
        autoOpen?: boolean;
        animationOpenDelay?: number;
        animationCloseDelay?: number;
        autoClose?: boolean;
        autoCloseDelay?: number | string;
        blink?: boolean;
        browserBoundsOffset?: number;
        closeOnClick?: boolean;
        disabled?: boolean;
        height?: number | string;
        hoverOpacity?: number;
        icon?: NotificationIcon;
        notificationOffset?: number;
        opacity?: number;
        position?: string;
        rtl?: boolean;
        showCloseButton?: boolean;
        template?: string;
        theme?: string;
        width?: string | number;
    }// NotificationOptions

    export interface jqxNotification extends widget, NotificationOptions {

        // jqxNotification functions
        closeAll(): void;
        closeLast(): void;
        destroy(): void;
        open(): void;
        refresh(): void;
        render(): void;
    }// jqxNotification

    export interface NumberInputOptions {
        // NumberInputOptions properties
        allowNull?: boolean;
        decimal?: number | string;
        disabled?: boolean;
        decimalDigits?: number | string;
        decimalSeparator?: number | string;
        digits?: number | string;
        groupSeparator?: string;
        groupSize?: number | string;
        height?: string | number;
        inputMode?: string;
        min?: number | string;
        max?: number | string;
        negativeSymbol?: string;
        placeHolder?: number | string;
        promptChar?: string;
        rtl?: boolean;
        readOnly?: boolean;
        spinMode?: string;
        spinButtons?: boolean;
        spinButtonsWidth?: number;
        spinButtonsStep?: number | string;
        symbol?: string;
        symbolPosition?: string;
        textAlign?: string;
        template?: string;
        theme?: string;
        value?: number | string;
        width?: string | number;
    }// NumberInputOptions

    export interface jqxNumberInput extends widget, NumberInputOptions {

        // jqxNumberInput functions
        clear(): void;
        destroy(): void;
        focus(): void;
        getDecimal(): number;
        setDecimal(index: number | string): void;
        val(value: number | string): number;
    }// jqxNumberInput

    export interface PanelOptions {
        // PanelOptions properties
        autoUpdate?: boolean;
        disabled?: boolean;
        height?: string | number;
        rtl?: boolean;
        sizeMode?: string;
        scrollBarSize?: number | string;
        theme?: string;
        width?: string | number;
    }// PanelOptions

    export interface jqxPanel extends widget, PanelOptions {

        // jqxPanel functions
        append(HTMLElement: any): void;
        clearcontent(): void;
        destroy(): void;
        focus(): void;
        getScrollHeight(): number;
        getVScrollPosition(): number;
        getScrollWidth(): number;
        getHScrollPosition(): number;
        prepend(HTMLElement: any): void;
        remove(HTMLElement: any): void;
        scrollTo(left: number | string, top: number | string): void;
    }// jqxPanel

    export interface PasswordInputLocalization {
        // PasswordInputLocalization properties
        passwordStrengthString?: string;
        tooShort?: string;
        weak?: string;
        fair?: string;
        good?: string;
        strong?: string;
    }// PasswordInputLocalization

    export interface PasswordInputStrengthColors {
        // PasswordInputStrengthColors properties
        tooShort?: string;
        weak?: string;
        fair?: string;
        good?: string;
        strong?: string;
    }// PasswordInputStrengthColors

    export interface PasswordInputPasswordStrength {
        // PasswordInputPasswordStrength properties
        password?: any;
        characters?: any;
        defaultStrength?: string;
    }// PasswordInputPasswordStrength

    export interface PasswordInputStrengthTypeRenderer {
        // PasswordInputStrengthTypeRenderer properties
        password?: any;
        characters?: any;
        defaultStrength?: string;
    }// PasswordInputStrengthTypeRenderer

    export interface PasswordInputOptions {
        // PasswordInputOptions properties
        disabled?: boolean;
        height?: string | number;
        localization?: PasswordInputLocalization;
        maxLength?: number | string;
        placeHolder?: number | string;
        passwordStrength?: (password:PasswordInputPasswordStrength['password'], characters:PasswordInputPasswordStrength['characters'], defaultStrength:PasswordInputPasswordStrength['defaultStrength']) => string;
        rtl?: boolean;
        strengthColors?: PasswordInputStrengthColors;
        showStrength?: boolean;
        showStrengthPosition?: string;
        strengthTypeRenderer?: (password:PasswordInputStrengthTypeRenderer['password'], characters:PasswordInputStrengthTypeRenderer['characters'], defaultStrength:PasswordInputStrengthTypeRenderer['defaultStrength']) => string;
        showPasswordIcon?: boolean;
        theme?: string;
        width?: string | number;
    }// PasswordInputOptions

    export interface jqxPasswordInput extends widget, PasswordInputOptions {

        // jqxPasswordInput functions
        render(): void;
        refresh(): void;
        val(value: string): string;
    }// jqxPasswordInput

    export interface PivotDesignerOptions {
        // PivotDesignerOptions properties
        type?: string;
        target: any;
    }// PivotDesignerOptions

    export interface jqxPivotDesigner extends widget, PivotDesignerOptions {

        // jqxPivotDesigner functions
        refresh(): void;
    }// jqxPivotDesigner

    export interface PivotGridItemsRenderer {
        // PivotGridItemsRenderer properties
        pivotItem?: any;
    }// PivotGridItemsRenderer

    export interface PivotGridCellsRenderer {
        // PivotGridCellsRenderer properties
        pivotCell?: any;
    }// PivotGridCellsRenderer

    export class PivotGridDesigner {
        // PivotGridDesigner properties
        type: string;
        target: any;
        // PivotGridDesigner functions
        refresh(): void;
    }// PivotGridDesigner

    export interface PivotGridCell {
        // PivotGridCell properties
        pivotRow: PivotGridItem;
        pivotColumn: PivotGridItem;
    }// PivotGridCell

    export interface PivotGridCellFormatting {
        // PivotGridCellFormatting properties
        prefix?: string;
        sufix?: string;
        decimalSeparator?: string;
        thousandsSeparator?: string;
        decimalPlaces?: number;
        negativeWithBrackets?: boolean;
    }// PivotGridCellFormatting

    export interface PivotGridCells {
        // PivotGridCells properties

        // PivotGridCells functions
        hitTest(point: PivotGridPoint): any;
        clear(): void;
        setCellValue(pivotRow: PivotGridItem, pivotColumn: PivotGridItem, value: any): void;
        getCellValue(pivotRow: PivotGridItem, pivotColumn: PivotGridItem): any;
        drillThroughCell(pivotRow: PivotGridItem, pivotColumn: PivotGridItem): Array<any>;
        selectCell(pivotRow: PivotGridItem, pivotColumn: PivotGridItem): void;
        unselectCell(pivotRow: PivotGridItem, pivotColumn: PivotGridItem): void;
        clearSelection(): void;
        isCellSelected(pivotRow: PivotGridItem, pivotColumn: PivotGridItem): boolean;
        getSelectedCellsCount(): number;
        getSelectedCells(): Array<PivotGridCell>;
        getNextCell(pivotCell: PivotGridCell, position: string): any;
    }// PivotGridCells

    export interface PivotGridColumns {
        // PivotGridColumns properties
        resizable: boolean;
        sortable: boolean;
        showExpandCollapseButtons: boolean;
        parentPivotGrid: object;
        items: Array<PivotGridItem>;
        valueItems: Array<PivotGridItem>;
        isHidden: boolean;
        // PivotGridColumns functions
        show(): void;
        hide(): void;
        refresh(): void;
        getHierarchyDepth(): number;
        autoResize(autoResizeMode: string): void;
        getSortItem(): any;
        getSortOrder(): any;
        sortBy(pivotItem: PivotGridItem, order: string): void;
        removeSort(): void;
        selectItem(pivotItem: PivotGridItem): void;
        unselectItem(pivotItem: PivotGridItem): void;
        clearSelection(): void;
        getSelectedItems(): Array<any>;
    }// PivotGridColumns

    export interface PivotGridField {
        // PivotGridField properties
        dataField: string;
        text?: string;
        align?: string;
        className?: string;
        classNameSelected?: string;
    }// PivotGridField

    export interface PivotGridFilterField {
        // PivotGridFilterField properties
        dataField: string;
        text?: string;
        filterFunction: (value: any) => boolean;
    }// PivotGridFilterField

    export interface PivotGridItem {
        // PivotGridItem properties
        isExpanded: boolean;
        isHidden: boolean;
        isSelected: boolean;
        parentItem: PivotGridItem;
        hierarchy: any;
        parentPivotGrid: object;
        items: Array<PivotGridItem>;
        valueItems: Array<PivotGridItem>;
        // PivotGridItem functions
        getWidth(): number;
        getDisplayWidth(): number;
        autoResize(): void;
        getHeight(): number;
        getDisplayHeight(): number;
        setHeight(height: number): void;
        expand(): void;
        collapse(): void;
    }// PivotGridItem

    export interface PivotGridRows {
        // PivotGridRows properties
        resizable: boolean;
        sortable: boolean;
        showExpandCollapseButtons: boolean;
        parentPivotGrid: object;
        items: Array<PivotGridItem>;
        valueItems: Array<PivotGridItem>;
        isHidden?: boolean;
        // PivotGridRows functions
        show(): void;
        hide(): void;
        refresh(): void;
        getHierarchyDepth(): number;
        autoResize(autoResizeMode: string): void;
        getSortItem(): any;
        getSortOrder(): any;
        sortBy(pivotItem: PivotGridItem, sortOrder: string): void;
        removeSort(): void;
        selectItem(pivotItem: PivotGridItem): void;
        unselectItem(pivotItem: PivotGridItem): void;
        clearSelection(): void;
        getSelectedItems(): Array<any>;
    }// PivotGridRows

    export interface PivotGridSettings {
        // PivotGridSettings properties
        pivotValuesOnRows?: boolean;
        rows: Array<PivotGridField>;
        columns: Array<PivotGridField>;
        values: Array<PivotGridValueField>;
        filters?: Array<PivotGridFilterField>;
        theme?: string;
    }// PivotGridSettings

    export interface PivotGridValueField {
        // PivotGridValueField properties
        dataField: string;
        function: any;
        text?: string;
        align?: string;
        className?: string;
        classNameSelected?: string;
        cellsClassName?: string;
        cellsClassNameSelected?: string;
        formatSettings?: PivotGridCellFormatting;
    }// PivotGridValueField

    export interface PivotGridPoint {
        // PivotGridPoint properties
        x: number;
        y: number;
    }// PivotGridPoint

    export interface PivotGridOptions {
        // PivotGridOptions properties
        source: any;
        localization?: any;
        scrollBarsEnabled?: boolean;
        selectionEnabled?: boolean;
        multipleSelectionEnabled?: boolean;
        treeStyleRows?: boolean;
        autoResize?: boolean;
        itemsRenderer?: (pivotItem: PivotGridItemsRenderer['pivotItem']) => string;
        cellsRenderer?: (pivotCell: PivotGridCellsRenderer['pivotCell']) => string;
    }// PivotGridOptions

    export interface jqxPivotGrid extends widget, PivotGridOptions {

        // jqxPivotGrid functions
        getInstance(): any;
        refresh(): void;
        getPivotRows(): PivotGridRows;
        getPivotColumns(): PivotGridColumns;
        getPivotCells(): PivotGridCells;
    }// jqxPivotGrid

    export interface PopoverOptions {
        // PopoverOptions properties
        arrowOffsetValue?: number;
        animationOpenDelay?: number | string;
        animationCloseDelay?: number | string;
        autoClose?: boolean;
        animationType?: string;
        height?: number | string;
        initContent?: () => void;
        isModal?: boolean;
        offset?: any;
        position?: string;
        rtl?: boolean;
        selector?: string;
        showArrow?: boolean;
        showCloseButton?: boolean;
        width?: number | string;
        title?: string | number;
        theme?: string;
    }// PopoverOptions

    export interface jqxPopover extends widget, PopoverOptions {

        // jqxPopover functions
        close(): void;
        destroy(): void;
        open(): void;
    }// jqxPopover

    export interface ProgressBarColorRanges {
        // ProgressBarColorRanges properties
        stop: number | string;
        color: string;
    }// ProgressBarColorRanges

    export interface ProgressBarRenderText {
        // ProgressBarRenderText properties
        text?: string;
        value?: number;
    }// ProgressBarRenderText

    export interface ProgressBarOptions {
        // ProgressBarOptions properties
        animationDuration?: number;
        colorRanges?: Array<ProgressBarColorRanges>;
        disabled?: boolean;
        height?: string  | number;
        layout?: string;
        max?: string  | number;
        min?: number | string;
        orientation?: string;
        rtl?: boolean;
        renderText?: (text?: ProgressBarRenderText['text'], value?: ProgressBarRenderText['value']) => string;
        showText?: boolean;
        template?: string;
        theme?: string;
        value?: string | number;
        width?: string | number;
    }// ProgressBarOptions

    export interface jqxProgressBar extends widget, ProgressBarOptions {

        // jqxProgressBar functions
        actualValue(value: number | string): void;
        destroy(): void;
        val(value: number | string): number;
    }// jqxProgressBar

    export interface RadioButtonOptions {
        // RadioButtonOptions properties
        animationShowDelay?: number;
        animationHideDelay?: number;
        boxSize?: number | string;
        checked?: boolean;
        disabled?: boolean;
        enableContainerClick?: boolean;
        groupName?: string;
        hasThreeStates?: boolean;
        height?: string | number;
        rtl?: boolean;
        theme?: string;
        width?: string | number;
    }// RadioButtonOptions

    export interface jqxRadioButton extends widget, RadioButtonOptions {

        // jqxRadioButton functions
        check(): void;
        disable(): void;
        destroy(): void;
        enable(): void;
        focus(): void;
        render(): void;
        uncheck(): void;
        val(value: boolean): boolean;
    }// jqxRadioButton

    export interface RangeSelectorRange {
        // RangeSelectorRange properties
        from?: number | string | Date;
        to?: number | string | Date;
        min?: number | string | object;
        max?: number | string | object;
    }// RangeSelectorRange

    export interface RangeSelectorGetRange {
        // RangeSelectorGetRange properties
        from?: number | string;
        to?: number | string;
    }// RangeSelectorGetRange

    export interface RangeSelectorLabelsFormatFunction {
        // RangeSelectorLabelsFormatFunction properties
        value?: number | string;
    }// RangeSelectorLabelsFormatFunction

    export interface RangeSelectorMarkersFormatFunction {
        // RangeSelectorMarkersFormatFunction properties
        value?: number | string;
        position?: string;
    }// RangeSelectorMarkersFormatFunction

    export interface RangeSelectorGroupLabelsFormatFunction {
        // RangeSelectorGroupLabelsFormatFunction properties
        value?: string;
        date?: any;
    }// RangeSelectorGroupLabelsFormatFunction

    export interface RangeSelectorOptions {
        // RangeSelectorOptions properties
        disabled?: boolean;
        groupLabelsFormatFunction?: (value: RangeSelectorGroupLabelsFormatFunction['value'], date: RangeSelectorGroupLabelsFormatFunction['date']) => string;
        height?: string | number;
        labelsFormat?: string;
        labelsFormatFunction?: (value: RangeSelectorLabelsFormatFunction['value']) => string;
        labelsOnTicks?: boolean;
        markersFormat?: string;
        markersFormatFunction?: (value: RangeSelectorMarkersFormatFunction['value'], position: RangeSelectorMarkersFormatFunction['position']) => string;
        majorTicksInterval?: any;
        minorTicksInterval?: any;
        max?: any;
        min?: any;
        moveOnClick?: boolean;
        padding?: number | string;
        range?: RangeSelectorRange;
        resizable?: boolean;
        rtl?: boolean;
        showGroupLabels?: boolean;
        showMinorTicks?: boolean;
        snapToTicks?: boolean;
        showMajorLabels?: boolean;
        showMarkers?: boolean;
        theme?: string;
        width?: string | number;
    }// RangeSelectorOptions

    export interface jqxRangeSelector extends widget, RangeSelectorOptions {

        // jqxRangeSelector functions
        destroy(): void;
        getRange(): RangeSelectorGetRange;
        render(): void;
        refresh(): void;
        setRange(from: any, to: any): void;
    }// jqxRangeSelector

    export interface RatingOptions {
        // RatingOptions properties
        count?: number;
        disabled?: boolean;
        height?: string | number;
        itemHeight?: number;
        itemWidth?: number;
        precision?: number;
        singleVote?: boolean;
        value?: number;
        width?: string | number;
    }// RatingOptions

    export interface jqxRating extends widget, RatingOptions {

        // jqxRating functions
        disable(): void;
        enable(): void;
        getValue(): number;
        setValue(value: number): void;
        val(value: number): number;
    }// jqxRating

    export interface RepeatButtonOptions {
        // RepeatButtonOptions properties
        delay?: number;
        disabled?: boolean;
        height?: number | string;
        imgSrc?: string;
        imgWidth?: number | string;
        imgHeight?: number | string;
        imgPosition?: string;
        roundedCorners?: string;
        rtl?: boolean;
        textPosition?: string;
        textImageRelation?: string;
        theme?: string;
        template?: string;
        toggled?: boolean;
        width?: string | number;
        value?: string;
    }// RepeatButtonOptions

    export interface jqxRepeatButton extends widget, RepeatButtonOptions {

        // jqxRepeatButton functions
        destroy(): void;
        focus(): void;
        render(): void;
        val(value: string): string;
    }// jqxRepeatButton

    export interface ResponsivePanelOptions {
        // ResponsivePanelOptions properties
        animationDirection?: string;
        animationHideDelay?: number | string;
        animationShowDelay?: number | string;
        animationType?: string;
        autoClose?: boolean;
        collapseBreakpoint?: number;
        collapseWidth?: number;
        height?: string | number;
        initContent?: () => void;
        theme?: string;
        toggleButton?: string | any;
        toggleButtonSize?: number | string;
        width?: string | number;
    }// ResponsivePanelOptions

    export interface jqxResponsivePanel extends widget, ResponsivePanelOptions {

        // jqxResponsivePanel functions
        close(): void;
        destroy(): void;
        isCollapsed(): boolean;
        isOpened(): boolean;
        open(): void;
        refresh(): void;
        render(): void;
    }// jqxResponsivePanel

    export interface RibbonItem {

    }// RibbonItem

    export interface RibbonOptions {
        // RibbonOptions properties
        animationType?: string;
        animationDelay?: number | string;
        disabled?: boolean;
        height?: number | string;
        initContent?: (index: any) => void;
        mode?: string;
        popupCloseMode?: string;
        position?: string;
        reorder?: boolean;
        rtl?: boolean;
        selectedIndex?: number;
        selectionMode?: string;
        scrollPosition?: string;
        scrollStep?: number;
        scrollDelay?: number;
        theme?: string;
        width?: string | number;
    }// RibbonOptions

    export interface jqxRibbon extends widget, RibbonOptions {

        // jqxRibbon functions
        addAt(index: number, item: RibbonItem): void;
        clearSelection(): void;
        disableAt(index: number): void;
        destroy(): void;
        enableAt(index: number): void;
        hideAt(index: number): void;
        removeAt(index: number): void;
        render(): void;
        refresh(): void;
        selectAt(index: number): void;
        showAt(index: number): void;
        setPopupLayout(index: number, layout: any, width: number | string, height: number | string): void;
        updateAt(index: number, item: RibbonItem): void;
        val(value: string): string;
    }// jqxRibbon

    export interface SchedulerAppointmentDataFields {
        // SchedulerAppointmentDataFields properties
        allDay?: boolean | string;
        background?: string;
        borderColor?: string;
        color?: string;
        description?: string;
        draggable?: boolean | string;
        from?: string;
        hidden?: boolean | string;
        id?: number | string;
        location?: string;
        recurrencePattern?: SchedulerRecurrencePattern | string;
        recurrenceException?: string;
        resizable?: boolean | string;
        resourceId?: number | string;
        readOnly?: boolean | string;
        subject?: string;
        style?: string;
        status?: string;
        to?: string;
        tooltip?: string;
        timeZone?: string;
    }// SchedulerAppointmentDataFields

    export interface SchedulerRecurrencePattern {
        // SchedulerRecurrencePattern properties
        FREQ?: string;
        COUNT?: number;
        UNTIL?: string;
        BYDAY?: string;
        BYMONTHDAY?: string;
        BYMONTH?: number;
        INTERVAL?: number;
    }// SchedulerRecurrencePattern

    export interface SchedulerChangedAppointments {
        // SchedulerChangedAppointments properties
        type?: string;
        appointment?: SchedulerAppointmentDataFields;
    }// SchedulerChangedAppointments

    export interface SchedulerContextMenuOpen {
        // SchedulerContextMenuOpen properties
        menu?: any;
        appointment?: any;
        event?: any;
    }// SchedulerContextMenuOpen

    export interface SchedulerContextMenuClose {
        // SchedulerContextMenuClose properties
        menu?: any;
        appointment?: any;
        event?: any;
    }// SchedulerContextMenuClose

    export interface SchedulerContextMenuItemClick {
        // SchedulerContextMenuItemClick properties
        menu?: any;
        appointment?: any;
        event?: any;
    }// SchedulerContextMenuItemClick

    export interface SchedulerContextMenuCreate {
        // SchedulerContextMenuCreate properties
        menu?: any;
        settings?: any;
    }// SchedulerContextMenuCreate

    export interface SchedulerEditDialogCreate {
        // SchedulerEditDialogCreate properties
        dialog?: any;
        fields?: any;
        editAppointment?: any;
    }// SchedulerEditDialogCreate

    export interface SchedulerEditDialogOpen {
        // SchedulerEditDialogOpen properties
        dialog?: any;
        fields?: any;
        editAppointment?: any;
    }// SchedulerEditDialogOpen

    export interface SchedulerEditDialogClose {
        // SchedulerEditDialogClose properties
        dialog?: any;
        fields?: any;
        editAppointment?: any;
    }// SchedulerEditDialogClose

    export interface SchedulerEditDialogKeyDown {
        // SchedulerEditDialogKeyDown properties
        dialog?: any;
        fields?: any;
        editAppointment?: any;
        event?: any;
    }// SchedulerEditDialogKeyDown

    export interface SchedulerExportSettings {
        // SchedulerExportSettings properties
        serverURL?: string;
        characterSet?: string;
        fileName?: string | null;
        dateTimeFormatString?: string;
        resourcesInMultipleICSFiles?: boolean;
    }// SchedulerExportSettings

    export interface SchedulerRenderAppointment {
        // SchedulerRenderAppointment properties
        data?: any;
    }// SchedulerRenderAppointment

    export interface SchedulerResources {
        // SchedulerResources properties
        source?: string;
        colorScheme?: string;
        orientation?: string;
        dataField?: string;
        resourceColumnWidth?: number | string;
        resourceRowHeight?: number;
    }// SchedulerResources

    export interface SchedulerStatuses {
        // SchedulerStatuses properties
        free?: string;
        tentative?: string;
        busy?: string;
        doNotDisturb?: string;
        outOfOffice?: string;
    }// SchedulerStatuses

    export interface SchedulerGetSelection {
        // SchedulerGetSelection properties
        from?: any;
        to?: any;
        ResourceId?: any;
    }// SchedulerGetSelection

    export interface SchedulerOptions {
        // SchedulerOptions properties
        appointmentOpacity?: number;
        appointmentsMinHeight?: number;
        appointmentDataFields?: SchedulerAppointmentDataFields;
        appointmentTooltips?: boolean;
        columnsHeight?: number;
        contextMenu?: boolean;
        contextMenuOpen?: (menu: SchedulerContextMenuOpen['menu'], appointment: SchedulerContextMenuOpen['appointment'], event: SchedulerContextMenuOpen['event']) => void;
        contextMenuClose?: (menu: SchedulerContextMenuClose['menu'], appointment: SchedulerContextMenuClose['appointment'], event: SchedulerContextMenuClose['event']) => void;
        contextMenuItemClick?: (menu: SchedulerContextMenuItemClick['menu'], appointment: SchedulerContextMenuItemClick['appointment'], event: SchedulerContextMenuItemClick['event']) => boolean;
        contextMenuCreate?: (menu: SchedulerContextMenuCreate['menu'], settings: SchedulerContextMenuCreate['settings']) => void;
        changedAppointments?: Array<SchedulerChangedAppointments>;
        disabled?: boolean;
        date?: any;
        dayNameFormat?: string;
        enableHover?: boolean;
        editDialog?: boolean;
        editDialogDateTimeFormatString?: string;
        editDialogDateFormatString?: string;
        editDialogOpen?: (dialog?: SchedulerEditDialogOpen['dialog'], fields?: SchedulerEditDialogOpen['fields'], editAppointment?: SchedulerEditDialogOpen['editAppointment']) => void;
        editDialogCreate?: (dialog?: SchedulerEditDialogCreate['dialog'], fields?: SchedulerEditDialogCreate['fields'], editAppointment?: SchedulerEditDialogCreate['editAppointment']) => void;
        editDialogKeyDown?: (dialog?: SchedulerEditDialogKeyDown['dialog'], fields?: SchedulerEditDialogKeyDown['fields'], editAppointment?: SchedulerEditDialogKeyDown['editAppointment'], event?: SchedulerEditDialogKeyDown['event']) => boolean;
        editDialogClose?: (dialog?: SchedulerEditDialogClose['dialog'], fields?: SchedulerEditDialogClose['fields'], editAppointment?: SchedulerEditDialogClose['editAppointment']) => void;
        exportSettings?: SchedulerExportSettings;
        height?: number | string;
        legendPosition?: string;
        legendHeight?: number;
        localization?: any;
        min?: any;
        max?: any;
        ready?: () => void;
        renderAppointment?: (data: SchedulerRenderAppointment['data']) => any;
        rendering?: () => void;
        rendered?: () => void;
        rtl?: boolean;
        resources?: SchedulerResources;
        rowsHeight?: number;
        showToolbar?: boolean;
        showLegend?: boolean;
        showCurrent?: boolean;
        showCurrentAppointment?: boolean;
        scrollBarSize?: number;
        source?: any;
        statuses?: SchedulerStatuses;
        touchRowsHeight?: number;
        theme?: string;
        touchAppointmentsMinHeight?: number;
        touchScrollBarSize?: number;
        timeZone?: string;
        touchDayNameFormat?: string;
        toolBarRangeFormat?: string;
        toolBarRangeFormatAbbr?: string;
        toolbarHeight?: number;
        views?: Array<any>;
        view?: string;
        width?: number | string;
    }// SchedulerOptions

    export interface jqxScheduler extends widget, SchedulerOptions {

        // jqxScheduler functions
        addAppointment(item: SchedulerAppointmentDataFields): void;
        beginAppointmentsUpdate(): void;
        clearAppointmentsSelection(): void;
        clearSelection(): void;
        closeMenu(): void;
        closeDialog(): void;
        deleteAppointment(appointmenId: string): void;
        destroy(): void;
        endAppointmentsUpdate(): void;
        ensureAppointmentVisible(id: string): void;
        ensureVisible(item: any, resourceId: string): void;
        exportData(format: string): any;
        focus(): void;
        getAppointmentProperty(appointmentId: string, name: string): any;
        getSelection(): SchedulerGetSelection;
        getAppointments(): Array<SchedulerAppointmentDataFields>;
        getDataAppointments(): Array<any>;
        hideAppointmentsByResource(resourcesId: string): void;
        openMenu(left: number, top: number): void;
        openDialog(left: number, top: number): void;
        selectAppointment(appointmentId: string): void;
        setAppointmentProperty(appointmentId: string, name: string, value: any): void;
        selectCell(date: any, allday: boolean, resourceId: string): void;
        showAppointmentsByResource(resourceId: string): void;
        scrollWidth(): number;
        scrollHeight(): number;
        scrollLeft(left: number): void;
        scrollTop(top: number): void;
    }// jqxScheduler

    export interface ScrollBarOptions {
        // ScrollBarOptions properties
        disabled?: boolean;
        height?: string | number;
        largestep?: number;
        min?: number;
        max?: number;
        rtl?: boolean;
        step?: number;
        showButtons?: boolean;
        thumbMinSize?: number;
        theme?: string;
        vertical?: boolean;
        value?: number;
        width?: string | number;
    }// ScrollBarOptions

    export interface jqxScrollBar extends widget, ScrollBarOptions {

        // jqxScrollBar functions
        destroy(): void;
        isScrolling(): boolean;
        setPosition(index: number): void;
    }// jqxScrollBar

    export interface ScrollViewOptions {
        // ScrollViewOptions properties
        animationDuration?: number;
        bounceEnabled?: boolean;
        buttonsOffset?: Array<number>;
        currentPage?: number;
        disabled?: boolean;
        height?: string | number;
        moveThreshold?: number;
        showButtons?: boolean;
        slideShow?: boolean;
        slideDuration?: number;
        theme?: string;
        width?: string | number;
    }// ScrollViewOptions

    export interface jqxScrollView extends widget, ScrollViewOptions {

        // jqxScrollView functions
        back(): void;
        changePage(index: number): void;
        forward(): void;
        refresh(): void;
    }// jqxScrollView

    export interface SliderTickLabelFormatFunction {
        // SliderTickLabelFormatFunction properties
        value?: number;
    }// SliderTickLabelFormatFunction

    export interface SliderTooltipFormatFunction {
        // SliderTooltipFormatFunction properties
        value?: number;
    }// SliderTooltipFormatFunction

    export interface SliderOptions {
        // SliderOptions properties
        buttonsPosition?: string;
        disabled?: boolean;
        height?: string | number;
        layout?: string;
        mode?: string;
        minorTicksFrequency?: number;
        minorTickSize?: number;
        max?: number;
        min?: number;
        orientation?: string;
        rangeSlider?: boolean;
        rtl?: boolean;
        step?: number;
        showTicks?: boolean;
        showMinorTicks?: boolean;
        showTickLabels?: boolean;
        showButtons?: boolean;
        showRange?: boolean;
        template?: string;
        theme?: string;
        ticksPosition?: string;
        ticksFrequency?: number;
        tickSize?: number;
        tickLabelFormatFunction?: (value: SliderTickLabelFormatFunction['value']) => string;
        tooltip?: boolean;
        tooltipHideDelay?: number;
        tooltipPosition?: string;
        tooltipFormatFunction?: (value: SliderTooltipFormatFunction['value']) => any;
        value?: any;
        values?: Array<number>;
        width?: number | string;
    }// SliderOptions

    export interface jqxSlider extends widget, SliderOptions {

        // jqxSlider functions
        destroy(): void;
        decrementValue(): void;
        disable(): void;
        enable(): void;
        focus(): void;
        getValue(): number;
        incrementValue(): void;
        setValue(index: number | number[]): void;
        val(value: string): string;
    }// jqxSlider

    export interface SortableCursorAt {
        // SortableCursorAt properties
        left?: number;
        top?: number;
        right?: number;
        bottom?: number;
    }// SortableCursorAt

    export interface SortableOptions {
        // SortableOptions properties
        appendTo?: string;
        axis?: number | string;
        cancel?: string;
        connectWith?: string | boolean;
        containment?: string | boolean;
        cursor?: string;
        cursorAt?: SortableCursorAt;
        delay?: number;
        disabled?: boolean;
        distance?: number;
        dropOnEmpty?: boolean;
        forceHelperSize?: boolean;
        forcePlaceholderSize?: boolean;
        grid?: Array<number>;
        handle?: string | boolean;
        helper?: (originalEvent?: any, content?: any) => void | 'original' | 'clone';
        items?: string;
        opacity?: number | boolean;
        placeholderShow?: string | boolean;
        revert?: number | boolean;
        scroll?: boolean;
        scrollSensitivity?: number;
        scrollSpeed?: number;
        tolerance?: string;
        zIndex?: number;
    }// SortableOptions

    export interface jqxSortable extends widget, SortableOptions {

        // jqxSortable functions
        cancelMethod(): void;
        destroy(): void;
        disable(): void;
        enable(): void;
        refresh(): void;
        refreshPositions(): void;
        serialize(object: any): string;
        toArray(): Array<any>;
    }// jqxSortable

    export interface SplitterPanel {
        // SplitterPanel properties
        size?: number | string;
        min?: number | string;
        collapsible?: boolean;
        collapsed?: boolean;
    }// SplitterPanel

    export interface SplitterOptions {
        // SplitterOptions properties
        disabled?: boolean;
        height?: string | number;
        orientation?: string;
        panels?: Array<SplitterPanel>;
        resizable?: boolean;
        splitBarSize?: number;
        showSplitBar?: boolean;
        theme?: string;
        width?: string | number;
    }// SplitterOptions

    export interface jqxSplitter extends widget, SplitterOptions {

        // jqxSplitter functions
        collapse(): void;
        destroy(): void;
        disable(): void;
        enable(): void;
        expand(): void;
        render(): void;
        refresh(): void;
    }// jqxSplitter

    export interface SwitchButtonOptions {
        // SwitchButtonOptions properties
        checked?: boolean;
        disabled?: boolean;
        height?: string | number;
        orientation?: string;
        onLabel?: string;
        offLabel?: string;
        thumbSize?: string;
        rtl?: boolean;
        width?: string | number;
    }// SwitchButtonOptions

    export interface jqxSwitchButton extends widget, SwitchButtonOptions {

        // jqxSwitchButton functions
        check(): void;
        disable(): void;
        enable(): void;
        toggle(): void;
        uncheck(): void;
        val(value: boolean): boolean;
    }// jqxSwitchButton

    export interface TabsOptions {
        // TabsOptions properties
        animationType?: string;
        autoHeight?: boolean;
        closeButtonSize?: number;
        collapsible?: boolean;
        contentTransitionDuration?: number;
        disabled?: boolean;
        enabledHover?: boolean;
        enableScrollAnimation?: boolean;
        enableDropAnimation?: boolean;
        height?: string | number;
        initTabContent?: (tab?: number) => void;
        keyboardNavigation?: boolean;
        next?: any;
        previous?: any;
        position?: string;
        reorder?: boolean;
        rtl?: boolean;
        scrollAnimationDuration?: number;
        selectedItem?: number;
        selectionTracker?: boolean;
        scrollable?: boolean;
        scrollPosition?: string;
        scrollStep?: number;
        showCloseButtons?: boolean;
        toggleMode?: string;
        theme?: string;
        width?: string | number;
    }// TabsOptions

    export interface jqxTabs extends widget, TabsOptions {

        // jqxTabs functions
        addAt(index: number, title: string, content: string): void;
        addFirst(htmlElement1: any, htmlElement2: any): void;
        addLast(htmlElement1: any, htmlElement2: any): void;
        collapse(): void;
        disable(): void;
        disableAt(index: number): void;
        destroy(): void;
        ensureVisible(index: number): void;
        enableAt(index: number): void;
        expand(): void;
        enable(): void;
        focus(): void;
        getTitleAt(index: number): string;
        getContentAt(index: number): any;
        getDisabledTabsCount(): any;
        hideCloseButtonAt(index: number): void;
        hideAllCloseButtons(): void;
        length(): number;
        removeAt(index: number): void;
        removeFirst(): void;
        removeLast(): void;
        select(index: number): void;
        setContentAt(index: number, htmlElement: string): void;
        setTitleAt(index: number, htmlElement: string): void;
        showCloseButtonAt(index: number): void;
        showAllCloseButtons(): void;
        val(value: string): string;
    }// jqxTabs

    export interface TagCloudTagRenderer {
        // TagCloudTagRenderer properties
        itemData?: any;
        minValue?: number;
        valueRange?: number;
    }// TagCloudTagRenderer

    export interface TagCloudSource {
        // TagCloudSource properties
        url?: string;
        data?: any;
        localdata?: string;
        datatype?: string;
        type?: string;
        id?: string;
        root?: string;
        record?: string;
    }// TagCloudSource

    export interface TagCloudOptions {
        // TagCloudOptions properties
        alterTextCase?: string;
        disabled?: boolean;
        displayLimit?: number;
        displayMember?: string;
        displayValue?: boolean;
        fontSizeUnit?: string;
        height?: number | string;
        maxColor?: string;
        maxFontSize?: number;
        maxValueToDisplay?: number;
        minColor?: string;
        minFontSize?: number;
        minValueToDisplay?: number;
        rtl?: boolean;
        sortBy?: string;
        sortOrder?: string;
        source?: TagCloudSource;
        tagRenderer?: (itemData: TagCloudTagRenderer['itemData'], minValue: TagCloudTagRenderer['minValue'], valueRange: TagCloudTagRenderer['valueRange']) => any;
        takeTopWeightedItems?: boolean;
        textColor?: string;
        urlBase?: string;
        urlMember?: string;
        valueMember?: string;
        width?: string | number;
    }// TagCloudOptions

    export interface jqxTagCloud extends widget, TagCloudOptions {

        // jqxTagCloud functions
        destroy(): void;
        findTagIndex(tag: string): number;
        getHiddenTagsList(): Array<any>;
        getRenderedTags(): Array<any>;
        getTagsList(): Array<any>;
        hideItem(index: number): void;
        insertAt(index: number, item: any): void;
        removeAt(index: number): void;
        updateAt(index: number, item: any): void;
        showItem(index: number): void;
    }// jqxTagCloud

    export interface ToggleButtonOptions {
        // ToggleButtonOptions properties
        disabled?: boolean;
        height?: number | string;
        imgSrc?: string;
        imgWidth?: number | string;
        imgHeight?: number | string;
        imgPosition?: string;
        roundedCorners?: string;
        rtl?: boolean;
        textPosition?: string;
        textImageRelation?: string;
        theme?: string;
        template?: string;
        toggled?: boolean;
        width?: string | number;
        value?: string;
    }// ToggleButtonOptions

    export interface jqxToggleButton extends widget, ToggleButtonOptions {

        // jqxToggleButton functions
        check(): void;
        destroy(): void;
        focus(): void;
        render(): void;
        toggle(): void;
        unCheck(): void;
        val(value: string): string;
    }// jqxToggleButton

    export interface TextAreaOptions {
        // TextAreaOptions properties
        disabled?: boolean;
        displayMember?: string;
        dropDownWidth?: number | string;
        height?: string | number;
        items?: number;
        maxLength?: number;
        minLength?: number;
        opened?: boolean;
        placeHolder?: string;
        popupZIndex?: number;
        query?: string;
        renderer?: (itemValue: any, inputValue: any) => any;
        roundedCorners?: boolean;
        rtl?: boolean;
        scrollBarSize?: number;
        searchMode?: string;
        source?: any;
        theme?: string;
        valueMember?: string;
        width?: string | number;
    }// TextAreaOptions

    export interface jqxTextArea extends widget, TextAreaOptions {

        // jqxTextArea functions
        destroy(): void;
        focus(): void;
        refresh(): void;
        render(): void;
        selectAll(): void;
        val(value: string): string;
    }// jqxTextArea

    export interface ToolBarToolItem {
        // ToolBarToolItem properties
        type?: string;
        tool?: any;
        separatorAfterWidget?: boolean;
        minimizable?: boolean;
        minimized?: boolean;
        menuTool?: any;
        menuSeparator?: any;
    }// ToolBarToolItem

    export interface ToolBarOptions {
        // ToolBarOptions properties
        disabled?: boolean;
        height?: string | number;
        initTools?: (type?: string, index?: number, tool?: any, menuToolIninitialization?: boolean) => void;
        minimizeWidth?: number;
        minWidth?: number | string;
        maxWidth?: number | string;
        rtl?: boolean;
        tools?: string;
        theme?: string;
        width?: string | number;
    }// ToolBarOptions

    export interface jqxToolBar extends widget, ToolBarOptions {

        // jqxToolBar functions
        addTool(type: string, position: string, separator: boolean, menuToolIninitialization: (type?: string, tool?: any, menuToolIninitialization?: boolean) => void): void;
        disableTool(index: number, disable: boolean): void;
        destroy(): void;
        destroyTool(index: number): void;
        getTools(): Array<ToolBarToolItem>;
        render(): void;
        refresh(): void;
    }// jqxToolBar

    export interface TooltipOptions {
        // TooltipOptions properties
        absolutePositionX?: number;
        absolutePositionY?: number;
        autoHide?: boolean;
        autoHideDelay?: number;
        animationShowDelay?: number | string;
        animationHideDelay?: number | string;
        content?: string;
        closeOnClick?: boolean;
        disabled?: boolean;
        enableBrowserBoundsDetection?: boolean;
        height?: number | string;
        left?: number;
        name?: string;
        opacity?: number;
        position?: string;
        rtl?: boolean;
        showDelay?: number;
        showArrow?: boolean;
        top?: number | string;
        trigger?: string;
        theme?: string;
        width?: number | string;
    }// TooltipOptions

    export interface jqxTooltip extends widget, TooltipOptions {

        // jqxTooltip functions
        close(index: number): void;
        destroy(): void;
        open(left: number, top: number): void;
        refresh(): void;
    }// jqxTooltip

    export interface TreeDragStart {
        // TreeDragStart properties
        item?: any;
    }// TreeDragStart

    export interface TreeDragEnd {
        // TreeDragEnd properties
        dragItem?: any;
        dropItem?: any;
        args?: any;
        dropPosition?: any;
        tree?: any;
    }// TreeDragEnd

    export interface TreeItem {
        // TreeItem properties
        label?: string;
        value?: string;
        disabled?: boolean;
        checked?: boolean;
        element?: any;
        parentElement?: any;
        isExpanded?: boolean;
        selected?: boolean;
    }// TreeItem

    export interface TreeOffset {
        // TreeOffset properties
        top?: number;
        left?: number;
    }// TreeOffset

    export interface TreeOptions {
        // TreeOptions properties
        animationShowDuration?: number;
        animationHideDuration?: number;
        allowDrag?: boolean;
        allowDrop?: boolean;
        checkboxes?: boolean;
        dragStart?: (item: TreeDragStart['item']) => boolean;
        dragEnd?: (dragItem?: TreeDragEnd['dragItem'], dropItem?: TreeDragEnd['dropItem'], args?: TreeDragEnd['args'], dropPosition?: TreeDragEnd['dropPosition'], tree?: TreeDragEnd['tree']) => boolean;
        disabled?: boolean;
        easing?: string;
        enableHover?: boolean;
        height?: number | string;
        hasThreeStates?: boolean;
        incrementalSearch?: boolean;
        keyboardNavigation?: boolean;
        rtl?: boolean;
        source?: any;
        toggleIndicatorSize?: number;
        toggleMode?: string;
        theme?: string;
        width?: string | number;
    }// TreeOptions

    export interface jqxTree extends widget, TreeOptions {

        // jqxTree functions
        addBefore(item: any, id: string): void;
        addAfter(item: any, id: string): void;
        addTo(item: any, id: string | null): void;
        clear(): void;
        checkAll(): void;
        checkItem(item: any, checked: boolean): void;
        collapseAll(): void;
        collapseItem(item: any): void;
        destroy(): void;
        disableItem(item: any): void;
        ensureVisible(item: any): void;
        enableItem(item: any): void;
        enableAll(): void;
        expandAll(): void;
        expandItem(item: any): void;
        focus(): void;
        getCheckedItems(): Array<TreeItem>;
        getUncheckedItems(): Array<TreeItem>;
        getItems(): Array<TreeItem>;
        getItem(element: any): TreeItem;
        getSelectedItem(): TreeItem;
        getPrevItem(item: any): TreeItem;
        getNextItem(item: any): TreeItem;
        hitTest(left: number, top: number): any;
        removeItem(item: any): void;
        render(): void;
        refresh(): void;
        selectItem(item: any): void;
        uncheckAll(): void;
        uncheckItem(item: any): void;
        updateItem(item: any, newItem: any): void;
        val(value: string): string;
    }// jqxTree

    export interface TreeGridEditSettings {
        // TreeGridEditSettings properties
        saveOnEnter?: boolean;
        saveOnPageChange?: boolean;
        saveOnBlur?: boolean;
        saveOnSelectionChange?: boolean;
        cancelOnEsc?: boolean;
        editSingleCell?: boolean;
        editOnDoubleClick?: boolean;
        editOnF2?: boolean;
    }// TreeGridEditSettings

    export interface TreeGridExportSettings {
        // TreeGridExportSettings properties
        columnsHeader?: boolean;
        hiddenColumns?: boolean;
        serverURL?: string | any;
        characterSet?: string;
        collapsedRecords?: boolean;
        recordsInView?: boolean;
        fileName?: string | null;
    }// TreeGridExportSettings

    export interface TreeGridGetRow {
        // TreeGridGetRow properties
        type?: string;
        checked?: boolean;
        expanded?: boolean;
        icon?: string;
        leaf?: boolean;
        level?: number;
        parent?: any;
        records?: Array<any>;
        selected?: boolean;
        uid?: number | string;
    }// TreeGridGetRow

    export interface TreeGridRowDetailsRenderer {
        // TreeGridRowDetailsRenderer properties
        key?: number;
        dataRow?: number;
    }// TreeGridRowDetailsRenderer

    export interface TreeGridRenderStatusBar {
        // TreeGridRenderStatusBar properties
        statusbar?: any;
    }// TreeGridRenderStatusBar

    export interface TreeGridRenderToolbar {
        // TreeGridRenderToolbar properties
        toolbar?: any;
    }// TreeGridRenderToolbar

    export interface TreeGridScrollOffset {
        // TreeGridScrollOffset properties
        top?: number;
        left?: number;
    }// TreeGridScrollOffset

    export interface TreeGridOptions {
        // TreeGridOptions properties
        altRows?: boolean;
        autoRowHeight?: boolean;
        aggregatesHeight?: number;
        autoShowLoadElement?: boolean;
        checkboxes?: boolean;
        columnsHeight?: number;
        columns?: Array<any>;
        columnGroups?: Array<any>;
        columnsResize?: boolean;
        columnsReorder?: boolean;
        disabled?: boolean;
        editable?: boolean;
        editSettings?: TreeGridEditSettings;
        exportSettings?: TreeGridExportSettings;
        enableHover?: boolean;
        enableBrowserSelection?: boolean;
        filterable?: boolean;
        filterHeight?: number;
        filterMode?: string;
        height?: number | string;
        hierarchicalCheckboxes?: boolean;
        icons?: any;
        incrementalSearch?: boolean;
        localization?: any;
        pagerHeight?: number;
        pageSize?: number;
        pageSizeOptions?: Array<number | string>;
        pageable?: boolean;
        pagerPosition?: string;
        pagerMode?: string;
        pageSizeMode?: string;
        pagerButtonsCount?: number;
        pagerRenderer?: () => any;
        ready?: () => void;
        rowDetails?: boolean;
        rowDetailsRenderer?: (key: TreeGridRowDetailsRenderer['key'], dataRow: TreeGridRowDetailsRenderer['dataRow']) => any;
        renderToolbar?: (toolBar?: TreeGridRenderToolbar['toolbar']) => void;
        renderStatusBar?: (statusBar?: TreeGridRenderStatusBar['statusbar']) => void;
        rendering?: () => void;
        rendered?: () => void;
        rtl?: boolean;
        source?: any;
        sortable?: boolean;
        showAggregates?: boolean;
        showSubAggregates?: boolean;
        showToolbar?: boolean;
        showStatusbar?: boolean;
        statusBarHeight?: number;
        scrollBarSize?: number;
        selectionMode?: string;
        showHeader?: boolean;
        theme?: string;
        toolbarHeight?: number;
        width?: string | number;
        virtualModeCreateRecords?: (expandedRecord?: any, done?: any) => void;
        virtualModeRecordCreating?: (record?: any) => any;
    }// TreeGridOptions

    export interface jqxTreeGrid extends widget, TreeGridOptions {

        // jqxTreeGrid functions
        addRow(rowKey: number | string | null, rowData: any, rowPosition: string, parent: string): void;
        addFilter(dataField: string, filerGroup: any): void;
        applyFilters(): void;
        beginUpdate(): void;
        beginRowEdit(rowKey: number | string): void;
        beginCellEdit(rowKey: number | string, dataField: string): void;
        clearSelection(): void;
        clearFilters(): void;
        clear(): void;
        checkRow(rowKey: number | string): void;
        collapseRow(rowKey: number | string): void;
        collapseAll(): void;
        destroy(): void;
        deleteRow(rowKey: string[] | string): void;
        expandRow(rowKey: Array<number | string> | string | number): void;
        expandAll(): void;
        endUpdate(): void;
        ensureRowVisible(rowKey: number | string): void;
        endRowEdit(rowKey: number | string, cancelChanges: boolean): void;
        endCellEdit(rowKey: number | string, dataField: string, cancelChanges: boolean): void;
        exportData(exportDataType: any): any;
        focus(): void;
        getColumnProperty(dataField: string, propertyName: string): any;
        goToPage(pageIndex: number): void;
        goToPrevPage(): void;
        goToNextPage(): void;
        getSelection(): Array<any>;
        getKey(row: any): string;
        getRow(rowKey: number | string): TreeGridGetRow;
        getRows(): Array<TreeGridGetRow>;
        getCheckedRows(): Array<TreeGridGetRow>;
        getView(): Array<TreeGridGetRow>;
        getCellValue(rowKey: number | string, dataField: string): any;
        hideColumn(dataField: string): void;
        isBindingCompleted(): boolean;
        lockRow(rowKey: string | number | Array<number | string>): void;
        refresh(): void;
        render(): void;
        removeFilter(dataField: string): void;
        scrollOffset(top: number, left: number): TreeGridScrollOffset;
        setColumnProperty(dataField: string, propertyName: string, propertyValue: any): void;
        showColumn(dataField: string): void;
        selectRow(rowId: string | number | Array<number | string>): void;
        setCellValue(rowId: string, dataField: string, cellValue: any): void;
        sortBy(dataField: number | string, sortOrder: 'asc' | 'desc' | null): void;
        updating(): boolean;
        updateBoundData(): void;
        unselectRow(rowId: string | number | Array<number | string>): void;
        uncheckRow(rowId: string): void;
        updateRow(rowId: number | string, data: any): void;
        unlockRow(rowId: string | number | Array<number | string>): void;
    }// jqxTreeGrid

    export interface TreeMapColorRanges {
        // TreeMapColorRanges properties
        color?: string;
        min?: number;
        max?: number;
    }// TreeMapColorRanges

    export interface TreeMapLegendPosition {
        // TreeMapLegendPosition properties
        x?: number | string;
        y?: number | string;
    }// TreeMapLegendPosition

    export interface TreeMapLegendScaleCallback {
        // TreeMapLegendScaleCallback properties
        v?: number;
    }// TreeMapLegendScaleCallback

    export interface TreeMapOptions {
        // TreeMapOptions properties
        baseColor?: string;
        colorRanges?: Array<TreeMapColorRanges>;
        colorRange?: number;
        colorMode?: string;
        displayMember?: string;
        height?: string | number;
        hoverEnabled?: boolean;
        headerHeight?: number;
        legendLabel?: string;
        legendPosition?: TreeMapLegendPosition;
        legendScaleCallback?: (v: TreeMapLegendScaleCallback['v']) => string | number;
        renderCallbacks?: any;
        selectionEnabled?: boolean;
        showLegend?: boolean;
        source?: any;
        theme?: string;
        valueMember?: string;
        width?: string | number;
    }// TreeMapOptions

    export interface jqxTreeMap extends widget, TreeMapOptions {

        // jqxTreeMap functions
        destroy(): void;
        render(): void;
    }// jqxTreeMap

    export interface ValidatorRule {
        // ValidatorRule properties
        input?: string;
        message?: string;
        action?: string;
        rule?: string | any;
        position?: string;
        hintRender?: any;
    }// ValidatorRule

    export interface ValidatorOptions {
        // ValidatorOptions properties
        arrow?: boolean;
        animation?: string;
        animationDuration?: number;
        closeOnClick?: boolean;
        focus?: boolean;
        hintType?: string;
        onError?: () => void;
        onSuccess?: () => void;
        position?: string;
        rules?: Array<ValidatorRule>;
        rtl?: boolean;
    }// ValidatorOptions

    export interface jqxValidator extends widget, ValidatorOptions {

        // jqxValidator functions
        hideHint(id: string): void;
        hide(): void;
        updatePosition(): void;
        validate(htmlElement: any): void;
        validateInput(id: string): void;
    }// jqxValidator

    export interface WindowDragArea {
        // WindowDragArea properties
        left: number;
        top: number;
        width: number | string;
        height: number | string;
    }// WindowDragArea

    export interface WindowOptions {
        // WindowOptions properties
        autoOpen?: boolean;
        animationType?: string;
        collapsed?: boolean;
        collapseAnimationDuration?: number;
        content?: string;
        closeAnimationDuration?: number;
        closeButtonSize?: number;
        closeButtonAction?: string;
        cancelButton?: any;
        dragArea?: WindowDragArea;
        draggable?: boolean;
        disabled?: boolean;
        height?: string | number;
        initContent?: () => void;
        isModal?: boolean;
        keyboardCloseKey?: number | string;
        keyboardNavigation?: boolean;
        minHeight?: string | number;
        maxHeight?: string | number;
        minWidth?: number | string;
        maxWidth?: number | string;
        modalOpacity?: any;
        modalZIndex?: number;
        modalBackgroundZIndex?: number;
        okButton?: any;
        position?: string | any;
        rtl?: boolean;
        resizable?: boolean;
        showAnimationDuration?: number;
        showCloseButton?: boolean;
        showCollapseButton?: boolean;
        theme?: string;
        title?: string;
        width?: string | number;
        zIndex?: number;
    }// WindowOptions

    export interface jqxWindow extends widget, WindowOptions {

        // jqxWindow functions
        bringToFront(): void;
        close(): void;
        collapse(): void;
        closeAll(): void;
        disable(): void;
        destroy(): void;
        enable(): void;
        expand(): void;
        focus(): void;
        isOpen(): boolean;
        move(top: number, left: number): void;
        open(): void;
        hide(): void;
        resize(top: number, left: number): void;
        setTitle(title: string): void;
        setContent(content: string): void;
    }// jqxWindow

    export interface HeatMapXAxis {
        // HeatMapXAxis properties
        labels?: any[];
        opposedPosition?: boolean;
        isInversed?: boolean;
        minimum?: any;
        maximum?: any;
        labelFormat?: string;
    }// HeatMapXAxis

    export interface HeatMapYAxis {
        // HeatMapYAxis properties
        labels?: any[];
        opposedPosition?: boolean;
        isInversed?: boolean;
    }// HeatMapYAxis

    export interface HeatMapPaletteSettings {
        // HeatMapPaletteSettings properties
        palette?: any[];
        type?: string;
        emptyPointColor?: string;
    }// HeatMapPaletteSettings

    export interface HeatMapPalette {
        // HeatMapPalette properties
        value: number;
        color: string;
        label?: string;
    }// HeatMapPalette

    export interface HeatMapLegendSettings {
        // HeatMapLegendSettings properties
        position?: string;
    }// HeatMapLegendSettings

    export interface HeatMapTooltipRender {
        // HeatMapTooltipRender properties
        xLabel?: any[];
        yLabel?: any[];
        value?: string;
        content?: string;
        date?: Date;
    }// HeatMapTooltipRender

    export interface HeatMapOptions {
        // HeatMapOptions properties
        xAxis?: HeatMapXAxis;
        yAxis?: HeatMapYAxis;
        paletteSettings?: HeatMapPaletteSettings;
        legendSettings?: HeatMapLegendSettings;
        source?: any[];
        title?: string;
        width?: number | string;
        tooltipRender?: (args: HeatMapTooltipRender) => void;
    }// HeatMapOptions

    export interface jqxHeatMap extends widget, HeatMapOptions {

        // jqxHeatMap functions
        destroy(): void;
        setLegendPosition(position: string): void;
        setOpposedXAxisPosition(opposedPosition: boolean): void;
        setOpposedYAxisPosition(opposedPosition: boolean): void;
        reverseXAxisPosition(isInversed: boolean): void;
        reverseYAxisPosition(isInversed: boolean): void;
        setPaletteType(type: string): void;
    }// jqxHeatMap

    export interface TimePickerOptions {
        // TimePickerOptions properties
        autoSwitchToMinutes?: boolean;
        disabled?: boolean;
        footer?: boolean;
        footerTemplate?: string;
        format?: string;
        height?: number | string;
        minuteInterval?: number;
        name?: string;
        readonly?: boolean;
        selection?: string;
        theme?: string;
        unfocusable?: boolean;
        value?: any;
        view?: string;
        width?: number | string;
    }// TimePickerOptions

    export interface jqxTimePicker extends widget, TimePickerOptions {

        // jqxTimePicker functions
        setHours(hours: number): void;
        setMinutes(minutes: number): void;
    }// jqxTimePicker

    export interface SplitLayoutOptions {
        // SplitLayoutOptions properties
        disabled?: boolean;
        dataSource?: any;
        ready?: any;
        orientation?: string;
    }// SplitLayoutOptions

    export interface jqxSplitLayout extends widget, SplitLayoutOptions {

        // jqxSplitLayout functions
        refresh(): void;
    }// jqxSplitLayout

    export interface BarcodeOptions {
        // BarcodeOptions properties
        backgroundColor?: string;
        displayLabel?: boolean;
        labelColor?: string;
        labelFont?: string;
        labelFontSize?: number;
        labelMarginBottom?: number;
        labelMarginTop?: number;
        labelPosition?: string;
        lineColor?: string;
        lineHeight?: number;
        lineWidth?: number;
        renderAs?: string;
        type?: string;
        value?: string;
    }// BarcodeOptions

    export interface jqxBarcode extends widget, BarcodeOptions {

        // jqxBarcode functions
        export(format: string, fileName: string): any;
        getDataURL(format: string): string;
        getDataURLAsync(format: string): any;
        isValid(): boolean;
    }// jqxBarcode

    export interface QRcodeOptions {
        // QRcodeOptions properties
        backgroundColor?: string;
        displayLabel?: boolean;
        embedImage?: string;
        errorLevel?: string;
        imageHeight?: number;
        imageWidth?: number;
        labelColor?: string;
        labelFont?: string;
        labelFontSize?: number;
        labelMarginBottom?: number;
        labelMarginTop?: number;
        labelPosition?: string;
        lineColor?: string;
        squareWidth?: number;
        renderAs?: string;
        value?: string;
    }// QRcodeOptions

    export interface jqxQRcode extends widget, QRcodeOptions {

        // jqxQRcode functions
        export(format: string, fileName: string): any;
        getDataURL(format: string): string;
        getDataURLAsync(format: string): any;
        isValid(): boolean;
    }// jqxQRcode

    export interface CheckBoxGroupOptions {
        // CheckBoxGroupOptions properties
        change?: (item?: any) => void;
        disabled?: boolean;
        items?: any;
        value?: any;
        layout?: string;
        labelPosition?: string;
        rtl?: boolean;
        theme?: string;
    }// CheckBoxGroupOptions

    export interface jqxCheckBoxGroup extends widget, CheckBoxGroupOptions {

        // jqxCheckBoxGroup functions
        getValue(): any;
        getValueAt(index: number): string;
        enableAt(index: number): void;
        disableAt(index: number): void;
        checkAt(index: number): void;
        uncheckAt(index: number): void;
        uncheckAll(): void;
        checkAll(): void;
        checkValue(value: string): void;
        uncheckValue(value: string): void;
        disable(): void;
        destroy(): void;
        enable(): void;
        render(): void;
        val(value: any): any;
    }// jqxCheckBoxGroup

    export interface RadioButtonGroupOptions {
        // RadioButtonGroupOptions properties
        change?: (item?: any) => void;
        disabled?: boolean;
        items?: any;
        value?: any;
        layout?: string;
        labelPosition?: string;
        rtl?: boolean;
        theme?: string;
    }// RadioButtonGroupOptions

    export interface jqxRadioButtonGroup extends widget, RadioButtonGroupOptions {

        // jqxRadioButtonGroup functions
        getValue(): any;
        getValueAt(index: number): string;
        enableAt(index: number): void;
        disableAt(index: number): void;
        checkAt(index: number): void;
        uncheckAt(index: number): void;
        uncheckAll(): void;
        checkValue(value: string): void;
        uncheckValue(value: string): void;
        disable(): void;
        destroy(): void;
        enable(): void;
        render(): void;
        val(value: any): any;
    }// jqxRadioButtonGroup

    export interface GanttOptions {
        // GanttOptions properties
        adjustToNonworkingTime?: boolean;
        autoSchedule?: boolean;
        autoScheduleStrictMode?: boolean;
        autoScrollStep?: number;
        columnMenu?: boolean;
        columnMinWidth?: any;
        columnResize?: boolean;
        columnResizeFeedback?: boolean;
        currentTime?: any;
        currentTimeIndicator?: boolean;
        currentTimeIndicatorInterval?: number;
        dataExportFileName?: string;
        source?: any;
        dayFormat?: string;
        dateEnd?: any;
        dateStart?: any;
        dateMarkers?: any;
        disabled?: boolean;
        disableAutoScroll?: boolean;
        disableTaskDrag?: boolean;
        disableTaskProgressChange?: boolean;
        disableTaskResize?: boolean;
        disableSelection?: boolean;
        disableSegmentDrag?: boolean;
        disableSegmentResize?: boolean;
        disableWindowEditor?: boolean;
        durationUnit?: string;
        filterRow?: boolean;
        firstDayOfWeek?: number;
        groupByResources?: boolean;
        headerTemplate?: any;
        hideDateMarkers?: boolean;
        hideTimelineHeader?: boolean;
        hideTimelineHeaderDetails?: boolean;
        hideTimelineSecondHeaderDetails?: boolean;
        hideResourcePanel?: boolean;
        horizontalScrollBarVisibility?: string;
        hourFormat?: string;
        infiniteTimeline?: boolean;
        infiniteTimelineStep?: number;
        inverted?: boolean;
        keyboardNavigation?: boolean;
        max?: any;
        min?: any;
        monthFormat?: string;
        monthScale?: string;
        nonworkingDays?: any;
        nonworkingHours?: any;
        onTaskRender?: any;
        popupWindowCustomizationFunction?: any;
        popupWindowTabs?: any;
        progressLabelFormatFunction?: any;
        quarterFormat?: string;
        resources?: any;
        resourceColumns?: any;
        resourceFiltering?: boolean;
        resourceGroupFormatFunction?: any;
        resourcePanelHeaderTemplate?: any;
        resourcePanelMin?: any;
        resourcePanelSize?: any;
        resourcePanelRefreshRate?: number;
        resourceTimelineFormatFunction?: any;
        resourceTimelineMode?: string;
        resourceTimelineView?: string;
        rightToLeft?: boolean;
        selectedTaskIds?: any;
        selectedResourceIds?: any;
        shadeUntilCurrentTime?: boolean;
        showSelectionColumn?: boolean;
        showBaseline?: boolean;
        showProgressLabel?: boolean;
        snapToNearest?: boolean;
        sortFunction?: any;
        sortMode?: string;
        tasks?: any;
        taskColumns?: any;
        taskFiltering?: boolean;
        taskPanelMin?: any;
        taskPanelSize?: any;
        timelineMin?: any;
        treeMin?: any;
        treeSize?: any;
        timelineHeaderFormatFunction?: any;
        tooltip?: any;
        verticalScrollBarVisibility?: string;
        view?: string;
        yearFormat?: string;
        weekFormat?: string;
        theme?: string;
    }// GanttOptions

    export interface jqxGantt extends widget, GanttOptions {

        // jqxGantt functions
        addFilter(columns: any, filterGroup: any): any;
        clearFilters(): any;
        clearSort(): any;
        clearSelection(): any;
        clearState(): any;
        clearTasks(): any;
        clearResources(): any;
        createConnection(startTaskIndex: any, taskEndIndex: any, connectionType: number, lag: number): any;
        collapse(id: any): any;
        beginUpdate(): any;
        endUpdate(): any;
        ensureVisible(taskId: any): any;
        expand(id: any): any;
        exportData(dataFormat: string, callback: any): any;
        getConnections(): any;
        getConnectionDetails(connectionId: string): any;
        getState(): any;
        getItemPath(item: any): string;
        getTask(itemId: any): any;
        getTasks(): any;
        getTaskIndex(task: any): number;
        getTaskConnections(taskId: any): any;
        getTaskProject(task: any): any;
        getResource(itemId: any): any;
        getResources(): any;
        getResourceIndex(resource: any): number;
        getResourceTasks(resource: any): any;
        getSelectedIds(): any;
        getSelectedTasks(): any;
        getSelectedResources(): any;
        getWorkingHours(): any;
        hideTooltip(): any;
        isWorkingDay(date: any): any;
        loadState(state: any): any;
        removeAllConnections(): any;
        removeConnection(startTaskIndex: any, taskEndIndex: number, connectionType: number): any;
        removeTaskConnection(taskStart: any, taskEnd: any): any;
        showTooltip(target: any, content: string): any;
        saveState(state: any): any;
        insertTask(taskObject: any, project: any, index: number): any;
        updateTask(taskId: any, taskObject: any): any;
        removeTask(taskId: any): any;
        insertResource(resourceId: any, resourceObject: any): any;
        updateResource(resourceId: any, taskObject: any): any;
        removeResource(resourceId: any): any;
        openWindow(taskId: any): any;
        closeWindow(): any;
        print(): any;
        setWorkTime(settings: any): any;
        selectTask(id: any): any;
        selectResource(id: any): any;
        unselectTask(id: any): any;
        unselectResource(id: any): any;
        unsetWorkTime(settings: any): any;
        sort(columns: any): any;
    }// jqxGantt



} // module jqwidgets