diff --git a/chartjs/dx.chartjs-tests.ts b/chartjs/dx.chartjs-tests.ts new file mode 100644 index 000000000..70c53a602 --- /dev/null +++ b/chartjs/dx.chartjs-tests.ts @@ -0,0 +1,26 @@ +/// + +module Test { + $("
").appendTo(document.body).dxChart({ + size: { + width: 600, + height: 400 + }, + title: { + text: 'Chart in jQuery mode', + font: { color: 'rgb(0, 128, 128)!important' } + }, + argumentAxis: { + categories: ['January', 'February', 'March', 'April', 'May', 'June'] + }, + dataSource: [ + { arg: 'January', v1: 10, v2: 20, v3: 24 }, + { arg: 'February', v1: 5, v2: 35, v3: 43 }, + { arg: 'March', v1: 50, v2: 10, v3: 80 }, + { arg: 'April', v1: 9, v2: 79, v3: 39 }, + { arg: 'May', v1: 100, v2: 42, v3: 22 }, + { arg: 'June', v1: 95, v2: 11, v3: 41 } + ], + series: [{ valueField: 'v1' }, { valueField: 'v2' }, { valueField: 'v3' }] + }); +} \ No newline at end of file diff --git a/chartjs/dx.chartjs.d.ts b/chartjs/dx.chartjs.d.ts new file mode 100644 index 000000000..c605c20ca --- /dev/null +++ b/chartjs/dx.chartjs.d.ts @@ -0,0 +1,1662 @@ +// Type definitions for ChartJS 13.2 +// Project: http://chartjs.devexpress.com +// Definitions by: Developer Express Inc. +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/// + +declare module DevExpress { + export function abstract(); + interface Endpoint { + local?: string; + production: string; + } + class EndpointSelector { + constructor(config: { [key: string]: Endpoint }); + urlFor(key: string): string; + } + export interface ActionOptions { + context?: Object; + component?: any; + beforeExecute? (e: ActionExecuteArgs): void; + afterExecute? (e: ActionExecuteArgs): void; + } + export interface ActionExecuteArgs { + action: any; + args: any[]; + context: any; + component: any; + canceled: boolean; + handled: boolean; + } + export class Action { + constructor(action?: any, config?: ActionOptions); + execute(): any; + } + export module devices { + interface Device { + phone?: boolean; + tablet?: boolean; + android?: boolean; + ios?: boolean; + win8?: boolean; + tizen?: boolean; + platform?: string; + } + export function current(): Device; + export function current(device: Device): Device; + } +} +declare module DevExpress.data { + export interface ErrorHandler { (e: Error): void; } + export interface EntityOptions { key: any; keyType: any; } + export interface Getter { (obj: any, options?: any): any; } + export interface Setter { (obj: any, value: any, options?: any) } + export interface QueryOptions { + errorHandler?: ErrorHandler; + requireTotalCount?: boolean; + } + export interface ODataQueryOptions extends QueryOptions { + adapter?: any; + } + interface IQuery { + enumerate(): JQueryDeferred>; + count(): JQueryDeferred; + slice(skip: number, take?: number): IQuery; + sortBy(field: string[]): IQuery; + sortBy(field: Getter[]): IQuery; + sortBy(field: { field: string; desc?: boolean }[]): IQuery; + sortBy(field: { field: Getter; desc?: boolean }[]): IQuery; + thenBy(field: string[]): IQuery; + thenBy(field: Getter[]): IQuery; + thenBy(field: { field: string; desc?: boolean }[]): IQuery; + thenBy(field: { field: Getter; desc?: boolean }[]): IQuery; + filter(field: string, operator: string, value: any): IQuery; + filter(field: string, value: any): IQuery; + filter(criteria: any[]): IQuery; + select(field: string): IQuery; + select(field: string[]): IQuery; + select(...field: string[]): IQuery; + select(field: Getter): IQuery; + select(field: Getter[]): IQuery; + select(...field: Getter[]): IQuery; + groupBy(field: string[]): IQuery; + groupBy(field: Getter[]): IQuery; + groupBy(field: { field: string; desc?: boolean }[]): IQuery; + groupBy(field: { field: Getter; desc?: boolean }[]): IQuery; + sum(getter?: string): JQueryDeferred; + min(getter?: string): JQueryDeferred; + max(getter?: string): JQueryDeferred; + avg(getter?: string): JQueryDeferred; + aggregate(step: number): JQueryDeferred; + aggregate(seed: number, step: (accumulator: any, current: any) => any, finalize?: (accumulator: any) => any): JQueryDeferred; + } + export interface ArrayQuery extends IQuery { + toArray(): Array; + } + export interface RemoteQuery extends IQuery { /*todo: exec() ? */ } + export function base64_encode(input: string): string; + export function base64_encode(input: any[]): string; + export function query(items?: any[]): IQuery; + export var queryImpl: { + remote: (url: string, queryOptions: QueryOptions) => RemoteQuery; + array: (iter: Array, queryOptions: QueryOptions) => ArrayQuery; + }; + export class Guid { + constructor(value?: string); + constructor(value?: any); + toString(): string; + valueOf(): string; + toJSON(): string; + } + export class EdmLiteral { + constructor(value: any); + valueOf(): any; + } + export module utils { + export function normalizeSortingInfo(info: string): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: string[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: Getter): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: Getter[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { field: string; dir?: string }): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { field: string; dir?: string }[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { field: string; desc?: boolean }): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { field: string; desc?: boolean }[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { selector: string; dir?: string }): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { selector: string; dir?: string }[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { selector: string; desc?: boolean }): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { selector: string; desc?: boolean }[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeBinaryCriterion(criteria: Array): Array; + export function keysEqual(keyExpr, key1, key2): boolean; + export function toComparable(value: Date, caseSensitive?: boolean): number; + export function toComparable(value: Guid, caseSensitive?: boolean): string; + export function toComparable(value: string, caseSensitive?: boolean): string; + export function compileGetter(): Getter; + export function compileGetter(expr: any[]): Getter; + export function compileGetter(expr: string): Getter; + export function compileGetter(expr: "this"): Getter; + export function compileGetter(expr: Getter): Getter; + export function compileSetter(expr: string): Setter; + export module odata { + export function sendRequest(request: JQueryXHR, requestOptions?: JQueryAjaxSettings); + export function serializePropName(propName: EdmLiteral): string; + export function serializePropName(propName: string): string; + export function serializeValue(value: Date): string; + export function serializeValue(value: Guid): string; + export function serializeValue(value: string): string; + export function serializeValue(value: "string"): string; + export function serializeValue(value: EdmLiteral): string; + export function serializeKey(key: any): string; + export function serializeKey(key: Date): string; + export function serializeKey(key: Guid): string; + export function serializeKey(key: string): string; + export function serializeKey(key: "string"): string; + export function serializeKey(key: EdmLiteral): string; + export var keyConverters: { + String(value: any): string; + Guid(value: any): Guid; + Int32(value: any): number; + Int64(value: any): EdmLiteral; + }; + } + } + export module queryAdapters { + export function odata(queryOptions: ODataQueryOptions): RemoteQuery; + } + export interface DataSourceOptions { + map? (item: any): any; + postProcess? (result: any[]): any; + pageSize: number; + paginate: boolean; + } + export class DataSource { + public changed: JQueryCallback; + public loadError: JQueryCallback; + public loadingChanged: JQueryCallback; + constructor(options?: Store); + constructor(options?: string); + constructor(options?: Array); + constructor(options?: { store: Store }); + constructor(options?: CustomStoreOptions); + constructor(options?: { store: Array }); + constructor(options?: { store: { type: string } }); + constructor(options?: { load(options?: LoadOptions): JQueryXHR; }); + constructor(options?: { load(options?: LoadOptions): Array; }); + constructor(options?: { load(options?: LoadOptions): JQueryDeferred; }); + constructor(options?: DataSourceOptions); + loadOptions(): { [key: string]: any }; + items(): Array; + store(): data.Store; + isLastPage(): boolean; + pageIndex(newIndex?: number): number; + sort(expr: any[]): any[]; + group(expr: any[]): any[]; + filter(expr: any[]): any[]; + select(expr: string[]): string[]; + searchValue(value?: string): string; + searchOperation(op?: string): string; + searchExpr(selector: string): string; + key(): any; + isLoaded(): boolean; + isLoading(): boolean; + totalCount(): number; + load(): JQueryDeferred; + dispose(): void; + } + export interface StoreOptions { + key?: any; + errorHandler: ErrorHandler; + loaded?: JQueryCallback; + loading?: JQueryCallback; + modified?: JQueryCallback; + modifying?: JQueryCallback; + inserted?: JQueryCallback; + inserting?: JQueryCallback; + updated?: JQueryCallback; + updating?: JQueryCallback; + removed?: JQueryCallback; + removing?: JQueryCallback; + } + export interface LoadOptions extends QueryOptions { + skip?: number; + take?: number; + sort?: any; + select?: any; + filter?: any; + group?: any; + } + export class Store { + loaded: JQueryCallback; + loading: JQueryCallback; + modified: JQueryCallback; + modifying: JQueryCallback; + inserted: JQueryCallback; + inserting: JQueryCallback; + updated: JQueryCallback; + updating: JQueryCallback; + removed: JQueryCallback; + removing: JQueryCallback; + constructor(options?: StoreOptions); + key(): any; + keyOf(obj: any): any; + load(options?: LoadOptions): JQueryDeferred; + createQuery(options?: QueryOptions): IQuery; + totalCount(options?: { + filter?: any[]; + group?: string[]; + }): JQueryDeferred; + byKey(key: any, extraOptions?: { + expand?: string[] + }): JQueryDeferred; + remove(key: any): JQueryDeferred; + insert(values: any): JQueryDeferred; + update(key: any, values: any): JQueryDeferred; + } + export interface CustomStoreOptions extends StoreOptions { + load? (options?: LoadOptions): any; + byKey? (key: any): any; + insert? (values: any): any; + update? (key: any, values: any): any; + remove? (key: any): any; + totalCount? (options?: { + filter?: any[]; + group?: string[]; + }): any; + } + export class CustomStore extends Store { + constructor(options?: CustomStoreOptions); + } + export interface ArrayStoreOptions extends StoreOptions { + data?: Array + } + export class ArrayStore extends Store { + constructor(options?: Array); + constructor(options?: ArrayStoreOptions); + } + export interface LocalStoreOptions extends ArrayStoreOptions { + name: string; + } + export class LocalStore extends ArrayStore { + constructor(options?: string); + constructor(options?: LocalStoreOptions); + clear(): void; + } + export interface ODataStoreOptions extends StoreOptions { + url?: string; + name?: string; + keyType?: string; + jsonp?: boolean; + withCredentials?: boolean; + } + export class ODataStore extends Store { + constructor(options?: ODataStoreOptions); + } + interface IODataContextBase { + get(operationName: string, params: { [key: string]: any }): JQueryDeferred>; + invoke(operationName: string, params: { [key: string]: any }, httpMethod?: string): JQueryDeferred>; + objectLink(entityAlias: string, key: any): { __metadata: { uri: string }; } + } + interface IODataContext extends IODataContextBase { + [entitySetName: string]: Store; + } + export interface ODataContextOptions { + url: string; + jsonp?: boolean; + withCredentials?: boolean; + errorHandler?: ErrorHandler; + beforeSend?: () => any; + entities?: Array; + } + export class ODataContext implements IODataContextBase { + constructor(options?: ODataContextOptions); + get(operationName: string, params: { [key: string]: any }): JQueryDeferred>; + invoke(operationName: string, params: { [key: string]: any }, httpMethod?: string): JQueryDeferred>; + objectLink(entityAlias: string, key: any): { __metadata: { uri: string }; } + } +} +declare module DevExpress.ui { + interface ViewportOptions { + allowPan?: boolean; + allowZoom?: boolean; + } + export interface ITemplate { + compile(html: string); + render(template: JQuery, data: any); + render(template: any, data: any); + } + class Template { + constructor(element: HTMLElement); + constructor(element: JQueryStatic); + render(container: HTMLElement); + render(container: JQueryStatic); + dispose(): void; + } + interface TemplateStatic { + new (element: HTMLElement): Template; + new (element: JQueryStatic): Template; + } + class TemplateProvider { + constructor(); + getTemplateClass(widget: any): TemplateStatic; + getDefaultTemplate(widget: any): void; supportDefaultTemplate(): boolean; + } + export function initViewport(options: ViewportOptions): void; + interface NotifyOptions { + message: string; + type?: string; + displayTime?: number; + hiddenAction: () => any; + } + export function notyfy(options: any): void; + export function notify(message: string, type?: string, displayTime?: number): void; + export module dialog { + interface Dialog { + show(): JQueryDeferred; + hide(value?: any): void; + } + interface DialogButton { + text: string; + icon: string; + clickAction: () => any; + } + interface DialogOptions { + message: string; + title?: string; + } + export function custom(options: DialogOptions): Dialog; + export function custom(message: string, title?: string): Dialog; + export function alert(options: DialogOptions): JQueryDeferred; + export function alert(message: string, title?: string): JQueryDeferred; + export function confirm(options: DialogOptions): JQueryDeferred; + export function confirm(message: string, title?: string): JQueryDeferred; + } + export interface CollectionContainerWidgetOptions extends ContainerWidgetOptions { + items?: Array; + itemTemplate?: any; + itemRender?: Function; + itemClickAction?: any; + itemRenderedAction?: any; + noDataText?: string; + dataSource?: data.DataSource; + } + export class CollectionContainerWidget extends ContainerWidget { + constructor(element: Element, options?: CollectionContainerWidgetOptions); + constructor(element: JQuery, options?: CollectionContainerWidgetOptions); + } + export interface ComponentOptions { + disabled?: boolean; + } + export class Component { + constructor(element: Element, options?: ComponentOptions); + constructor(element: JQuery, options?: ComponentOptions); + disposing: JQueryCallback; + optionChanged: JQueryCallback; + instance(): Component; + beginUpdate(): void; + endUpdate(): void; + option(): any; + option(options: string): any; + option(options: string): T; + option(options: string, value: any): void; + option(options: { [key: string]: any }): void; + option(options?: any): any; + } + export interface ContainerWidgetOptions extends WidgetOptions { + contentReadyAction?: any + } + export class ContainerWidget extends Widget { + constructor(element: Element, options?: WidgetOptions); + constructor(element: JQuery, options?: WidgetOptions); + addTemplate(template: ITemplate): void; + } + export interface SelectableCollectionWidgetOptions extends CollectionContainerWidgetOptions { + selectedIndex?: number; + itemSelectAction?: any; + } + export class SelectableCollectionWidget extends CollectionContainerWidget { + constructor(element: Element, options?: SelectableCollectionWidget); + constructor(element: JQuery, options?: SelectableCollectionWidget); + } + export interface WidgetOptions extends ComponentOptions { + clickAction?: any; + width?: any; + height?: any; + visible?: boolean; + activeStateEnabled?: boolean; + } + export class Widget extends Component { + constructor(element: Element, options?: WidgetOptions); + constructor(element: JQuery, options?: WidgetOptions); + init(); + repaint(); + } +} +declare module DevExpress.viz { + export class Chart extends ui.Component { + constructor(element: Element, options?: viz.charts.ChartOptions); + constructor(element: JQuery, options?: viz.charts.ChartOptions); + clearSelection(): void; + getSeries(): viz.charts.series.Series; + hidiTooltip(): void; + render(options: viz.charts.RenderOptions): void; + render(): void; + zoomArgument(minArg: any, maxArg: any): void; + getSeriesByPos(seriesIndex: number): viz.charts.series.Series; + getSeriesByName(seriesName: string): viz.charts.series.Series; + getAllSeries(): Array; + instance(): Chart; + } + export class PieChart extends ui.Component { + constructor(element: Element, options?: viz.charts.PieOptions); + constructor(element: JQuery, options?: viz.charts.PieOptions); + clearSelection(): void; + getSeries(): viz.charts.series.PieSeries; + hidiTooltip(): void; + render(options: viz.charts.RenderOptions): void; + render(): void; + instance(): PieChart; + } + export class RangeSelector extends ui.Component { + constructor(element: Element, options?: viz.rangeSelector.RangeSelectorOptions); + constructor(element: JQuery, options?: viz.rangeSelector.RangeSelectorOptions); + getSelectedRange: () => viz.rangeSelector.SelectedRange; + setSelectedRange: (selectedRange: viz.rangeSelector.SelectedRange) => void; + instance(): RangeSelector; + } + export class CircularGauge extends ui.Component { + constructor(element: Element, options?: viz.gauges.CircularGaugeOptions); + constructor(element: JQuery, options?: viz.gauges.CircularGaugeOptions); + value(): number; + value(val: number): CircularGauge; + subvalues(): Array; + subvalues(values: Array): CircularGauge; + instance(): CircularGauge; + } + export class LinearGauge extends ui.Component { + constructor(element: Element, options?: viz.gauges.LinearGaugeOptions); + constructor(element: JQuery, options?: viz.gauges.LinearGaugeOptions); + value(): number; + value(val: number): LinearGauge; + subvalues(): Array; + subvalues(values: Array): LinearGauge; + instance(): LinearGauge; + } + export class Sparkline extends ui.Component { + constructor(element: Element, options?: viz.sparklines.SparklineOptions); + constructor(element: JQuery, options?: viz.sparklines.SparklineOptions); + render(): Sparkline; + instance(): Sparkline; + } + export class Bullet extends ui.Component { + constructor(element: Element, options?: viz.sparklines.BulletOptions); + constructor(element: JQuery, options?: viz.sparklines.BulletOptions); + render(): Bullet; + instance(): Bullet; + } + export class Map extends ui.Component { + constructor(element: Element, options?: viz.map.VectorMapOptions); + constructor(element: JQuery, options?: viz.map.VectorMapOptions); + render(): void; + instance(): Map; + getAreas(): Array; + getMarkers(): Array; + clearAreaSelection(): void; + clearMarkerSelection(): void; + clearSelection(): void; + } +} +declare module DevExpress.viz.charts { + interface z_BaseLegendOptions { + backgroundColor?: string; + hoverMode?: string; + customizeText?: (arg: { + seriesName: string; + seriesNumber: number; + seriesColor: string; + }) => string; + verticalAlignment?: string; + horizontalAlignment?: string; + itemTextPosition?: string; + equalColumnWidth?: boolean; + font?: viz.common.FontOptions; + visible?: boolean; + margin?: number; + markerSize?: number; + border?: { + visible?: boolean; + width?: number; + color?: string; + cornerRadius?: number; + opacity?: number; + dashStyle?: string; + }; + paddingLeftRight?: number; + paddingTopBottom?: number; + columnsCount?: number; + rowsCount?: number; + columnItemSpacing?: number; + rowItemSpacing?: number; + } + interface z_BaseTooltipCustomizeArgument { + value?: any; + valueText: string; + originalValue: string; + argument: any; + argumentText: string; + originalArgument: any; + percent?: any; + percentText?: string; + seriesName: string; + } + interface z_BaseTooltipOptions { + enabled?: boolean; + color?: string; + customizeText?: (arg: z_BaseTooltipCustomizeArgument) => string; + format?: string; + argumentFormat?: string; + precision?: number; + argumentPrecision?: number; + percentPrecision?: number; + font?: viz.common.FontOptions; + arrowLength?: number; + paddingLeftRight?: number; + paddingTopBottom?: number; + } + interface z_ChartTooltipCustomizeArgument extends z_BaseTooltipCustomizeArgument { + closeValueText?: string; + highValueText?: string; + lowValueText?: string; + openValueText?: string; + originalCloseValue?: any; + originalHighValue?: any; + originalLowValue?: any; + originalOpenValue?: any; + closeValue?: any; + highValue?: any; + lowValue?: any; + openValue?: any; + reductionValue?: any; + reductionValueText?: string; + originalMinValue?: any; + rangeValue1?: any; + rangeValue1Text?: string; + rangeValue2?: any; + rangeValue2Text?: string; + point: series.Point; + } + interface z_ChartTooltipOptions extends z_BaseTooltipOptions { + customizeText?: (arg: z_ChartTooltipCustomizeArgument) => string; + shared?: boolean; + } + interface z_BaseChartOptions extends ui.ComponentOptions { + incidentOccured?: () => void; + done?: () => void; + drawn?: () => void; + tooltipShown?: () => void; + tooltipHidden?: () => void; + pointSelectionMode?: string; + redrawOnResize?: boolean; + tooltip?: z_BaseTooltipOptions; + margin?: { + left?: number; + top?: number; + right?: number; + bottom?: number; + }; + size?: { + width?: number; + height?: number; + }; + title?: { + horizontalAlignment?: string; + verticalAlignment?: string; + font?: viz.common.FontOptions; + text?: string; + placeholderSize?: number; + }; + dataSource?: any; + palette?: any; legend?: z_BaseLegendOptions; + theme?: string; + animation?: { + enabled?: boolean; + duration?: number; + easing?: string; + maxPointCountSupported?: number; + asyncSeriesRendering?: boolean; + asyncTrackersRendering?: boolean; + trackerRenderingDelay?: number; + }; + } + export interface CommonPaneSettings { + backgroundColor?: string; + border?: { + color?: string; + bottom?: boolean; + left?: boolean; + right?: boolean; + top?: boolean; + dashStyle?: string; + visible?: boolean; + width?: number; + opacity?: number; + }; + } + export interface PaneSettings extends CommonPaneSettings { + name: string; + } + export interface ChartLegendOptions extends z_BaseLegendOptions { + hoverMode?: string; + position?: string; + } + interface z_CommonAxisLabelSettings { + alignment?: string; + font?: viz.common.FontOptions; + indentFromAxis?: number; + overlappingBehavior?: { + mode?: string; + rotationAngle?: number; + staggeringSpacing?: number; + }; + rotationAngle?: number; + staggered?: boolean; + staggeringSpacing?: number; + } + interface z_BaseConstantLineLabel { + visible?: boolean; + position?: string; + font?: viz.common.FontOptions; + } + interface ConstantLineAxisLabel extends z_BaseConstantLineLabel { + horizontalAlignment?: string; + verticalAlignment?: string; + } + export interface ConstantLineLabel extends ConstantLineAxisLabel { + text?: string; + } + export interface CommonConstantLineStyle { + paddingLeftRight?: number; + paddingTopBottom?: number; + width?: number; + dashStyle?: string; + color?: string; + label?: z_BaseConstantLineLabel; + } + export interface ConstantLineOptions extends CommonConstantLineStyle { + value?: any; + label?: ConstantLineLabel; + } + interface z_AxisConstantLineStyle extends CommonConstantLineStyle { + label?: ConstantLineAxisLabel; + } + interface z_StripStyle { + label?: { + font?: viz.common.FontOptions; + horizontalAlignment?: string; + verticalAlignment?: string; + }; + paddingLeftRight?: number; + paddingTopBottom?: number; + } + export interface CommonAxisSettings { + color?: string; + discreteAxisDivisionMode?: string; + grid?: { + color?: string; + opacity?: string; + visible?: boolean; + width?: number; + } + inverted?: boolean; + label?: z_CommonAxisLabelSettings; + maxValueMargin?: number; + minValueMargin?: number; + opacity?: number; + placeholderSize?: number; + setTicksAtUnitBeginning?: boolean; + stripStyle?: z_StripStyle + constantLineStyle?: CommonConstantLineStyle; + tick?: { + color?: string; + opacity?: number; + visible?: boolean; + }; + title?: { + font?: viz.common.FontOptions; + margin?: number; + text?: string; + }; + valueMarginsEnabled?: boolean; + visible?: boolean; + width?: number; + } + export interface StripOptions extends z_StripStyle { + color?: string; + endValue: any; + startValue: any; + label?: { + font?: viz.common.FontOptions; + horizontalAlignment?: string; + verticalAlignment?: string; + text?: string; + }; + } + interface z_AxisLabelSettings extends z_CommonAxisLabelSettings { + customizeText: (arg: { + value: any; + valueText: string; + }) => string; + } + export interface ArgumentAxisOptions extends CommonAxisSettings { + argumentType?: string; + axisDivisionFactor?: number; + categories?: Array; + hoverMode?: string; + label?: z_AxisLabelSettings; + max?: number; + min?: number; + tickInterval?: any; + position?: string; + constantLineStyle?: z_AxisConstantLineStyle; + strips?: Array; + constantLines?: Array; + type?: string; + } + export interface ValueAxisOptions extends CommonAxisSettings { + valueType?: string; + axisDivisionFactor?: number; + categories?: Array; + hoverMode?: string; + max?: number; + min?: number; + tickInterval?: any; position?: string; + strips?: Array; + constantLines?: Array; + constantLineStyle?: z_AxisConstantLineStyle; + type?: string; + name?: string; + label?: z_AxisLabelSettings; + } + interface z_CrosshairLine { + color?: string; + width?: number; + dashStyle?: string; + opacity?: number; + } + interface z_CrosshairOptions extends z_CrosshairLine { + enabled?: boolean; + verticalLine?: z_CrosshairLine; + horizontalLine?: z_CrosshairLine; + } + export interface ChartOptions extends z_BaseChartOptions { + needAggregate?: boolean; + defaultPane?: string; + adjustOnZoom?: boolean; + rotated?: boolean; + synchronizeMultiAxes?: boolean; + equalBarWidth?: { + spacing?: number; + width?: number; + }; + customizePoint?: (arg: { + index: number; + argument: any; + seriesName: string; + tag: any; + value?: any; + rangeValue1?: any; + rangeValue2?: any; + }) => series.BasePointOptions; + commonPaneSettings?: CommonPaneSettings; + panes?: Array; + containerBackgroundColor?: string; + seriesTemplate?: { + nameField?: string; + customizeSeries?: (valueFromNameField: string) => viz.charts.series.SeriesOptions; + }; + crosshair?: z_CrosshairOptions; + seriesSelectionMode?: string; + tooltip?: z_ChartTooltipOptions; + dataPrepareSettings?: { + checkTypeForAllData?: boolean; + convertToAxisDataType?: boolean; + sortingMethod?: any; + }; + useAggregation?: boolean; + argumentAxisClick?: (axis, argument, event: JQueryMouseEventObject) => void; + legend?: ChartLegendOptions; + argumentAxis?: ArgumentAxisOptions; + valueAxis?: Array; + commonAxisSettings?: CommonAxisSettings; + series?: Array; + commonSeriesSettings?: viz.charts.series.commonSeriesSettings; + seriesClick?: (series: viz.charts.series.Series, event: JQueryMouseEventObject) => void; + seriesHover?: (series: viz.charts.series.Series) => void; + seriesSelected?: (series: viz.charts.series.Series) => void; + seriesHoverChanged?: (series: viz.charts.series.Series) => void; + pointClick?: (point: viz.charts.series.Point, event: JQueryMouseEventObject) => void; + legendClick?: (obj: any, event: JQueryMouseEventObject) => void; pointHover?: (point: viz.charts.series.Point) => void; + pointSelected?: (point: viz.charts.series.Point) => void; + seriesSelectionChanged?: (series: viz.charts.series.Series) => void; + pointSelectionChanged?: (point: viz.charts.series.Point) => void; + pointHoverChanged?: (point: viz.charts.series.Point) => void; + } + export interface PieOptions extends z_BaseChartOptions { + pointClick?: (point: viz.charts.series.PiePoint, event: JQueryMouseEventObject) => void; + legendClick?: (point: viz.charts.series.PiePoint, event: JQueryMouseEventObject) => void; + pointHover?: (point: viz.charts.series.PiePoint) => void; + pointSelected?: (point: viz.charts.series.PiePoint) => void; + pointSelectionChanged?: (point: viz.charts.series.PiePoint) => void; + pointHoverChanged?: (point: viz.charts.series.PiePoint) => void; + series?: viz.charts.series.PieSeriesOptions; + } + export interface RenderOptions { + force?: boolean; + animate?: boolean; + asyncSeriesRendering?: boolean; + } +} +declare module DevExpress.viz.charts.series { + export interface z_BasePointStyle { + color?: string; + border?: { + visible?: boolean; + width?: number; + color?: string; + }; + size?: number; + } + interface BasePointOptions extends z_BasePointStyle { + hoverMode?: string; + selectionMode?: string; + visible?: boolean; + symbol?: string; + image?: any; + hoverStyle?: z_BasePointStyle; + selectionStyle?: z_BasePointStyle; + } + interface z_BaseSeriesOptions { + argumentField?: string; + hoverMode?: string; + maxLabelCount?: number; + label?: z_BaseLabelOptions; + selectionMode?: string; + showInLegend?: boolean; + tagField?: string; + } + interface z_BaseLabelOptions { + visible?: boolean; + alignment?: string; + rotationAngle?: number; + format?: string; + precision?: number; + argumentFormat?: string; + argumentPrecision?: number; + precission?: number; + percentPrecision?: number; + font?: viz.common.FontOptions; + backgroundColor?: string; + border?: { + visible?: boolean; + width?: number; + color?: string; + dashStyle?: string; + }; + connector?: { + visible?: boolean; + width?: number; + color?: string; + } + } + interface z_BaseChartSeriesLabelOptions extends z_BaseLabelOptions { + horizontalOffset?: number; + verticalOffset?: number; + customizeText?: (arg: { + originalValue: any; + value: any; + valueText: string; + originalArgument: any; + argument: any; + argumentText: string; + seriesName: string; + }) => string; + } + interface z_BaseSeriesStyle { + color?: string; + } + export interface ScatterSeriesOptions extends z_BaseSeriesOptions, z_BaseSeriesStyle { + selectionStyle?: z_BaseSeriesStyle; + hoverStyle?: z_BaseSeriesStyle; + valueField?: string; + point?: BasePointOptions; + axis?: string; + pane?: string; + } + export interface LineSeriesStyle extends z_BaseSeriesStyle { + dashStyle?: string; + width?: number; + } + export interface LineSeriesOptions extends LineSeriesStyle, z_BaseSeriesOptions { + selectionStyle?: LineSeriesStyle; + hoverStyle?: LineSeriesStyle; + valueField?: string; + point?: BasePointOptions; + pane?: string; + } + export interface AreaSeriesStyle extends z_BaseSeriesStyle { + hatching?: { + direction?: string; + width?: number; + step?: number; + opacity?: number + }; + border?: { + visible?: boolean; + width?: number; + color?: string; + }; + } + export interface AreaSeriesOptions extends AreaSeriesStyle, z_BaseSeriesOptions { + selectionStyle?: AreaSeriesStyle; + hoverStyle?: AreaSeriesStyle; + valueField?: string; + point?: BasePointOptions; + pane?: string; + axis?: string; + } + export interface BarSeriesLabel extends z_BaseChartSeriesLabelOptions { + position?: string; + showForZeroValues?: boolean; + } + export interface BarSeriesStyle extends AreaSeriesStyle { } + interface z_BaseBarSeriesOptions extends z_BaseSeriesOptions, BarSeriesStyle { + minBarSize?: number; + cornerRadius?: number; + label?: BarSeriesLabel; + selectionStyle?: BarSeriesStyle; + hoverStyle?: BarSeriesStyle; + pane?: string; + axis?: string; + } + export interface BarSeriesOptions extends z_BaseBarSeriesOptions { + valueField?: string; + } + export interface OHLCSeriesStyle extends z_BaseSeriesStyle { + width?: number; + } + interface z_BaseOHLCSeries extends z_BaseSeriesOptions { + openValueField?: string; + highValueField?: string; + lowValueField?: string; + closeValueField?: string; + reduction?: { + color?: string; + level?: string; + }; + pane?: string; + axis?: string; + } + export interface CandleStickSeriesOptions extends z_BaseOHLCSeries, OHLCSeriesStyle { + innerColor?: string; + selectionStyle?: OHLCSeriesStyle; + hoverStyle?: OHLCSeriesStyle; + } + export interface StockSeriesOptions extends z_BaseOHLCSeries, OHLCSeriesStyle { + selectionStyle?: OHLCSeriesStyle; + hoverStyle?: OHLCSeriesStyle; + } + export interface FullStackedAreaSeriesOptions extends z_BaseSeriesOptions, AreaSeriesOptions { + valueField?: string; + selectionStyle?: AreaSeriesStyle; + hoverStyle?: AreaSeriesStyle; + point?: BasePointOptions; + } + export interface FullStackedBarSeriesOptions extends BarSeriesOptions { + stack?: string; + } + export interface FullStackedLineSeriesOptions extends LineSeriesOptions { + point?: BasePointOptions; + } + interface z_BaseRangeSeriesOptions extends z_BaseSeriesOptions { + rangeValue1Field?: string; + rangeValue2Field?: string; + pane?: string; + axis?: string; + } + export interface RangeAreaSeriesOptions extends z_BaseSeriesOptions, AreaSeriesStyle { + selectionStyle?: AreaSeriesStyle; + hoverStyle?: AreaSeriesStyle; + point?: BasePointOptions; + } + export interface RangeBarSeriesOptions extends z_BaseRangeSeriesOptions, z_BaseBarSeriesOptions { } + export interface SplineSeriesOptions extends LineSeriesOptions { } + export interface SplineAreaSeries extends AreaSeriesOptions { } + export interface StackedLineSeries extends LineSeriesOptions { } + export interface StackedAreaSeries extends AreaSeriesOptions { } + export interface StackedBasrSeriesOptions extends BarSeriesOptions { + stack?: string; + } + export interface BubbleSeriesStyle extends AreaSeriesStyle { } + export interface BubbleSeriesOptions extends z_BaseBarSeriesOptions, BubbleSeriesStyle { + selectionStyle?: LineSeriesStyle; + hoverStyle?: LineSeriesStyle; + valueField?: string; + pane?: string; + sizeField?: string; + } + export interface StepLineSeries extends LineSeriesOptions { } + export interface StepAreaSeries extends AreaSeriesOptions { } + export interface PieSeriesStyle extends AreaSeriesStyle { } + interface PieSeriesLabelOptions extends z_BaseLabelOptions { + customizeText: (arg: { + value: any; + valueText: string; + originalValue: any; + argument: any; + argumentText: string; + originalArgument: any; + percent: any; + percentText: string; + seriesName: string; + }) => string; + radialOffset?: number; + } + export interface PieSeriesOptions extends z_BaseSeriesOptions, PieSeriesStyle { + valueField?: string; + minSegmentSize?: string; + selectionStyle?: PieSeriesStyle; + hoverStyle?: PieSeriesStyle; + segmentsDirection?: string; + type?: string; + label?: PieSeriesLabelOptions; + } + interface AllSeriesStyleOptions extends z_BaseSeriesStyle, AreaSeriesStyle, LineSeriesStyle { } + interface z_AllLabelsOptions extends z_BaseChartSeriesLabelOptions, BarSeriesLabel { } + export interface CommonSeriesOptions extends z_BaseSeriesOptions, z_BaseBarSeriesOptions, z_BaseRangeSeriesOptions, z_BaseOHLCSeries, AllSeriesStyleOptions, BubbleSeriesOptions { + selectionStyle?: AllSeriesStyleOptions; + hoverStyle?: AllSeriesStyleOptions; + label?: z_AllLabelsOptions; + valueField?: string; + } + export interface SeriesOptions extends CommonSeriesOptions { + tag?: any; + name?: string; + type?: string; + } + export interface commonSeriesSettings extends CommonSeriesOptions { + area?: AreaSeriesOptions; + bar?: BarSeriesOptions; + candlestick?: CandleStickSeriesOptions; + fullstackedarea?: FullStackedAreaSeriesOptions; + fullstackedbar?: FullStackedBarSeriesOptions; + fullstackedline?: FullStackedLineSeriesOptions; + line?: LineSeriesOptions; + rangearea?: RangeAreaSeriesOptions; + rangebar?: RangeBarSeriesOptions; + scatter?: ScatterSeriesOptions; + spline?: SplineSeriesOptions; + splinearea?: SplineAreaSeries; + stackedarea?: StackedAreaSeries; + stackedbar?: StackedBasrSeriesOptions; + stackedline?: StackedLineSeries; + steparea?: StepAreaSeries; + stepline?: StepLineSeries; + stock?: StockSeriesOptions; + bubble?: BubbleSeriesOptions; + } + export class Point { + fullState: number; + originalArgument: any; + originalValue: any; + series: Series; + tag: any; + clearSelection(): void; + select(): void; + hideTootip(): void; + isSelected(): boolean; + isHovered(): boolean; + } + export class PiePoint { + fullState: number; + originalArgument: any; + originalValue: any; + percent: any; + series: PieSeries; + tag: any; + clearSelection(): void; + select(): void; + hideTootip(): void; + isSelected(): boolean; + isHovered(): boolean; + } + export class Series { + axis: string; + fullState: number; + name: string; + pane: string; + tag: any; + type: string; + clearSelection(): void; + deselectPoint(point: Point): void; + getAllPoints(): Array + getPointByArg(pointArg: any): Point; + getPointByPos(positionIndex: number): Point; + select(): void; + selectPoint(point: Point): void; + isSelected(): boolean; + isHovered(): boolean; + } + export class PieSeries { + fullState: number; + type: string; + clearSelection(): void; + deselectPoint(point: PiePoint): void; + getAllPoints(): Array + getPointByArg(pointArg: any): PiePoint; + getPointByPos(positionIndex: number): PiePoint; + select(): void; + selectPoint(point: PiePoint): void; + isSelected(): boolean; + isHovered(): boolean; + } +} +declare module DevExpress.viz.common { + export interface FontOptions { + color?: string; + family?: string; + opacity?: number; + size?: number; + weight?: number; + } + export interface tickIntervalObject { + years?: number; + quarters?: number; + months?: number; + days?: number; + hours?: number; + minutes?: number; + seconds?: number; + milliseconds?: number; + } +} +declare module DevExpress.viz.gauges { + interface CustomizeTextArgument { + value: number; + valueText: string; + } + interface z_textOptions { + format?: string; + precision?: number; + customizeText?: (arg: CustomizeTextArgument) => string; + font?: viz.common.FontOptions; + } + interface z_textOptionsWithIndent extends z_textOptions { + indent?: number; + } + interface z_BaseGaugeOptions { + size?: { + width?: number; + height?: number; + }; + margin?: { + left?: number; + right?: number; + top?: number; + bottom?: number; + }; + containerBackgroundColor?: string; + animationEnabled?: boolean; + animationDuration?: number; + redrawOnResize?: boolean; + title?: { + position?: string; + text?: string; + font?: viz.common.FontOptions; + }; + subtitle?: { + text?: string; + font?: viz.common.FontOptions; + }; + tooltip?: { + enabled?: boolean; + format?: string; + precision?: number; + customizeText?: (arg: CustomizeTextArgument) => string; + font?: viz.common.FontOptions; + }; + value?: number; + subvalues?: Array + } + interface z_BaseRangeContainer { + offset?: number; + backgroundColor?: string; + ranges?: Array<{ + startValue?: number; + endValue?: number; + color?: string; + }> + } + interface z_BaseScale { + startValue?: number; + endValue?: number; + hideFirstTick?: boolean; + hideLastTick?: boolean; + hideFirstLabel?: boolean; + hideLastLabel?: boolean; + majorTick?: { + color?: string; + length?: number; + width?: number; + customTickValues?: Array; + useTicksAutoArrangement?: boolean; + tickInterval?: number; + showCalculatedTicks?: boolean; + visible?: boolean; + }; + minorTick?: { + color?: string; + length?: number; + width?: number; + customTickValues?: Array; + tickInterval?: number; + showCalculatedTicks?: boolean; + visible?: boolean; + }; + label?: z_textOptions; + } + interface z_BaseValueIndicator { + color?: string; + baseValue?: number; + size?: number; + backgroundColor?: string; + text?: z_textOptionsWithIndent; + } + interface z_BaseSubValueIndicator { + type?: string; + length?: number; + width?: number; + color?: string; + arrowLength?: number; + text?: z_textOptions; + } + export interface CircularGaugeRangeContainer extends z_BaseRangeContainer { + width?: number; + orientation?: string; + } + export interface CircularGaugeScale extends z_BaseScale { + orientation: string; + label: { + format?: string; + precision?: number; + customizeText?: (arg: CustomizeTextArgument) => string; + font?: viz.common.FontOptions; + indentFromTick?: number; + } + } + export interface CircularGaugeValueIndicator extends z_BaseValueIndicator { + type?: string; + offset?: number; + indentFromCenter?: number; + width?: number; + secondColor?: string; + secondFraction?: number; + spindleSize?: number; + spindleGapSize?: number; + } + export interface CircularGaugeSubValueIndicator extends z_BaseSubValueIndicator { + offset?: number; + } + export interface CircularGaugeOptions extends z_BaseGaugeOptions { + rangeContainer?: CircularGaugeRangeContainer; + geometry?: { + startAngle?: number; + endAngle?: number; + }; + scale?: CircularGaugeScale; + valueIndicator?: CircularGaugeValueIndicator; + spindle?: { + visible?: boolean; + size?: number; + gapSize?: number; + color?: string; + } + } + export interface LinearGaugeScale extends z_BaseScale { + verticalOrientation?: string; + horizontalOrientation?: string; + label?: { + format?: string; + precision?: number; + customizeText?: (arg: CustomizeTextArgument) => string; + font?: viz.common.FontOptions; + indentFromTick?: number; + } + } + export interface LinearGaugeRangeContainer extends z_BaseRangeContainer { + width?: { + start?: number; + end?: number; + }; + verticalOrientation?: string; + horizontalOrientation?: string; + } + export interface LinearGaugeValueIndicator extends z_BaseValueIndicator { + offset?: number; + horizontalOrientation?: string; + verticalOrientation?: string; + length?: number; + width?: number; + } + export interface LinearGaugeSubValueIndicator extends z_BaseSubValueIndicator { + offset?: number; + horizontalOrientation?: string; + verticalOrientation?: string; + } + export interface LinearGaugeOptions extends z_BaseGaugeOptions { + geometry?: { + orientation?: string; + }; + scale?: LinearGaugeScale; + valueIndicator?: LinearGaugeValueIndicator; + } +} +declare module DevExpress.viz.map { + export interface VectorMapOptions { + size?: { + width?: number; + height?: number; + }; + theme?: string; + background?: { + borderColor?: string; + color?: string; + }; + dataSource?: any; + area?: { + borderColor?: string; + color?: string; + hoveredBorderColor?: string; + hoveredColor?: string; + selectedBorderColor?: string; + selectedColor?: string; + hoverEnabled?: boolean; + selectionMode?: string; + palette?: any; + paletteSize?: number; + customize?: (arg: any) => AreaOptions; + click?: (arg: Proxy) => void; + selectionChanged?: (arg: Proxy) => void; + }; + markerDataSource?: any; + marker?: { + borderColor?: string; + color?: string; + hoveredBorderColor?: string; + hoveredColor?: string; + selectedBorderColor?: string; + selectedColor?: string; + font?: common.FontOptions; + hoverEnabled?: boolean; + selectionMode?: string; + customize?: (arg: any) => MarkerOptions; + click?: (arg: Proxy) => void; + selectionChanged?: (arg: Proxy) => void; + }; + controlBar?: { + enabled?: boolean; + borderColor?: string; + color?: string; + }; + tooltip?: { + enabled?: boolean; + borderColor?: string; + color?: string; + font?: common.FontOptions; + }; + bounds?: { + minLat?: number; + maxLat?: number; + minLon?: number; + maxLon?: number; + }; + center?: { + lat?: number; + lon?: number; + }; + zoomFactor?: number; + } + export interface AreaOptions { + borderColor?: string; + color?: string; + hoveredBorderColor?: string; + hoveredColor?: string; + selectedBorderColor?: string; + selectedColor?: string; + paletteIndex?: number; + isSelected?: boolean; + } + export interface MarkerOptions { + borderColor?: string; + color?: string; + hoveredBorderColor?: string; + hoveredColor?: string; + selectedBorderColor?: string; + selectedColor?: string; + isSelected?: boolean; + } + export class Proxy { + type: string; + attr(name: string): any; + selected(state: boolean): void; + selected(): boolean; + } +} +declare module DevExpress.viz.rangeSelector { + export interface SelectedRange { + startValue: any; endValue: any; + } + interface CustomizeTextArgument { + value: any; + valueText: string; + } + export interface RangeSelectorOptions { + background?: { + color?: string; + image?: { + location?: string; + url?: string; + } + visible?: boolean; + }; + behavior?: { + allowSlidersSwap?: boolean; + animationEnabled?: boolean; + callSelectedRangeChanged?: string; + manualRangeSelectionEnabled?: boolean; + moveSelectedRangeByClick?: boolean; + snapToTicks?: boolean; + }; + chart?: { + bottomIndent?: number; + equalBarWidth?: { + spacing?: number; + width?: number; + }; + dataPrepareSettings?: { + checkTypeForAllData?: boolean; + convertToAxisDataType?: boolean; + sortingMethod?: any; + }; + useAggregation?: boolean; + series?: Array; + commonSeriesSettings?: viz.charts.series.commonSeriesSettings; + topIndent?: number; + valueAxis?: { + max?: any; min?: any; inverted?: boolean; + valueType?: string; + }; + } + containerBackgroundColor?: string; + dataSource?: Array<{}>; + dataSourceField?: string; + margin?: { + left?: number; + top?: number; + right?: number; + bottom?: number; + }; + redrawOnResize?: boolean; + scale?: { + startValue?: any; endValue?: any; + label?: { + customizeText?: (arg: CustomizeTextArgument) => string; + font?: viz.common.FontOptions; + format?: string; + precision?: number; + topIndent?: number; + visible?: boolean; + }; + majorTickInterval?: any; marker?: { + label?: { + customizeText?: (arg: CustomizeTextArgument) => string; + format?: string; + }; + separatorHeight?: number; + textLeftIndent?: number; + textTopIndent?: number; + topIndent?: number; + visible?: boolean; + }; + maxRange?: any; minorTickCount?: number; + placeHolderHeight?: number; + setTicksAtUnitBeginning?: boolean; + showCustomBoundaryTicks?: boolean; + showMinorTicks?: boolean; + tick?: { + color?: string; + opacity?: number; + width?: number; + }; + minorTickInterval?: any; useTicksAutoArrangement?: boolean; + valueType?: string; + } + selectedRange?: SelectedRange; + selectedRangeChaged?: (startValue, endValue) => void; + shutter?: { + color?: string; + opacity?: string; + } + size?: { + width?: number; + height?: number; + }; + sliderHandle?: { + color?: string; + opacity?: number; + width?: string; + }; + sliderMarker?: { + color?: string; + customizeText?: (arg: CustomizeTextArgument) => string; + font?: viz.common.FontOptions; + format?: string; + invalidRangeColor?: string; + padding?: number; + placeHolderSize?: { + height?: number; + width?: { + left?: number; + right?: number; + } + precission?: number; + visible?: boolean; + } + }; + theme?: string; + } +} +declare module DevExpress.viz.sparklines { + interface SparklineTooltipOptions { + customizeText?: (arg: { + firstValue?: string; + lastValue?: string; + maxValue?: string; + minValue?: string; + originalFirstValue?: any; + originalLastValue?: any; + originalMaxValue?: any; + originalMinValue?: any; + }) => string; + enabled?: boolean; + allowContainerResizing?: boolean; + position?: string; + format?: string; + precision?: number; + color?: string; + font?: common.FontOptions; + } + interface z_BaseSparklineSettings { + theme?: string; + size?: { + width?: number; + height?: number; + }; + tooltip?: SparklineTooltipOptions; + } + interface SparklineOptions extends z_BaseSparklineSettings { + dataSource?: Array; + argumentField?: string; + valueField?: string; + type?: string; + lineColor?: string; + lineWidth?: number; + showFirstLast?: boolean; + showMinMax?: boolean; + minColor?: string; + maxColor?: string; + firstLastColor?: string; + barPositiveColor?: string; + barNegativeColor?: string; + winColor?: string; + lossColor?: string; + pointSymbol?: string; + pointSize?: number; + pointColor?: string; + winlossThreshold?: number; + } + interface BulletTooltipOptions extends SparklineTooltipOptions { + customizeText?: (arg: { + originalValue?: any; + originalTarget?: any; + value?: string; + target?: string; + }) => string; + } + interface BulletOptions extends z_BaseSparklineSettings { + value?: number; + target?: number; + endScaleValue?: number; + color?: string; + targetColor?: string; + targetWidth?: number; + targetVisible?: boolean; + tooltip?: BulletTooltipOptions; + } +} +interface JQuery { + dxChart(options?: DevExpress.viz.charts.ChartOptions): JQuery; + dxChart(method: string, param1?: any, param2?: any): any; + dxPieChart(options?: DevExpress.viz.charts.PieOptions): JQuery; + dxPieChart(method: string, param1?: any, param2?: any): any; + dxRangeSelector(options?: DevExpress.viz.rangeSelector.RangeSelectorOptions): JQuery; + dxRangeSelector(method: string, param1?: any, param2?: any): any; + dxCircularGauge(options?: DevExpress.viz.gauges.CircularGaugeOptions): JQuery; + dxCircularGauge(method: string, param1?: any, param2?: any): any; + dxLinearGauge(options?: DevExpress.viz.gauges.LinearGaugeOptions): JQuery; + dxLinearGauge(method: string, param1?: any, param2?: any): any; + dxSparkline(options?: DevExpress.viz.sparklines.SparklineOptions): JQuery; + dxSparkline(method: string, param1?: any, param2?: any): any; + dxBullet(options?: DevExpress.viz.sparklines.BulletOptions): JQuery; + dxBullet(method: string, param1?: any, param2?: any): any; + dxVectorMap(options?: DevExpress.viz.map.VectorMapOptions): JQuery; + dxVectorMap(method: string, param1?: any, param2?: any): any; +} \ No newline at end of file diff --git a/phonejs/dx.phonejs-tests.ts b/phonejs/dx.phonejs-tests.ts new file mode 100644 index 000000000..41fbc2c11 --- /dev/null +++ b/phonejs/dx.phonejs-tests.ts @@ -0,0 +1,265 @@ +/// + +module Test { + var url = "http://some-json-service.net/data.json"; + var dsFromUrl = new DevExpress.data.DataSource(url); + + var dsFromObject = new DevExpress.data.DataSource({ + load: function (loadOptions?: DevExpress.data.LoadOptions) { + return $.ajax(url); + } + }); + + var application = new DevExpress.framework.html.HtmlApplication({ + namespace: "global", + defaultLayout: "slideout", + navigation: [ + { title: "Home", action: "#home" }, + { title: "About", action: "#about" } + ] + }); + application.router.register(":view/:id", { view: "home", id: undefined }); + application.navigate(); + + $("div").appendTo(document.body).dxMap({ + location: [40.749825, -73.987963], + zoom: 13, + provider: "googleStatic", + controls: true, + routes: [ + { + weight: 4, + opacity: 0.75, + color: "red", + mode: "walking", + locations: [ + [40.737102, -73.990318], + [40.749825, -73.987963], + [40.75, -73.98], + [40.755823, -73.986397] + ] + } + ] + }); + $("div").appendTo(document.body).dxTabs({ + itemClickAction: function (e) { + console.log(e.itemData.text); + }, + items: [ + { text: "user" }, + { text: "analytics" }, + { text: "customers" }, + { text: "search" }, + { text: "favorites" } + ] + }); + + $("div").appendTo(document.body).dxList({ + scrollByContent: true, + items: ["item1", "item2", "item3"], + itemHoldAction: function (e: any) { console.log("itemHold"); }, + itemClickAction: function (e: any) { console.log("itemClick"); }, + itemSwipeAction: function (e: any) { console.log("itemSwipe " + e.direction); } + }); + $("div").appendTo(document.body).dxToast({ + type: 'error', + message: 'Sample error message' + }); + $("div").appendTo(document.body).dxPopup({ + closeButton: true, + title: "Popup title" + }); + $("div").appendTo(document.body).dxPivot({ + items: [ + { title: "all", text: "all" }, + { title: "unread", text: "unread" }, + { title: "favorites", text: "favorites" } + ], + itemSelectAction: function (e) { console.log("itemSelectAction"); } + }); + $("div").appendTo(document.body).dxLookup({ + items: [ + { id: 1, caption: "red" }, + { id: 3, caption: "blue" }, + { id: 6, caption: "white" }, + { id: 2, caption: "green" }, + { id: 4, caption: "yellow" }, + { id: 5, caption: "orange" }, + { id: 7, caption: "purple" } + ], + valueExpr: 'id', + displayExpr: 'caption', + itemRender: function (item) { + return "Text is: " + item.caption; + } + }); + $("div").appendTo(document.body).dxSlider({ + min: 50, + value: 75, + max: 100, + disabled: false + }); + $("div").appendTo(document.body).dxNavBar({ + items: [ + { text: "user", icon: "user" }, + { text: "find", icon: "find", disabled: false }, + { text: "favorites", icon: "favorites" }, + { text: "about", icon: "info" }, + { text: "home", icon: "home" }, + { text: "URI", icon: "tips" } + ], + itemClickAction: function (e) { console.log(e.itemData.text); } + }); + $("div").appendTo(document.body).dxSwitch({ + value: false, + onText: 'LongName', + offText: 'Short', + width: "100%", + visible: true + }); + $("div").appendTo(document.body).dxButton({ + text: "Click me", + icon: 'add', + clickAction: function () { console.log("clicked"); } + }); + $("div").appendTo(document.body).dxOverlay({ + visible: false, + closeOnOutsideClick: true, + contentReadyAction: function () { + $("#hideButton").dxButton({ + text: "Hide", + clickAction: function () { $("#overlay").data("dxOverlay").option("visible", false); } + }); + } + }); + $("div").appendTo(document.body).dxDateBox({ + value: new Date(), + format: "datetime" + }); + $("div").appendTo(document.body).dxPopover({ + width: '300', + height: 'auto', + visible: true, + target: '.dx-button' + }); + $("div").appendTo(document.body).dxEditBox({ + value: "Value", + readOnly: false, + enterKeyAction: function (e) { console.log("key entered"); }, + focusOutAction: function (e) { console.log("focus out"); }, + focusInAction: function (e) { console.log("focus in"); } + }); + $("div").appendTo(document.body).dxTextBox({ + value: "Text", + placeholder: "Placeholder", + mode: "email", + maxLength: 20, + readOnly: false, + changeAction: function (e) { console.log("value changed"); }, + valueUpdateAction: function (e) { console.log("value updated"); } + }); + $("div").appendTo(document.body).dxToolbar({ + items: [ + { align: 'left', widget: 'button', options: { type: 'back', text: 'Back', clickAction: function (e) { console.log("back clicked"); } } }, + { align: 'center', widget: 'button', options: { text: 'button', clickAction: function (e) { console.log("button clicked"); } } }, + { align: 'center', widget: 'button', options: { icon: 'plus', text: 'add', clickAction: function (e) { console.log("plus clicked"); } } }, + { align: 'right', widget: 'button', options: { icon: 'find', clickAction: function (e) { console.log("find clicked"); } }, useMenu: false }, + { text: 'Products', isMenu: true } + ] + }); + $("div").appendTo(document.body).dxTileView({ + items: [ + { text: "item1", widthRatio: 1.7, heightRatio: 1.7 }, + { text: "item2", widthRatio: 0.2, heightRatio: 0.2 }, + { text: "item3", widthRatio: 2, heightRatio: 2 } + ], + listHeight: 500, + itemRender: function (item) { return "Text is: " + item.text; }, + itemClickAction: function () { console.log("itemClick"); }, + baseItemWidth: 100, + baseItemHeight: 100, + itemMargin: 20 + }); + $("div").appendTo(document.body).dxPanorama({ + title: "my panorama", + items: [ + { header: "first", text: "first item" }, + { text: "second item" }, + { text: "third" }, + { text: "fourth" } + ], + selectedIndex: 0, + backgroundImage: { width: 89, height: 50 }, + itemSelectAction: function () { console.log("item selected"); } + }); + $("div").appendTo(document.body).dxCheckBox({ + checked: false, + disabled: false, + clickAction: function (e) { console.log("clicked"); } + }); + $("div").appendTo(document.body).dxTextArea({ + value: 'Disabled', + disabled: true, + placeholder: "Placeholder" + }); + $("div").appendTo(document.body).dxLoadPanel({ + message: 'Please wait ...', + showIndicator: true, + visible: true + }); + $("div").appendTo(document.body).dxNumberBox({ + value: 100, + min: 0, + max: 200 + }); + $("div").appendTo(document.body).dxSelectBox({ + value: 2, + dataSource: new DevExpress.data.DataSource([1, 2, 2, 3]) + }); + $("div").appendTo(document.body).dxScrollable({ + useNative: false, + startAction: function (e) { console.log("start"); }, + endAction: function (e) { console.log("end"); } + }); + $("div").appendTo(document.body).dxRadioGroup({ + items: [{ text: "0" }, { text: "1" }, { text: "2" }], + name: "Sample", + selectedIndex: -1 + }); + $("div").appendTo(document.body).dxScrollView({ + pullDownAction: function (e) { console.log("pulling down"); }, + reachBottomAction: function (e) { console.log("bottom reached"); }, + disabled: false + }); + $("div").appendTo(document.body).dxActionSheet({ + title: 'Select action', + items: [ + { text: "Reply", clickAction: function () { console.log("Reply"); } }, + { text: "Forward", clickAction: function () { console.log("Forward"); } }, + { text: "Delete", clickAction: function () { console.log("Delete"); }, type: "danger" }, + { text: "Save Image", clickAction: function () { console.log("Save Image"); }, disabled: true } + ], + showTitle: true, + disabled: false, + target: '#button' + }); + $("div").appendTo(document.body).dxRangeSlider({ + start: 30, + end: 70, + min: 0, + max: 100, + step: 1 + }); + $("div").appendTo(document.body).dxAutocomplete({ + value: "Ivan", + dataSource: new DevExpress.data.DataSource(["Ivan", "Svyatoslav", "Alexander", "Nikolay", "Dmitry", "Afanasiy", "John", "Nash", "Stacy", "Izabella", "Margarita", "Anna"]), + placeholder: "Type name, please", + maxItemsCount: 3, + minSearchLength: 2, + searchTimeout: 1000 + }); + $("div").appendTo(document.body).dxDropDownMenu({ + items: ["Item 1", "Item 2", "Item 3"], + itemTemplate: 'itemWithIcon' + }); +} \ No newline at end of file diff --git a/phonejs/dx.phonejs.d.ts b/phonejs/dx.phonejs.d.ts new file mode 100644 index 000000000..05d4f8c97 --- /dev/null +++ b/phonejs/dx.phonejs.d.ts @@ -0,0 +1,1234 @@ +// Type definitions for PhoneJS 13.2 +// Project: http://phonejs.devexpress.com +// Definitions by: Developer Express Inc. +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/// + +declare module DevExpress { + export function abstract(); + interface Endpoint { + local?: string; + production: string; + } + class EndpointSelector { + constructor(config: { [key: string]: Endpoint }); + urlFor(key: string): string; + } + export interface ActionOptions { + context?: Object; + component?: any; + beforeExecute? (e: ActionExecuteArgs): void; + afterExecute? (e: ActionExecuteArgs): void; + } + export interface ActionExecuteArgs { + action: any; + args: any[]; + context: any; + component: any; + canceled: boolean; + handled: boolean; + } + export class Action { + constructor(action?: any, config?: ActionOptions); + execute(): any; + } + export module devices { + interface Device { + phone?: boolean; + tablet?: boolean; + android?: boolean; + ios?: boolean; + win8?: boolean; + tizen?: boolean; + platform?: string; + } + export function current(): Device; + export function current(device: Device): Device; + } +} +declare module DevExpress.data { + export interface ErrorHandler { (e: Error): void; } + export interface EntityOptions { key: any; keyType: any; } + export interface Getter { (obj: any, options?: any): any; } + export interface Setter { (obj: any, value: any, options?: any) } + export interface QueryOptions { + errorHandler?: ErrorHandler; + requireTotalCount?: boolean; + } + export interface ODataQueryOptions extends QueryOptions { + adapter?: any; + } + interface IQuery { + enumerate(): JQueryDeferred>; + count(): JQueryDeferred; + slice(skip: number, take?: number): IQuery; + sortBy(field: string[]): IQuery; + sortBy(field: Getter[]): IQuery; + sortBy(field: { field: string; desc?: boolean }[]): IQuery; + sortBy(field: { field: Getter; desc?: boolean }[]): IQuery; + thenBy(field: string[]): IQuery; + thenBy(field: Getter[]): IQuery; + thenBy(field: { field: string; desc?: boolean }[]): IQuery; + thenBy(field: { field: Getter; desc?: boolean }[]): IQuery; + filter(field: string, operator: string, value: any): IQuery; + filter(field: string, value: any): IQuery; + filter(criteria: any[]): IQuery; + select(field: string): IQuery; + select(field: string[]): IQuery; + select(...field: string[]): IQuery; + select(field: Getter): IQuery; + select(field: Getter[]): IQuery; + select(...field: Getter[]): IQuery; + groupBy(field: string[]): IQuery; + groupBy(field: Getter[]): IQuery; + groupBy(field: { field: string; desc?: boolean }[]): IQuery; + groupBy(field: { field: Getter; desc?: boolean }[]): IQuery; + sum(getter?: string): JQueryDeferred; + min(getter?: string): JQueryDeferred; + max(getter?: string): JQueryDeferred; + avg(getter?: string): JQueryDeferred; + aggregate(step: number): JQueryDeferred; + aggregate(seed: number, step: (accumulator: any, current: any) => any, finalize?: (accumulator: any) => any): JQueryDeferred; + } + export interface ArrayQuery extends IQuery { + toArray(): Array; + } + export interface RemoteQuery extends IQuery { /*todo: exec() ? */ } + export function base64_encode(input: string): string; + export function base64_encode(input: any[]): string; + export function query(items?: any[]): IQuery; + export var queryImpl: { + remote: (url: string, queryOptions: QueryOptions) => RemoteQuery; + array: (iter: Array, queryOptions: QueryOptions) => ArrayQuery; + }; + export class Guid { + constructor(value?: string); + constructor(value?: any); + toString(): string; + valueOf(): string; + toJSON(): string; + } + export class EdmLiteral { + constructor(value: any); + valueOf(): any; + } + export module utils { + export function normalizeSortingInfo(info: string): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: string[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: Getter): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: Getter[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { field: string; dir?: string }): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { field: string; dir?: string }[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { field: string; desc?: boolean }): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { field: string; desc?: boolean }[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { selector: string; dir?: string }): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { selector: string; dir?: string }[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { selector: string; desc?: boolean }): Array<{ selector: string; desc?: boolean }>; + export function normalizeSortingInfo(info: { selector: string; desc?: boolean }[]): Array<{ selector: string; desc?: boolean }>; + export function normalizeBinaryCriterion(criteria: Array): Array; + export function keysEqual(keyExpr, key1, key2): boolean; + export function toComparable(value: Date, caseSensitive?: boolean): number; + export function toComparable(value: Guid, caseSensitive?: boolean): string; + export function toComparable(value: string, caseSensitive?: boolean): string; + export function compileGetter(): Getter; + export function compileGetter(expr: any[]): Getter; + export function compileGetter(expr: string): Getter; + export function compileGetter(expr: "this"): Getter; + export function compileGetter(expr: Getter): Getter; + export function compileSetter(expr: string): Setter; + export module odata { + export function sendRequest(request: JQueryXHR, requestOptions?: JQueryAjaxSettings); + export function serializePropName(propName: EdmLiteral): string; + export function serializePropName(propName: string): string; + export function serializeValue(value: Date): string; + export function serializeValue(value: Guid): string; + export function serializeValue(value: string): string; + export function serializeValue(value: "string"): string; + export function serializeValue(value: EdmLiteral): string; + export function serializeKey(key: any): string; + export function serializeKey(key: Date): string; + export function serializeKey(key: Guid): string; + export function serializeKey(key: string): string; + export function serializeKey(key: "string"): string; + export function serializeKey(key: EdmLiteral): string; + export var keyConverters: { + String(value: any): string; + Guid(value: any): Guid; + Int32(value: any): number; + Int64(value: any): EdmLiteral; + }; + } + } + export module queryAdapters { + export function odata(queryOptions: ODataQueryOptions): RemoteQuery; + } + export interface DataSourceOptions { + map? (item: any): any; + postProcess? (result: any[]): any; + pageSize: number; + paginate: boolean; + } + export class DataSource { + public changed: JQueryCallback; + public loadError: JQueryCallback; + public loadingChanged: JQueryCallback; + constructor(options?: Store); + constructor(options?: string); + constructor(options?: Array); + constructor(options?: { store: Store }); + constructor(options?: CustomStoreOptions); + constructor(options?: { store: Array }); + constructor(options?: { store: { type: string } }); + constructor(options?: { load(options?: LoadOptions): JQueryXHR; }); + constructor(options?: { load(options?: LoadOptions): Array; }); + constructor(options?: { load(options?: LoadOptions): JQueryDeferred; }); + constructor(options?: DataSourceOptions); + loadOptions(): { [key: string]: any }; + items(): Array; + store(): data.Store; + isLastPage(): boolean; + pageIndex(newIndex?: number): number; + sort(expr: any[]): any[]; + group(expr: any[]): any[]; + filter(expr: any[]): any[]; + select(expr: string[]): string[]; + searchValue(value?: string): string; + searchOperation(op?: string): string; + searchExpr(selector: string): string; + key(): any; + isLoaded(): boolean; + isLoading(): boolean; + totalCount(): number; + load(): JQueryDeferred; + dispose(): void; + } + export interface StoreOptions { + key?: any; + errorHandler: ErrorHandler; + loaded?: JQueryCallback; + loading?: JQueryCallback; + modified?: JQueryCallback; + modifying?: JQueryCallback; + inserted?: JQueryCallback; + inserting?: JQueryCallback; + updated?: JQueryCallback; + updating?: JQueryCallback; + removed?: JQueryCallback; + removing?: JQueryCallback; + } + export interface LoadOptions extends QueryOptions { + skip?: number; + take?: number; + sort?: any; + select?: any; + filter?: any; + group?: any; + } + export class Store { + loaded: JQueryCallback; + loading: JQueryCallback; + modified: JQueryCallback; + modifying: JQueryCallback; + inserted: JQueryCallback; + inserting: JQueryCallback; + updated: JQueryCallback; + updating: JQueryCallback; + removed: JQueryCallback; + removing: JQueryCallback; + constructor(options?: StoreOptions); + key(): any; + keyOf(obj: any): any; + load(options?: LoadOptions): JQueryDeferred; + createQuery(options?: QueryOptions): IQuery; + totalCount(options?: { + filter?: any[]; + group?: string[]; + }): JQueryDeferred; + byKey(key: any, extraOptions?: { + expand?: string[] + }): JQueryDeferred; + remove(key: any): JQueryDeferred; + insert(values: any): JQueryDeferred; + update(key: any, values: any): JQueryDeferred; + } + export interface CustomStoreOptions extends StoreOptions { + load? (options?: LoadOptions): any; + byKey? (key: any): any; + insert? (values: any): any; + update? (key: any, values: any): any; + remove? (key: any): any; + totalCount? (options?: { + filter?: any[]; + group?: string[]; + }): any; + } + export class CustomStore extends Store { + constructor(options?: CustomStoreOptions); + } + export interface ArrayStoreOptions extends StoreOptions { + data?: Array + } + export class ArrayStore extends Store { + constructor(options?: Array); + constructor(options?: ArrayStoreOptions); + } + export interface LocalStoreOptions extends ArrayStoreOptions { + name: string; + } + export class LocalStore extends ArrayStore { + constructor(options?: string); + constructor(options?: LocalStoreOptions); + clear(): void; + } + export interface ODataStoreOptions extends StoreOptions { + url?: string; + name?: string; + keyType?: string; + jsonp?: boolean; + withCredentials?: boolean; + } + export class ODataStore extends Store { + constructor(options?: ODataStoreOptions); + } + interface IODataContextBase { + get(operationName: string, params: { [key: string]: any }): JQueryDeferred>; + invoke(operationName: string, params: { [key: string]: any }, httpMethod?: string): JQueryDeferred>; + objectLink(entityAlias: string, key: any): { __metadata: { uri: string }; } + } + interface IODataContext extends IODataContextBase { + [entitySetName: string]: Store; + } + export interface ODataContextOptions { + url: string; + jsonp?: boolean; + withCredentials?: boolean; + errorHandler?: ErrorHandler; + beforeSend?: () => any; + entities?: Array; + } + export class ODataContext implements IODataContextBase { + constructor(options?: ODataContextOptions); + get(operationName: string, params: { [key: string]: any }): JQueryDeferred>; + invoke(operationName: string, params: { [key: string]: any }, httpMethod?: string): JQueryDeferred>; + objectLink(entityAlias: string, key: any): { __metadata: { uri: string }; } + } +} +declare module DevExpress.framework { + interface NavigationItem { + title: string; + icon?: string; + root?: boolean; + action: any; + } + export interface dxViewOptions { + name: string; + title: string; + layout: string; + } + export class dxView extends ui.Component { + constructor(options?: dxViewOptions); + } + export interface dxLayoutOptions { + name: string; + controller: string; + } + export class dxLayout extends ui.Component { + constructor(options?: dxLayoutOptions); + } + export interface dxViewPlaceholderOptions { + viewName: string; + } + export class dxViewPlaceholder extends ui.Component { + constructor(options?: dxLayoutOptions); + } + export interface dxTransitionOptions { + name: string; + type: string; + } + export class dxTransition extends ui.Component { + constructor(options?: dxLayoutOptions); + } + export interface dxContentPlaceholderOptions { + name: string; + transition: string; + } + export class dxContentPlaceholder extends ui.Component { + constructor(options?: dxLayoutOptions); + } + export interface dxContentOptions { + targetPlaceholder: string; + } + export class dxContent extends ui.Component { + constructor(options?: dxLayoutOptions); + } + export interface CommandOptions extends ui.ComponentOptions { + id: string; + action: any; + icon: string; + title: string; + iconSrc: string; + visible: boolean; + } + export class dxCommand extends ui.Component { + public beforeExecute: JQueryCallback; + public afterExecute: JQueryCallback; + constructor(element: JQuery, options?: CommandOptions); + constructor(element: Element, options?: CommandOptions); + execute(): void; + } + export class dxCommandContainer extends ui.Component { + constructor(options: ui.ComponentOptions); + constructor(element: JQuery, options?: ui.ComponentOptions); + constructor(element: Element, options?: ui.ComponentOptions); + } + export interface CommandMap { + [containerId: string]: { commands: any[]; defaults?: any; } + } + export class CommandMapping { + constructor(); + static defaultMapping: CommandMap; + mapCommands(containerId: string, commandMappings: any[]): CommandMapping; + unmapCommands(containerId: string, commandIds: string[]): void; + getCommandMappingForContainer(commandId: string, containerId: string): any; + load(config: CommandMap): CommandMapping; + } + interface IViewCache { + setView(key: string, viewInfo: any); + removeView(key: string); + hasView(viewInfo: any); + getView(key: string); + clear(); + } + export class ViewCache implements IViewCache { + constructor(); + setView(key: string, viewInfo: any); + removeView(key: string): any; + hasView(viewInfo: any): boolean; + getView(key: string): any; + clear(); + } + export class NullViewCache implements IViewCache { + constructor(); + setView(key: string, viewInfo: any); + removeView(key: string): any; + hasView(viewInfo: any): boolean; + getView(key: string): any; + clear(); + } + export interface IStorage { + getItem(key: string); + setItem(key: string, value: any); + removeItem(key: string); + } + export class MemoryKeyValueStorage implements IStorage { + constructor(); + getItem(key: string); + setItem(key: string, value: any); + removeItem(key: string); + } + export interface StateManagerOptions { + storage?: IStorage; + stateSources?: any[]; + } + export class StateManager { + public storage: IStorage; + public stateSources: any[]; + constructor(options?: StateManagerOptions); + addStateSource(stateSource: any): void; + removeStateSource(stateSource: any): void; + saveState(): void; + restoreState(): void; + clearState(): void; + } + export class Route { + constructor(pattern: string, defaults?: any, constraints?: any); + parse(url: string): any; + format(routeValues: any): string; + formatSegment(value: any): string; + parseSegment(): any; + } + export class MvcRouter { + constructor(); + register(pattern: string, defaults?: any, constraints?: any): void; + parse(uri: string): any; + format(obj: any): string; + } + interface BrowserAdapterOptions { + window: Window; + } + export class DefaultBrowserAdapter { + constructor(options?: BrowserAdapterOptions); + replaceState(uri: string): void; + pushState(uri: string): void; + createRootPage(): void; + getWindowName(): string; + setWindowName(windowName: string): void; + back(): void; + getHash(): string; + isRootPage(): boolean; + } + export class OldBrowserAdapter extends DefaultBrowserAdapter { } + export class HistorylessBrowserAdapter extends DefaultBrowserAdapter { } + export interface INavigationDevice { + setUri(uri: string): void; + getUri(): string; + back(): void; + } + export class BrowserNavigationDevice implements INavigationDevice { + constructor(options?: BrowserAdapterOptions); + setUri(uri: string): void; + getUri(): string; + back(): void; + } + export class NavigationStack { + public items: any[]; + public currentIndex: number; + public itemsRemoved: JQueryCallback; + constructor(); + currentItem(): any; + back(uri: string): void; + forward(): void; + navigate(uri: string, replaceCurrent?: boolean): any; + getPreviousItem(): any; + canBack(): boolean; + clear(): void; + } + export interface NavigationManagerOptions { + stateStorageKey?: string; + navigationDevice?: INavigationDevice; + keepPositionInStack?: boolean; + } + export class NavigationManager { + public currentUri: string; + public currentStack: NavigationStack; + public navigationStacks: { + [key: string]: NavigationStack + }; + public navigating: JQueryCallback; + public navigated: JQueryCallback; + public navigatingBack: JQueryCallback; + public navigationCanceled: JQueryCallback; + public itemRemoved: JQueryCallback; + constructor(options?: NavigationManagerOptions); + navigate(uri, options?: { + root?: boolean; + target?: string; + direction?: string; + }): void; + back(alternate): void; + rootUri(): string; + canBack(): boolean; + currentItem(): any; + currentIndex(): number; + getPreviousItem(): any; + getItemByIndex(index: number): any; + saveState(storage: IStorage): void; + restoreState(storage: IStorage): void; + removeState(storage: IStorage): void; + clearHistory(): void; + static NAVIGATION_TARGETS: { + [key: string]: string + }; + } + export module utils { + export function mergeCommands(destination: any, source: any); + } + export interface ApplicationOptions { + router?: MvcRouter; + namespace?: any; + disableViewCache?: boolean; + stateManager?: StateManager; + navigationManager?: NavigationManager; + navigation?: NavigationItem[]; + commandMapping?: CommandMap; + } + export class Application { + public router: MvcRouter; + public namespace: any; + public components: any[]; + public stateManager: StateManager; + public commandMapping: CommandMap; + public navigation: NavigationItem[]; + public navigationManager: NavigationManager; + public beforeViewSetup: JQueryCallback; + public afterViewSetup: JQueryCallback; + public viewShowing: JQueryCallback; + public viewShown: JQueryCallback; + public viewHidden: JQueryCallback; + public viewDisposing: JQueryCallback; + public viewDisposed: JQueryCallback; + public navigating: JQueryCallback; + constructor(options?: ApplicationOptions); + init(): any; + navigate(uri?: string, options?: { + root?: boolean; + target?: string; + direction?: string; + }): void; + back(): void; + canBack(): boolean; + saveState(): void; + clearState(): void; + restoreState(): void; + } + export function createActionExecutors(app: Application): { + [key: string]: { execute(e): void; } + }; +} +declare module DevExpress.framework.html { + export interface ILayoutController { + viewReleased: JQueryCallback; + init(options: InitLayoutControllerOptions): void; + activate(): void; + deactivate(): void; + showView(viewInfo: any, direction?: string): JQueryDeferred; + } + export interface ILayoutControllerRegistration extends devices.Device { + name: string; + controller: ILayoutController; + root?: boolean; + } + export var layoutControllers: Array; + export interface InitLayoutControllerOptions { + $viewPort: JQuery; + $hiddenBag: JQuery; + navigationManager: framework.NavigationManager; + } + export class DefaultLayoutController implements ILayoutController { + public viewReleased: JQueryCallback; + constructor(options?: { layoutTemplateName: string }); + init(options: InitLayoutControllerOptions): void; + activate(): void; + deactivate(): void; + showView(viewInfo: any, direction?: string): JQueryDeferred; + } + export interface CommandManagerOptions { + globalCommands?: framework.dxCommand[]; + commandMapping?: framework.CommandMapping; + } + export class CommandManager { + public globalCommands: framework.dxCommand[]; + public commandMapping: framework.CommandMapping; + constructor(options?: CommandManagerOptions); + layoutCommands($markup: JQuery, extraCommands?: any); + } + export interface ITemplateEngine { + applyTemplate(template: string, model: any); + applyTemplate(template: Element, model: any); + applyTemplate(template: JQuery, model: any); + } + export class KnockoutJSTemplateEngine implements ITemplateEngine { + constructor(); + applyTemplate(template: string, model: any); + applyTemplate(template: Element, model: any); + applyTemplate(template: JQuery, model: any); + } + export interface TransitionExecutorOptions { + type: string; + source: JQuery; + destination: JQuery; + } + export class TransitionExecutor { + public container: JQuery; + constructor(container: JQuery, options: TransitionExecutorOptions); + finalize(): void; + exec(): JQueryDeferred; + static create(container: JQuery, options: TransitionExecutorOptions): TransitionExecutor; + } + export interface ViewEngineOptions { + $root?: JQuery; + device?: devices.Device; + commandManager: CommandManager; + templateEngine: ITemplateEngine; + dataOptionsAttributeName?: string; + } + export class ViewEngineBase { + public $root: JQuery; + public device: devices.Device; + public commandManager: CommandManager; + public templateEngine: ITemplateEngine; + public dataOptionsAttributeName: string; + public viewSelecting: JQueryCallback; + public modelFromViewDataExtended: JQueryCallback; + constructor(options?: ViewEngineOptions); + init(): JQueryDeferred; + findViewTemplate(viewName: string): JQuery; + afterViewSetup(viewInfo: any): void; + } + export class ViewEngine extends ViewEngineBase { + public layoutSelecting: JQueryCallback; + public layoutApplying: JQueryCallback; + public layoutApplied: JQueryCallback; + constructor(options?: ViewEngineOptions); + init(): JQueryDeferred; + findLayoutTemplate(layoutName: string): JQuery; + renderBlankView(viewInfo: any, $renderTarget: JQuery); + renderCompleteView(viewInfo: any, $renderTarget: JQuery); + } + export interface HtmlApplicationBaseOptions extends framework.ApplicationOptions { + device?: devices.Device; + defaultLayout?: string; + } + export class HtmlApplicationBase extends framework.Application { + public viewRendered: JQueryCallback; + constructor(options?: HtmlApplicationBaseOptions); + init(): any; + viewPort(): JQuery; + } + export interface HtmlApplicationOptions extends HtmlApplicationBaseOptions { + commandManager?: CommandManager; + templateEngine?: ITemplateEngine; + navigateToRootViewMode?: string; + layoutControllers?: Array + } + export class HtmlApplication extends HtmlApplicationBase { + public viewEngine: ViewEngineBase; + public blankViewRendered: JQueryCallback; + constructor(options?: HtmlApplicationOptions); + } +} +declare module DevExpress.ui { + interface ViewportOptions { + allowPan?: boolean; + allowZoom?: boolean; + } + export interface ITemplate { + compile(html: string); + render(template: JQuery, data: any); + render(template: any, data: any); + } + class Template { + constructor(element: HTMLElement); + constructor(element: JQueryStatic); + render(container: HTMLElement); + render(container: JQueryStatic); + dispose(): void; + } + interface TemplateStatic { + new (element: HTMLElement): Template; + new (element: JQueryStatic): Template; + } + class TemplateProvider { + constructor(); + getTemplateClass(widget: any): TemplateStatic; + getDefaultTemplate(widget: any): void; supportDefaultTemplate(): boolean; + } + export function initViewport(options: ViewportOptions): void; + interface NotifyOptions { + message: string; + type?: string; + displayTime?: number; + hiddenAction: () => any; + } + export function notyfy(options: any): void; + export function notify(message: string, type?: string, displayTime?: number): void; + export module dialog { + interface Dialog { + show(): JQueryDeferred; + hide(value?: any): void; + } + interface DialogButton { + text: string; + icon: string; + clickAction: () => any; + } + interface DialogOptions { + message: string; + title?: string; + } + export function custom(options: DialogOptions): Dialog; + export function custom(message: string, title?: string): Dialog; + export function alert(options: DialogOptions): JQueryDeferred; + export function alert(message: string, title?: string): JQueryDeferred; + export function confirm(options: DialogOptions): JQueryDeferred; + export function confirm(message: string, title?: string): JQueryDeferred; + } + export interface CollectionContainerWidgetOptions extends ContainerWidgetOptions { + items?: Array; + itemTemplate?: any; + itemRender?: Function; + itemClickAction?: any; + itemRenderedAction?: any; + noDataText?: string; + dataSource?: data.DataSource; + } + export class CollectionContainerWidget extends ContainerWidget { + constructor(element: Element, options?: CollectionContainerWidgetOptions); + constructor(element: JQuery, options?: CollectionContainerWidgetOptions); + } + export interface ComponentOptions { + disabled?: boolean; + } + export class Component { + constructor(element: Element, options?: ComponentOptions); + constructor(element: JQuery, options?: ComponentOptions); + disposing: JQueryCallback; + optionChanged: JQueryCallback; + instance(): Component; + beginUpdate(): void; + endUpdate(): void; + option(): any; + option(options: string): any; + option(options: string): T; + option(options: string, value: any): void; + option(options: { [key: string]: any }): void; + option(options?: any): any; + } + export interface ContainerWidgetOptions extends WidgetOptions { + contentReadyAction?: any + } + export class ContainerWidget extends Widget { + constructor(element: Element, options?: WidgetOptions); + constructor(element: JQuery, options?: WidgetOptions); + addTemplate(template: ITemplate): void; + } + export interface SelectableCollectionWidgetOptions extends CollectionContainerWidgetOptions { + selectedIndex?: number; + itemSelectAction?: any; + } + export class SelectableCollectionWidget extends CollectionContainerWidget { + constructor(element: Element, options?: SelectableCollectionWidget); + constructor(element: JQuery, options?: SelectableCollectionWidget); + } + export interface WidgetOptions extends ComponentOptions { + clickAction?: any; + width?: any; + height?: any; + visible?: boolean; + activeStateEnabled?: boolean; + } + export class Widget extends Component { + constructor(element: Element, options?: WidgetOptions); + constructor(element: JQuery, options?: WidgetOptions); + init(); + repaint(); + } + export interface ActionSheetOptions extends CollectionContainerWidgetOptions { + usePopover?: boolean; + target?: any; + title?: string; + showTitle?: boolean; + cancelText?: string; + noDataText?: string; + } + export class ActionSheet extends CollectionContainerWidget { + constructor(element: Element, options?: ActionSheetOptions); + constructor(element: JQuery, options?: ActionSheetOptions); + toggle(): void; + show(): void; + hide(): void; + } + export interface AutocompleteOptions extends CollectionContainerWidgetOptions { + value?: any; + minSearchLength?: number; + searchTimeout?: number; + placeholder?: string; + filterOperator?: string; + displayExpr?: string; + valueUpdateAction?: any; + valueUpdateEvent?: string; + } + export class Autocomplete extends CollectionContainerWidget { + constructor(element: Element, options?: AutocompleteOptions); + constructor(element: JQuery, options?: AutocompleteOptions); + toggle(): void; + show(): void; + hide(): void; + } + export interface ButtonOptions extends WidgetOptions { + type?: string; + text?: string; + icon?: string; + iconSrc?: string; + } + export class Button extends Widget { + constructor(element: Element, options?: ButtonOptions); + constructor(element: JQuery, options?: ButtonOptions); + } + export interface CheckBoxOptions extends WidgetOptions { + checked?: boolean; + } + export class CheckBox extends Widget { + constructor(element: Element, options?: CheckBoxOptions); + constructor(element: JQuery, options?: CheckBoxOptions); + } + export interface DateBoxOptions extends EditBoxOptions { + format?: string; + useNativePicker?: boolean; + value?: Date; + } + export class DateBox extends EditBox { + constructor(element: Element, options?: DateBoxOptions); + constructor(element: JQuery, options?: DateBoxOptions); + } + export interface DropDownMenuOptions extends ContainerWidgetOptions { + items?: Array; + itemClickAction?: any; + dataSource?: data.DataSource; + itemTemplate?: any; + itemRender?: Function; + buttonText?: string; + buttonIcon?: string; + buttonIconSrc?: string; + buttonClickAction?: any; + usePopover?: boolean; + } + export class DropDownMenu extends ContainerWidget { + constructor(element: Element, options?: DropDownMenuOptions); + constructor(element: JQuery, options?: DropDownMenuOptions); + } + export interface EditBoxOptions extends WidgetOptions { + value?: any; + valueUpdateEvent?: string; + valueUpdateAction?: any; + placeholder?: string; + readOnly?: boolean; + focusInAction?: any; + focusOutAction?: any; + keyDownAction?: any; + keyPressAction?: any; + keyUpAction?: any; + changeAction?: any; + enterKeyAction?: any; + mode?: string; + } + export class EditBox extends Widget { + constructor(element: Element, options?: EditBoxOptions); + constructor(element: JQuery, options?: EditBoxOptions); + focus(): void; + } + export interface ListOptions extends CollectionContainerWidgetOptions { + pullRefreshEnabled?: boolean; + autoPagingEnabled?: boolean; + scrollingEnabled?: boolean; + showScrollbar?: boolean; + useNative?: boolean; + grouped?: boolean; + editEnabled?: boolean; + showNextButton?: boolean; + groupTemplate?: string; + pullingDownText?: string; + pulledDownText?: string; + refreshingText?: string; + pageLoadingText?: string; + scrollAction?: any; + pullRefreshAction?: any; + pageLoadingAction?: any; + itemHoldAction?: any; + itemSwipeAction?: any; + itemHoldTimeout?: number; + groupRender? (groupData: any, groupIndex: number, groupElement: Element): any; + editConfig?: { + itemTemplate?: any; + itemRenderer? (itemData: any, itemIndex: number, itemElement: Element): any; + deleteEnabled?: boolean; + deleteMode?: string; + selectionEnabled?: boolean; + selectionMode?: string; + } + itemDeleteAction?: any; + selectedItems?: any[]; + itemSelectAction?: any; + itemUnselectAction?: any; + } + export class List extends CollectionContainerWidget { + constructor(element: Element, options?: ListOptions); + constructor(element: JQuery, options?: ListOptions); + update(): JQueryDeferred; + deleteItem(itemElement: JQuery): JQueryDeferred; + deleteItem(itemElement: Element): JQueryDeferred; + clearSelectedItems(); + isItemSelected(itemElement: JQuery): boolean; + isItemSelected(itemElement: Element): boolean; + selectItem(itemElement: JQuery); + selectItem(itemElement: Element); + unselectItem(itemElement: JQuery); + unselectItem(itemElement: Element); + getSelectedItems(): number[]; + } + export interface LoadPanelOptions extends OverlayOptions { + message?: string; + width?: number; + height?: number; + } + export class LoadPanel extends Overlay { + constructor(element: Element, options?: LoadPanelOptions); + constructor(element: JQuery, options?: LoadPanelOptions); + } + export interface LookupOptions extends ContainerWidgetOptions { + dataSource?: data.DataSource; + value?: any; + displayValue?: string; + title?: string; + valueExpr?: string; + displayExpr?: string; + placeholder?: string; + searchPlaceholder?: string; + searchEnabled?: boolean; + searchTimeout?: number; + minFilterLength?: number; + fullScreen?: boolean; + valueChangeAction?: any; + itemTemplate?: any; + itemRender?: Function; + showCancelButton?: boolean; + showClearButton?: boolean; + showDoneButton?: boolean; + } + export class Lookup extends ContainerWidget { + constructor(element: Element, options?: LookupOptions); + constructor(element: JQuery, options?: LookupOptions); + } + export interface MapOptions extends WidgetOptions { + location?: any; + width?: number; + height?: number; + zoom?: number; + mapType?: string; + provider?: string; + markers?: Array; + routes?: Array; + key?: string; + controls?: any; + mapReadyAction?: any; + } + export class Map extends Widget { + constructor(element: Element, options?: MapOptions); + constructor(element: JQuery, options?: MapOptions); + addMarker(markerOptions: any, callback: Function): JQueryDeferred; + removeMarker(marker: any): void; + addRoute(routeOptions: any, callback: Function): JQueryDeferred; + removeRoute(route: any): void; + } + export interface NavBarOptions extends TabsOptions { } + export class NavBar extends Tabs { + constructor(element: Element, options?: NavBarOptions); + constructor(element: JQuery, options?: NavBarOptions); + } + export interface NumberBoxOptions extends EditBoxOptions { + min?: number; + max?: number; + value?: number; + } + export class NumberBox extends EditBox { + constructor(element: Element, options?: NumberBoxOptions); + constructor(element: JQuery, options?: NumberBoxOptions); + } + export interface OverlayOptions extends WidgetOptions { + activeStateEnabled?: boolean; + shading?: boolean; + closeOnOutsideClick?: boolean; + position?: any; + animation?: any; + showingAction?: any; + shownAction?: any; + hidingAction?: any; + hiddenAction?: any; + deferRendering?: boolean; + targetContainer?: any; + } + export class Overlay extends Widget { + constructor(element: Element, options?: OverlayOptions); + constructor(element: JQuery, options?: OverlayOptions); + } + export interface PanoramaOptions extends SelectableCollectionWidgetOptions { + title?: string; + backgroundImage?: any; + } + export class Panorama extends SelectableCollectionWidget { + constructor(element: Element, options?: PanoramaOptions); + constructor(element: JQuery, options?: PanoramaOptions); + } + export interface PivotOptions extends SelectableCollectionWidgetOptions { } + export class Pivot extends SelectableCollectionWidget { + constructor(element: Element, options?: PivotOptions); + constructor(element: JQuery, options?: PivotOptions); + } + export interface PopoverOptions extends PopupOptions { + target?: any; + } + export class Popover extends Popup { + constructor(element: Element, options?: PopoverOptions); + constructor(element: JQuery, options?: PopoverOptions); + } + export interface PopupOptions extends OverlayOptions { + title?: string; + showTitle?: boolean; + fullScreen?: boolean; + cancelButton?: any; + doneButton?: any; + clearButton?: any; + } + export class Popup extends Overlay { + constructor(element: Element, options?: PopupOptions); + constructor(element: JQuery, options?: PopupOptions); + content(): Element; + } + export interface RadioGroupOptions extends SelectableCollectionWidgetOptions { + layout?: string; + name?: string; + } + export class RadioGroup extends SelectableCollectionWidget { + constructor(element: Element, options?: RadioGroupOptions); + constructor(element: JQuery, options?: RadioGroupOptions); + } + export interface RangeSliderOptions extends SliderOptions { + start?: number; + end?: number; + } + export class RangeSlider extends Slider { + constructor(element: Element, options?: RangeSliderOptions); + constructor(element: JQuery, options?: RangeSliderOptions); + } + export interface ScrollableOptions extends ComponentOptions { + startAction?: any; + scrollAction?: any; + endAction?: any; + stopAction?: any; + inertiaAction?: any; + bounceAction?: any; + updateAction?: any; + bounceEnabled?: boolean; + direction?: string; + showScrollbar?: boolean; + useNative?: boolean; + } + export class Scrollable extends Component { + constructor(element: Element, options?: ScrollableOptions); + constructor(element: JQuery, options?: ScrollableOptions); + update(): void; + content(): JQuery; + location(): Object; + clientHeight(): number; + scrollHeight(): number; + scrollBy(distance: number): void; + scrollBy(distance: Object): void; + scrollTo(targetLocation: number): void; + scrollTo(targetLocation: Object): void; + } + export interface ScrollViewOptions extends ScrollableOptions { + pullingDownText?: string; + pulledDownText?: string; + refreshingText?: string; + reachBottomText?: string; + pullDownAction?: any; + reachBottomAction?: any; + } + export class ScrollView extends Scrollable { + constructor(element: Element, options?: ScrollViewOptions); + constructor(element: JQuery, options?: ScrollViewOptions); + release(preventReachBottom: boolean): JQueryDeferred; + toggleLoading(showOrHide: boolean): void; + isFull(): boolean; + } + export interface SelectBoxOptions extends AutocompleteOptions { + valueChangeAction?: any; + } + export class SelectBox extends Autocomplete { + constructor(element: Element, options?: SelectBoxOptions); + constructor(element: JQuery, options?: SelectBoxOptions); + } + export interface SliderOptions extends WidgetOptions { + min?: number; + max?: number; + step?: number; + value?: number; + } + export class Slider extends Widget { + constructor(element: Element, options?: SliderOptions); + constructor(element: JQuery, options?: SliderOptions); + } + export interface SwitchOptions extends WidgetOptions { + onText?: string; + offText?: string; + value?: boolean; + } + export class Switch extends Widget { + constructor(element: Element, options?: SwitchOptions); + constructor(element: JQuery, options?: SwitchOptions); + } + export interface TabsOptions extends SelectableCollectionWidgetOptions { } + export class Tabs extends SelectableCollectionWidget { + constructor(element: Element, options?: TabsOptions); + constructor(element: JQuery, options?: TabsOptions); + } + export interface TextAreaOptions extends EditBoxOptions { + cols?: number; + rows?: number; + } + export class TextArea extends EditBox { + constructor(element: Element, options?: TextAreaOptions); + constructor(element: JQuery, options?: TextAreaOptions); + } + export interface TextBoxOptions extends EditBoxOptions { + maxLength?: any; + } + export class TextBox extends EditBox { + constructor(element: Element, options?: TextBoxOptions); + constructor(element: JQuery, options?: TextBoxOptions); + } + export interface TileViewOptions extends CollectionContainerWidgetOptions { + bounceEnabled?: boolean; + showScrollbar?: boolean; + listHeight?: number; + baseItemWidth?: number; + baseItemHeight?: number; + itemMargin?: number; + } + export class TileView extends CollectionContainerWidget { + constructor(element: Element, options?: TileViewOptions); + constructor(element: JQuery, options?: TileViewOptions); + } + export interface ToastOptions extends OverlayOptions { + message?: string; + type?: string; + displayTime?: number; + } + export class Toast extends Overlay { + constructor(element: Element, options?: ToastOptions); + constructor(element: JQuery, options?: ToastOptions); + } + export interface ToolbarOptions extends CollectionContainerWidgetOptions { + menuItemRender?: Function; + menuItemTemplate?: any; + submenuType?: string; + } + export class Toolbar extends CollectionContainerWidget { + constructor(element: Element, options?: ToolbarOptions); + constructor(element: JQuery, options?: ToolbarOptions); + } +} +interface JQuery { + dxActionSheet(options?: DevExpress.ui.ActionSheetOptions): JQuery; + dxAutocomplete(options?: DevExpress.ui.AutocompleteOptions): JQuery; + dxButton(options?: DevExpress.ui.ButtonOptions): JQuery; + dxCheckBox(options?: DevExpress.ui.CheckBoxOptions): JQuery; + dxDateBox(options?: DevExpress.ui.DateBoxOptions): JQuery; + dxDropDownMenu(options?: DevExpress.ui.DropDownMenuOptions): JQuery; + dxEditBox(options?: DevExpress.ui.EditBoxOptions): JQuery; + dxList(options?: DevExpress.ui.ListOptions): JQuery; + dxLoadPanel(options?: DevExpress.ui.LoadPanelOptions): JQuery; + dxLookup(options?: DevExpress.ui.LookupOptions): JQuery; + dxMap(options?: DevExpress.ui.MapOptions): JQuery; + dxNavBar(options?: DevExpress.ui.NavBarOptions): JQuery; + dxNumberBox(options?: DevExpress.ui.NumberBoxOptions): JQuery; + dxOverlay(options?: DevExpress.ui.OverlayOptions): JQuery; + dxPanorama(options?: DevExpress.ui.PanoramaOptions): JQuery; + dxPivot(options?: DevExpress.ui.PivotOptions): JQuery; + dxPopover(options?: DevExpress.ui.PopoverOptions): JQuery; + dxPopup(options?: DevExpress.ui.PopupOptions): JQuery; + dxRadioGroup(options?: DevExpress.ui.RadioGroupOptions): JQuery; + dxRangeSlider(options?: DevExpress.ui.RangeSliderOptions): JQuery; + dxScrollable(options?: DevExpress.ui.ScrollableOptions): JQuery; + dxScrollView(options?: DevExpress.ui.ScrollViewOptions): JQuery; + dxSelectBox(options?: DevExpress.ui.SelectBoxOptions): JQuery; + dxSlider(options?: DevExpress.ui.SliderOptions): JQuery; + dxSwitch(options?: DevExpress.ui.SwitchOptions): JQuery; + dxTabs(options?: DevExpress.ui.TabsOptions): JQuery; + dxTextArea(options?: DevExpress.ui.TextAreaOptions): JQuery; + dxTextBox(options?: DevExpress.ui.TextBoxOptions): JQuery; + dxTileView(options?: DevExpress.ui.TileViewOptions): JQuery; + dxToast(options?: DevExpress.ui.ToastOptions): JQuery; + dxToolbar(options?: DevExpress.ui.ToolbarOptions): JQuery; +} \ No newline at end of file