devexpress-reporting
Version:
DevExpress Reporting provides the capability to develop a reporting application to create and customize reports.
1,007 lines (938 loc) • 610 kB
TypeScript
declare module DevExpress.Reporting.Chart.Internal.Widgets {
import FieldListEditor = DevExpress.Analytics.Widgets.FieldListEditor;;
export class SummaryFunctionModel {
static availableItems: string[];
static from(val: any): SummaryFunctionModel;
static toJson(value: SummaryFunctionModel): {};
private _updateArgs;
constructor(functionName: any, args: any);
functionName: ko.Observable<any>;
args: ko.ObservableArray<{
value: ko.Observable<string>;
}>;
}
export class SummaryFunctionEditor extends FieldListEditor {
constructor(modelPropertyInfo: any, level: any, parentDisabled?: ko.Computed<boolean>);
getLocalization(displayName: any, localizationId: any): any;
memberPadding: any;
argumentTemplateName: string;
actionsAreAvailable: ko.Observable<boolean>;
add(): void;
remove(index: any): void;
availableItems(): string[];
}
}
declare module DevExpress.Reporting.Chart.Internal {
import IDisplayedValue = DevExpress.Analytics.Utils.IDisplayedValue;
import ISerializationInfo = DevExpress.Analytics.Utils.ISerializationInfo;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export var defaultBooleanValues: Array<IDisplayedValue>;
export var scaleTypeValues: Array<IDisplayedValue>;
export var stringAlignmentValues: Array<IDisplayedValue>;
export var angle: ISerializationInfo;
export var borderColor: ISerializationInfo;
export var backColor: ISerializationInfo;
export var dataMember: ISerializationInfo;
export var text: ISerializationInfo;
export var visible: ISerializationInfo;
export var name: ISerializationInfo;
export var tag: ISerializationInfo;
export var legendText: ISerializationInfo;
export var showInLegend: ISerializationInfo;
export var thickness: ISerializationInfo;
export var visibility: ISerializationInfo;
export var color: ISerializationInfo;
export var titleAlignment: ISerializationInfo;
export var textPattern: ISerializationInfo;
export var textAlignment: ISerializationInfo;
export var maxLineCount: ISerializationInfo;
export var maxWidth: ISerializationInfo;
export var textColor: ISerializationInfo;
export var antialiasing: ISerializationInfo;
export var font: ISerializationInfo;
export var enableAxisXZooming: ISerializationInfo;
export var enableAxisXScrolling: ISerializationInfo;
export var enableAxisYZooming: ISerializationInfo;
export var enableAxisYScrolling: ISerializationInfo;
export var rotated: ISerializationInfo;
export var typeNameNotShow: ISerializationInfo;
export var left: ISerializationInfo;
export var right: ISerializationInfo;
export var top: ISerializationInfo;
export var bottom: ISerializationInfo;
export var margin: ISerializationInfo;
export var font18: ISerializationInfo;
export var font12: ISerializationInfo;
export var font8: ISerializationInfo;
export var paneSerializationsInfo: ISerializationInfoArray;
export var defaultPane: ISerializationInfo;
export var additionalPaneSerializationsInfo: ISerializationInfoArray;
export var filterString: ISerializationInfo;
export var filterStringEditable: ISerializationInfo;
}
declare module DevExpress.Reporting.Chart.Internal {
import EditorTemplates = DevExpress.Analytics.Widgets.EditorTemplates;;
import ISerializationInfo = DevExpress.Analytics.Utils.ISerializationInfo;;
export var editorTemplates: EditorTemplates<ChartEditorTemplates>;
export var chartDataSource: ISerializationInfo;
export {};
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import ISerializationInfo = DevExpress.Analytics.Utils.ISerializationInfo;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export var summaryFunctionSerializationInfo: ISerializationInfo;
export var summaryOptionsSerializationInfoArray: ISerializationInfoArray;
export var numericSummaryOptionsSerializationInfoArray: ISerializationInfo[];
export var dateTimeSummaryOptionsSerializationInfoArray: ISerializationInfo[];
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import SummaryFunctionModel = DevExpress.Reporting.Chart.Internal.Widgets.SummaryFunctionModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;
import ISerializableModel = DevExpress.Analytics.Utils.ISerializableModel;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export class SummaryOptionsModelBase implements ISerializableModel {
constructor(model: any, serializer?: IModelSerializer);
getInfo(): ISerializationInfoArray;
resetAllProperties(): void;
summaryFunction: SummaryFunctionModel;
}
export class QualitativeSummaryOptionsModel extends SummaryOptionsModelBase {
static from(model: any, serializer?: IModelSerializer): QualitativeSummaryOptionsModel;
static toJson(value: QualitativeSummaryOptionsModel, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer);
}
export class NumericSummaryOptionsModel extends SummaryOptionsModelBase {
static from(model: any, serializer?: IModelSerializer): NumericSummaryOptionsModel;
static toJson(value: QualitativeSummaryOptionsModel, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer);
getInfo(): ISerializationInfoArray;
}
export class DateTimeSummaryOptionsModel extends SummaryOptionsModelBase {
static from(model: any, serializer?: IModelSerializer): DateTimeSummaryOptionsModel;
static toJson(value: QualitativeSummaryOptionsModel, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer);
getInfo(): ISerializationInfoArray;
}
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class SeriesLabelViewModel extends SerializableModel {
static from(model: any, serializer?: IModelSerializer): SeriesLabelViewModel;
static toJson(value: any, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer);
typeNameSerializable: ko.Observable<string> | ko.Computed<string>;
seriesLabelPosition: ko.Observable<string>;
}
}
declare module DevExpress.Reporting.Chart.Internal {
import ISerializationInfo = DevExpress.Analytics.Utils.ISerializationInfo;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export var typeNameSerializable: ISerializationInfo;
export var barSeriesViewGroup: string[];
export var bar3DSeriesViewGroup: string[];
export var barWidth: ISerializationInfo;
export var colorEach: ISerializationInfo;
export var borderSerializationsInfo: ISerializationInfoArray;
export var border: ISerializationInfo;
export var fillMode: ISerializationInfo;
export var fillStyleOptionsSerialize: ISerializationInfo;
export var fillMode3D: ISerializationInfo;
export var fillStyle: ISerializationInfo;
export var viewSerializationsInfo: ISerializationInfoArray;
export var fillModeMapper: {
'Empty': any[];
'Solid': ISerializationInfo[];
'Gradient': ISerializationInfoArray;
'Hatch': ISerializationInfoArray;
};
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export class FillStyle extends SerializableModel {
static from(info: any, gradientTypeName: any): (model: any, serializer: any) => FillStyle;
static toJson(model: FillStyle, serializer: IModelSerializer, refs: any): any;
private _optionsTypeMap;
constructor(model: any, info: ISerializationInfoArray, gradientTypeName: string, serializer?: IModelSerializer);
isPropertyVisible(propertyName: any): any;
updateOptions(fillMode: string, serializer: any, optionsObject: any): void;
fillMode: ko.Observable<string> | ko.Computed<string>;
options: ko.Observable<any>;
gradientTypeName: string;
}
}
declare module DevExpress.Reporting.Chart.Internal.Axis {
import IAction = DevExpress.Analytics.Utils.IAction;;
export interface ICollectionItem {
parent: ko.ObservableArray<ICollectionItem>;
innerActions: Array<IAction>;
}
export function initCollectionItem(item: ICollectionItem, parent: ko.ObservableArray<ICollectionItem>): () => void;
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import ICollectionItem = DevExpress.Reporting.Chart.Internal.Axis.ICollectionItem;;
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;
import IAction = DevExpress.Analytics.Utils.IAction;;
export class ChartElementCollectionItemBase extends SerializableModel implements ICollectionItem {
static toJson(value: ChartElementCollectionItemBase, serializer: any, refs: any): any;
constructor(model: any, parent: ko.ObservableArray<ChartElementCollectionItemBase>, serializer?: IModelSerializer, info?: ISerializationInfoArray);
parent: ko.ObservableArray<ICollectionItem>;
name: ko.Observable<string> | ko.Computed<string>;
defaultItemName: (parentName?: string) => string;
innerActions: IAction[];
}
}
declare module DevExpress.Reporting.Chart.Internal {
export function parseDate(val: any): Date;
export function serializeDate(date: Date): string;
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import SeriesViewModel = DevExpress.Reporting.Chart.Internal.Series.SeriesViewModel;;
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class SeriesPointModel extends SerializableModel {
static separator: string;
static getSerializationValue(array: Array<ko.Observable<any>>, dateConverter: any): any[];
static createNew(series: any): SeriesPointModel;
static getPointModelBySeries(series: SeriesViewModel): {
'@ValuesSerializable': any;
};
static getDefaultValueByScaleType(scaleType: string): 0 | Date;
static valueToJsonObject(value: any): string;
private _valueDataMembersToString;
private _assignValueDataMembers;
constructor(model: any, series: SeriesViewModel, serializer?: IModelSerializer);
readonly isDateType: boolean;
argumentSerializable: ko.Observable | ko.Computed;
argumentSerializableInfo: ko.Computed;
valuesSerializable: ko.Observable | ko.Computed;
series: SeriesViewModel;
arrayValueDataMemberNames: string[];
}
}
declare module DevExpress.Reporting.Chart.Internal {
import SeriesPointModel = DevExpress.Reporting.Chart.Internal.Series.SeriesPointModel;;
export function createInnerActionsWithPopover(text: any, id: any, actions: any): {
text: any;
imageClassName: string;
imageTemplateName: string;
disabled: ko.Observable<boolean>;
id: any;
_visible: ko.Observable<boolean>;
popoverVisible: any;
togglePopoverVisible: any;
closePopover: any;
templateName: string;
getContainer: (element: HTMLElement, selector: string) => JQuery<HTMLElement>;
actions: any;
}[];
export function _isNumericTypeSpecific(specific: string): boolean;
export function _isDateTypeSpecific(specific: string): boolean;
export function _getUnconvertiblePoint(propertyName: string, oldValue: string, newValue: string, points: SeriesPointModel[]): SeriesPointModel;
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import ChartElementCollectionItemBase = DevExpress.Reporting.Chart.Internal.Models.ChartElementCollectionItemBase;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class TitleViewModel extends ChartElementCollectionItemBase {
static prefix: string;
static from(model: any, serializer?: IModelSerializer): TitleViewModel;
constructor(model: any, parent: ko.ObservableArray<TitleViewModel>, serializer?: IModelSerializer);
}
export function assignTitleActions(titles: ko.ObservableArray<TitleViewModel>): void;
}
declare module DevExpress.Reporting {
export function getSeriesClassName(typeName: any): any;
export function deserializeModelArray<T>(model: any, creator: (item: any, parent: any) => T, prefix: string): ko.ObservableArray<T>;
}
declare module DevExpress.Reporting.Chart.Internal {
import ISerializationInfo = DevExpress.Analytics.Utils.ISerializationInfo;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export var paneName: ISerializationInfo;
export var axisXName: ISerializationInfo;
export var axisYName: ISerializationInfo;
export var fillStyleInfo: (ISerializationInfo | {
propertyName: string;
modelName: string;
displayName: string;
localizationId: string;
editor: DevExpress.Analytics.Utils.IEditorInfo;
valuesArray: {
value: string;
displayValue: string;
localizationId: string;
}[];
defaultVal: string;
})[];
export var viewMapper: {
FullStackedStepAreaSeriesView: ISerializationInfoArray;
PolarRangeAreaSeriesView: ISerializationInfoArray;
RadarRangeAreaSeriesView: ISerializationInfoArray;
RangeArea3DSeriesView: ISerializationInfoArray;
RangeAreaSeriesView: ISerializationInfoArray;
StackedStepAreaSeriesView: ISerializationInfoArray;
StepArea3DSeriesView: ISerializationInfoArray;
StepAreaSeriesView: ISerializationInfoArray;
SideBySideFullStackedBar3DSeriesView: ISerializationInfoArray;
SideBySideFullStackedBarSeriesView: ISerializationInfoArray;
SideBySideStackedBar3DSeriesView: ISerializationInfoArray;
SideBySideStackedBarSeriesView: ISerializationInfoArray;
FullStackedLine3DSeriesView: ISerializationInfoArray;
FullStackedLineSeriesView: ISerializationInfoArray;
ScatterPolarLineSeriesView: ISerializationInfoArray;
ScatterRadarLineSeriesView: ISerializationInfoArray;
StackedLine3DSeriesView: ISerializationInfoArray;
StackedLineSeriesView: ISerializationInfoArray;
NestedDoughnutSeriesView: ISerializationInfoArray;
SwiftPlotSeriesView: ISerializationInfoArray;
Funnel3DSeriesView: ISerializationInfoArray;
FunnelSeriesView: ISerializationInfoArray;
ScatterLineSeriesView: ISerializationInfoArray;
BubbleSeriesView: ISerializationInfoArray;
Spline3DSeriesView: ISerializationInfoArray;
SplineArea3DSeriesView: ISerializationInfoArray;
FullStackedSplineArea3DSeriesView: ISerializationInfoArray;
SplineAreaSeriesView: ISerializationInfoArray;
FullStackedSplineAreaSeriesView: ISerializationInfoArray;
StackedSplineArea3DSeriesView: ISerializationInfoArray;
SplineSeriesView: ISerializationInfoArray;
StackedSplineAreaSeriesView: ISerializationInfoArray;
Area3DSeriesView: ISerializationInfoArray;
FullStackedArea3DSeriesView: ISerializationInfoArray;
PolarAreaSeriesView: ISerializationInfoArray;
RadarAreaSeriesView: ISerializationInfoArray;
StackedArea3DSeriesView: ISerializationInfoArray;
FullStackedBar3DSeriesView: ISerializationInfoArray;
SideBySideBar3DSeriesView: ISerializationInfoArray;
StackedBar3DSeriesView: ISerializationInfoArray;
PolarLineSeriesView: ISerializationInfoArray;
RadarLineSeriesView: ISerializationInfoArray;
Doughnut3DSeriesView: ISerializationInfoArray;
DoughnutSeriesView: ISerializationInfoArray;
PolarPointSeriesView: ISerializationInfoArray;
OverlappedGanttSeriesView: ISerializationInfoArray;
RadarPointSeriesView: ISerializationInfoArray;
SideBySideGanttSeriesView: ISerializationInfoArray;
AreaSeriesView: ISerializationInfoArray;
CandleStickSeriesView: ISerializationInfoArray;
FullStackedAreaSeriesView: ISerializationInfoArray;
FullStackedBarSeriesView: ISerializationInfoArray;
Line3DSeriesView: ISerializationInfoArray;
LineSeriesView: ISerializationInfoArray;
ManhattanBarSeriesView: ISerializationInfoArray;
OverlappedRangeBarSeriesView: ISerializationInfoArray;
Pie3DSeriesView: ISerializationInfoArray;
PieSeriesView: ISerializationInfoArray;
PointSeriesView: ISerializationInfoArray;
SideBySideBarSeriesView: ISerializationInfoArray;
SideBySideRangeBarSeriesView: ISerializationInfoArray;
StackedAreaSeriesView: ISerializationInfoArray;
StackedBarSeriesView: ISerializationInfoArray;
StepLineSeriesView: ISerializationInfoArray;
StockSeriesView: ISerializationInfoArray;
StepLine3DSeriesView: ISerializationInfoArray;
};
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import FillStyle = DevExpress.Reporting.Chart.Internal.Series.FillStyle;;
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class SeriesViewViewModel extends SerializableModel {
static from(model: any, serializer?: IModelSerializer): ko.Observable<SeriesViewViewModel>;
dispose(): void;
static toJson(value: any, serializer: any, refs: any): any;
_getInfo(typeName: string): DevExpress.Analytics.Utils.ISerializationInfo[];
private _createPropertyDisabledDependence;
private _createMarkerDependences;
private _createLinkOptionsDependences;
preInitProperties(model: any): void;
constructor(model: any, serializer?: IModelSerializer);
axisXName: ko.Observable<string> | ko.Computed<string>;
axisYName: ko.Observable<string> | ko.Computed<string>;
paneName: ko.Observable<string> | ko.Computed<string>;
fillStyle: FillStyle;
barWidth: ko.Observable<number> | ko.Computed<number>;
typeName: string;
}
}
declare module DevExpress.Reporting.Chart.Internal.DataMembers {
import Disposable = DevExpress.Analytics.Utils.Disposable;;
export class DataMemberBase extends Disposable {
private _separator;
private _assignValueDataMembers;
private _valueDataMembersToString;
toString(): string;
constructor(value: any, valueScaleType?: any);
valueScaleType: any;
arrayValueDataMemberNames: string[];
}
}
declare module DevExpress.Reporting.Chart.Internal {
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export var commonValueSerializationsInfo: ISerializationInfoArray;
export var valueWeightSerializationsInfo: ISerializationInfoArray;
export var value1Value2SerializationsInfo: ISerializationInfoArray;
export var stockValueSerializationsInfo: ISerializationInfoArray;
}
declare module DevExpress.Reporting.Chart.Internal.DataMembers {
import DataMemberBase = DevExpress.Reporting.Chart.Internal.DataMembers.DataMemberBase;;
export class ValueWeightDataMembers extends DataMemberBase {
getInfo(): DevExpress.Analytics.Utils.ISerializationInfoArray;
readonly arrayValueDataMemberNames: string[];
}
}
declare module DevExpress.Reporting.Chart.Internal.DataMembers {
import DataMemberBase = DevExpress.Reporting.Chart.Internal.DataMembers.DataMemberBase;;
export class Value1Value2DataMembers extends DataMemberBase {
getInfo(): DevExpress.Analytics.Utils.ISerializationInfoArray;
readonly arrayValueDataMemberNames: string[];
}
}
declare module DevExpress.Reporting.Chart.Internal.DataMembers {
import DataMemberBase = DevExpress.Reporting.Chart.Internal.DataMembers.DataMemberBase;;
export class StockValueDataMembers extends DataMemberBase {
getInfo(): DevExpress.Analytics.Utils.ISerializationInfoArray;
readonly arrayValueDataMemberNames: string[];
}
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import ValueWeightDataMembers = DevExpress.Reporting.Chart.Internal.DataMembers.ValueWeightDataMembers;;
import Value1Value2DataMembers = DevExpress.Reporting.Chart.Internal.DataMembers.Value1Value2DataMembers;;
import StockValueDataMembers = DevExpress.Reporting.Chart.Internal.DataMembers.StockValueDataMembers;;
export var viewTypesDataMembers: {
'BubbleSeriesView': typeof ValueWeightDataMembers;
'OverlappedRangeBarSeriesView': typeof Value1Value2DataMembers;
'SideBySideRangeBarSeriesView': typeof Value1Value2DataMembers;
'RangeAreaSeriesView': typeof Value1Value2DataMembers;
'RangeArea3DSeriesView': typeof Value1Value2DataMembers;
'OverlappedGanttSeriesView': typeof Value1Value2DataMembers;
'SideBySideGanttSeriesView': typeof Value1Value2DataMembers;
'StockSeriesView': typeof StockValueDataMembers;
'CandleStickSeriesView': typeof StockValueDataMembers;
};
export var mapTypes: {
[key: string]: string;
};
export var onlyNumericArgumentSupportedSeriesViewTypes: Array<string>;
}
declare module DevExpress.Reporting.Chart.Internal.DataMembers {
import DataMemberBase = DevExpress.Reporting.Chart.Internal.DataMembers.DataMemberBase;;
export class CommonValueDataMembers extends DataMemberBase {
static from(value: any): CommonValueDataMembers;
static toJson(value: any): any;
getInfo(): DevExpress.Analytics.Utils.ISerializationInfoArray;
readonly arrayValueDataMemberNames: string[];
}
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import QualitativeSummaryOptionsModel = DevExpress.Reporting.Chart.Internal.Series.QualitativeSummaryOptionsModel;
import NumericSummaryOptionsModel = DevExpress.Reporting.Chart.Internal.Series.NumericSummaryOptionsModel;
import DateTimeSummaryOptionsModel = DevExpress.Reporting.Chart.Internal.Series.DateTimeSummaryOptionsModel;;
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export interface IViewBindableProperty {
model: ko.Observable<any>;
type: ko.Observable<string> | ko.Computed<string>;
}
export enum ScaleType {
Qualitative = 0,
Numerical = 1,
DateTime = 2,
Auto = 3
}
export var ScaleTypeMap: {
[key: string]: ScaleType;
};
export class SeriesTemplateViewModel extends SerializableModel {
static from(model: any, serializer?: IModelSerializer): SeriesTemplateViewModel;
static toJson(value: SeriesTemplateViewModel, serializer: any, refs: any): any;
updateByView(view: SeriesViewViewModel): void;
preInitProperties(model: any): void;
_isOnlyNumericArgumentScaleTypeSupported(): boolean;
private _getCurrentSeriesPointsSortingKeys;
private _adjustArgumentScaleType;
private _updateSeriesPointsSortingKey;
_isPropertyDisabled(name: string): boolean;
constructor(model: any, serializer?: IModelSerializer, info?: ISerializationInfoArray);
isPropertyVisible(propertyName: any): boolean;
viewBindable: IViewBindableProperty;
viewType: ko.Observable<string> | ko.Computed<string>;
view: ko.Observable<SeriesViewViewModel>;
label: SeriesLabelViewModel;
argumentDataMember: ko.Observable<string> | ko.Computed<string>;
argumentScaleType: ko.Observable<string> | ko.Computed<string>;
valueScaleType: ko.Observable<string> | ko.Computed<string>;
valueDataMembers: any;
filterString: any;
_filterString: any;
qualitativeSummaryOptions: QualitativeSummaryOptionsModel;
numericSummaryOptions: NumericSummaryOptionsModel;
dateTimeSummaryOptions: DateTimeSummaryOptionsModel;
_actualArgumentScaleType: ko.Observable<ScaleType>;
}
import SeriesLabelViewModel = DevExpress.Reporting.Chart.Internal.Series.SeriesLabelViewModel;;
import SeriesViewViewModel = DevExpress.Reporting.Chart.Internal.Series.SeriesViewViewModel;;
}
declare module DevExpress.Reporting.Chart.Internal.Series {
import SeriesTemplateViewModel = DevExpress.Reporting.Chart.Internal.Series.SeriesTemplateViewModel;;
import ICollectionItem = DevExpress.Reporting.Chart.Internal.Axis.ICollectionItem;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;
import IAction = DevExpress.Analytics.Utils.IAction;;
export class SeriesViewModel extends SeriesTemplateViewModel implements ICollectionItem {
static prefix: string;
updateByView(view: SeriesViewViewModel): void;
constructor(model: any, parent: ko.ObservableArray<SeriesViewModel>, serializer?: IModelSerializer);
isIncompatible: ko.Observable<boolean>;
parent: ko.ObservableArray<SeriesViewModel>;
points: ko.ObservableArray<SeriesPointModel>;
innerActions: IAction[];
}
import SeriesViewViewModel = DevExpress.Reporting.Chart.Internal.Series.SeriesViewViewModel;;
import SeriesPointModel = DevExpress.Reporting.Chart.Internal.Series.SeriesPointModel;;
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;
import ISerializableModel = DevExpress.Analytics.Utils.ISerializableModel;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export var dataFilterSerializationsInfo: ISerializationInfoArray;
export class DataFilterModel implements ISerializableModel {
static createNew(): DataFilterModel;
getInfo(): ISerializationInfoArray;
constructor(model: any, serializer?: IModelSerializer);
columnName: ko.Observable<string>;
name: ko.Computed<string>;
}
export var DefaultDataFilterModel: (newVal?: typeof DataFilterModel) => typeof DataFilterModel;
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export class StripLimitViewModel extends SerializableModel {
static from(model: any, serializer?: IModelSerializer): StripLimitViewModel;
static toJson(value: any, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer, info?: ISerializationInfoArray);
enabled: ko.Observable<boolean>;
axisValue: ko.Observable<string>;
_axisValue: ko.Observable<string>;
}
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import ChartElementCollectionItemBase = DevExpress.Reporting.Chart.Internal.Models.ChartElementCollectionItemBase;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class ConstantLineViewModel extends ChartElementCollectionItemBase {
static from(model: any, serializer?: IModelSerializer): ConstantLineViewModel;
constructor(model: any, parent: ko.ObservableArray<ConstantLineViewModel>, serializer?: IModelSerializer);
static prefix: string;
axisValue: ko.Observable<string>;
_axisValue: ko.Observable<string>;
}
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import ChartElementCollectionItemBase = DevExpress.Reporting.Chart.Internal.Models.ChartElementCollectionItemBase;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class ScaleBreakViewModel extends ChartElementCollectionItemBase {
static from(model: any, serializer?: IModelSerializer): ScaleBreakViewModel;
constructor(model: any, parent: ko.ObservableArray<ScaleBreakViewModel>, serializer?: IModelSerializer);
static prefix: string;
}
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import ChartElementCollectionItemBase = DevExpress.Reporting.Chart.Internal.Models.ChartElementCollectionItemBase;;
import StripLimitViewModel = DevExpress.Reporting.Chart.Internal.Models.StripLimitViewModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class StripViewModel extends ChartElementCollectionItemBase {
static initialModel: {
'MinLimit': {
'@AxisValueSerializable': string;
};
'MaxLimit': {
'@AxisValueSerializable': string;
};
};
static from(model: any, serializer?: IModelSerializer): StripViewModel;
constructor(model: any, parent: ko.ObservableArray<StripViewModel>, serializer?: IModelSerializer);
static prefix: string;
minLimit: StripLimitViewModel;
maxLimit: StripLimitViewModel;
}
}
declare module DevExpress.Reporting.Chart.Internal.Axis {
import ConstantLineViewModel = DevExpress.Reporting.Chart.Internal.Models.ConstantLineViewModel;;
import ScaleBreakViewModel = DevExpress.Reporting.Chart.Internal.Models.ScaleBreakViewModel;;
import StripViewModel = DevExpress.Reporting.Chart.Internal.Models.StripViewModel;;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
export class AxisXYViewModel extends SerializableModel {
static from(info?: ISerializationInfoArray): (model: any, serializer: any) => AxisXYViewModel;
static toJson(value: any, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer, info?: ISerializationInfoArray);
constantLines: ko.ObservableArray<ConstantLineViewModel>;
scaleBreaks: ko.ObservableArray<ScaleBreakViewModel>;
strips: ko.ObservableArray<StripViewModel>;
}
}
declare module DevExpress.Reporting.Chart.Internal {
import ISerializationInfo = DevExpress.Analytics.Utils.ISerializationInfo;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export var scaleBreakSerializationsInfo: ISerializationInfoArray;
export var legendName: ISerializationInfo;
export var stripLimitSerializationsInfo: ISerializationInfoArray;
export var stripSerializationsInfo: ISerializationInfoArray;
export var constantLineSerializationsInfo: ISerializationInfoArray;
export var axisXYSerializationsInfo: ISerializationInfoArray;
export var secondaryAxisXYSerializationsInfo: ISerializationInfoArray;
export var radarAxisX: ISerializationInfo;
export var radarAxisY: ISerializationInfo;
export var axisX3D: ISerializationInfo;
export var axisY3D: ISerializationInfo;
export var axisX: ISerializationInfo;
export var axisY: ISerializationInfo;
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import SeriesViewModel = DevExpress.Reporting.Chart.Internal.Series.SeriesViewModel;;
import SeriesTemplateViewModel = DevExpress.Reporting.Chart.Internal.Series.SeriesTemplateViewModel;;
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class DataContainerViewModel extends SerializableModel {
static from(model: any, serializer?: IModelSerializer): DataContainerViewModel;
static toJson(value: any, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer);
seriesTemplate: SeriesTemplateViewModel;
series: ko.ObservableArray<SeriesViewModel>;
dataMember: ko.Observable<string> | ko.Computed<string>;
seriesDataMember: ko.Observable<string> | ko.Computed<string>;
pivotGridDataSourceOptions: {
autoBindingSettingsEnabled: ko.Observable<boolean> | ko.Computed<boolean>;
};
}
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class LegendViewModel extends SerializableModel {
static from(model: any, serializer?: IModelSerializer): LegendViewModel;
static toJson(value: any, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer);
}
}
declare module DevExpress.Reporting.Chart.Internal.Axis {
import AxisXYViewModel = DevExpress.Reporting.Chart.Internal.Axis.AxisXYViewModel;;
import ICollectionItem = DevExpress.Reporting.Chart.Internal.Axis.ICollectionItem;;
import IAction = DevExpress.Analytics.Utils.IAction;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class SecondaryAxisViewModel extends AxisXYViewModel implements ICollectionItem {
static xPrefix: string;
static yPrefix: string;
constructor(model: any, parent: ko.ObservableArray<SecondaryAxisViewModel>, serializer?: IModelSerializer);
readonly axisID: number;
parent: ko.ObservableArray<SecondaryAxisViewModel>;
innerActions: Array<IAction>;
}
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import ChartElementCollectionItemBase = DevExpress.Reporting.Chart.Internal.Models.ChartElementCollectionItemBase;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class AdditionalPaneViewModel extends ChartElementCollectionItemBase {
static from(model: any, serializer?: IModelSerializer): AdditionalPaneViewModel;
constructor(model: any, parent: ko.ObservableArray<AdditionalPaneViewModel>, serializer?: IModelSerializer);
static prefix: string;
}
}
declare module DevExpress.Reporting.Chart.Internal {
import SecondaryAxisViewModel = DevExpress.Reporting.Chart.Internal.Axis.SecondaryAxisViewModel;;
import AdditionalPaneViewModel = DevExpress.Reporting.Chart.Internal.Models.AdditionalPaneViewModel;;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;
import ModelSerializer = DevExpress.Analytics.Utils.ModelSerializer;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
export interface IDiagramViewModel {
axisX?: any;
axisY?: any;
secondaryAxesX?: ko.ObservableArray<SecondaryAxisViewModel>;
secondaryAxesY?: ko.ObservableArray<SecondaryAxisViewModel>;
defaultPanes?: any;
panes?: ko.ObservableArray<AdditionalPaneViewModel>;
getInfo: () => ISerializationInfoArray;
}
export class DiagramViewModel extends SerializableModel implements IDiagramViewModel {
static createDiagram(model: any, type: any, serializer?: ModelSerializer): IDiagramViewModel;
static from(model: any, serializer?: IModelSerializer): DiagramViewModel;
static toJson(value: any, serializer: any, refs: any): any;
constructor(model: any, serializer?: IModelSerializer);
secondaryAxesX: ko.ObservableArray<SecondaryAxisViewModel>;
secondaryAxesY: ko.ObservableArray<SecondaryAxisViewModel>;
panes: ko.ObservableArray<AdditionalPaneViewModel>;
}
}
declare module DevExpress.Reporting.Chart.Internal {
import ISerializationInfo = DevExpress.Analytics.Utils.ISerializationInfo;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export var diagram: ISerializationInfo;
export var secondaryAxesX: ISerializationInfo;
export var secondaryAxesY: ISerializationInfo;
export var panes: ISerializationInfo;
export var diagramSerializationsInfo: ISerializationInfoArray;
export var diagramMapper: {
[key: string]: {
info: ISerializationInfoArray;
type: string;
};
};
}
declare module DevExpress.Reporting.Designer.Internal {
export var reportStorageWebIsRegister: (newVal?: boolean) => boolean;
export var limitation: (newVal?: boolean) => boolean;
}
declare module DevExpress.Reporting.Chart.Internal {
import ISerializationInfo = DevExpress.Analytics.Utils.ISerializationInfo;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
export var commonSeriesPointsSortingKeys: {
value: string;
displayValue: string;
localizationId: string;
}[], bubbleSeriesPointsSortingKeys: {
value: string;
displayValue: string;
localizationId: string;
}[], rangeSeriesPointsSortingKeys: {
value: string;
displayValue: string;
localizationId: string;
}[], stockSeriesPointsSortingKeys: {
value: string;
displayValue: string;
localizationId: string;
}[];
export var seriesPointsSorting: ISerializationInfo, seriesPointsSortingKey: ISerializationInfo, legendTextPattern: ISerializationInfo, _argumentScaleTypeValidatorOptions: {
_seriesViewModel: any;
onInitialized: (e: any) => void;
validationRules: {
type: string;
reevaluate: boolean;
validationCallback: (params: any) => boolean;
}[];
}, argumentScaleType: ISerializationInfo, valueScaleType: ISerializationInfo, labelsVisibility: ISerializationInfo, argumentDataMember: ISerializationInfo, valueDataMembersSerializable: ISerializationInfo;
export var barPositionValues: {
value: string;
displayValue: string;
localizationId: string;
}[];
export var piePositionValues: {
value: string;
displayValue: string;
localizationId: string;
}[];
export var funnelPositionValues: {
value: string;
displayValue: string;
localizationId: string;
}[];
export var padding: ISerializationInfo;
export var seriesLabelSerializationsInfo: ISerializationInfoArray;
export var seriesLabel: ISerializationInfo;
export var pivotGridDataSourceOptions: ISerializationInfo;
export var valuesSerializable: ISerializationInfo, argumentSerializable: ISerializationInfo, colorSerializable: ISerializationInfo;
export var seriesPointSerializationsInfo: ISerializationInfo[];
export var points: ISerializationInfo;
export var createViewsArray: (limitation: any) => any[];
export var view: ISerializationInfo;
export var viewBindableSerializationInfo: ISerializationInfo;
export var qualitativeSummaryOptions: ISerializationInfo;
export var numericSummaryOptions: ISerializationInfo;
export var dateTimeSumaryOptions: ISerializationInfo;
export var seriesTemplateSerializationsInfo: ISerializationInfoArray;
export var seriesTemplate: ISerializationInfo;
export var seriesSerializationsInfo: ISerializationInfoArray;
export var seriesSerializable: ISerializationInfo;
export var seriesDataMember: ISerializationInfo;
export var dataContainerSerializationsInfo: ISerializationInfoArray;
export var dataContainer: ISerializationInfo;
export var emptyChartTextSerializationsInfo: ISerializationInfoArray;
export var emptyChartText: ISerializationInfo;
export var titleSerializationsInfo: ISerializationInfoArray;
export var titles: ISerializationInfo;
export var legendSerializationsInfo: ISerializationInfoArray;
export var legend: ISerializationInfo;
export var additionalLegendSerializationsInfo: ISerializationInfoArray;
export var legends: ISerializationInfo;
export var appearanceName: ISerializationInfo;
export var paletteName: ISerializationInfo;
export var backImage: ISerializationInfo;
export var chartSerializationsInfo: ISerializationInfoArray;
export var chart: ISerializationInfo;
export var chartDataMember: ISerializationInfo;
export var chartSeriesDataMember: ISerializationInfo;
export var fakeChartSerializationInfo: ISerializationInfoArray;
export var chartControlSerializationsInfo: ISerializationInfoArray;
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import ChartElementCollectionItemBase = DevExpress.Reporting.Chart.Internal.Models.ChartElementCollectionItemBase;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class AdditionalLegendViewModel extends ChartElementCollectionItemBase {
static from(model: any, serializer?: IModelSerializer): AdditionalLegendViewModel;
constructor(model: any, parent: ko.ObservableArray<AdditionalLegendViewModel>, serializer?: IModelSerializer);
static prefix: string;
}
}
declare module DevExpress.Reporting.Chart.Internal.Models {
import DiagramViewModel = DevExpress.Reporting.Chart.Internal.DiagramViewModel;;
import TitleViewModel = DevExpress.Reporting.Chart.Internal.Models.TitleViewModel;;
import AdditionalLegendViewModel = DevExpress.Reporting.Chart.Internal.Models.AdditionalLegendViewModel;;
import DataContainerViewModel = DevExpress.Reporting.Chart.Internal.Models.DataContainerViewModel;;
import SerializableModel = DevExpress.Analytics.Elements.SerializableModel;;
import IModelSerializer = DevExpress.Analytics.Utils.IModelSerializer;;
export class ChartViewModel extends SerializableModel {
static from(model: any, serializer?: IModelSerializer): ChartViewModel;
static toJson(value: any, serializer: any, refs: any): any;
private _patchView;
private _patchSeries;
_createDiagram(model: any, oldType: ko.Observable<string>, serializer: any): void;
constructor(model: any, serializer?: IModelSerializer);
barDistance: ko.Observable<number>;
barDistanceFixed: ko.Observable<number>;
titles: ko.ObservableArray<TitleViewModel>;
legends: ko.ObservableArray<AdditionalLegendViewModel>;
dataContainer: DataContainerViewModel;
diagram: ko.Observable<DiagramViewModel> | ko.Computed<DiagramViewModel>;
}
}
declare module DevExpress.Reporting.Chart.Internal {
import ReorderTreeListDragDropHelper = DevExpress.Analytics.Widgets.Internal.ReorderTreeListDragDropHelper;;
export class ChartTreeListDragDropHelper extends ReorderTreeListDragDropHelper {
getSiblings(): ObservableArray<any>;
stop(): void;
}
}
declare module DevExpress.Reporting.Chart.Internal {
/// <reference types="jqueryui" />
import DragDropHandler = DevExpress.Analytics.Internal.DragDropHandler;
import DragHelperContent = DevExpress.Analytics.Internal.DragHelperContent;
import ObjectStructureTreeListController = DevExpress.Analytics.Internal.ObjectStructureTreeListController;
import SurfaceSelection = DevExpress.Analytics.Internal.SurfaceSelection;;
import TreeListItemViewModel = DevExpress.Analytics.Widgets.Internal.TreeListItemViewModel;;
import UndoEngine = DevExpress.Analytics.Utils.UndoEngine;;
import ISurfaceContext = DevExpress.Analytics.Elements.ISurfaceContext;;
import ChartTreeListDragDropHelper = DevExpress.Reporting.Chart.Internal.ChartTreeListDragDropHelper;;
export class ChartStructureTreeListController extends ObjectStructureTreeListController {
private surface?;
private undoEngine?;
private dragdrophandler?;
constructor(propertyNames?: string[], listPropertyNames?: string[], selectCallback?: (value: TreeListItemViewModel) => void, surface?: any, undoEngine?: any, dragdrophandler?: any);
}
export class ChartDragDropHandler extends DragDropHandler {
private undoEngine;
dispose(): void;
constructor(surface: ko.Observable<ISurfaceContext> | ko.Computed<ISurfaceContext>, selection: SurfaceSelection, undoEngine: ko.Observable<UndoEngine> | ko.Computed<UndoEngine>, dragHelperContent: DragHelperContent);
startDrag(draggable: any): void;
drag(event: JQueryEventObject, ui: JQueryUI.DraggableEventUIParams): void;
doStopDrag(ui: any, draggable: any, event: JQueryEventObject): void;
dragDropHelper: ChartTreeListDragDropHelper;
}
}
declare module DevExpress.Reporting.Chart.Internal {
import ObjectStructureProvider = DevExpress.Analytics.Internal.ObjectStructureProvider;;
export class ChartStructureObjectProvider extends ObjectStructureProvider {
getClassName(instance: any): any;
createArrayItem(currentTarget: Array<any>, result: IDataMemberInfo[], propertyName?: any): void;
constructor(target: any, displayName?: string, localizationId?: string);
}
import IDataMemberInfo = null.IDataMemberInfo;;
}
declare module DevExpress.Reporting.Chart.Internal {
export var HandlerUri: (newVal?: string) => string;
}
declare module DevExpress.Reporting.Chart.Internal {
import IPathRequest = DevExpress.Analytics.Utils.IPathRequest;
import IDataMemberInfo = DevExpress.Analytics.Utils.IDataMemberInfo;;
export class ChartRequests {
static getChartImage(uri: string, chartLayout: any, width: number, height: number): any;
static fieldListCallback(request: IPathRequest): JQueryPromise<IDataMemberInfo[]>;
}
}
declare module DevExpress.Reporting.Chart.Internal {
import ChartControlViewModel = DevExpress.Reporting.Chart.Internal.ChartControlViewModel;;
import Disposable = DevExpress.Analytics.Utils.Disposable;;
import ISize = DevExpress.Analytics.Elements.ISize;;
export class ChartControlSurface extends Disposable {
constructor(control: ChartControlViewModel, zoom?: ko.Observable<number>, size?: ISize);
width: ko.Computed<number>;
height: ko.Computed<number>;
imageSrc: ko.Observable<string>;
zoom: ko.Observable<number> | ko.Computed<number>;
templateName: string;
}
}
declare module DevExpress.Reporting.Chart.Internal {
import FieldListProvider = DevExpress.Analytics.Internal.FieldListProvider;
import IDataSourceInfo = DevExpress.Analytics.Internal.IDataSourceInfo;;
import ControlsFactory = DevExpress.Analytics.Utils.ControlsFactory;
import IAction = DevExpress.Analytics.Utils.IAction;
import IDataMemberInfo = DevExpress.Analytics.Utils.IDataMemberInfo;
import ISerializationInfoArray = DevExpress.Analytics.Utils.ISerializationInfoArray;;
import ChartStructureTreeListController = DevExpress.Reporting.Chart.Internal.ChartStructureTreeListController;;
import ChartStructureObjectProvider = DevExpress.Reporting.Chart.Internal.ChartStructureObjectProvider;;
import ChartControlViewModel = DevExpress.Reporting.Chart.Internal.ChartControlViewModel;;
export var ActionId: {
Save: string;
};
export var controlsFactory: ControlsFactory;
export function registerControls(): void;
export function _setChartLimitation(chartLimitation: any): void;
export function updateChartSurfaceContentSize(element: any, surfaceSize: ko.Observable<number> | ko.Computed<number>, rtl?: boolean): () => void;
export interface IChartControlCallbacks {
fieldLists?: (IPathRequest: any) => JQueryPromise<IDataMemberInfo[]>;
customizeActions?: (actions: IAction[]) => void;
init?: (designerModel: any) => void;
}
export interface IChartDesignerOptions {
data: {
chartSource?: ko.Observable<any>;
chart?: ko.Observable<ChartControlViewModel>;
dataSource?: ko.Observable<IDataSourceInfo>;
availableChartDataSources?: ko.Computed<Array<{
displayName: string;
value: any;
}>>;
width?: number;
height?: number;
};
fieldListProvider?: FieldListProvider;
callbacks?: IChartControlCallbacks;
visible?: ko.Observable<boolean>;
localization?: any;
rtl?: boolean;
}
export function subscribeTreelistArray(chartStructureProvider: any, array: ko.ObservableArray<any>, getPath: () => string[], subscribeNewItem?: (item: any, array: any, path: any) => void): ko.Subscription;
export function getPropertyInfo(serializationsInfo: ISerializationInfoArray, index: number, pathComponets: any): DevExpress.Analytics.Utils.ISerializationInfo;
export function createChartStructure(chart: ChartControlViewModel, selectedItem: any, subscriptions: any, surface: any, undoEngine: any, dragdrophandler: any): {
itemsProvider: ChartStructureObjectProvider;
treeListController: ChartStructureTreeListController;
expandRootItems: boolean;
selectedPath: ko.Observable<string> | ko.Computed<string>;
};
export function createChartDesigner(element: Element, options: IChartDesignerOptions, applyBindings?: boolean): any;
}
declare module DevExpress.Reporting.Chart.Internal {
import ChartViewModel = DevExpress.Reporting.Chart.Internal.Models.ChartViewModel;;
import IChartControlCallbacks = DevExpress.Reporting.Chart.Internal.IChartControlCallbacks;;
import IDataSourceInfo = DevExpress.Analytics.Internal.IDataSourceInfo;
import FieldListProvider = DevExpress.Analytics.Internal.FieldListProvider;;
import ISize = DevExpress.Analytics.Elements.ISize;;
import Disposable = DevExpress.Analytics.Utils.Disposable;;
export interface IChartControlOptions {
chartSource?: any;
chart?: ChartViewModel;
dataSource: ko.Observable<IDataSourceInfo> | ko.Computed<IDataSourceInfo>;
size?: ISize;
disabled?: ko.Observable<boolean> | ko.Computed<boolean>;
callbacks?: IChartControlCallbacks;
parameters?: ko.ObservableArray;
}
export class ChartControlViewModel extends Disposable {
getInfo(): DevExp