text: declare module "devexpress-aspnetcore-bootstrap" {
    declare var npm$namespace$DevExpress: {
      AspNetCore: typeof npm$namespace$DevExpress$AspNetCore
    };
  
    declare var npm$namespace$DevExpress$AspNetCore: {
      Utils: typeof DevExpress$AspNetCore$Utils,
      BootstrapSchedulerGroupType: typeof DevExpress$AspNetCore$BootstrapSchedulerGroupType,
      BootstrapSchedulerViewType: typeof DevExpress$AspNetCore$BootstrapSchedulerViewType,
      BootstrapSchedulerAppointmentType: typeof DevExpress$AspNetCore$BootstrapSchedulerAppointmentType,
      BootstrapSchedulerRecurrenceRange: typeof DevExpress$AspNetCore$BootstrapSchedulerRecurrenceRange,
      BootstrapSchedulerRecurrenceType: typeof DevExpress$AspNetCore$BootstrapSchedulerRecurrenceType,
      WeekDays: typeof DevExpress$AspNetCore$WeekDays,
      WeekOfMonth: typeof DevExpress$AspNetCore$WeekOfMonth,
      BootstrapPopupControlCloseReason: typeof DevExpress$AspNetCore$BootstrapPopupControlCloseReason,
      Control: typeof DevExpress$AspNetCore$Control,
      BootstrapClientEdit: typeof DevExpress$AspNetCore$BootstrapClientEdit,
      BootstrapAccordion: typeof DevExpress$AspNetCore$BootstrapAccordion,
      BootstrapAccordionGroup: typeof DevExpress$AspNetCore$BootstrapAccordionGroup,
      BootstrapAccordionItem: typeof DevExpress$AspNetCore$BootstrapAccordionItem,
      BootstrapBinaryImage: typeof DevExpress$AspNetCore$BootstrapBinaryImage,
      BootstrapButton: typeof DevExpress$AspNetCore$BootstrapButton,
      BootstrapCalendar: typeof DevExpress$AspNetCore$BootstrapCalendar,
      BootstrapGridBase: typeof DevExpress$AspNetCore$BootstrapGridBase,
      BootstrapCardView: typeof DevExpress$AspNetCore$BootstrapCardView,
      BootstrapCardViewBatchEditApi: typeof DevExpress$AspNetCore$BootstrapCardViewBatchEditApi,
      BootstrapCardViewColumn: typeof DevExpress$AspNetCore$BootstrapCardViewColumn,
      BootstrapCardViewCellInfo: typeof DevExpress$AspNetCore$BootstrapCardViewCellInfo,
      BootstrapChart: typeof DevExpress$AspNetCore$BootstrapChart,
      BootstrapPolarChart: typeof DevExpress$AspNetCore$BootstrapPolarChart,
      BootstrapPieChart: typeof DevExpress$AspNetCore$BootstrapPieChart,
      BootstrapCheckBox: typeof DevExpress$AspNetCore$BootstrapCheckBox,
      BootstrapRadioButton: typeof DevExpress$AspNetCore$BootstrapRadioButton,
      BootstrapComboBox: typeof DevExpress$AspNetCore$BootstrapComboBox,
      BootstrapDateEdit: typeof DevExpress$AspNetCore$BootstrapDateEdit,
      BootstrapDropDownEdit: typeof DevExpress$AspNetCore$BootstrapDropDownEdit,
      BootstrapFormLayout: typeof DevExpress$AspNetCore$BootstrapFormLayout,
      BootstrapFormLayoutItem: typeof DevExpress$AspNetCore$BootstrapFormLayoutItem,
      BootstrapGridView: typeof DevExpress$AspNetCore$BootstrapGridView,
      BootstrapGridViewBatchEditApi: typeof DevExpress$AspNetCore$BootstrapGridViewBatchEditApi,
      BootstrapGridViewColumn: typeof DevExpress$AspNetCore$BootstrapGridViewColumn,
      BootstrapGridViewCellInfo: typeof DevExpress$AspNetCore$BootstrapGridViewCellInfo,
      BootstrapHyperLink: typeof DevExpress$AspNetCore$BootstrapHyperLink,
      BootstrapListBox: typeof DevExpress$AspNetCore$BootstrapListBox,
      BootstrapListBoxItem: typeof DevExpress$AspNetCore$BootstrapListBoxItem,
      BootstrapCheckBoxList: typeof DevExpress$AspNetCore$BootstrapCheckBoxList,
      BootstrapRadioButtonList: typeof DevExpress$AspNetCore$BootstrapRadioButtonList,
      BootstrapMenu: typeof DevExpress$AspNetCore$BootstrapMenu,
      BootstrapMenuItem: typeof DevExpress$AspNetCore$BootstrapMenuItem,
      BootstrapPopupControl: typeof DevExpress$AspNetCore$BootstrapPopupControl,
      BootstrapPopupWindow: typeof DevExpress$AspNetCore$BootstrapPopupWindow,
      BootstrapPopupMenu: typeof DevExpress$AspNetCore$BootstrapPopupMenu,
      BootstrapProgressBar: typeof DevExpress$AspNetCore$BootstrapProgressBar,
      BootstrapScheduler: typeof DevExpress$AspNetCore$BootstrapScheduler,
      BootstrapTimeInterval: typeof DevExpress$AspNetCore$BootstrapTimeInterval,
      BootstrapSchedulerAppointment: typeof DevExpress$AspNetCore$BootstrapSchedulerAppointment,
      BootstrapSchedulerAppointmentDragInfo: typeof DevExpress$AspNetCore$BootstrapSchedulerAppointmentDragInfo,
      BootstrapSchedulerAppointmentOperation: typeof DevExpress$AspNetCore$BootstrapSchedulerAppointmentOperation,
      BootstrapSchedulerRecurrenceInfo: typeof DevExpress$AspNetCore$BootstrapSchedulerRecurrenceInfo,
      BootstrapSparkline: typeof DevExpress$AspNetCore$BootstrapSparkline,
      BootstrapTimeEdit: typeof DevExpress$AspNetCore$BootstrapTimeEdit,
      BootstrapSpinEdit: typeof DevExpress$AspNetCore$BootstrapSpinEdit,
      BootstrapTabControl: typeof DevExpress$AspNetCore$BootstrapTabControl,
      BootstrapTab: typeof DevExpress$AspNetCore$BootstrapTab,
      BootstrapPageControl: typeof DevExpress$AspNetCore$BootstrapPageControl,
      BootstrapTagBox: typeof DevExpress$AspNetCore$BootstrapTagBox,
      BootstrapButtonEdit: typeof DevExpress$AspNetCore$BootstrapButtonEdit,
      BootstrapMemo: typeof DevExpress$AspNetCore$BootstrapMemo,
      BootstrapTextBox: typeof DevExpress$AspNetCore$BootstrapTextBox,
      BootstrapToolbar: typeof DevExpress$AspNetCore$BootstrapToolbar,
      BootstrapTreeView: typeof DevExpress$AspNetCore$BootstrapTreeView,
      BootstrapTreeViewNode: typeof DevExpress$AspNetCore$BootstrapTreeViewNode,
      BootstrapUploadControl: typeof DevExpress$AspNetCore$BootstrapUploadControl,
      BootstrapUploadControlFile: typeof DevExpress$AspNetCore$BootstrapUploadControlFile,
      BootstrapUploadControlInvalidFileInfo: typeof DevExpress$AspNetCore$BootstrapUploadControlInvalidFileInfo,
      BootstrapUploadControlValidationSettings: typeof DevExpress$AspNetCore$BootstrapUploadControlValidationSettings
    };
  
    declare var DevExpress$AspNetCore$BootstrapSchedulerGroupType: {|
      +Date: "Date", // "Date"
      +None: "None", // "None"
      +Resource: "Resource" // "Resource"
    |};
  
    declare var DevExpress$AspNetCore$BootstrapSchedulerViewType: {|
      +Day: "Day", // "Day"
      +WorkWeek: "WorkWeek", // "WorkWeek"
      +Week: "Week", // "Week"
      +Month: "Month", // "Month"
      +Timeline: "Timeline", // "Timeline"
      +FullWeek: "FullWeek", // "FullWeek"
      +Agenda: "Agenda" // "Agenda"
    |};
  
    declare var DevExpress$AspNetCore$BootstrapSchedulerAppointmentType: {|
      +Normal: "Normal", // "Normal"
      +Pattern: "Pattern", // "Pattern"
      +Occurrence: "Occurrence", // "Occurrence"
      +ChangedOccurrence: "ChangedOccurrence", // "ChangedOccurrence"
      +DeletedOccurrence: "DeletedOccurrence" // "DeletedOccurrence"
    |};
  
    declare var DevExpress$AspNetCore$BootstrapSchedulerRecurrenceRange: {|
      +NoEndDate: "NoEndDate", // "NoEndDate"
      +OccurrenceCount: "OccurrenceCount", // "OccurrenceCount"
      +EndByDate: "EndByDate" // "EndByDate"
    |};
  
    declare var DevExpress$AspNetCore$BootstrapSchedulerRecurrenceType: {|
      +Daily: "Daily", // "Daily"
      +Weekly: "Weekly", // "Weekly"
      +Monthly: "Monthly", // "Monthly"
      +Yearly: "Yearly", // "Yearly"
      +Hourly: "Hourly" // "Hourly"
    |};
  
    declare var DevExpress$AspNetCore$WeekDays: {|
      +Sunday: 1, // 1
      +Monday: 2, // 2
      +Tuesday: 4, // 4
      +Wednesday: 8, // 8
      +Thursday: 16, // 16
      +Friday: 32, // 32
      +Saturday: 64, // 64
      +WeekendDays: 65, // 65
      +WorkDays: 62, // 62
      +EveryDay: 127 // 127
    |};
  
    declare var DevExpress$AspNetCore$WeekOfMonth: {|
      +None: 0, // 0
      +First: 1, // 1
      +Second: 2, // 2
      +Third: 3, // 3
      +Fourth: 4, // 4
      +Last: 5 // 5
    |};
  
    declare var DevExpress$AspNetCore$BootstrapPopupControlCloseReason: {|
      +API: "API", // "API"
      +CloseButton: "CloseButton", // "CloseButton"
      +OuterMouseClick: "OuterMouseClick", // "OuterMouseClick"
      +MouseOut: "MouseOut", // "MouseOut"
      +Escape: "Escape" // "Escape"
    |};
  
    declare var DevExpress$AspNetCore$Utils: {
      getControls: () => AspNetCore$Control[],
      getSerializedEditorValuesInContainer: (
        containerOrId: string | HTMLElement,
        processInvisibleEditors?: boolean
      ) => any,
      getEditorValuesInContainer: (
        containerOrId: string | HTMLElement,
        processInvisibleEditors?: boolean
      ) => any
    };
  
    declare interface DevExpress$AspNetCore$EventArgs {
      +sender: AspNetCore$Control;
    }
  
    declare type DevExpress$AspNetCore$CancelEventArgs = {
      cancel: boolean
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$BeginCallbackEventArgs = {
      +command: string
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$ProcessingModeEventArgs = {
      processOnServer: boolean
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$ProcessingModeCancelEventArgs = {
      cancel: boolean
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$GlobalBeginCallbackEventArgs = {
      +control: AspNetCore$Control
    } & BeginCallbackEventArgs;
  
    declare type DevExpress$AspNetCore$EndCallbackEventArgs = {} & EventArgs;
  
    declare type DevExpress$AspNetCore$GlobalEndCallbackEventArgs = {
      +control: AspNetCore$Control
    } & EndCallbackEventArgs;
  
    declare type DevExpress$AspNetCore$CustomDataCallbackEventArgs = {
      result: string
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$CallbackErrorEventArgs = {
      handled: boolean,
      message: string
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$GlobalCallbackErrorEventArgs = {
      +control: AspNetCore$Control
    } & CallbackErrorEventArgs;
  
    declare type DevExpress$AspNetCore$EditValidationEventArgs = {
      errorText: string,
      isValid: boolean,
      value: string
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$ValidationCompletedEventArgs = {
      +container: any,
      +firstInvalidControl: AspNetCore$Control,
      +firstVisibleInvalidControl: AspNetCore$Control,
      +invisibleControlsValidated: boolean,
      isValid: boolean,
      +validationGroup: string
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$EditClickEventArgs = {
      +htmlElement: any,
      +htmlEvent: any
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$EditKeyEventArgs = {
      +htmlEvent: any
    } & EventArgs;
  
    declare class DevExpress$AspNetCore$Control {
      instance: any;
      constructor(instance: any): this;
      name: string;
      adjustControl(): void;
      getHeight(): number;
      getMainElement(): any;
      getParentControl(): any;
      getVisible(): boolean;
      getWidth(): number;
      inCallback(): boolean;
      sendMessageToAssistiveTechnology(message: string): void;
      setHeight(height: number): void;
      setVisible(visible: boolean): void;
      setWidth(width: number): void;
      on<K: $Keys<AspNetCore$ControlEventMap>>(
        eventName: K,
        callback: (args?: $ElementType<AspNetCore$ControlEventMap, K>) => void
      ): this;
      once<K: $Keys<AspNetCore$ControlEventMap>>(
        eventName: K,
        callback: (args?: $ElementType<AspNetCore$ControlEventMap, K>) => void
      ): this;
      off<K: $Keys<AspNetCore$ControlEventMap>>(): this;
      off<K: $Keys<AspNetCore$ControlEventMap>>(eventName: K): this;
      off<K: $Keys<AspNetCore$ControlEventMap>>(
        eventName: K,
        callback: (args?: $ElementType<AspNetCore$ControlEventMap, K>) => void
      ): this;
    }
  
    declare interface DevExpress$AspNetCore$ControlEventMap {
      init: DevExpress$AspNetCore$EventArgs;
    }
  
    declare class DevExpress$AspNetCore$BootstrapClientEdit mixins Control {
      focus(): void;
      getCaption(): string;
      getEnabled(): boolean;
      getErrorText(): string;
      getInputElement(): any;
      getIsValid(): boolean;
      getReadOnly(): boolean;
      getValue(): any;
      setCaption(caption: string): void;
      setEnabled(value: boolean): void;
      setErrorText(errorText: string): void;
      setIsValid(isValid: boolean): void;
      setReadOnly(readOnly: boolean): void;
      setValue(value: any): void;
      validate(): void;
      on<K: $Keys<AspNetCore$BootstrapClientEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapClientEditEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapClientEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapClientEditEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapClientEditEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapClientEditEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapClientEditEventMap = {
      gotFocus: DevExpress$AspNetCore$EventArgs,
      lostFocus: DevExpress$AspNetCore$EventArgs,
      validation: DevExpress$AspNetCore$EditValidationEventArgs,
      valueChanged: DevExpress$AspNetCore$ProcessingModeEventArgs
    } & ControlEventMap;
  
    declare type DevExpress$AspNetCore$AccordionItemEventArgs = {
      +htmlElement: { [key: string]: any },
      +htmlEvent: { [key: string]: any },
      +item: AspNetCore$BootstrapAccordionItem
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$AccordionGroupEventArgs = {
      +group: AspNetCore$BootstrapAccordionGroup
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$AccordionGroupCancelEventArgs = {
      +group: AspNetCore$BootstrapAccordionGroup
    } & ProcessingModeCancelEventArgs;
  
    declare type DevExpress$AspNetCore$AccordionGroupClickEventArgs = {
      +htmlElement: { [key: string]: any },
      +htmlEvent: { [key: string]: any }
    } & AccordionGroupCancelEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapAccordion mixins Control {
      collapseAll(): void;
      expandAll(): void;
      getActiveGroup(): AspNetCore$BootstrapAccordionGroup | null;
      getGroup(index: number): AspNetCore$BootstrapAccordionGroup | null;
      getGroupByName(name: string): AspNetCore$BootstrapAccordionGroup | null;
      getGroupCount(): number;
      getItemByName(name: string): AspNetCore$BootstrapAccordionItem | null;
      getSelectedItem(): AspNetCore$BootstrapAccordionItem | null;
      setActiveGroup(group: AspNetCore$BootstrapAccordionGroup): void;
      setSelectedItem(item: AspNetCore$BootstrapAccordionItem): void;
      on<K: $Keys<AspNetCore$BootstrapAccordionEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapAccordionEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapAccordionEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapAccordionEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapAccordionEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapAccordionEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapAccordionEventMap = {
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      expandedChanged: DevExpress$AspNetCore$AccordionGroupEventArgs,
      expandedChanging: DevExpress$AspNetCore$AccordionGroupCancelEventArgs,
      headerClick: DevExpress$AspNetCore$AccordionGroupClickEventArgs,
      itemClick: DevExpress$AspNetCore$AccordionItemEventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapAccordionGroup {
      instance: any;
      constructor(instance: any): this;
      index: number;
      name: string;
      navBar: DevExpress$AspNetCore$BootstrapAccordion | null;
      getEnabled(): boolean;
      getExpanded(): boolean;
      getHeaderBadgeIconCssClass(): string;
      getHeaderBadgeText(): string;
      getItem(index: number): AspNetCore$BootstrapAccordionItem | null;
      getItemByName(name: string): AspNetCore$BootstrapAccordionItem | null;
      getItemCount(): number;
      getText(): string;
      getVisible(): boolean;
      setExpanded(value: boolean): void;
      setHeaderBadgeIconCssClass(cssClass: string): void;
      setHeaderBadgeText(text: string): void;
      setText(text: string): void;
      setVisible(value: boolean): void;
    }
  
    declare class DevExpress$AspNetCore$BootstrapAccordionItem {
      instance: any;
      constructor(instance: any): this;
      group: DevExpress$AspNetCore$BootstrapAccordionGroup | null;
      index: number;
      name: string;
      navBar: DevExpress$AspNetCore$BootstrapAccordion | null;
      getBadgeIconCssClass(): string;
      getBadgeText(): string;
      getEnabled(): boolean;
      getIconCssClass(): string;
      getImageUrl(): string;
      getNavigateUrl(): string;
      getText(): string;
      getVisible(): boolean;
      setBadgeIconCssClass(cssClass: string): void;
      setBadgeText(text: string): void;
      setEnabled(value: boolean): void;
      setIconCssClass(cssClass: string): void;
      setImageUrl(value: string): void;
      setNavigateUrl(value: string): void;
      setText(value: string): void;
      setVisible(value: boolean): void;
    }
  
    declare class DevExpress$AspNetCore$BootstrapBinaryImage
      mixins BootstrapClientEdit {
      clear(): void;
      getUploadedFileName(): string;
      getValue(): any;
      performCallback(data: any): Promise<void>;
      performCallback(data: any, onSuccess: () => void): void;
      setSize(width: number, height: number): void;
      setValue(value: any): void;
      on<K: $Keys<AspNetCore$BootstrapBinaryImageEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapBinaryImageEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapBinaryImageEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapBinaryImageEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapBinaryImageEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapBinaryImageEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapBinaryImageEventMap = {
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      click: DevExpress$AspNetCore$EditClickEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs
    } & BootstrapClientEditEventMap;
  
    declare type DevExpress$AspNetCore$ButtonClickEventArgs = {
      +cancelEventAndBubble: boolean
    } & ProcessingModeEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapButton mixins Control {
      doClick(): void;
      focus(): void;
      getBadgeIconCssClass(): string;
      getBadgeText(): string;
      getChecked(): boolean;
      getEnabled(): boolean;
      getImageUrl(): string;
      getText(): string;
      setBadgeIconCssClass(cssClass: string): void;
      setBadgeText(text: string): void;
      setChecked(value: boolean): void;
      setEnabled(value: boolean): void;
      setImageUrl(value: string): void;
      setText(value: string): void;
      on<K: $Keys<AspNetCore$BootstrapButtonEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapButtonEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapButtonEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapButtonEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapButtonEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapButtonEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapButtonEventMap = {
      checkedChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      click: DevExpress$AspNetCore$ButtonClickEventArgs,
      gotFocus: DevExpress$AspNetCore$EventArgs,
      lostFocus: DevExpress$AspNetCore$EventArgs
    } & ControlEventMap;
  
    declare type DevExpress$AspNetCore$CalendarCustomDisabledDateEventArgs = {
      +date: Date,
      isDisabled: boolean
    } & EventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapCalendar
      mixins BootstrapClientEdit {
      clearSelection(): void;
      deselectDate(date: Date): void;
      deselectRange(start: Date, end: Date): void;
      getEnabled(): boolean;
      getMaxDate(): Date;
      getMinDate(): Date;
      getSelectedDate(): Date;
      getSelectedDates(): Date[];
      getVisibleDate(): Date;
      isDateSelected(date: Date): boolean;
      selectDate(date: Date): void;
      selectRange(start: Date, end: Date): void;
      setEnabled(enabled: boolean): void;
      setMaxDate(date: Date): void;
      setMinDate(date: Date): void;
      setSelectedDate(date: Date): void;
      setVisibleDate(date: Date): void;
      on<K: $Keys<AspNetCore$BootstrapCalendarEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapCalendarEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapCalendarEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapCalendarEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapCalendarEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapCalendarEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapCalendarEventMap = {
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      customDisabledDate: DevExpress$AspNetCore$CalendarCustomDisabledDateEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      selectionChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      visibleMonthChanged: DevExpress$AspNetCore$ProcessingModeEventArgs
    } & BootstrapClientEditEventMap;
  
    declare type DevExpress$AspNetCore$GridToolbarItemClickEventArgs = {
      +item: AspNetCore$BootstrapMenuItem,
      +toolbarIndex: number,
      +toolbarName: string,
      usePostBack: boolean
    } & ProcessingModeEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapGridBase mixins Control {
      getToolbar(index: number): AspNetCore$BootstrapMenu | null;
      getToolbarByName(name: string): AspNetCore$BootstrapMenu | null;
      on<K: $Keys<AspNetCore$BootstrapGridBaseEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapGridBaseEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapGridBaseEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapGridBaseEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapGridBaseEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapGridBaseEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapGridBaseEventMap = {
      toolbarItemClick: DevExpress$AspNetCore$GridToolbarItemClickEventArgs
    } & ControlEventMap;
  
    declare type DevExpress$AspNetCore$CardViewColumnCancelEventArgs = {
      +column: AspNetCore$BootstrapCardViewColumn
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewCardFocusingEventArgs = {
      +htmlEvent: any,
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewCardClickEventArgs = {
      +htmlEvent: any,
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewCustomButtonEventArgs = {
      +buttonID: string,
      +visibleIndex: number
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewSelectionEventArgs = {
      +isAllRecordsOnPage: boolean,
      +isChangedOnServer: boolean,
      +isSelected: boolean,
      +visibleIndex: number
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewFocusEventArgs = {
      +isChangedOnServer: boolean
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditStartEditingEventArgs = {
      +cardValues: any,
      focusedColumn: AspNetCore$BootstrapCardViewColumn,
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditEndEditingEventArgs = {
      +cardValues: any,
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditCardValidatingEventArgs = {
      +validationInfo: any,
      +visibleIndex: number
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditConfirmShowingEventArgs = {
      +requestTriggerID: string
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditTemplateCellFocusedEventArgs = {
      +column: AspNetCore$BootstrapCardViewColumn,
      handled: boolean
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditChangesSavingEventArgs = {
      +deletedValues: any,
      +insertedValues: any,
      +updatedValues: any
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditChangesCancelingEventArgs = {
      +deletedValues: any,
      +insertedValues: any,
      +updatedValues: any
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditCardInsertingEventArgs = {
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewBatchEditCardDeletingEventArgs = {
      +cardValues: any,
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$CardViewFocusedCellChangingEventArgs = {
      +cellInfo: AspNetCore$BootstrapCardViewCellInfo
    } & CancelEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapCardView
      mixins BootstrapGridBase {
      batchEditApi: AspNetCore$BootstrapCardViewBatchEditApi | null;
      addNewCard(): void;
      applyFilter(filterExpression: string): void;
      applySearchPanelFilter(value: string): void;
      cancelEdit(): void;
      clearFilter(): void;
      closeFilterControl(): void;
      deleteCard(visibleIndex: number): void;
      deleteCardByKey(key: any): void;
      focus(): void;
      focusEditor(column: AspNetCore$BootstrapCardViewColumn): void;
      focusEditor(columnIndex: number): void;
      focusEditor(columnFieldNameOrId: string): void;
      getCardKey(visibleIndex: number): string;
      getColumn(columnIndex: number): AspNetCore$BootstrapCardViewColumn | null;
      getColumnByField(
        columnFieldName: string
      ): AspNetCore$BootstrapCardViewColumn | null;
      getColumnById(columnId: string): AspNetCore$BootstrapCardViewColumn | null;
      getColumnCount(): number;
      getEditValue(column: AspNetCore$BootstrapCardViewColumn): string;
      getEditValue(columnIndex: number): string;
      getEditValue(columnFieldNameOrId: string): string;
      getEditor(
        column: AspNetCore$BootstrapCardViewColumn
      ): DevExpress$AspNetCore$BootstrapClientEdit;
      getEditor(columnIndex: number): DevExpress$AspNetCore$BootstrapClientEdit;
      getEditor(
        columnFieldNameOrId: string
      ): DevExpress$AspNetCore$BootstrapClientEdit;
      getFocusedCardIndex(): number;
      getFocusedCell(): AspNetCore$BootstrapCardViewCellInfo | null;
      getPageCount(): number;
      getPageIndex(): number;
      getPopupEditForm(): AspNetCore$BootstrapPopupControl | null;
      getSelectedCardCount(): number;
      getSelectedKeysOnPage(): any[];
      getTopVisibleIndex(): number;
      getVerticalScrollPosition(): number;
      getVisibleCardsOnPage(): number;
      gotoPage(pageIndex: number): void;
      hideCustomizationWindow(): void;
      isCardSelectedOnPage(visibleIndex: number): boolean;
      isCustomizationWindowVisible(): boolean;
      isEditing(): boolean;
      isNewCardEditing(): boolean;
      moveColumn(column: AspNetCore$BootstrapCardViewColumn): void;
      moveColumn(columnIndex: number): void;
      moveColumn(columnFieldNameOrId: string): void;
      moveColumn(
        column: AspNetCore$BootstrapCardViewColumn,
        moveToColumnVisibleIndex: number
      ): void;
      moveColumn(columnIndex: number, moveToColumnVisibleIndex: number): void;
      moveColumn(
        columnFieldNameOrId: string,
        moveToColumnVisibleIndex: number
      ): void;
      moveColumn(
        column: AspNetCore$BootstrapCardViewColumn,
        moveToColumnVisibleIndex: number,
        moveBefore: boolean
      ): void;
      moveColumn(
        columnIndex: number,
        moveToColumnVisibleIndex: number,
        moveBefore: boolean
      ): void;
      moveColumn(
        columnFieldNameOrId: string,
        moveToColumnVisibleIndex: number,
        moveBefore: boolean
      ): void;
      nextPage(): void;
      performCallback(data: any): Promise<void>;
      performCallback(data: any, onSuccess: () => void): void;
      prevPage(): void;
      refresh(): void;
      selectAllCardsOnPage(): void;
      selectCardOnPage(visibleIndex: number): void;
      selectCardOnPage(visibleIndex: number, selected: boolean): void;
      selectCards(): void;
      selectCardsByKey(keys: any[]): void;
      selectCardsByKey(key: any): void;
      selectCardsByKey(keys: any[], selected: boolean): void;
      selectCardsByKey(key: any, selected: boolean): void;
      setEditValue(
        column: AspNetCore$BootstrapCardViewColumn,
        value: string
      ): void;
      setEditValue(columnIndex: number, value: string): void;
      setEditValue(columnFieldNameOrId: string, value: string): void;
      setFilterEnabled(isFilterEnabled: boolean): void;
      setFocusedCardIndex(visibleIndex: number): void;
      setFocusedCell(cardVisibleIndex: number, columnIndex: number): void;
      setSearchPanelCustomEditor(
        editor: DevExpress$AspNetCore$BootstrapClientEdit
      ): void;
      setVerticalScrollPosition(position: number): void;
      showCustomizationWindow(): void;
      showFilterControl(): void;
      sortBy(column: AspNetCore$BootstrapCardViewColumn): void;
      sortBy(columnIndex: number): void;
      sortBy(columnFieldNameOrId: string): void;
      sortBy(column: AspNetCore$BootstrapCardViewColumn, sortOrder: string): void;
      sortBy(columnIndex: number, sortOrder: string): void;
      sortBy(columnFieldNameOrId: string, sortOrder: string): void;
      sortBy(
        column: AspNetCore$BootstrapCardViewColumn,
        sortOrder: string,
        reset: boolean
      ): void;
      sortBy(columnIndex: number, sortOrder: string, reset: boolean): void;
      sortBy(
        columnFieldNameOrId: string,
        sortOrder: string,
        reset: boolean
      ): void;
      sortBy(
        column: AspNetCore$BootstrapCardViewColumn,
        sortOrder: string,
        reset: boolean,
        sortIndex: number
      ): void;
      sortBy(
        columnIndex: number,
        sortOrder: string,
        reset: boolean,
        sortIndex: number
      ): void;
      sortBy(
        columnFieldNameOrId: string,
        sortOrder: string,
        reset: boolean,
        sortIndex: number
      ): void;
      startEditCard(visibleIndex: number): void;
      startEditCardByKey(key: any): void;
      unselectAllCardsOnPage(): void;
      unselectCardOnPage(visibleIndex: number): void;
      unselectCards(): void;
      unselectCardsByKey(keys: any[]): void;
      unselectCardsByKey(key: any): void;
      unselectFilteredCards(): void;
      updateEdit(): void;
      on<K: $Keys<AspNetCore$BootstrapCardViewEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapCardViewEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapCardViewEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapCardViewEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapCardViewEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapCardViewEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapCardViewEventMap = {
      batchEditCardDeleting: DevExpress$AspNetCore$CardViewBatchEditCardDeletingEventArgs,
      batchEditCardInserting: DevExpress$AspNetCore$CardViewBatchEditCardInsertingEventArgs,
      batchEditCardValidating: DevExpress$AspNetCore$CardViewBatchEditCardValidatingEventArgs,
      batchEditChangesCanceling: DevExpress$AspNetCore$CardViewBatchEditChangesCancelingEventArgs,
      batchEditChangesSaving: DevExpress$AspNetCore$CardViewBatchEditChangesSavingEventArgs,
      batchEditConfirmShowing: DevExpress$AspNetCore$CardViewBatchEditConfirmShowingEventArgs,
      batchEditEndEditing: DevExpress$AspNetCore$CardViewBatchEditEndEditingEventArgs,
      batchEditStartEditing: DevExpress$AspNetCore$CardViewBatchEditStartEditingEventArgs,
      batchEditTemplateCellFocused: DevExpress$AspNetCore$CardViewBatchEditTemplateCellFocusedEventArgs,
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      cardClick: DevExpress$AspNetCore$CardViewCardClickEventArgs,
      cardDblClick: DevExpress$AspNetCore$CardViewCardClickEventArgs,
      cardFocusing: DevExpress$AspNetCore$CardViewCardFocusingEventArgs,
      columnSorting: DevExpress$AspNetCore$CardViewColumnCancelEventArgs,
      customButtonClick: DevExpress$AspNetCore$CardViewCustomButtonEventArgs,
      customizationWindowCloseUp: DevExpress$AspNetCore$EventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      focusedCardChanged: DevExpress$AspNetCore$CardViewFocusEventArgs,
      focusedCellChanging: DevExpress$AspNetCore$CardViewFocusedCellChangingEventArgs,
      selectionChanged: DevExpress$AspNetCore$CardViewSelectionEventArgs
    } & BootstrapGridBaseEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapCardViewBatchEditApi {
      instance: any;
      constructor(instance: any): this;
      addNewCard(): void;
      deleteCard(visibleIndex: number): void;
      deleteCardByKey(key: any): void;
      getCardVisibleIndices(includeDeleted: boolean): number[];
      getDeletedCardIndices(): number[];
      getInsertedCardIndices(): number[];
      isDeletedCard(visibleIndex: number): boolean;
      isNewCard(visibleIndex: number): boolean;
      recoverCard(visibleIndex: number): void;
      recoverCardByKey(key: any): void;
      validateCard(visibleIndex: number): boolean;
      validateCards(validateOnlyModified: boolean): boolean;
    }
  
    declare class DevExpress$AspNetCore$BootstrapCardViewColumn {
      instance: any;
      constructor(instance: any): this;
    }
  
    declare class DevExpress$AspNetCore$BootstrapCardViewCellInfo {
      instance: any;
      constructor(instance: any): this;
      cardVisibleIndex: number;
      endEdit(): void;
      getCellTextContainer(
        visibleIndex: number,
        columnFieldNameOrId: string
      ): any;
      getCellValue(
        visibleIndex: number,
        columnFieldNameOrId: string,
        initial: boolean
      ): any;
      getColumnDisplayText(columnFieldNameOrId: string, value: any): string;
      getEditCellInfo(): DevExpress$AspNetCore$BootstrapCardViewCellInfo | null;
      hasChanges(): boolean;
      moveFocusBackward(): boolean;
      moveFocusForward(): boolean;
      resetChanges(visibleIndex: number): void;
      resetChanges(visibleIndex: number, columnIndex: number): void;
      setCellValue(
        visibleIndex: number,
        columnFieldNameOrId: string,
        value: any
      ): void;
      setCellValue(
        visibleIndex: number,
        columnFieldNameOrId: string,
        value: any,
        displayText: string,
        cancelCellHighlighting: boolean
      ): void;
      startEdit(visibleIndex: number, columnIndex: number): void;
    }
  
    declare type DevExpress$AspNetCore$BootstrapChartEventArgsBase = {
      +component: any,
      +element: any
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$BootstrapChartErrorEventArgs = {
      +target: any
    } & BootstrapChartEventArgsBase;
  
    declare type DevExpress$AspNetCore$BootstrapChartElementActionEventArgs = {
      +target: any
    } & BootstrapChartEventArgsBase;
  
    declare type DevExpress$AspNetCore$BootstrapChartElementClickEventArgs = {
      +jQueryEvent: any
    } & BootstrapChartElementActionEventArgs;
  
    declare type DevExpress$AspNetCore$BootstrapChartExportEventArgs = {
      cancel: boolean,
      +data: any,
      +fileName: string,
      +format: string
    } & BootstrapChartEventArgsBase;
  
    declare type DevExpress$AspNetCore$BootstrapChartOptionChangedEventArgs = {
      +fullName: string,
      +name: string,
      +previousValue: any,
      +value: any
    } & BootstrapChartEventArgsBase;
  
    declare type DevExpress$AspNetCore$BootstrapChartZoomEndEventArgs = {
      +rangeEnd: any,
      +rangeStart: any
    } & BootstrapChartEventArgsBase;
  
    declare class DevExpress$AspNetCore$BootstrapChart mixins Control {
      exportTo(format: string, fileName: string): void;
      getDataSource(): any;
      getInstance(): any;
      print(): void;
      setDataSource(dataSource: any): void;
      setOptions(options: any): void;
      on<K: $Keys<AspNetCore$BootstrapChartEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapChartEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapChartEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapChartEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapChartEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapChartEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapChartEventMap = {
      argumentAxisClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      disposing: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      done: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      drawn: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      exported: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      exporting: DevExpress$AspNetCore$BootstrapChartExportEventArgs,
      fileSaving: DevExpress$AspNetCore$BootstrapChartExportEventArgs,
      incidentOccurred: DevExpress$AspNetCore$BootstrapChartErrorEventArgs,
      init: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      legendClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      optionChanged: DevExpress$AspNetCore$BootstrapChartOptionChangedEventArgs,
      pointClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      pointHoverChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      pointSelectionChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      seriesClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      seriesHoverChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      seriesSelectionChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      tooltipHidden: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      tooltipShown: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      zoomEnd: DevExpress$AspNetCore$BootstrapChartZoomEndEventArgs,
      zoomStart: DevExpress$AspNetCore$BootstrapChartEventArgsBase
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapPolarChart mixins Control {
      exportTo(format: string, fileName: string): void;
      getDataSource(): any;
      getInstance(): any;
      print(): void;
      setDataSource(dataSource: any): void;
      setOptions(options: any): void;
      on<K: $Keys<AspNetCore$BootstrapPolarChartEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPolarChartEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapPolarChartEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPolarChartEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapPolarChartEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapPolarChartEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapPolarChartEventMap = {
      argumentAxisClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      disposing: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      done: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      drawn: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      exported: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      exporting: DevExpress$AspNetCore$BootstrapChartExportEventArgs,
      fileSaving: DevExpress$AspNetCore$BootstrapChartExportEventArgs,
      incidentOccurred: DevExpress$AspNetCore$BootstrapChartErrorEventArgs,
      init: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      legendClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      optionChanged: DevExpress$AspNetCore$BootstrapChartOptionChangedEventArgs,
      pointClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      pointHoverChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      pointSelectionChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      seriesClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      seriesHoverChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      seriesSelectionChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      tooltipHidden: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      tooltipShown: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapPieChart mixins Control {
      exportTo(format: string, fileName: string): void;
      getDataSource(): any;
      getInstance(): any;
      print(): void;
      setDataSource(dataSource: any): void;
      setOptions(options: any): void;
      on<K: $Keys<AspNetCore$BootstrapPieChartEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPieChartEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapPieChartEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPieChartEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapPieChartEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapPieChartEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapPieChartEventMap = {
      disposing: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      done: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      drawn: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      exported: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      exporting: DevExpress$AspNetCore$BootstrapChartExportEventArgs,
      fileSaving: DevExpress$AspNetCore$BootstrapChartExportEventArgs,
      incidentOccurred: DevExpress$AspNetCore$BootstrapChartErrorEventArgs,
      init: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      legendClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      optionChanged: DevExpress$AspNetCore$BootstrapChartOptionChangedEventArgs,
      pointClick: DevExpress$AspNetCore$BootstrapChartElementClickEventArgs,
      pointHoverChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      pointSelectionChanged: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      tooltipHidden: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs,
      tooltipShown: DevExpress$AspNetCore$BootstrapChartElementActionEventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapCheckBox
      mixins BootstrapClientEdit {
      getCheckState(): string;
      getChecked(): boolean;
      getText(): string;
      setCheckState(checkState: string): void;
      setChecked(isChecked: boolean): void;
      setText(text: string): void;
      on<K: $Keys<AspNetCore$BootstrapCheckBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapCheckBoxEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapCheckBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapCheckBoxEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapCheckBoxEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapCheckBoxEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapCheckBoxEventMap = {
      checkedChanged: DevExpress$AspNetCore$ProcessingModeEventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapRadioButton
      mixins BootstrapClientEdit {
      getCheckState(): string;
      getChecked(): boolean;
      getText(): string;
      setCheckState(checkState: string): void;
      setChecked(isChecked: boolean): void;
      setText(text: string): void;
      on<K: $Keys<AspNetCore$BootstrapRadioButtonEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapRadioButtonEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapRadioButtonEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapRadioButtonEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapRadioButtonEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapRadioButtonEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapRadioButtonEventMap = {
      checkedChanged: DevExpress$AspNetCore$ProcessingModeEventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapComboBox
      mixins BootstrapClientEdit {
      addItem(texts: string[]): number;
      addItem(text: string): number;
      addItem(texts: string[], value: any): number;
      addItem(text: string, value: any): number;
      addItem(texts: string[], value: any, iconCssClass: string): number;
      addItem(text: string, value: any, iconCssClass: string): number;
      addItemCssClass(index: number, className: string): void;
      addItemTextCellCssClass(
        itemIndex: number,
        textCellIndex: number,
        className: string
      ): void;
      adjustDropDownWindow(): void;
      beginUpdate(): void;
      clearItems(): void;
      endUpdate(): void;
      ensureDropDownLoaded(callbackFunction: any): void;
      findItemByText(text: string): AspNetCore$BootstrapListBoxItem | null;
      findItemByValue(value: any): AspNetCore$BootstrapListBoxItem | null;
      getButtonVisible(number: number): boolean;
      getCaretPosition(): number;
      getItem(index: number): AspNetCore$BootstrapListBoxItem | null;
      getItemBadgeIconCssClass(index: number): string;
      getItemBadgeText(index: number): string;
      getItemCount(): number;
      getSelectedIndex(): number;
      getSelectedItem(): AspNetCore$BootstrapListBoxItem | null;
      getText(): string;
      hideDropDown(): void;
      insertItem(index: number, texts: string[]): void;
      insertItem(index: number, text: string): void;
      insertItem(index: number, texts: string[], value: any): void;
      insertItem(index: number, text: string, value: any): void;
      insertItem(
        index: number,
        texts: string[],
        value: any,
        iconCssClass: string
      ): void;
      insertItem(
        index: number,
        text: string,
        value: any,
        iconCssClass: string
      ): void;
      makeItemVisible(index: number): void;
      performCallback(data: any): Promise<void>;
      performCallback(data: any, onSuccess: () => void): void;
      removeItem(index: number): void;
      removeItemCssClass(index: number, className: string): void;
      removeItemTextCellCssClass(
        itemIndex: number,
        textCellIndex: number,
        className: string
      ): void;
      selectAll(): void;
      setButtonVisible(number: number, value: boolean): void;
      setCaretPosition(position: number): void;
      setItemBadgeIconCssClass(index: number, cssClass: string): void;
      setItemBadgeText(index: number, text: string): void;
      setItemHtml(index: number, html: string): void;
      setItemTextCellHtml(
        itemIndex: number,
        textCellIndex: number,
        html: string
      ): void;
      setItemTextCellTooltip(
        itemIndex: number,
        textCellIndex: number,
        tooltip: string
      ): void;
      setItemTooltip(index: number, tooltip: string): void;
      setSelectedIndex(index: number): void;
      setSelectedItem(item: AspNetCore$BootstrapListBoxItem): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setText(text: string, applyFilter: boolean): void;
      showDropDown(): void;
      on<K: $Keys<AspNetCore$BootstrapComboBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapComboBoxEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapComboBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapComboBoxEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapComboBoxEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapComboBoxEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapComboBoxEventMap = {
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      buttonClick: AspNetCore$ButtonEditClickEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      closeUp: DevExpress$AspNetCore$EventArgs,
      customHighlighting: AspNetCore$ListEditCustomHighlightingEventArgs,
      dropDown: DevExpress$AspNetCore$EventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      itemFiltering: AspNetCore$ListEditItemFilteringEventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      queryCloseUp: DevExpress$AspNetCore$CancelEventArgs,
      selectedIndexChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare type DevExpress$AspNetCore$ParseDateEventArgs = {
      +date: Date,
      +handled: boolean,
      +value: string
    } & EventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapDateEdit
      mixins BootstrapClientEdit {
      adjustDropDownWindow(): void;
      getButtonVisible(number: number): boolean;
      getCalendar(): DevExpress$AspNetCore$BootstrapCalendar | null;
      getCaretPosition(): number;
      getDate(): Date;
      getMaxDate(): Date;
      getMinDate(): Date;
      getRangeDayCount(): number;
      getText(): string;
      getTimeEdit(): AspNetCore$BootstrapTimeEdit | null;
      hideDropDown(): void;
      selectAll(): void;
      setButtonVisible(number: number, value: boolean): void;
      setCaretPosition(position: number): void;
      setDate(date: Date): void;
      setMaxDate(date: Date): void;
      setMinDate(date: Date): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setText(text: string): void;
      showDropDown(): void;
      on<K: $Keys<AspNetCore$BootstrapDateEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapDateEditEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapDateEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapDateEditEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapDateEditEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapDateEditEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapDateEditEventMap = {
      buttonClick: AspNetCore$ButtonEditClickEventArgs,
      calendarCustomDisabledDate: DevExpress$AspNetCore$CalendarCustomDisabledDateEventArgs,
      closeUp: DevExpress$AspNetCore$EventArgs,
      dateChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      dropDown: DevExpress$AspNetCore$EventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      parseDate: DevExpress$AspNetCore$ParseDateEventArgs,
      queryCloseUp: DevExpress$AspNetCore$CancelEventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapDropDownEdit
      mixins BootstrapClientEdit {
      adjustDropDownWindow(): void;
      getButtonVisible(number: number): boolean;
      getCaretPosition(): number;
      getKeyValue(): string;
      getText(): string;
      hideDropDown(): void;
      selectAll(): void;
      setButtonVisible(number: number, value: boolean): void;
      setCaretPosition(position: number): void;
      setKeyValue(keyValue: string): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setText(text: string): void;
      showDropDown(): void;
      on<K: $Keys<AspNetCore$BootstrapDropDownEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapDropDownEditEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapDropDownEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapDropDownEditEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapDropDownEditEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapDropDownEditEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapDropDownEditEventMap = {
      buttonClick: AspNetCore$ButtonEditClickEventArgs,
      closeUp: DevExpress$AspNetCore$EventArgs,
      dropDown: DevExpress$AspNetCore$EventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      queryCloseUp: DevExpress$AspNetCore$CancelEventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapFormLayout mixins Control {
      getItemByName(name: string): AspNetCore$BootstrapFormLayoutItem | null;
      on<K: $Keys<AspNetCore$BootstrapFormLayoutEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapFormLayoutEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapFormLayoutEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapFormLayoutEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapFormLayoutEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapFormLayoutEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapFormLayoutEventMap = {} & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapFormLayoutItem {
      instance: any;
      constructor(instance: any): this;
      formLayout: DevExpress$AspNetCore$BootstrapFormLayout | null;
      name: string;
      parent: DevExpress$AspNetCore$BootstrapFormLayoutItem | null;
      getCaption(): string;
      getItemByName(
        name: string
      ): DevExpress$AspNetCore$BootstrapFormLayoutItem | null;
      getVisible(): boolean;
      setCaption(caption: string): void;
      setVisible(value: boolean): void;
    }
  
    declare type DevExpress$AspNetCore$GridViewColumnCancelEventArgs = {
      +column: AspNetCore$BootstrapGridViewColumn
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewColumnProcessingModeEventArgs = {
      +column: AspNetCore$BootstrapGridViewColumn
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewRowCancelEventArgs = {
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewSelectionEventArgs = {
      +isAllRecordsOnPage: boolean,
      +isChangedOnServer: boolean,
      +isSelected: boolean,
      +visibleIndex: number
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewFocusEventArgs = {
      +isChangedOnServer: boolean
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewRowFocusingEventArgs = {
      +htmlEvent: any
    } & GridViewRowCancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewRowClickEventArgs = {
      +htmlEvent: any
    } & GridViewRowCancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewContextMenuEventArgs = {
      +htmlEvent: any,
      +index: number,
      +menu: any,
      +objectType: string,
      showBrowserMenu: boolean
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$GridViewContextMenuItemClickEventArgs = {
      +elementIndex: number,
      handled: boolean,
      +item: AspNetCore$BootstrapMenuItem,
      +objectType: string,
      usePostBack: boolean
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewCustomButtonEventArgs = {
      +buttonID: string,
      +visibleIndex: number
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewColumnMovingEventArgs = {
      allow: boolean,
      +destinationColumn: AspNetCore$BootstrapGridViewColumn,
      +isDropBefore: boolean,
      +isGroupPanel: boolean,
      +sourceColumn: AspNetCore$BootstrapGridViewColumn
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditConfirmShowingEventArgs = {
      +requestTriggerID: string
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditStartEditingEventArgs = {
      focusedColumn: AspNetCore$BootstrapGridViewColumn,
      +rowValues: any,
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditEndEditingEventArgs = {
      +rowValues: any,
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditRowValidatingEventArgs = {
      +validationInfo: any,
      +visibleIndex: number
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditTemplateCellFocusedEventArgs = {
      +column: AspNetCore$BootstrapGridViewColumn,
      handled: boolean
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditChangesSavingEventArgs = {
      +deletedValues: any,
      +insertedValues: any,
      +updatedValues: any
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditChangesCancelingEventArgs = {
      +deletedValues: any,
      +insertedValues: any,
      +updatedValues: any
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditRowInsertingEventArgs = {
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewBatchEditRowDeletingEventArgs = {
      +rowValues: any,
      +visibleIndex: number
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$GridViewFocusedCellChangingEventArgs = {
      +cellInfo: AspNetCore$BootstrapGridViewCellInfo
    } & CancelEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapGridView
      mixins BootstrapGridBase {
      batchEditApi: AspNetCore$BootstrapGridViewBatchEditApi | null;
      addNewRow(): void;
      applyFilter(filterExpression: string): void;
      applyOnClickRowFilter(): void;
      applySearchPanelFilter(value: string): void;
      autoFilterByColumn(
        column: AspNetCore$BootstrapGridViewColumn,
        val: string
      ): void;
      autoFilterByColumn(columnIndex: number, val: string): void;
      autoFilterByColumn(columnFieldNameOrId: string, val: string): void;
      cancelEdit(): void;
      clearFilter(): void;
      closeFilterControl(): void;
      collapseAll(): void;
      collapseAllDetailRows(): void;
      collapseDetailRow(visibleIndex: number): void;
      collapseRow(visibleIndex: number): void;
      collapseRow(visibleIndex: number, recursive: boolean): void;
      deleteRow(visibleIndex: number): void;
      deleteRowByKey(key: any): void;
      expandAll(): void;
      expandAllDetailRows(): void;
      expandDetailRow(visibleIndex: number): void;
      expandRow(visibleIndex: number): void;
      expandRow(visibleIndex: number, recursive: boolean): void;
      focus(): void;
      focusEditor(column: AspNetCore$BootstrapGridViewColumn): void;
      focusEditor(columnIndex: number): void;
      focusEditor(columnFieldNameOrId: string): void;
      getAutoFilterEditor(column: AspNetCore$BootstrapGridViewColumn): any;
      getAutoFilterEditor(columnIndex: number): any;
      getAutoFilterEditor(columnFieldNameOrId: string): any;
      getColumn(columnIndex: number): AspNetCore$BootstrapGridViewColumn | null;
      getColumnByField(
        columnFieldName: string
      ): AspNetCore$BootstrapGridViewColumn | null;
      getColumnById(columnId: string): AspNetCore$BootstrapGridViewColumn | null;
      getColumnCount(): number;
      getColumnLayout(): any;
      getEditValue(column: AspNetCore$BootstrapGridViewColumn): string;
      getEditValue(columnIndex: number): string;
      getEditValue(columnFieldNameOrId: string): string;
      getEditor(
        column: AspNetCore$BootstrapGridViewColumn
      ): DevExpress$AspNetCore$BootstrapClientEdit;
      getEditor(columnIndex: number): DevExpress$AspNetCore$BootstrapClientEdit;
      getEditor(
        columnFieldNameOrId: string
      ): DevExpress$AspNetCore$BootstrapClientEdit;
      getFocusedCell(): AspNetCore$BootstrapGridViewCellInfo | null;
      getFocusedRowIndex(): number;
      getHorizontalScrollPosition(): number;
      getPageCount(): number;
      getPageIndex(): number;
      getPopupEditForm(): AspNetCore$BootstrapPopupControl | null;
      getRowIndicesVisibleInViewPort(includePartiallyVisible: boolean): number[];
      getRowKey(visibleIndex: number): string;
      getSelectedKeysOnPage(): any[];
      getSelectedRowCount(): number;
      getTopVisibleIndex(): number;
      getVerticalScrollPosition(): number;
      getVisibleRowsOnPage(): number;
      gotoPage(pageIndex: number): void;
      groupBy(column: AspNetCore$BootstrapGridViewColumn): void;
      groupBy(columnIndex: number): void;
      groupBy(columnFieldNameOrId: string): void;
      groupBy(
        column: AspNetCore$BootstrapGridViewColumn,
        groupIndex: number
      ): void;
      groupBy(columnIndex: number, groupIndex: number): void;
      groupBy(columnFieldNameOrId: string, groupIndex: number): void;
      groupBy(
        column: AspNetCore$BootstrapGridViewColumn,
        groupIndex: number,
        sortOrder: string
      ): void;
      groupBy(columnIndex: number, groupIndex: number, sortOrder: string): void;
      groupBy(
        columnFieldNameOrId: string,
        groupIndex: number,
        sortOrder: string
      ): void;
      hideCustomizationWindow(): void;
      isCustomizationWindowVisible(): boolean;
      isDataRow(visibleIndex: number): boolean;
      isEditing(): boolean;
      isGroupRow(visibleIndex: number): boolean;
      isGroupRowExpanded(visibleIndex: number): boolean;
      isNewRowEditing(): boolean;
      isRowSelectedOnPage(visibleIndex: number): boolean;
      makeRowVisible(visibleIndex: number): void;
      nextPage(): void;
      performCallback(data: any): Promise<void>;
      performCallback(data: any, onSuccess: () => void): void;
      prevPage(): void;
      refresh(): void;
      selectAllRowsOnPage(): void;
      selectRowOnPage(visibleIndex: number): void;
      selectRowOnPage(visibleIndex: number, selected: boolean): void;
      selectRows(): void;
      selectRowsByKey(keys: any[]): void;
      selectRowsByKey(key: any): void;
      selectRowsByKey(keys: any[], selected: boolean): void;
      selectRowsByKey(key: any, selected: boolean): void;
      setColumnLayout(columnLayout: any): void;
      setEditValue(
        column: AspNetCore$BootstrapGridViewColumn,
        value: string
      ): void;
      setEditValue(columnIndex: number, value: string): void;
      setEditValue(columnFieldNameOrId: string, value: string): void;
      setFilterEnabled(isFilterEnabled: boolean): void;
      setFixedColumnScrollableRows(scrollableRowSettings: any): void;
      setFocusedCell(rowVisibleIndex: number, columnIndex: number): void;
      setFocusedRowIndex(visibleIndex: number): void;
      setHorizontalScrollPosition(position: number): void;
      setSearchPanelCustomEditor(
        editor: DevExpress$AspNetCore$BootstrapClientEdit
      ): void;
      setVerticalScrollPosition(position: number): void;
      showCustomizationDialog(): void;
      showCustomizationWindow(): void;
      showFilterControl(): void;
      sortBy(column: AspNetCore$BootstrapGridViewColumn): void;
      sortBy(columnIndex: number): void;
      sortBy(columnFieldNameOrId: string): void;
      sortBy(column: AspNetCore$BootstrapGridViewColumn, sortOrder: string): void;
      sortBy(columnIndex: number, sortOrder: string): void;
      sortBy(columnFieldNameOrId: string, sortOrder: string): void;
      sortBy(
        column: AspNetCore$BootstrapGridViewColumn,
        sortOrder: string,
        reset: boolean
      ): void;
      sortBy(columnIndex: number, sortOrder: string, reset: boolean): void;
      sortBy(
        columnFieldNameOrId: string,
        sortOrder: string,
        reset: boolean
      ): void;
      sortBy(
        column: AspNetCore$BootstrapGridViewColumn,
        sortOrder: string,
        reset: boolean,
        sortIndex: number
      ): void;
      sortBy(
        columnIndex: number,
        sortOrder: string,
        reset: boolean,
        sortIndex: number
      ): void;
      sortBy(
        columnFieldNameOrId: string,
        sortOrder: string,
        reset: boolean,
        sortIndex: number
      ): void;
      startEditRow(visibleIndex: number): void;
      startEditRowByKey(key: any): void;
      ungroup(column: AspNetCore$BootstrapGridViewColumn): void;
      ungroup(columnIndex: number): void;
      ungroup(columnFieldNameOrId: string): void;
      unselectAllRowsOnPage(): void;
      unselectFilteredRows(): void;
      unselectRowOnPage(visibleIndex: number): void;
      unselectRows(): void;
      unselectRowsByKey(keys: any[]): void;
      unselectRowsByKey(key: any): void;
      updateEdit(): void;
      on<K: $Keys<AspNetCore$BootstrapGridViewEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapGridViewEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapGridViewEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapGridViewEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapGridViewEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapGridViewEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapGridViewEventMap = {
      batchEditChangesCanceling: DevExpress$AspNetCore$GridViewBatchEditChangesCancelingEventArgs,
      batchEditChangesSaving: DevExpress$AspNetCore$GridViewBatchEditChangesSavingEventArgs,
      batchEditConfirmShowing: DevExpress$AspNetCore$GridViewBatchEditConfirmShowingEventArgs,
      batchEditEndEditing: DevExpress$AspNetCore$GridViewBatchEditEndEditingEventArgs,
      batchEditRowDeleting: DevExpress$AspNetCore$GridViewBatchEditRowDeletingEventArgs,
      batchEditRowInserting: DevExpress$AspNetCore$GridViewBatchEditRowInsertingEventArgs,
      batchEditRowValidating: DevExpress$AspNetCore$GridViewBatchEditRowValidatingEventArgs,
      batchEditStartEditing: DevExpress$AspNetCore$GridViewBatchEditStartEditingEventArgs,
      batchEditTemplateCellFocused: DevExpress$AspNetCore$GridViewBatchEditTemplateCellFocusedEventArgs,
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      columnGrouping: DevExpress$AspNetCore$GridViewColumnCancelEventArgs,
      columnMoving: DevExpress$AspNetCore$GridViewColumnMovingEventArgs,
      columnResized: DevExpress$AspNetCore$GridViewColumnProcessingModeEventArgs,
      columnResizing: DevExpress$AspNetCore$GridViewColumnCancelEventArgs,
      columnSorting: DevExpress$AspNetCore$GridViewColumnCancelEventArgs,
      columnStartDragging: DevExpress$AspNetCore$GridViewColumnCancelEventArgs,
      contextMenu: DevExpress$AspNetCore$GridViewContextMenuEventArgs,
      contextMenuItemClick: DevExpress$AspNetCore$GridViewContextMenuItemClickEventArgs,
      customButtonClick: DevExpress$AspNetCore$GridViewCustomButtonEventArgs,
      customizationWindowCloseUp: DevExpress$AspNetCore$EventArgs,
      detailRowCollapsing: DevExpress$AspNetCore$GridViewRowCancelEventArgs,
      detailRowExpanding: DevExpress$AspNetCore$GridViewRowCancelEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      focusedCellChanging: DevExpress$AspNetCore$GridViewFocusedCellChangingEventArgs,
      focusedRowChanged: DevExpress$AspNetCore$GridViewFocusEventArgs,
      rowClick: DevExpress$AspNetCore$GridViewRowClickEventArgs,
      rowCollapsing: DevExpress$AspNetCore$GridViewRowCancelEventArgs,
      rowDblClick: DevExpress$AspNetCore$GridViewRowClickEventArgs,
      rowExpanding: DevExpress$AspNetCore$GridViewRowCancelEventArgs,
      rowFocusing: DevExpress$AspNetCore$GridViewRowFocusingEventArgs,
      selectionChanged: DevExpress$AspNetCore$GridViewSelectionEventArgs
    } & BootstrapGridBaseEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapGridViewBatchEditApi {
      instance: any;
      constructor(instance: any): this;
      addNewRow(): void;
      deleteRow(visibleIndex: number): void;
      deleteRowByKey(key: any): void;
      endEdit(): void;
      getCellTextContainer(
        visibleIndex: number,
        columnFieldNameOrId: string
      ): any;
      getCellValue(
        visibleIndex: number,
        columnFieldNameOrId: string,
        initial: boolean
      ): any;
      getColumnDisplayText(columnFieldNameOrId: string, value: any): string;
      getDeletedRowIndices(): number[];
      getEditCellInfo(): AspNetCore$BootstrapGridViewCellInfo | null;
      getInsertedRowIndices(): number[];
      getRowVisibleIndices(includeDeleted: boolean): number[];
      hasChanges(): boolean;
      isDeletedRow(visibleIndex: number): boolean;
      isNewRow(visibleIndex: number): boolean;
      moveFocusBackward(): boolean;
      moveFocusForward(): boolean;
      recoverRow(visibleIndex: number): void;
      recoverRowByKey(key: any): void;
      resetChanges(visibleIndex: number): void;
      resetChanges(visibleIndex: number, columnIndex: number): void;
      setCellValue(
        visibleIndex: number,
        columnFieldNameOrId: string,
        value: any
      ): void;
      setCellValue(
        visibleIndex: number,
        columnFieldNameOrId: string,
        value: any,
        displayText: string,
        cancelCellHighlighting: boolean
      ): void;
      startEdit(visibleIndex: number, columnIndex: number): void;
      validateRow(visibleIndex: number): boolean;
      validateRows(validateOnlyModified: boolean): boolean;
    }
  
    declare class DevExpress$AspNetCore$BootstrapGridViewColumn {
      instance: any;
      constructor(instance: any): this;
      fieldName: string;
      index: number;
      name: string;
      visible: boolean;
    }
  
    declare class DevExpress$AspNetCore$BootstrapGridViewCellInfo {
      instance: any;
      constructor(instance: any): this;
      rowVisibleIndex: number;
    }
  
    declare class DevExpress$AspNetCore$BootstrapHyperLink mixins Control {
      getBadgeIconCssClass(): string;
      getBadgeText(): string;
      getCaption(): string;
      getEnabled(): boolean;
      getNavigateUrl(): string;
      getText(): string;
      getValue(): any;
      setBadgeIconCssClass(cssClass: string): void;
      setBadgeText(text: string): void;
      setCaption(caption: string): void;
      setEnabled(value: boolean): void;
      setNavigateUrl(url: string): void;
      setText(text: string): void;
      setValue(value: any): void;
      on<K: $Keys<AspNetCore$BootstrapHyperLinkEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapHyperLinkEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapHyperLinkEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapHyperLinkEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapHyperLinkEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapHyperLinkEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapHyperLinkEventMap = {
      click: DevExpress$AspNetCore$EditClickEventArgs
    } & ControlEventMap;
  
    declare type DevExpress$AspNetCore$ListEditItemSelectedChangedEventArgs = {
      +index: number,
      +isSelected: boolean
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$ListEditCustomHighlightingEventArgs = {
      +filter: string,
      highlighting: any
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$ListEditItemFilteringEventArgs = {
      +filter: string,
      isFit: boolean,
      +item: AspNetCore$BootstrapListBoxItem
    } & EventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapListBox
      mixins BootstrapClientEdit {
      addItem(texts: string[]): number;
      addItem(text: string): number;
      addItem(texts: string[], value: any): number;
      addItem(text: string, value: any): number;
      addItem(texts: string[], value: any, iconCssClass: string): number;
      addItem(text: string, value: any, iconCssClass: string): number;
      addItemCssClass(index: number, className: string): void;
      addItemTextCellCssClass(
        itemIndex: number,
        textCellIndex: number,
        className: string
      ): void;
      beginUpdate(): void;
      clearItems(): void;
      endUpdate(): void;
      findItemByText(text: string): AspNetCore$BootstrapListBoxItem | null;
      findItemByValue(value: any): AspNetCore$BootstrapListBoxItem | null;
      getItem(index: number): AspNetCore$BootstrapListBoxItem | null;
      getItemBadgeIconCssClass(index: number): string;
      getItemBadgeText(index: number): string;
      getItemCount(): number;
      getSelectedIndex(): number;
      getSelectedIndices(): number[];
      getSelectedItem(): AspNetCore$BootstrapListBoxItem | null;
      getSelectedItems(): AspNetCore$BootstrapListBoxItem[];
      getSelectedValues(): any[];
      insertItem(index: number, texts: string[]): void;
      insertItem(index: number, text: string): void;
      insertItem(index: number, texts: string[], value: any): void;
      insertItem(index: number, text: string, value: any): void;
      insertItem(
        index: number,
        texts: string[],
        value: any,
        iconCssClass: string
      ): void;
      insertItem(
        index: number,
        text: string,
        value: any,
        iconCssClass: string
      ): void;
      makeItemVisible(index: number): void;
      performCallback(data: any): Promise<void>;
      performCallback(data: any, onSuccess: () => void): void;
      removeItem(index: number): void;
      removeItemCssClass(index: number, className: string): void;
      removeItemTextCellCssClass(
        itemIndex: number,
        textCellIndex: number,
        className: string
      ): void;
      selectAll(): void;
      selectIndices(indices: number[]): void;
      selectItems(items: AspNetCore$BootstrapListBoxItem[]): void;
      selectValues(values: any[]): void;
      setItemBadgeIconCssClass(index: number, cssClass: string): void;
      setItemBadgeText(index: number, text: string): void;
      setItemHtml(index: number, html: string): void;
      setItemTextCellHtml(
        itemIndex: number,
        textCellIndex: number,
        html: string
      ): void;
      setItemTextCellTooltip(
        itemIndex: number,
        textCellIndex: number,
        tooltip: string
      ): void;
      setItemTooltip(index: number, tooltip: string): void;
      setSelectedIndex(index: number): void;
      setSelectedItem(item: AspNetCore$BootstrapListBoxItem): void;
      unselectAll(): void;
      unselectIndices(indices: number[]): void;
      unselectItems(items: AspNetCore$BootstrapListBoxItem[]): void;
      unselectValues(values: any[]): void;
      on<K: $Keys<AspNetCore$BootstrapListBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapListBoxEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapListBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapListBoxEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapListBoxEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapListBoxEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapListBoxEventMap = {
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      customHighlighting: DevExpress$AspNetCore$ListEditCustomHighlightingEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      itemDoubleClick: DevExpress$AspNetCore$EventArgs,
      itemFiltering: DevExpress$AspNetCore$ListEditItemFilteringEventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      selectedIndexChanged: DevExpress$AspNetCore$ProcessingModeEventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapListBoxItem {
      instance: any;
      constructor(instance: any): this;
      iconCssClass: string;
      imageUrl: string;
      index: number;
      listEditBase: DevExpress$AspNetCore$BootstrapListBox | null;
      text: string;
      value: any;
      getColumnText(columnIndex: number): string;
      getColumnText(columnName: string): string;
      getFieldText(fieldIndex: number): string;
      getFieldText(fieldName: string): string;
    }
  
    declare class DevExpress$AspNetCore$BootstrapCheckBoxList
      mixins BootstrapListBox {
      getItem(index: number): DevExpress$AspNetCore$BootstrapListBoxItem | null;
      getItemCount(): number;
      getSelectedIndices(): number[];
      getSelectedItems(): DevExpress$AspNetCore$BootstrapListBoxItem[];
      getSelectedValues(): any[];
      selectAll(): void;
      selectIndices(indices: number[]): void;
      selectItems(items: DevExpress$AspNetCore$BootstrapListBoxItem[]): void;
      selectValues(values: any[]): void;
      unselectAll(): void;
      unselectIndices(indices: number[]): void;
      unselectItems(items: DevExpress$AspNetCore$BootstrapListBoxItem[]): void;
      unselectValues(values: any[]): void;
      on<K: $Keys<AspNetCore$BootstrapCheckBoxListEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapCheckBoxListEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapCheckBoxListEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapCheckBoxListEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapCheckBoxListEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapCheckBoxListEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapCheckBoxListEventMap = {} & BootstrapListBoxEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapRadioButtonList
      mixins BootstrapListBox {
      getItem(index: number): DevExpress$AspNetCore$BootstrapListBoxItem | null;
      getItemCount(): number;
      on<K: $Keys<AspNetCore$BootstrapRadioButtonListEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapRadioButtonListEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapRadioButtonListEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapRadioButtonListEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapRadioButtonListEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapRadioButtonListEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapRadioButtonListEventMap = {} & BootstrapListBoxEventMap;
  
    declare type DevExpress$AspNetCore$MenuItemEventArgs = {
      +item: AspNetCore$BootstrapMenuItem
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$MenuItemMouseEventArgs = {} & MenuItemEventArgs;
  
    declare type DevExpress$AspNetCore$MenuItemClickEventArgs = {
      +htmlElement: { [key: string]: any },
      +htmlEvent: { [key: string]: any },
      +item: AspNetCore$BootstrapMenuItem
    } & ProcessingModeEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapMenu mixins Control {
      getItem(index: number): AspNetCore$BootstrapMenuItem | null;
      getItemByName(name: string): AspNetCore$BootstrapMenuItem | null;
      getItemCount(): number;
      getOrientation(): string;
      getRootItem(): AspNetCore$BootstrapMenuItem | null;
      getSelectedItem(): AspNetCore$BootstrapMenuItem | null;
      setOrientation(orientation: string): void;
      setSelectedItem(item: AspNetCore$BootstrapMenuItem): void;
      on<K: $Keys<AspNetCore$BootstrapMenuEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapMenuEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapMenuEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapMenuEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapMenuEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapMenuEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapMenuEventMap = {
      closeUp: DevExpress$AspNetCore$MenuItemEventArgs,
      itemClick: DevExpress$AspNetCore$MenuItemClickEventArgs,
      itemMouseOut: DevExpress$AspNetCore$MenuItemMouseEventArgs,
      itemMouseOver: DevExpress$AspNetCore$MenuItemMouseEventArgs,
      popUp: DevExpress$AspNetCore$MenuItemEventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapMenuItem {
      instance: any;
      constructor(instance: any): this;
      index: number;
      indexPath: string;
      menu: DevExpress$AspNetCore$BootstrapMenu | null;
      name: string;
      parent: DevExpress$AspNetCore$BootstrapMenuItem | null;
      getBadgeIconCssClass(): string;
      getBadgeText(): string;
      getChecked(): boolean;
      getEnabled(): boolean;
      getIconCssClass(): string;
      getImageUrl(): string;
      getItem(index: number): DevExpress$AspNetCore$BootstrapMenuItem | null;
      getItemByName(name: string): DevExpress$AspNetCore$BootstrapMenuItem | null;
      getItemCount(): number;
      getNavigateUrl(): string;
      getText(): string;
      getVisible(): boolean;
      setBadgeIconCssClass(cssClass: string): void;
      setBadgeText(text: string): void;
      setChecked(value: boolean): void;
      setEnabled(value: boolean): void;
      setIconCssClass(cssClass: string): void;
      setImageUrl(value: string): void;
      setNavigateUrl(value: string): void;
      setText(value: string): void;
      setVisible(value: boolean): void;
    }
  
    declare type DevExpress$AspNetCore$PopupWindowEventArgs = {
      +window: AspNetCore$BootstrapPopupWindow
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$PopupWindowCloseUpEventArgs = {
      +closeReason: DevExpress$AspNetCore$BootstrapPopupControlCloseReason
    } & PopupWindowEventArgs;
  
    declare type DevExpress$AspNetCore$PopupWindowCancelEventArgs = {
      +closeReason: DevExpress$AspNetCore$BootstrapPopupControlCloseReason,
      +window: AspNetCore$BootstrapPopupWindow
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$PopupWindowPinnedChangedEventArgs = {
      +pinned: boolean
    } & PopupWindowEventArgs;
  
    declare type DevExpress$AspNetCore$PopupWindowResizeEventArgs = {
      +resizeState: number
    } & PopupWindowEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapPopupControl mixins Control {
      adjustSize(): void;
      bringToFront(): void;
      bringWindowToFront(window: AspNetCore$BootstrapPopupWindow): void;
      getCollapsed(): boolean;
      getContentHeight(): number;
      getContentHtml(): string;
      getContentIFrame(): any;
      getContentIFrameWindow(): any;
      getContentUrl(): string;
      getContentWidth(): number;
      getCurrentPopupElement(): any;
      getCurrentPopupElementIndex(): number;
      getFooterImageUrl(): string;
      getFooterNavigateUrl(): string;
      getFooterText(): string;
      getHeaderImageUrl(): string;
      getHeaderNavigateUrl(): string;
      getHeaderText(): string;
      getMainElement(): any;
      getMaximized(): boolean;
      getPinned(): boolean;
      getPopUpReasonMouseEvent(): any;
      getWindow(index: number): AspNetCore$BootstrapPopupWindow | null;
      getWindowByName(name: string): AspNetCore$BootstrapPopupWindow | null;
      getWindowCollapsed(window: AspNetCore$BootstrapPopupWindow): boolean;
      getWindowContentHeight(window: AspNetCore$BootstrapPopupWindow): number;
      getWindowContentHtml(window: AspNetCore$BootstrapPopupWindow): string;
      getWindowContentIFrame(window: AspNetCore$BootstrapPopupWindow): any;
      getWindowContentUrl(window: AspNetCore$BootstrapPopupWindow): string;
      getWindowContentWidth(window: AspNetCore$BootstrapPopupWindow): number;
      getWindowCount(): number;
      getWindowCurrentPopupElement(window: AspNetCore$BootstrapPopupWindow): any;
      getWindowCurrentPopupElementIndex(
        window: AspNetCore$BootstrapPopupWindow
      ): number;
      getWindowHeight(window: AspNetCore$BootstrapPopupWindow): number;
      getWindowMaximized(window: AspNetCore$BootstrapPopupWindow): boolean;
      getWindowPinned(window: AspNetCore$BootstrapPopupWindow): boolean;
      getWindowPopUpReasonMouseEvent(
        window: AspNetCore$BootstrapPopupWindow
      ): any;
      getWindowWidth(window: AspNetCore$BootstrapPopupWindow): number;
      hide(): void;
      hideWindow(window: AspNetCore$BootstrapPopupWindow): void;
      isVisible(): boolean;
      isWindowVisible(window: AspNetCore$BootstrapPopupWindow): boolean;
      performCallback(data: any): Promise<void>;
      performCallback(data: any, onSuccess: () => void): void;
      refreshContentUrl(): void;
      refreshPopupElementConnection(): void;
      refreshWindowContentUrl(window: AspNetCore$BootstrapPopupWindow): void;
      setAdaptiveMaxHeight(maxHeight: number): void;
      setAdaptiveMaxHeight(maxHeight: string): void;
      setAdaptiveMaxWidth(maxWidth: number): void;
      setAdaptiveMaxWidth(maxWidth: string): void;
      setAdaptiveMinHeight(minHeight: number): void;
      setAdaptiveMinHeight(minHeight: string): void;
      setAdaptiveMinWidth(minWidth: number): void;
      setAdaptiveMinWidth(minWidth: string): void;
      setCollapsed(value: boolean): void;
      setContentHtml(html: string): void;
      setContentUrl(url: string): void;
      setFooterImageUrl(value: string): void;
      setFooterNavigateUrl(value: string): void;
      setFooterText(value: string): void;
      setHeaderImageUrl(value: string): void;
      setHeaderNavigateUrl(value: string): void;
      setHeaderText(value: string): void;
      setMaximized(value: boolean): void;
      setPinned(value: boolean): void;
      setPopupElementCssSelector(selector: string): void;
      setPopupElementID(popupElementId: string): void;
      setSize(width: number, height: number): void;
      setWindowAdaptiveMaxHeight(
        window: AspNetCore$BootstrapPopupWindow,
        maxHeight: number
      ): void;
      setWindowAdaptiveMaxHeight(
        window: AspNetCore$BootstrapPopupWindow,
        maxHeight: string
      ): void;
      setWindowAdaptiveMaxWidth(
        window: AspNetCore$BootstrapPopupWindow,
        maxWidth: number
      ): void;
      setWindowAdaptiveMaxWidth(
        window: AspNetCore$BootstrapPopupWindow,
        maxWidth: string
      ): void;
      setWindowAdaptiveMinHeight(
        window: AspNetCore$BootstrapPopupWindow,
        minHeight: number
      ): void;
      setWindowAdaptiveMinHeight(
        window: AspNetCore$BootstrapPopupWindow,
        minHeight: string
      ): void;
      setWindowAdaptiveMinWidth(
        window: AspNetCore$BootstrapPopupWindow,
        minWidth: number
      ): void;
      setWindowAdaptiveMinWidth(
        window: AspNetCore$BootstrapPopupWindow,
        minWidth: string
      ): void;
      setWindowCollapsed(
        window: AspNetCore$BootstrapPopupWindow,
        value: boolean
      ): void;
      setWindowContentHtml(
        window: AspNetCore$BootstrapPopupWindow,
        html: string
      ): void;
      setWindowContentUrl(
        window: AspNetCore$BootstrapPopupWindow,
        url: string
      ): void;
      setWindowMaximized(
        window: AspNetCore$BootstrapPopupWindow,
        value: boolean
      ): void;
      setWindowPinned(
        window: AspNetCore$BootstrapPopupWindow,
        value: boolean
      ): void;
      setWindowPopupElementID(
        window: AspNetCore$BootstrapPopupWindow,
        popupElementId: string
      ): void;
      setWindowSize(
        window: AspNetCore$BootstrapPopupWindow,
        width: number,
        height: number
      ): void;
      show(): void;
      showAtElement(htmlElement: any): void;
      showAtElementByID(id: string): void;
      showAtPos(x: number, y: number): void;
      showWindow(window: AspNetCore$BootstrapPopupWindow): void;
      showWindow(
        window: AspNetCore$BootstrapPopupWindow,
        popupElementIndex: number
      ): void;
      showWindowAtElement(
        window: AspNetCore$BootstrapPopupWindow,
        htmlElement: any
      ): void;
      showWindowAtElementByID(
        window: AspNetCore$BootstrapPopupWindow,
        id: string
      ): void;
      showWindowAtPos(
        window: AspNetCore$BootstrapPopupWindow,
        x: number,
        y: number
      ): void;
      stretchVertically(): void;
      updatePosition(): void;
      updatePositionAtElement(htmlElement: any): void;
      updateWindowPosition(window: AspNetCore$BootstrapPopupWindow): void;
      updateWindowPositionAtElement(
        window: AspNetCore$BootstrapPopupWindow,
        htmlElement: any
      ): void;
      windowStretchVertically(window: AspNetCore$BootstrapPopupWindow): void;
      on<K: $Keys<AspNetCore$BootstrapPopupControlEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPopupControlEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapPopupControlEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPopupControlEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapPopupControlEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapPopupControlEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapPopupControlEventMap = {
      afterResizing: DevExpress$AspNetCore$PopupWindowEventArgs,
      beforeResizing: DevExpress$AspNetCore$PopupWindowEventArgs,
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      closeUp: DevExpress$AspNetCore$PopupWindowCloseUpEventArgs,
      closing: DevExpress$AspNetCore$PopupWindowCancelEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      pinnedChanged: DevExpress$AspNetCore$PopupWindowPinnedChangedEventArgs,
      popUp: DevExpress$AspNetCore$PopupWindowEventArgs,
      resize: DevExpress$AspNetCore$PopupWindowResizeEventArgs,
      shown: DevExpress$AspNetCore$PopupWindowEventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapPopupWindow {
      instance: any;
      constructor(instance: any): this;
      index: number;
      name: string;
      popupControl: DevExpress$AspNetCore$BootstrapPopupControl | null;
      getFooterImageUrl(): string;
      getFooterNavigateUrl(): string;
      getFooterText(): string;
      getHeaderImageUrl(): string;
      getHeaderNavigateUrl(): string;
      getHeaderText(): string;
      setFooterImageUrl(value: string): void;
      setFooterNavigateUrl(value: string): void;
      setFooterText(value: string): void;
      setHeaderImageUrl(value: string): void;
      setHeaderNavigateUrl(value: string): void;
      setHeaderText(value: string): void;
    }
  
    declare class DevExpress$AspNetCore$BootstrapPopupMenu mixins BootstrapMenu {
      getCurrentPopupElement(): any;
      getCurrentPopupElementIndex(): number;
      getItem(index: number): DevExpress$AspNetCore$BootstrapMenuItem | null;
      getItemByName(name: string): DevExpress$AspNetCore$BootstrapMenuItem | null;
      getRootItem(): DevExpress$AspNetCore$BootstrapMenuItem | null;
      getSelectedItem(): DevExpress$AspNetCore$BootstrapMenuItem | null;
      hide(): void;
      refreshPopupElementConnection(): void;
      setPopupElementCssSelector(selector: string): void;
      setPopupElementID(popupElementId: string): void;
      setSelectedItem(item: DevExpress$AspNetCore$BootstrapMenuItem): void;
      show(): void;
      showAtElement(htmlElement: any): void;
      showAtElementByID(id: string): void;
      showAtPos(x: number, y: number): void;
      on<K: $Keys<AspNetCore$BootstrapPopupMenuEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPopupMenuEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapPopupMenuEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPopupMenuEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapPopupMenuEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapPopupMenuEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapPopupMenuEventMap = {} & BootstrapMenuEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapProgressBar mixins Control {
      getCaption(): string;
      getDisplayText(): string;
      getEnabled(): boolean;
      getMaximum(): number;
      getMinimum(): number;
      getPercent(): number;
      getPosition(): number;
      getValue(): any;
      setCaption(caption: string): void;
      setCustomDisplayFormat(text: string): void;
      setEnabled(value: boolean): void;
      setMaximum(max: number): void;
      setMinMaxValues(minValue: number, maxValue: number): void;
      setMinimum(min: number): void;
      setPosition(position: number): void;
      setValue(value: any): void;
      on<K: $Keys<AspNetCore$BootstrapProgressBarEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapProgressBarEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapProgressBarEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapProgressBarEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapProgressBarEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapProgressBarEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapProgressBarEventMap = {} & ControlEventMap;
  
    declare type DevExpress$AspNetCore$ActiveViewChangingEventArgs = {
      cancel: boolean,
      +newView: DevExpress$AspNetCore$BootstrapSchedulerViewType,
      +oldView: DevExpress$AspNetCore$BootstrapSchedulerViewType
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$AppointmentClickEventArgs = {
      +appointmentId: string,
      +handled: boolean,
      +htmlElement: { [key: string]: any }
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$AppointmentDeletingEventArgs = {
      +appointmentIds: { [key: string]: any }[]
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$AppointmentDragEventArgs = {
      allow: boolean,
      +dragInformation: AspNetCore$BootstrapSchedulerAppointmentDragInfo[],
      +mouseEvent: any
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$AppointmentDropEventArgs = {
      +dragInformation: AspNetCore$BootstrapSchedulerAppointmentDragInfo[],
      handled: boolean,
      +operation: AspNetCore$BootstrapSchedulerAppointmentOperation
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$AppointmentResizeEventArgs = {
      +appointmentId: string,
      handled: boolean,
      +newInterval: AspNetCore$BootstrapTimeInterval,
      +oldInterval: AspNetCore$BootstrapTimeInterval,
      +operation: AspNetCore$BootstrapSchedulerAppointmentOperation
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$AppointmentResizingEventArgs = {
      allow: boolean,
      +appointmentId: string,
      +mouseEvent: any,
      +newInterval: AspNetCore$BootstrapTimeInterval,
      +oldInterval: AspNetCore$BootstrapTimeInterval
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$AppointmentToolTipShowingEventArgs = {
      +appointment: AspNetCore$BootstrapSchedulerAppointment
    } & CancelEventArgs;
  
    declare type DevExpress$AspNetCore$AppointmentsSelectionEventArgs = {
      +appointmentIds: string[]
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$CellClickEventArgs = {
      +htmlElement: { [key: string]: any },
      +interval: AspNetCore$BootstrapTimeInterval,
      +resource: string
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$MenuItemClickedEventArgs = {
      handled: boolean,
      +itemName: string
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$MoreButtonClickedEventArgs = {
      handled: boolean,
      +interval: AspNetCore$BootstrapTimeInterval,
      +resource: string,
      +targetDateTime: Date
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$ShortcutEventArgs = {
      +commandName: string,
      +handled: boolean,
      +htmlEvent: { [key: string]: any }
    } & EventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapScheduler mixins Control {
      appointmentFormCancel(): void;
      appointmentFormDelete(): void;
      appointmentFormSave(): void;
      changeFormContainer(container: any): void;
      changePopupMenuContainer(container: any): void;
      changeTimeZoneId(timeZoneId: string): void;
      changeToolTipContainer(container: any): void;
      deleteAppointment(apt: AspNetCore$BootstrapSchedulerAppointment): void;
      deselectAppointmentById(aptId: any): void;
      getActiveViewType(): DevExpress$AspNetCore$BootstrapSchedulerViewType;
      getAllDayAreaHeight(): number;
      getAppointmentById(
        id: any
      ): AspNetCore$BootstrapSchedulerAppointment | null;
      getAppointmentProperties(
        aptId: number,
        propertyNames: string[],
        onCallBack: any
      ): string[];
      getGroupType(): DevExpress$AspNetCore$BootstrapSchedulerGroupType;
      getResourceNavigatorVisible(): boolean;
      getScrollAreaHeight(): number;
      getSelectedAppointmentIds(): string[];
      getSelectedInterval(): AspNetCore$BootstrapTimeInterval | null;
      getSelectedResource(): string;
      getToolbarVisible(): boolean;
      getTopRowTime(
        viewType: DevExpress$AspNetCore$BootstrapSchedulerViewType
      ): number;
      getVisibleAppointments(): AspNetCore$BootstrapSchedulerAppointment[];
      getVisibleIntervals(): AspNetCore$BootstrapTimeInterval[];
      goToDateFormApply(): void;
      goToDateFormCancel(): void;
      gotoDate(date: Date): void;
      gotoToday(): void;
      hideLoadingPanel(): void;
      inplaceEditFormCancel(): void;
      inplaceEditFormSave(): void;
      inplaceEditFormShowMore(): void;
      insertAppointment(apt: AspNetCore$BootstrapSchedulerAppointment): void;
      navigateBackward(): void;
      navigateForward(): void;
      performCallback(parameter: string): void;
      refresh(): void;
      refreshClientAppointmentProperties(
        clientAppointment: AspNetCore$BootstrapSchedulerAppointment,
        propertyNames: string[],
        onCallBack: any
      ): void;
      reminderFormCancel(): void;
      reminderFormDismiss(): void;
      reminderFormDismissAll(): void;
      reminderFormSnooze(): void;
      selectAppointmentById(aptId: any): void;
      selectAppointmentById(aptId: any, scrollToSelection: boolean): void;
      setActiveViewType(
        value: DevExpress$AspNetCore$BootstrapSchedulerViewType
      ): void;
      setAllDayAreaHeight(height: number): void;
      setGroupType(
        value: DevExpress$AspNetCore$BootstrapSchedulerGroupType
      ): void;
      setHeight(height: number): void;
      setResourceNavigatorVisible(visible: boolean): void;
      setSelection(interval: AspNetCore$BootstrapTimeInterval): void;
      setSelection(
        interval: AspNetCore$BootstrapTimeInterval,
        resourceId: string
      ): void;
      setSelection(
        interval: AspNetCore$BootstrapTimeInterval,
        resourceId: string,
        scrollToSelection: boolean
      ): void;
      setToolbarVisible(visible: boolean): void;
      setTopRowTime(duration: number): void;
      setTopRowTime(
        duration: number,
        viewType: DevExpress$AspNetCore$BootstrapSchedulerViewType
      ): void;
      setVisibleResources(resourceIds: string[]): void;
      showAppointmentFormByClientId(aptClientId: string): void;
      showAppointmentFormByServerId(aptServerId: string): void;
      showInplaceEditor(start: Date, end: Date): void;
      showInplaceEditor(start: Date, end: Date, resourceId: string): void;
      showLoadingPanel(): void;
      showSelectionToolTip(x: number, y: number): void;
      updateAppointment(apt: AspNetCore$BootstrapSchedulerAppointment): void;
      on<K: $Keys<AspNetCore$BootstrapSchedulerEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapSchedulerEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapSchedulerEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapSchedulerEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapSchedulerEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapSchedulerEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapSchedulerEventMap = {
      activeViewChanged: DevExpress$AspNetCore$EventArgs,
      activeViewChanging: DevExpress$AspNetCore$ActiveViewChangingEventArgs,
      appointmentClick: DevExpress$AspNetCore$AppointmentClickEventArgs,
      appointmentDeleting: DevExpress$AspNetCore$AppointmentDeletingEventArgs,
      appointmentDoubleClick: DevExpress$AspNetCore$AppointmentClickEventArgs,
      appointmentDrag: DevExpress$AspNetCore$AppointmentDragEventArgs,
      appointmentDrop: DevExpress$AspNetCore$AppointmentDropEventArgs,
      appointmentResize: DevExpress$AspNetCore$AppointmentResizeEventArgs,
      appointmentResizing: DevExpress$AspNetCore$AppointmentResizingEventArgs,
      appointmentToolTipShowing: DevExpress$AspNetCore$AppointmentToolTipShowingEventArgs,
      appointmentsSelectionChanged: DevExpress$AspNetCore$AppointmentsSelectionEventArgs,
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      cellClick: DevExpress$AspNetCore$CellClickEventArgs,
      cellDoubleClick: DevExpress$AspNetCore$CellClickEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      menuItemClicked: DevExpress$AspNetCore$MenuItemClickedEventArgs,
      moreButtonClicked: DevExpress$AspNetCore$MoreButtonClickedEventArgs,
      selectionChanged: DevExpress$AspNetCore$EventArgs,
      selectionChanging: DevExpress$AspNetCore$EventArgs,
      shortcut: DevExpress$AspNetCore$ShortcutEventArgs,
      visibleIntervalChanged: DevExpress$AspNetCore$EventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapTimeInterval {
      instance: any;
      constructor(instance: any): this;
      contains(interval: DevExpress$AspNetCore$BootstrapTimeInterval): boolean;
      equals(interval: DevExpress$AspNetCore$BootstrapTimeInterval): boolean;
      getAllDay(): boolean;
      getDuration(): number;
      getEnd(): Date;
      getStart(): Date;
      intersectsWith(
        interval: DevExpress$AspNetCore$BootstrapTimeInterval
      ): boolean;
      intersectsWithExcludingBounds(
        interval: DevExpress$AspNetCore$BootstrapTimeInterval
      ): boolean;
      setAllDay(allDayValue: boolean): void;
      setDuration(value: number): void;
      setEnd(value: Date): void;
      setStart(value: Date): void;
    }
  
    declare class DevExpress$AspNetCore$BootstrapSchedulerAppointment {
      instance: any;
      constructor(instance: any): this;
      appointmentId: string;
      appointmentType: DevExpress$AspNetCore$BootstrapSchedulerAppointmentType;
      interval: DevExpress$AspNetCore$BootstrapTimeInterval | null;
      labelIndex: number;
      resources: string[];
      statusIndex: number;
      addResource(resourceId: { [key: string]: any }): void;
      getAllDay(): boolean;
      getAppointmentType(): DevExpress$AspNetCore$BootstrapSchedulerAppointmentType;
      getDescription(): string;
      getDuration(): number;
      getEnd(): Date;
      getId(): any;
      getLabelId(): number;
      getLocation(): string;
      getRecurrenceInfo(): AspNetCore$BootstrapSchedulerRecurrenceInfo | null;
      getRecurrencePattern(): DevExpress$AspNetCore$BootstrapSchedulerAppointment | null;
      getResource(index: number): any;
      getStart(): Date;
      getStatusId(): number;
      getSubject(): string;
      setAllDay(allDay: boolean): void;
      setAppointmentType(
        type: DevExpress$AspNetCore$BootstrapSchedulerAppointmentType
      ): void;
      setDescription(description: string): void;
      setDuration(duration: number): void;
      setEnd(end: Date): void;
      setId(id: any): void;
      setLabelId(statusId: number): void;
      setLocation(location: string): void;
      setRecurrenceInfo(
        recurrenceInfo: AspNetCore$BootstrapSchedulerRecurrenceInfo
      ): void;
      setStart(start: Date): void;
      setStatusId(statusId: number): void;
      setSubject(subject: string): void;
    }
  
    declare class DevExpress$AspNetCore$BootstrapSchedulerAppointmentDragInfo {
      instance: any;
      constructor(instance: any): this;
      appointmentId: string;
      newInterval: DevExpress$AspNetCore$BootstrapTimeInterval | null;
      oldInterval: DevExpress$AspNetCore$BootstrapTimeInterval | null;
    }
  
    declare class DevExpress$AspNetCore$BootstrapSchedulerAppointmentOperation {
      instance: any;
      constructor(instance: any): this;
      apply(): void;
      cancel(): void;
    }
  
    declare class DevExpress$AspNetCore$BootstrapSchedulerRecurrenceInfo {
      instance: any;
      constructor(instance: any): this;
      getDayNumber(): number;
      getDuration(): number;
      getEnd(): Date;
      getMonth(): number;
      getOccurrenceCount(): number;
      getPeriodicity(): number;
      getRange(): DevExpress$AspNetCore$BootstrapSchedulerRecurrenceRange;
      getRecurrenceType(): DevExpress$AspNetCore$BootstrapSchedulerRecurrenceType;
      getStart(): Date;
      getWeekDays(): DevExpress$AspNetCore$WeekDays;
      getWeekOfMonth(): DevExpress$AspNetCore$WeekOfMonth;
      setDayNumber(dayNumber: number): void;
      setDuration(duration: number): void;
      setEnd(end: Date): void;
      setMonth(month: number): void;
      setOccurrenceCount(occurrenceCount: number): void;
      setPeriodicity(periodicity: number): void;
      setRange(
        range: DevExpress$AspNetCore$BootstrapSchedulerRecurrenceRange
      ): void;
      setRecurrenceType(
        type: DevExpress$AspNetCore$BootstrapSchedulerRecurrenceType
      ): void;
      setStart(start: Date): void;
      setWeekDays(weekDays: DevExpress$AspNetCore$WeekDays): void;
      setWeekOfMonth(weekOfMonth: DevExpress$AspNetCore$WeekOfMonth): void;
    }
  
    declare class DevExpress$AspNetCore$BootstrapSparkline mixins Control {
      exportTo(fileName: string, format: string): void;
      getDataSource(): any;
      getInstance(): any;
      print(): void;
      setDataSource(dataSource: any): void;
      setOptions(options: any): void;
      on<K: $Keys<AspNetCore$BootstrapSparklineEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapSparklineEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapSparklineEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapSparklineEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapSparklineEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapSparklineEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapSparklineEventMap = {
      disposing: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      drawn: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      exported: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      exporting: DevExpress$AspNetCore$BootstrapChartExportEventArgs,
      fileSaving: DevExpress$AspNetCore$BootstrapChartExportEventArgs,
      incidentOccurred: DevExpress$AspNetCore$BootstrapChartErrorEventArgs,
      init: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      optionChanged: DevExpress$AspNetCore$BootstrapChartOptionChangedEventArgs,
      tooltipHidden: DevExpress$AspNetCore$BootstrapChartEventArgsBase,
      tooltipShown: DevExpress$AspNetCore$BootstrapChartEventArgsBase
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapTimeEdit
      mixins BootstrapClientEdit {
      getButtonVisible(number: number): boolean;
      getCaretPosition(): number;
      getDate(): Date;
      getText(): string;
      selectAll(): void;
      setButtonVisible(number: number, value: boolean): void;
      setCaretPosition(position: number): void;
      setDate(date: Date): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setText(text: string): void;
      on<K: $Keys<AspNetCore$BootstrapTimeEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTimeEditEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapTimeEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTimeEditEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapTimeEditEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapTimeEditEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapTimeEditEventMap = {
      buttonClick: AspNetCore$ButtonEditClickEventArgs,
      dateChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapSpinEdit
      mixins BootstrapClientEdit {
      getButtonVisible(number: number): boolean;
      getCaretPosition(): number;
      getMaxValue(): number;
      getMinValue(): number;
      getNumber(): number;
      getText(): string;
      selectAll(): void;
      setButtonVisible(number: number, value: boolean): void;
      setCaretPosition(position: number): void;
      setMaxValue(value: number): void;
      setMinValue(value: number): void;
      setNumber(number: number): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setText(text: string): void;
      setValue(number: number): void;
      on<K: $Keys<AspNetCore$BootstrapSpinEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapSpinEditEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapSpinEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapSpinEditEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapSpinEditEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapSpinEditEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapSpinEditEventMap = {
      buttonClick: AspNetCore$ButtonEditClickEventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      numberChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare type DevExpress$AspNetCore$TabControlTabEventArgs = {
      +tab: AspNetCore$BootstrapTab
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$TabControlTabCancelEventArgs = {
      reloadContentOnCallback: boolean,
      +tab: AspNetCore$BootstrapTab
    } & ProcessingModeCancelEventArgs;
  
    declare type DevExpress$AspNetCore$TabControlTabClickEventArgs = {
      +htmlElement: { [key: string]: any },
      +htmlEvent: { [key: string]: any }
    } & TabControlTabCancelEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapTabControl mixins Control {
      adjustSize(): void;
      getActiveTab(): AspNetCore$BootstrapTab | null;
      getActiveTabIndex(): number;
      getTab(index: number): AspNetCore$BootstrapTab | null;
      getTabByName(name: string): AspNetCore$BootstrapTab | null;
      getTabCount(): number;
      setActiveTab(tab: AspNetCore$BootstrapTab): void;
      setActiveTabIndex(index: number): void;
      on<K: $Keys<AspNetCore$BootstrapTabControlEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTabControlEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapTabControlEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTabControlEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapTabControlEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapTabControlEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapTabControlEventMap = {
      activeTabChanged: DevExpress$AspNetCore$TabControlTabEventArgs,
      activeTabChanging: DevExpress$AspNetCore$TabControlTabCancelEventArgs,
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      tabClick: DevExpress$AspNetCore$TabControlTabClickEventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapTab {
      instance: any;
      constructor(instance: any): this;
      index: number;
      name: string;
      tabControl: DevExpress$AspNetCore$BootstrapTabControl | null;
      getActiveIconCssClass(): string;
      getActiveImageUrl(): string;
      getBadgeIconCssClass(): string;
      getBadgeText(): string;
      getEnabled(): boolean;
      getIconCssClass(): string;
      getImageUrl(): string;
      getNavigateUrl(): string;
      getText(): string;
      getVisible(): boolean;
      setActiveIconCssClass(cssClass: string): void;
      setActiveImageUrl(value: string): void;
      setBadgeIconCssClass(cssClass: string): void;
      setBadgeText(text: string): void;
      setEnabled(value: boolean): void;
      setIconCssClass(cssClass: string): void;
      setImageUrl(value: string): void;
      setNavigateUrl(value: string): void;
      setText(value: string): void;
      setVisible(value: boolean): void;
    }
  
    declare class DevExpress$AspNetCore$BootstrapPageControl
      mixins BootstrapTabControl {
      getActiveTab(): DevExpress$AspNetCore$BootstrapTab | null;
      getTab(index: number): DevExpress$AspNetCore$BootstrapTab | null;
      getTabByName(name: string): DevExpress$AspNetCore$BootstrapTab | null;
      getTabContentHTML(tab: DevExpress$AspNetCore$BootstrapTab): string;
      performCallback(data: any): Promise<void>;
      performCallback(data: any, onSuccess: () => void): void;
      setActiveTab(tab: DevExpress$AspNetCore$BootstrapTab): void;
      setTabContentHTML(
        tab: DevExpress$AspNetCore$BootstrapTab,
        html: string
      ): void;
      on<K: $Keys<AspNetCore$BootstrapPageControlEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPageControlEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapPageControlEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapPageControlEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapPageControlEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapPageControlEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapPageControlEventMap = {} & BootstrapTabControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapTagBox
      mixins BootstrapClientEdit {
      addItem(texts: string[]): number;
      addItem(text: string): number;
      addItem(texts: string[], value: any): number;
      addItem(text: string, value: any): number;
      addItem(texts: string[], value: any, iconCssClass: string): number;
      addItem(text: string, value: any, iconCssClass: string): number;
      addItemCssClass(index: number, className: string): void;
      addItemTextCellCssClass(
        itemIndex: number,
        textCellIndex: number,
        className: string
      ): void;
      addTag(text: string): void;
      adjustDropDownWindow(): void;
      beginUpdate(): void;
      clearItems(): void;
      clearTagCollection(): void;
      endUpdate(): void;
      ensureDropDownLoaded(callbackFunction: any): void;
      findItemByText(
        text: string
      ): DevExpress$AspNetCore$BootstrapListBoxItem | null;
      findItemByValue(
        value: any
      ): DevExpress$AspNetCore$BootstrapListBoxItem | null;
      getButtonVisible(number: number): boolean;
      getCaretPosition(): number;
      getItem(index: number): DevExpress$AspNetCore$BootstrapListBoxItem | null;
      getItemBadgeIconCssClass(index: number): string;
      getItemBadgeText(index: number): string;
      getItemCount(): number;
      getSelectedIndex(): number;
      getSelectedItem(): DevExpress$AspNetCore$BootstrapListBoxItem | null;
      getTagCollection(): string[];
      getTagHtmlElement(index: number): any;
      getTagIndexByText(text: string): number;
      getTagRemoveButtonHtmlElement(index: number): any;
      getTagTextHtmlElement(index: number): any;
      getText(): string;
      getValue(): string;
      hideDropDown(): void;
      insertItem(index: number, texts: string[]): void;
      insertItem(index: number, text: string): void;
      insertItem(index: number, texts: string[], value: any): void;
      insertItem(index: number, text: string, value: any): void;
      insertItem(
        index: number,
        texts: string[],
        value: any,
        iconCssClass: string
      ): void;
      insertItem(
        index: number,
        text: string,
        value: any,
        iconCssClass: string
      ): void;
      isCustomTag(text: string, caseSensitive: boolean): boolean;
      makeItemVisible(index: number): void;
      performCallback(data: any): Promise<void>;
      performCallback(data: any, onSuccess: () => void): void;
      removeItem(index: number): void;
      removeItemCssClass(index: number, className: string): void;
      removeItemTextCellCssClass(
        itemIndex: number,
        textCellIndex: number,
        className: string
      ): void;
      removeTag(index: number): void;
      removeTagByText(text: string): void;
      selectAll(): void;
      setButtonVisible(number: number, value: boolean): void;
      setCaretPosition(position: number): void;
      setItemBadgeIconCssClass(index: number, cssClass: string): void;
      setItemBadgeText(index: number, text: string): void;
      setItemHtml(index: number, html: string): void;
      setItemTextCellHtml(
        itemIndex: number,
        textCellIndex: number,
        html: string
      ): void;
      setItemTextCellTooltip(
        itemIndex: number,
        textCellIndex: number,
        tooltip: string
      ): void;
      setItemTooltip(index: number, tooltip: string): void;
      setSelectedIndex(index: number): void;
      setSelectedItem(item: DevExpress$AspNetCore$BootstrapListBoxItem): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setTagCollection(collection: string[]): void;
      setText(text: string): void;
      setValue(value: string): void;
      showDropDown(): void;
      on<K: $Keys<AspNetCore$BootstrapTagBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTagBoxEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapTagBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTagBoxEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapTagBoxEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapTagBoxEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapTagBoxEventMap = {
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      buttonClick: AspNetCore$ButtonEditClickEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      closeUp: DevExpress$AspNetCore$EventArgs,
      customHighlighting: DevExpress$AspNetCore$ListEditCustomHighlightingEventArgs,
      dropDown: DevExpress$AspNetCore$EventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      itemFiltering: DevExpress$AspNetCore$ListEditItemFilteringEventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      queryCloseUp: DevExpress$AspNetCore$CancelEventArgs,
      selectedIndexChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      tagsChanged: DevExpress$AspNetCore$EventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare type DevExpress$AspNetCore$ButtonEditClickEventArgs = {
      +buttonIndex: number
    } & ProcessingModeEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapButtonEdit
      mixins BootstrapClientEdit {
      getButtonVisible(number: number): boolean;
      getCaretPosition(): number;
      getText(): string;
      selectAll(): void;
      setButtonVisible(number: number, value: boolean): void;
      setCaretPosition(position: number): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setText(text: string): void;
      on<K: $Keys<AspNetCore$BootstrapButtonEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapButtonEditEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapButtonEditEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapButtonEditEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapButtonEditEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapButtonEditEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapButtonEditEventMap = {
      buttonClick: DevExpress$AspNetCore$ButtonEditClickEventArgs,
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapMemo mixins BootstrapClientEdit {
      getCaretPosition(): number;
      getText(): string;
      selectAll(): void;
      setCaretPosition(position: number): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setText(text: string): void;
      on<K: $Keys<AspNetCore$BootstrapMemoEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapMemoEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapMemoEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapMemoEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapMemoEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapMemoEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapMemoEventMap = {
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapTextBox
      mixins BootstrapClientEdit {
      getCaretPosition(): number;
      getText(): string;
      selectAll(): void;
      setCaretPosition(position: number): void;
      setSelection(
        startPos: number,
        endPos: number,
        scrollToSelection: boolean
      ): void;
      setText(text: string): void;
      on<K: $Keys<AspNetCore$BootstrapTextBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTextBoxEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapTextBoxEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTextBoxEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapTextBoxEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapTextBoxEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapTextBoxEventMap = {
      keyDown: DevExpress$AspNetCore$EditKeyEventArgs,
      keyPress: DevExpress$AspNetCore$EditKeyEventArgs,
      keyUp: DevExpress$AspNetCore$EditKeyEventArgs,
      textChanged: DevExpress$AspNetCore$ProcessingModeEventArgs,
      userInput: DevExpress$AspNetCore$EventArgs
    } & BootstrapClientEditEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapToolbar mixins BootstrapMenu {
      on<K: $Keys<AspNetCore$BootstrapToolbarEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapToolbarEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapToolbarEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapToolbarEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapToolbarEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapToolbarEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapToolbarEventMap = {} & BootstrapMenuEventMap;
  
    declare type DevExpress$AspNetCore$TreeViewNodeProcessingModeEventArgs = {
      +node: AspNetCore$BootstrapTreeViewNode
    } & ProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$TreeViewNodeClickEventArgs = {
      +htmlElement: any,
      +htmlEvent: any
    } & TreeViewNodeProcessingModeEventArgs;
  
    declare type DevExpress$AspNetCore$TreeViewNodeEventArgs = {
      +node: AspNetCore$BootstrapTreeViewNode
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$TreeViewNodeCancelEventArgs = {
      +node: AspNetCore$BootstrapTreeViewNode
    } & ProcessingModeCancelEventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapTreeView mixins Control {
      collapseAll(): void;
      expandAll(): void;
      getNode(index: number): AspNetCore$BootstrapTreeViewNode | null;
      getNodeByName(name: string): AspNetCore$BootstrapTreeViewNode | null;
      getNodeByText(text: string): AspNetCore$BootstrapTreeViewNode | null;
      getNodeCount(): number;
      getRootNode(): AspNetCore$BootstrapTreeViewNode | null;
      getSelectedNode(): AspNetCore$BootstrapTreeViewNode | null;
      setSelectedNode(node: AspNetCore$BootstrapTreeViewNode): void;
      on<K: $Keys<AspNetCore$BootstrapTreeViewEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTreeViewEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapTreeViewEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTreeViewEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapTreeViewEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapTreeViewEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapTreeViewEventMap = {
      beginCallback: DevExpress$AspNetCore$BeginCallbackEventArgs,
      callbackError: DevExpress$AspNetCore$CallbackErrorEventArgs,
      checkedChanged: DevExpress$AspNetCore$TreeViewNodeProcessingModeEventArgs,
      endCallback: DevExpress$AspNetCore$EndCallbackEventArgs,
      expandedChanged: DevExpress$AspNetCore$TreeViewNodeEventArgs,
      expandedChanging: DevExpress$AspNetCore$TreeViewNodeCancelEventArgs,
      nodeClick: DevExpress$AspNetCore$TreeViewNodeClickEventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapTreeViewNode mixins Control {
      index: number;
      name: string;
      parent: DevExpress$AspNetCore$BootstrapTreeViewNode | null;
      treeView: DevExpress$AspNetCore$BootstrapTreeView | null;
      getBadgeIconCssClass(): string;
      getBadgeText(): string;
      getCheckState(): string;
      getChecked(): boolean;
      getEnabled(): boolean;
      getExpanded(): boolean;
      getHtmlElement(): any;
      getIconCssClass(): string;
      getImageUrl(): string;
      getNavigateUrl(): string;
      getNode(index: number): DevExpress$AspNetCore$BootstrapTreeViewNode | null;
      getNodeByName(
        name: string
      ): DevExpress$AspNetCore$BootstrapTreeViewNode | null;
      getNodeByText(
        text: string
      ): DevExpress$AspNetCore$BootstrapTreeViewNode | null;
      getNodeCount(): number;
      getText(): string;
      getVisible(): boolean;
      setBadgeIconCssClass(cssClass: string): void;
      setBadgeText(text: string): void;
      setChecked(value: boolean): void;
      setEnabled(value: boolean): void;
      setExpanded(value: boolean): void;
      setIconCssClass(cssClass: string): void;
      setImageUrl(value: string): void;
      setNavigateUrl(value: string): void;
      setText(value: string): void;
      setVisible(value: boolean): void;
      on<K: $Keys<AspNetCore$BootstrapTreeViewNodeEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTreeViewNodeEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapTreeViewNodeEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapTreeViewNodeEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapTreeViewNodeEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapTreeViewNodeEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapTreeViewNodeEventMap = {} & ControlEventMap;
  
    declare type DevExpress$AspNetCore$UploadControlFilesUploadStartEventArgs = {
      +cancel: boolean
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$UploadControlFileUploadCompleteEventArgs = {
      +callbackData: string,
      +errorText: string,
      +inputIndex: number,
      +isValid: boolean
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$UploadControlFilesUploadCompleteEventArgs = {
      +callbackData: string,
      +errorText: string
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$UploadControlTextChangedEventArgs = {
      +inputIndex: number
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$UploadControlUploadingProgressChangedEventArgs = {
      +currentFileContentLength: number,
      +currentFileName: string,
      +currentFileProgress: number,
      +currentFileUploadedContentLength: number,
      +fileCount: number,
      +progress: number,
      +totalContentLength: number,
      +uploadedContentLength: number
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$UploadControlValidationErrorOccurredEventArgs = {
      errorText: string,
      +invalidFiles: AspNetCore$BootstrapUploadControlInvalidFileInfo[],
      showAlert: boolean,
      +validationSettings: AspNetCore$BootstrapUploadControlValidationSettings
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$UploadControlDropZoneEnterEventArgs = {
      +dropZone: any
    } & EventArgs;
  
    declare type DevExpress$AspNetCore$UploadControlDropZoneLeaveEventArgs = {
      +dropZone: any
    } & EventArgs;
  
    declare class DevExpress$AspNetCore$BootstrapUploadControl mixins Control {
      addFileInput(): void;
      cancel(): void;
      clearText(): void;
      getAddButtonText(): string;
      getEnabled(): boolean;
      getFileInputCount(): number;
      getSelectedFiles(
        inputIndex: number
      ): AspNetCore$BootstrapUploadControlFile[];
      getText(index: number): string;
      getUploadButtonText(): string;
      removeFileFromSelection(fileIndex: number): void;
      removeFileFromSelection(file: AspNetCore$BootstrapUploadControlFile): void;
      removeFileInput(index: number): void;
      setAddButtonText(text: string): void;
      setDialogTriggerID(ids: string): void;
      setEnabled(enabled: boolean): void;
      setFileInputCount(count: number): void;
      setUploadButtonText(text: string): void;
      upload(): void;
      on<K: $Keys<AspNetCore$BootstrapUploadControlEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapUploadControlEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapUploadControlEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapUploadControlEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapUploadControlEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapUploadControlEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapUploadControlEventMap = {
      dropZoneEnter: DevExpress$AspNetCore$UploadControlDropZoneEnterEventArgs,
      dropZoneLeave: DevExpress$AspNetCore$UploadControlDropZoneLeaveEventArgs,
      fileInputCountChanged: DevExpress$AspNetCore$EventArgs,
      fileUploadComplete: DevExpress$AspNetCore$UploadControlFileUploadCompleteEventArgs,
      filesUploadComplete: DevExpress$AspNetCore$UploadControlFilesUploadCompleteEventArgs,
      filesUploadStart: DevExpress$AspNetCore$UploadControlFilesUploadStartEventArgs,
      textChanged: DevExpress$AspNetCore$UploadControlTextChangedEventArgs,
      uploadingProgressChanged: DevExpress$AspNetCore$UploadControlUploadingProgressChangedEventArgs,
      validationErrorOccurred: DevExpress$AspNetCore$UploadControlValidationErrorOccurredEventArgs
    } & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapUploadControlFile
      mixins Control {
      name: string;
      size: number;
      sourceFileObject: any;
      on<K: $Keys<AspNetCore$BootstrapUploadControlFileEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapUploadControlFileEventMap, K>
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapUploadControlFileEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<AspNetCore$BootstrapUploadControlFileEventMap, K>
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapUploadControlFileEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<AspNetCore$BootstrapUploadControlFileEventMap, K>
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapUploadControlFileEventMap = {} & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapUploadControlInvalidFileInfo
      mixins Control {
      fileName: string;
      fileSize: number;
      on<K: $Keys<AspNetCore$BootstrapUploadControlInvalidFileInfoEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<
            AspNetCore$BootstrapUploadControlInvalidFileInfoEventMap,
            K
          >
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapUploadControlInvalidFileInfoEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<
            AspNetCore$BootstrapUploadControlInvalidFileInfoEventMap,
            K
          >
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapUploadControlInvalidFileInfoEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<
            AspNetCore$BootstrapUploadControlInvalidFileInfoEventMap,
            K
          >
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapUploadControlInvalidFileInfoEventMap = {} & ControlEventMap;
  
    declare class DevExpress$AspNetCore$BootstrapUploadControlValidationSettings
      mixins Control {
      allowedFileExtensions: string[];
      invalidFileNameCharacters: string[];
      maxFileCount: number;
      maxFileSize: number;
      on<K: $Keys<AspNetCore$BootstrapUploadControlValidationSettingsEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<
            AspNetCore$BootstrapUploadControlValidationSettingsEventMap,
            K
          >
        ) => void
      ): this;
      once<K: $Keys<AspNetCore$BootstrapUploadControlValidationSettingsEventMap>>(
        eventName: K,
        callback: (
          args?: $ElementType<
            AspNetCore$BootstrapUploadControlValidationSettingsEventMap,
            K
          >
        ) => void
      ): this;
      off<K: $Keys<AspNetCore$BootstrapUploadControlValidationSettingsEventMap>>(
        eventName?: K,
        callback?: (
          args?: $ElementType<
            AspNetCore$BootstrapUploadControlValidationSettingsEventMap,
            K
          >
        ) => void
      ): this;
    }
  
    declare type DevExpress$AspNetCore$BootstrapUploadControlValidationSettingsEventMap = {} & ControlEventMap;
  }
  