1637 lines
61 KiB
TypeScript
1637 lines
61 KiB
TypeScript
/// <reference path="jquery.d.ts" />
|
|
declare module DevExpress {
|
|
export function abstract(): void;
|
|
export var rtlEnabled: boolean;
|
|
export var hardwareBackButton: JQueryCallback;
|
|
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;
|
|
cancel: boolean;
|
|
handled: boolean;
|
|
}
|
|
export class Action {
|
|
constructor(action?: any, config?: ActionOptions);
|
|
execute(): any;
|
|
}
|
|
export interface IDevice {
|
|
deviceType?: string;
|
|
platform?: string;
|
|
version?: Array<number>;
|
|
phone?: boolean;
|
|
tablet?: boolean;
|
|
android?: boolean;
|
|
ios?: boolean;
|
|
win8?: boolean;
|
|
tizen?: boolean;
|
|
generic?: boolean;
|
|
}
|
|
export module devices {
|
|
export function orientation(): string;
|
|
export var orientationChanged: JQueryCallback;
|
|
export function real(): IDevice;
|
|
export function current(deviceOrName: string): IDevice;
|
|
export function current(deviceOrName: IDevice): IDevice;
|
|
}
|
|
export function registerComponent(name: string, componentClass: any): void;
|
|
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<T>(options: string): T;
|
|
option(options: string, value: any): void;
|
|
option(options: { [key: string]: any }): void;
|
|
option(options?: any): any;
|
|
}
|
|
export interface DOMComponentOptions extends ComponentOptions {
|
|
rtlEnabled?: boolean;
|
|
}
|
|
export class DOMComponent extends Component {
|
|
constructor(element: HTMLElement, options?: DOMComponentOptions);
|
|
static defaultOptions(rule: {
|
|
device: any;
|
|
options: { [key: string]: any };
|
|
}): void;
|
|
}
|
|
}
|
|
declare module DevExpress.data {
|
|
export interface DataError extends Error {
|
|
httpStatus?: number;
|
|
errorDetails?: any;
|
|
}
|
|
export interface ErrorHandler { (e: DataError): 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): void; }
|
|
export interface QueryOptions {
|
|
errorHandler?: ErrorHandler;
|
|
requireTotalCount?: boolean;
|
|
}
|
|
export interface ODataQueryOptions extends QueryOptions {
|
|
adapter?: any;
|
|
}
|
|
interface IQuery {
|
|
enumerate(): JQueryPromise<Array<any>>;
|
|
count(): JQueryPromise<number>;
|
|
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): JQueryPromise<number>;
|
|
min(getter?: string): JQueryPromise<any>;
|
|
max(getter?: string): JQueryPromise<any>;
|
|
avg(getter?: string): JQueryPromise<any>;
|
|
aggregate(step: number): JQueryPromise<any>;
|
|
aggregate(seed: number, step: (accumulator: any, current: any) => any, finalize?: (accumulator: any) => any): JQueryPromise<any>;
|
|
}
|
|
export interface ArrayQuery extends IQuery {
|
|
toArray(): Array<any>;
|
|
}
|
|
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<any>, 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<any>): Array<any>;
|
|
export function keysEqual(key1: any, key2: any): boolean;
|
|
export function keysEqual(keyExpr: any, key1: any, key2: any): 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): any;
|
|
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<any>);
|
|
constructor(options?: { store: Store });
|
|
constructor(options?: CustomStoreOptions);
|
|
constructor(options?: { store: Array<any> });
|
|
constructor(options?: { store: { type: string } });
|
|
constructor(options?: { load(options?: LoadOptions): JQueryXHR; });
|
|
constructor(options?: { load(options?: LoadOptions): Array<any>; });
|
|
constructor(options?: { load(options?: LoadOptions): JQueryPromise<any>; });
|
|
constructor(options?: DataSourceOptions);
|
|
loadOptions(): { [key: string]: any };
|
|
items(): Array<any>;
|
|
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(): JQueryPromise<any>;
|
|
dispose(): void;
|
|
}
|
|
export interface StoreOptions {
|
|
key?: any;
|
|
errorHandler?: ErrorHandler;
|
|
loaded?: (result: Array<any>) => void;
|
|
loading?: (loadOptions: LoadOptions) => void;
|
|
modified?: () => void;
|
|
modifying?: () => void;
|
|
inserted?: (values: Object, key: any) => void;
|
|
inserting?: (values: Object) => void;
|
|
updated?: (key: any, values: Object) => void;
|
|
updating?: (key: any, values: Object) => void;
|
|
removed?: (key: any) => void;
|
|
removing?: (key: any) => void;
|
|
}
|
|
export interface LoadOptions extends QueryOptions {
|
|
skip?: number;
|
|
take?: number;
|
|
sort?: any;
|
|
select?: any;
|
|
filter?: any;
|
|
group?: any;
|
|
expand?: 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): JQueryPromise<any[]>;
|
|
createQuery(options?: QueryOptions): IQuery;
|
|
totalCount(options?: {
|
|
filter?: any[];
|
|
group?: string[];
|
|
}): JQueryPromise<number>;
|
|
byKey(key: any, extraOptions?: {
|
|
expand?: string[]
|
|
}): JQueryPromise<any>;
|
|
remove(key: any): JQueryPromise<any>;
|
|
insert(values: any): JQueryPromise<any>;
|
|
update(key: any, values: any): JQueryPromise<any>;
|
|
}
|
|
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<any>
|
|
}
|
|
export class ArrayStore extends Store {
|
|
constructor(options?: Array<any>);
|
|
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);
|
|
}
|
|
export interface ODataContextOptions {
|
|
url: string;
|
|
jsonp?: boolean;
|
|
withCredentials?: boolean;
|
|
errorHandler?: ErrorHandler;
|
|
beforeSend?: () => any;
|
|
entities?: {
|
|
[entityAlias: string]: ODataStoreOptions;
|
|
};
|
|
}
|
|
export class ODataContext {
|
|
constructor(options?: ODataContextOptions);
|
|
get(operationName: string, params: { [key: string]: any }): JQueryPromise<Array<any>>;
|
|
invoke(operationName: string, params: { [key: string]: any }, httpMethod?: string): JQueryPromise<Array<any>>;
|
|
objectLink(entityAlias: string, key: any): { __metadata: { uri: string }; };
|
|
}
|
|
}
|
|
declare module DevExpress.framework {
|
|
export interface dxViewOptions {
|
|
name: string;
|
|
title?: string;
|
|
layout?: string;
|
|
}
|
|
export class dxView extends Component {
|
|
constructor(options?: dxViewOptions);
|
|
}
|
|
export interface dxLayoutOptions {
|
|
name: string;
|
|
controller: string;
|
|
}
|
|
export class dxLayout extends Component {
|
|
constructor(options?: dxLayoutOptions);
|
|
}
|
|
export interface dxViewPlaceholderOptions {
|
|
viewName: string;
|
|
}
|
|
export class dxViewPlaceholder extends Component {
|
|
constructor(options?: dxLayoutOptions);
|
|
}
|
|
export interface dxTransitionOptions {
|
|
name: string;
|
|
type: string;
|
|
}
|
|
export class dxTransition extends Component {
|
|
constructor(options?: dxLayoutOptions);
|
|
}
|
|
export interface dxContentPlaceholderOptions {
|
|
name: string;
|
|
transition: string;
|
|
}
|
|
export class dxContentPlaceholder extends Component {
|
|
constructor(options?: dxLayoutOptions);
|
|
}
|
|
export interface dxContentOptions {
|
|
targetPlaceholder: string;
|
|
}
|
|
export class dxContent extends Component {
|
|
constructor(options?: dxLayoutOptions);
|
|
}
|
|
export interface dxCommandOptions extends ComponentOptions {
|
|
id: string;
|
|
action?: any;
|
|
icon?: string;
|
|
title?: string;
|
|
iconSrc?: string;
|
|
visible?: boolean;
|
|
}
|
|
export class dxCommand extends Component {
|
|
public beforeExecute: JQueryCallback;
|
|
public afterExecute: JQueryCallback;
|
|
constructor(element: JQuery, options?: dxCommandOptions);
|
|
constructor(element: Element, options?: dxCommandOptions);
|
|
execute(): void;
|
|
}
|
|
export class dxCommandContainer extends Component {
|
|
constructor(options: ComponentOptions);
|
|
constructor(element: JQuery, options?: ComponentOptions);
|
|
constructor(element: Element, options?: 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 {
|
|
viewRemoved: JQueryCallback;
|
|
setView(key: string, viewInfo: any): void;
|
|
removeView(key: string): any;
|
|
hasView(viewInfo: any): boolean;
|
|
getView(key: string): any;
|
|
clear(): void;
|
|
}
|
|
export class ViewCache implements IViewCache {
|
|
viewRemoved: JQueryCallback;
|
|
constructor();
|
|
setView(key: string, viewInfo: any): void;
|
|
removeView(key: string): any;
|
|
hasView(viewInfo: any): boolean;
|
|
getView(key: string): any;
|
|
clear(): void;
|
|
}
|
|
export class NullViewCache implements IViewCache {
|
|
viewRemoved: JQueryCallback;
|
|
constructor();
|
|
setView(key: string, viewInfo: any): void;
|
|
removeView(key: string): any;
|
|
hasView(viewInfo: any): boolean;
|
|
getView(key: string): any;
|
|
clear(): void;
|
|
}
|
|
export class CapacityViewCacheDecorator implements IViewCache {
|
|
viewRemoved: JQueryCallback;
|
|
constructor(options: {
|
|
size: number;
|
|
viewCache: IViewCache;
|
|
});
|
|
setView(key: string, viewInfo: any): void;
|
|
removeView(key: string): any;
|
|
hasView(viewInfo: any): boolean;
|
|
getView(key: string): any;
|
|
clear(): void;
|
|
}
|
|
export class ConditionalViewCacheDecorator implements IViewCache {
|
|
viewRemoved: JQueryCallback;
|
|
constructor(options: {
|
|
filter: (key: string, viewInfo: any) => boolean;
|
|
viewCache: IViewCache;
|
|
});
|
|
setView(key: string, viewInfo: any): void;
|
|
removeView(key: string): any;
|
|
hasView(viewInfo: any): boolean;
|
|
getView(key: string): any;
|
|
clear(): void;
|
|
}
|
|
export class HistoryDependentViewCacheDecorator implements IViewCache {
|
|
viewRemoved: JQueryCallback;
|
|
constructor(options: {
|
|
navigationManager: StackBasedNavigationManager;
|
|
viewCache: IViewCache;
|
|
});
|
|
setView(key: string, viewInfo: any): void;
|
|
removeView(key: string): any;
|
|
hasView(viewInfo: any): boolean;
|
|
getView(key: string): any;
|
|
clear(): void;
|
|
}
|
|
export interface IStorage {
|
|
getItem(key: string): any;
|
|
setItem(key: string, value: any): void;
|
|
removeItem(key: string): void;
|
|
}
|
|
export class MemoryKeyValueStorage implements IStorage {
|
|
constructor();
|
|
getItem(key: string): any;
|
|
setItem(key: string, value: any): void;
|
|
removeItem(key: string): void;
|
|
}
|
|
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 {
|
|
init: Function;
|
|
setUri(uri: string): void;
|
|
getUri(): string;
|
|
back(): void;
|
|
}
|
|
export class StackBasedNavigationDevice extends HistoryBasedNavigationDevice implements INavigationDevice {
|
|
uriChanged: JQueryCallback;
|
|
constructor(options?: BrowserAdapterOptions);
|
|
}
|
|
export class HistoryBasedNavigationDevice implements INavigationDevice {
|
|
backInitiated: JQueryCallback;
|
|
init: Function;
|
|
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: any, replaceCurrent?: boolean): any;
|
|
getPreviousItem(): any;
|
|
canBack(): boolean;
|
|
clear(): void;
|
|
}
|
|
export interface NavigationManagerOptions {
|
|
stateStorageKey?: string;
|
|
navigationDevice?: INavigationDevice;
|
|
keepPositionInStack?: boolean;
|
|
}
|
|
export interface INavigationManager {
|
|
navigating: JQueryCallback;
|
|
navigated: JQueryCallback;
|
|
navigatingBack: JQueryCallback;
|
|
navigationCanceled: JQueryCallback;
|
|
itemRemoved: JQueryCallback;
|
|
navigate(uri: any, options?: {
|
|
root?: boolean;
|
|
target?: string;
|
|
direction?: string;
|
|
}): void;
|
|
back(): void;
|
|
back(alternate: any): void;
|
|
canBack(): boolean;
|
|
rootUri(): string;
|
|
currentItem(): any;
|
|
previousItem(): any;
|
|
saveState(): void;
|
|
removeState(): void;
|
|
restoreState(): void;
|
|
}
|
|
export class StackBasedNavigationManager extends HistoryBasedNavigationManager {
|
|
init(): JQueryPromise<any>;
|
|
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: any, options?: {
|
|
root?: boolean;
|
|
target?: string;
|
|
direction?: string;
|
|
}): void;
|
|
currentIndex(): number;
|
|
getItemByIndex(index: number): any;
|
|
clearHistory(): void;
|
|
}
|
|
export class HistoryBasedNavigationManager implements INavigationManager {
|
|
navigating: JQueryCallback;
|
|
navigated: JQueryCallback;
|
|
navigatingBack: JQueryCallback;
|
|
navigationCanceled: JQueryCallback;
|
|
itemRemoved: JQueryCallback;
|
|
constructor(options?: NavigationManagerOptions);
|
|
navigate(uri: any, options?: {
|
|
root?: boolean;
|
|
target?: string;
|
|
direction?: string;
|
|
}): void;
|
|
back(): void;
|
|
back(alternate: any): void;
|
|
canBack(): boolean;
|
|
rootUri(): string;
|
|
currentItem(): any;
|
|
previousItem(): any;
|
|
saveState(): void;
|
|
removeState(): void;
|
|
restoreState(): void;
|
|
}
|
|
export module utils {
|
|
export function mergeCommands(destination: any, source: any): dxCommand[];
|
|
}
|
|
export interface ApplicationOptions {
|
|
router?: MvcRouter;
|
|
ns?: Object;
|
|
namespace?: Object;
|
|
viewCache?: IViewCache;
|
|
viewCacheSize?: number;
|
|
disableViewCache?: boolean;
|
|
useViewTitleAsBackText?: boolean;
|
|
stateManager?: StateManager;
|
|
navigationManager?: StackBasedNavigationManager;
|
|
navigation?: dxCommandOptions[];
|
|
commandMapping?: CommandMap;
|
|
}
|
|
export class Application {
|
|
public router: MvcRouter;
|
|
public namespace: any;
|
|
public components: any[];
|
|
public viewCache: IViewCache;
|
|
public stateManager: StateManager;
|
|
public commandMapping: CommandMap;
|
|
public navigation: dxCommand[];
|
|
public navigationManager: StackBasedNavigationManager;
|
|
public beforeViewSetup: JQueryCallback;
|
|
public afterViewSetup: JQueryCallback;
|
|
public viewShowing: JQueryCallback;
|
|
public viewShown: JQueryCallback;
|
|
public viewHidden: JQueryCallback;
|
|
public viewDisposing: JQueryCallback;
|
|
public viewDisposed: JQueryCallback;
|
|
public navigating: JQueryCallback;
|
|
public navigatingBack: JQueryCallback;
|
|
constructor(options?: ApplicationOptions);
|
|
init(): any;
|
|
navigate(uri?: any, 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: any): void; }
|
|
};
|
|
}
|
|
declare module DevExpress.framework.html {
|
|
export interface ILayoutController {
|
|
viewReleased: JQueryCallback;
|
|
init(options: InitLayoutControllerOptions): void;
|
|
activate(): void;
|
|
deactivate(): void;
|
|
showView(viewInfo: any, direction?: string): JQueryPromise<any>;
|
|
}
|
|
export interface ILayoutControllerRegistration extends IDevice {
|
|
name: string;
|
|
controller: ILayoutController;
|
|
root?: boolean;
|
|
}
|
|
export var layoutControllers: Array<ILayoutControllerRegistration>;
|
|
export var layoutSets: Object;
|
|
export interface InitLayoutControllerOptions {
|
|
$viewPort?: JQuery;
|
|
$hiddenBag?: JQuery;
|
|
navigationManager?: framework.StackBasedNavigationManager;
|
|
}
|
|
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): JQueryPromise<any>;
|
|
}
|
|
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): void; }
|
|
export interface ITemplateEngine {
|
|
applyTemplate(template: string, model: any): void;
|
|
applyTemplate(template: Element, model: any): void;
|
|
applyTemplate(template: JQuery, model: any): void;
|
|
}
|
|
export class KnockoutJSTemplateEngine implements ITemplateEngine {
|
|
constructor();
|
|
applyTemplate(template: string, model: any): void;
|
|
applyTemplate(template: Element, model: any): void;
|
|
applyTemplate(template: JQuery, model: any): void;
|
|
}
|
|
export interface TransitionExecutorOptions {
|
|
type?: string;
|
|
source?: JQuery;
|
|
destination?: JQuery;
|
|
}
|
|
export class TransitionExecutor {
|
|
public container: JQuery;
|
|
constructor(container: JQuery, options: TransitionExecutorOptions);
|
|
finalize(): void;
|
|
exec(): JQueryPromise<TransitionExecutorOptions>;
|
|
static create(container: JQuery, options: TransitionExecutorOptions): TransitionExecutor;
|
|
}
|
|
export interface ViewEngineOptions {
|
|
$root?: JQuery;
|
|
device?: IDevice;
|
|
commandManager?: CommandManager;
|
|
templateEngine?: ITemplateEngine;
|
|
dataOptionsAttributeName?: string;
|
|
}
|
|
export class ViewEngineBase {
|
|
public $root: JQuery;
|
|
public device: IDevice;
|
|
public commandManager: CommandManager;
|
|
public templateEngine: ITemplateEngine;
|
|
public dataOptionsAttributeName: string;
|
|
public viewSelecting: JQueryCallback;
|
|
public modelFromViewDataExtended: JQueryCallback;
|
|
constructor(options?: ViewEngineOptions);
|
|
init(): JQueryPromise<any>;
|
|
findViewTemplate(viewName: string): JQuery;
|
|
afterViewSetup(viewInfo: any): void;
|
|
}
|
|
export class ViewEngine extends ViewEngineBase {
|
|
public layoutSelecting: JQueryCallback;
|
|
constructor(options?: ViewEngineOptions);
|
|
init(): JQueryPromise<any>;
|
|
findLayoutTemplate(layoutName: string): JQuery;
|
|
}
|
|
export interface HtmlApplicationOptions extends framework.ApplicationOptions {
|
|
commandManager?: CommandManager;
|
|
templateEngine?: ITemplateEngine;
|
|
navigateToRootViewMode?: string;
|
|
layoutControllers?: Array<ILayoutControllerRegistration>
|
|
device?: IDevice;
|
|
layoutSet?: Array<any>;
|
|
}
|
|
export class HtmlApplication extends framework.Application {
|
|
public viewEngine: ViewEngineBase;
|
|
public viewRendered: JQueryCallback;
|
|
public resolveLayoutController: JQueryCallback;
|
|
constructor(options?: HtmlApplicationOptions);
|
|
init(): any;
|
|
viewPort(): JQuery;
|
|
}
|
|
}
|
|
declare module DevExpress.ui {
|
|
interface ViewportOptions {
|
|
allowPan?: boolean;
|
|
allowZoom?: boolean;
|
|
}
|
|
export interface ITemplate {
|
|
compile(html: string): any;
|
|
render(template: JQuery, data: any): any;
|
|
render(template: any, data: any): any;
|
|
}
|
|
class Template {
|
|
constructor(element: HTMLElement);
|
|
constructor(element: JQueryStatic);
|
|
render(container: HTMLElement): any;
|
|
render(container: JQueryStatic): any;
|
|
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(): JQueryPromise<any>;
|
|
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): JQueryPromise<boolean>;
|
|
export function alert(message: string, title?: string): JQueryPromise<boolean>;
|
|
export function confirm(options: DialogOptions): JQueryPromise<boolean>;
|
|
export function confirm(message: string, title?: string): JQueryPromise<boolean>;
|
|
}
|
|
export interface CollectionContainerWidgetOptions extends WidgetOptions {
|
|
items?: Array<any>;
|
|
itemTemplate?: any;
|
|
itemRender?: Function;
|
|
itemClickAction?: any;
|
|
itemRenderedAction?: any;
|
|
noDataText?: string;
|
|
dataSource?: data.DataSource;
|
|
selectedIndex?: number;
|
|
itemSelectAction?: any;
|
|
itemHoldAction?: any;
|
|
itemHoldTimeout?: number;
|
|
}
|
|
export class CollectionContainerWidget extends Widget {
|
|
constructor(element: Element, options?: CollectionContainerWidgetOptions);
|
|
constructor(element: JQuery, options?: CollectionContainerWidgetOptions);
|
|
}
|
|
export interface WidgetOptions extends ComponentOptions {
|
|
contentReadyAction?: 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(): void;
|
|
repaint(): void;
|
|
addTemplate(template: ITemplate): void;
|
|
}
|
|
export interface dxEditorOptions extends WidgetOptions {
|
|
value?: any;
|
|
valueChangeAction?: any;
|
|
}
|
|
export class dxEditor extends Widget {
|
|
constructor(element: Element, options?: dxEditorOptions);
|
|
constructor(element: JQuery, options?: dxEditorOptions);
|
|
}
|
|
export interface dxAutocompleteOptions extends dxDropDownEditorOptions {
|
|
minSearchLength?: number;
|
|
searchTimeout?: number;
|
|
placeholder?: string;
|
|
filterOperator?: string;
|
|
displayExpr?: string;
|
|
searchMode?: string;
|
|
dataSource?: data.DataSource;
|
|
items?: Array<any>;
|
|
itemRender?: Function;
|
|
itemTemplate?: any;
|
|
}
|
|
export class dxAutocomplete extends dxDropDownEditor {
|
|
constructor(element: Element, options?: dxAutocompleteOptions);
|
|
constructor(element: JQuery, options?: dxAutocompleteOptions);
|
|
}
|
|
export interface dxButtonOptions extends WidgetOptions {
|
|
type?: string;
|
|
text?: string;
|
|
icon?: string;
|
|
iconSrc?: string;
|
|
}
|
|
export class dxButton extends Widget {
|
|
constructor(element: Element, options?: dxButtonOptions);
|
|
constructor(element: JQuery, options?: dxButtonOptions);
|
|
}
|
|
export interface dxCheckBoxOptions extends dxEditorOptions { }
|
|
export class dxCheckBox extends dxEditor {
|
|
constructor(element: Element, options?: dxCheckBoxOptions);
|
|
constructor(element: JQuery, options?: dxCheckBoxOptions);
|
|
}
|
|
export interface dxCalendarOptions extends dxEditorOptions {
|
|
value?: Date;
|
|
min?: Date;
|
|
max?: Date;
|
|
firstDayOfWeek?: number;
|
|
}
|
|
export class dxCalendar extends dxEditor {
|
|
constructor(element: Element, options?: dxEditorOptions);
|
|
constructor(element: JQuery, options?: dxEditorOptions);
|
|
}
|
|
export interface dxDateBoxOptions extends dxTextEditorOptions {
|
|
format?: string;
|
|
useNativePicker?: boolean;
|
|
value?: Date;
|
|
type?: string;
|
|
min?: Date;
|
|
max?: Date;
|
|
useCalendar?: boolean;
|
|
formatString?: string;
|
|
closeOnValueChange?: boolean;
|
|
calendarOptions?: Object;
|
|
}
|
|
export class dxDateBox extends dxTextEditor {
|
|
constructor(element: Element, options?: dxDateBoxOptions);
|
|
constructor(element: JQuery, options?: dxDateBoxOptions);
|
|
}
|
|
export interface dxTextEditorOptions extends dxEditorOptions {
|
|
valueChangeEvent?: string;
|
|
placeholder?: string;
|
|
readOnly?: boolean;
|
|
focusInAction?: any;
|
|
focusOutAction?: any;
|
|
keyDownAction?: any;
|
|
keyPressAction?: any;
|
|
keyUpAction?: any;
|
|
changeAction?: any;
|
|
enterKeyAction?: any;
|
|
copyAction?: any;
|
|
pasteAction?: any;
|
|
cutAction?: any;
|
|
inputAction?: any;
|
|
showClearButton?: boolean;
|
|
mode?: string;
|
|
}
|
|
export class dxTextEditor extends dxEditor {
|
|
constructor(element: Element, options?: dxTextEditorOptions);
|
|
constructor(element: JQuery, options?: dxTextEditorOptions);
|
|
focus(): void;
|
|
blur(): void;
|
|
}
|
|
export interface dxListOptions extends CollectionContainerWidgetOptions {
|
|
pullRefreshEnabled?: boolean;
|
|
autoPagingEnabled?: boolean;
|
|
scrollingEnabled?: boolean;
|
|
showScrollbar?: boolean;
|
|
useNativeScrolling?: 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;
|
|
menuType?: string;
|
|
menuItems?: any[];
|
|
deleteEnabled?: boolean;
|
|
deleteMode?: string;
|
|
selectionEnabled?: boolean;
|
|
selectionMode?: string;
|
|
selectionType?: string;
|
|
reorderEnabled?: boolean;
|
|
}
|
|
itemDeleteAction?: any;
|
|
selectedItems?: any[];
|
|
itemSelectAction?: any;
|
|
itemUnselectAction?: any;
|
|
itemReorderAction?: any;
|
|
nextButtonText?: string;
|
|
selectionMode?: string;
|
|
}
|
|
export class dxList extends CollectionContainerWidget {
|
|
constructor(element: Element, options?: dxListOptions);
|
|
constructor(element: JQuery, options?: dxListOptions);
|
|
update(): JQueryPromise<dxList>;
|
|
updateDimensions(): JQueryPromise<dxList>;
|
|
refresh(): JQueryPromise<dxList>;
|
|
reload(): JQueryPromise<dxList>;
|
|
deleteItem(itemElement: JQuery): JQueryPromise<dxList>;
|
|
deleteItem(itemElement: Element): JQueryPromise<dxList>;
|
|
clearSelectedItems() : void;
|
|
isItemSelected(itemElement: JQuery): boolean;
|
|
isItemSelected(itemElement: Element): boolean;
|
|
selectItem(itemElement: JQuery): void;
|
|
selectItem(itemElement: Element): void;
|
|
unselectItem(itemElement: JQuery): void;
|
|
unselectItem(itemElement: Element): void;
|
|
reorderItem(itemElement: JQuery, toItemElement: JQuery): JQueryPromise<dxList>;
|
|
reorderItem(itemElement: Element, toItemElement: Element): JQueryPromise<dxList>;
|
|
getSelectedItems(): number[];
|
|
clientHeight(): number;
|
|
scrollHeight(): number;
|
|
scrollBy(distance: number): void;
|
|
scrollTo(targetLocation: number): void;
|
|
scrollTop(): number;
|
|
}
|
|
export interface dxLoadPanelOptions extends dxOverlayOptions {
|
|
message?: string;
|
|
width?: number;
|
|
height?: number;
|
|
delay?: number;
|
|
showPane?: boolean;
|
|
showIndicator?: boolean;
|
|
indicatorSrc?: string;
|
|
}
|
|
export class dxLoadPanel extends dxOverlay {
|
|
constructor(element: Element, options?: dxLoadPanelOptions);
|
|
constructor(element: JQuery, options?: dxLoadPanelOptions);
|
|
hide(): void;
|
|
show(): void;
|
|
toggle(showing: boolean): void;
|
|
}
|
|
export interface dxLookupOptions extends dxEditorOptions {
|
|
dataSource?: data.DataSource;
|
|
displayValue?: string;
|
|
title?: string;
|
|
titleTemplate?: any;
|
|
valueExpr?: string;
|
|
displayExpr?: string;
|
|
placeholder?: string;
|
|
searchPlaceholder?: string;
|
|
searchEnabled?: boolean;
|
|
searchTimeout?: number;
|
|
minFilterLength?: number;
|
|
fullScreen?: boolean;
|
|
itemTemplate?: any;
|
|
itemRender?: Function;
|
|
showCancelButton?: boolean;
|
|
showClearButton?: boolean;
|
|
showDoneButton?: boolean;
|
|
showNextButton?: boolean;
|
|
doneButtonText?: string;
|
|
cancelButtonText?: string;
|
|
clearButtonText?: string;
|
|
nextButtonText?: string;
|
|
grouped?: boolean;
|
|
groupRender?: Function;
|
|
groupTemplate?: string;
|
|
pullingDownText?: string;
|
|
pulledDownText?: string;
|
|
refreshingText?: string;
|
|
pageLoadingText?: string;
|
|
noDataText?: string;
|
|
scrollAction?: any;
|
|
shading?: boolean;
|
|
closeOnOutsideClick?: boolean;
|
|
position?: any;
|
|
animation?: any;
|
|
shownAction?: any;
|
|
hiddenAction?: any;
|
|
popupWidth?: any;
|
|
popupHeight?: any;
|
|
autoPagingEnabled?: boolean;
|
|
useNativeScrolling?: boolean;
|
|
usePopover?: boolean;
|
|
openAction?: any;
|
|
closeAction?: any;
|
|
}
|
|
export class dxLookup extends dxEditor {
|
|
constructor(element: Element, options?: dxLookupOptions);
|
|
constructor(element: JQuery, options?: dxLookupOptions);
|
|
close(): void;
|
|
open(): void;
|
|
}
|
|
export interface dxMapOptions extends WidgetOptions {
|
|
location?: any;
|
|
width?: number;
|
|
height?: number;
|
|
zoom?: number;
|
|
mapType?: string;
|
|
provider?: string;
|
|
markers?: Array<any>;
|
|
routes?: Array<any>;
|
|
key?: string;
|
|
controls?: any;
|
|
mapReadyAction?: any;
|
|
autoAdjust?: boolean;
|
|
center?: any;
|
|
markerAddedAction?: any;
|
|
markerRemovedAction?: any;
|
|
markerIconSrc?: string;
|
|
routeAddedAction?: any;
|
|
routeRemovedAction?: any;
|
|
type?: string;
|
|
}
|
|
export class dxMap extends Widget {
|
|
constructor(element: Element, options?: dxMapOptions);
|
|
constructor(element: JQuery, options?: dxMapOptions);
|
|
addMarker(markerOptions: any, callback: Function): JQueryPromise<any>;
|
|
removeMarker(marker: any): void;
|
|
addRoute(routeOptions: any, callback: Function): JQueryPromise<any>;
|
|
removeRoute(route: any): void;
|
|
}
|
|
export interface dxNavBarOptions extends dxTabsOptions { }
|
|
export class dxNavBar extends dxTabs {
|
|
constructor(element: Element, options?: dxNavBarOptions);
|
|
constructor(element: JQuery, options?: dxNavBarOptions);
|
|
}
|
|
export interface dxNumberBoxOptions extends dxTextEditorOptions {
|
|
min?: number;
|
|
max?: number;
|
|
value?: number;
|
|
step?: number;
|
|
showSpinButtons?: boolean;
|
|
}
|
|
export class dxNumberBox extends dxTextEditor {
|
|
constructor(element: Element, options?: dxNumberBoxOptions);
|
|
constructor(element: JQuery, options?: dxNumberBoxOptions);
|
|
}
|
|
export interface dxOverlayOptions extends WidgetOptions {
|
|
activeStateEnabled?: boolean;
|
|
shading?: boolean;
|
|
closeOnOutsideClick?: boolean;
|
|
position?: any;
|
|
animation?: any;
|
|
showingAction?: any;
|
|
shownAction?: any;
|
|
hidingAction?: any;
|
|
hiddenAction?: any;
|
|
deferRendering?: boolean;
|
|
targetContainer?: any;
|
|
contentTemplate?: any;
|
|
}
|
|
export class dxOverlay extends Widget {
|
|
constructor(element: Element, options?: dxOverlayOptions);
|
|
constructor(element: JQuery, options?: dxOverlayOptions);
|
|
content(): JQuery;
|
|
hide(): void;
|
|
show(): void;
|
|
toggle(showing: boolean): void;
|
|
}
|
|
export interface dxPopupOptions extends dxOverlayOptions {
|
|
title?: string;
|
|
showTitle?: boolean;
|
|
fullScreen?: boolean;
|
|
cancelButton?: any;
|
|
doneButton?: any;
|
|
clearButton?: any;
|
|
titleTemplate?: any;
|
|
dragEnabled?: boolean;
|
|
}
|
|
export class dxPopup extends dxOverlay {
|
|
constructor(element: Element, options?: dxPopupOptions);
|
|
constructor(element: JQuery, options?: dxPopupOptions);
|
|
}
|
|
export interface dxPopoverOptions extends dxPopupOptions {
|
|
target?: any;
|
|
}
|
|
export class dxPopover extends dxPopup {
|
|
constructor(element: Element, options?: dxPopoverOptions);
|
|
constructor(element: JQuery, options?: dxPopoverOptions);
|
|
}
|
|
export interface dxTooltipOptions extends dxPopoverOptions {
|
|
target?: any;
|
|
}
|
|
export class dxTooltip extends dxPopover {
|
|
constructor(element: Element, options?: dxTooltipOptions);
|
|
constructor(element: JQuery, options?: dxTooltipOptions);
|
|
}
|
|
export interface dxRadioGroupOptions extends CollectionContainerWidgetOptions {
|
|
layout?: string;
|
|
name?: string;
|
|
value?: Object;
|
|
valueExpr?: string;
|
|
}
|
|
export class dxRadioGroup extends CollectionContainerWidget {
|
|
constructor(element: Element, options?: dxRadioGroupOptions);
|
|
constructor(element: JQuery, options?: dxRadioGroupOptions);
|
|
}
|
|
export interface dxRangeSliderOptions extends dxSliderOptions {
|
|
start?: number;
|
|
end?: number;
|
|
}
|
|
export class dxRangeSlider extends dxSlider {
|
|
constructor(element: Element, options?: dxRangeSliderOptions);
|
|
constructor(element: JQuery, options?: dxRangeSliderOptions);
|
|
}
|
|
export interface dxScrollableOptions 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 dxScrollable extends Component {
|
|
constructor(element: Element, options?: dxScrollableOptions);
|
|
constructor(element: JQuery, options?: dxScrollableOptions);
|
|
update(): void;
|
|
content(): JQuery;
|
|
clientHeight(): number;
|
|
scrollHeight(): number;
|
|
clientWidth(): number;
|
|
scrollWidth(): number;
|
|
scrollLeft(): number;
|
|
scrollTop(): number;
|
|
scrollOffset(): Object;
|
|
scrollBy(distance: number): void;
|
|
scrollBy(distance: Object): void;
|
|
scrollTo(targetLocation: number): void;
|
|
scrollTo(targetLocation: Object): void;
|
|
}
|
|
export interface dxScrollViewOptions extends dxScrollableOptions {
|
|
pullingDownText?: string;
|
|
pulledDownText?: string;
|
|
refreshingText?: string;
|
|
reachBottomText?: string;
|
|
pullDownAction?: any;
|
|
reachBottomAction?: any;
|
|
}
|
|
export class dxScrollView extends dxScrollable {
|
|
constructor(element: Element, options?: dxScrollViewOptions);
|
|
constructor(element: JQuery, options?: dxScrollViewOptions);
|
|
release(preventReachBottom: boolean): JQueryPromise<any>;
|
|
toggleLoading(showOrHide: boolean): void;
|
|
refresh(): void;
|
|
}
|
|
export interface dxSelectBoxOptions extends dxAutocompleteOptions {
|
|
fieldTemplate?: any;
|
|
displayValue?: string;
|
|
multiSelectEnabled?: boolean;
|
|
values?: any[];
|
|
openAction?: any;
|
|
closeAction?: any;
|
|
}
|
|
export class dxSelectBox extends dxAutocomplete {
|
|
constructor(element: Element, options?: dxSelectBoxOptions);
|
|
constructor(element: JQuery, options?: dxSelectBoxOptions);
|
|
}
|
|
export interface dxSliderOptions extends dxEditorOptions {
|
|
min?: number;
|
|
max?: number;
|
|
step?: number;
|
|
showRange?: boolean;
|
|
label?: {
|
|
visible: boolean;
|
|
format?: any;
|
|
position?: string;
|
|
}
|
|
tooltip?: {
|
|
enabled?: boolean;
|
|
format?: any;
|
|
position?: string;
|
|
showMode?: string;
|
|
}
|
|
}
|
|
export class dxSlider extends dxEditor {
|
|
constructor(element: Element, options?: dxSliderOptions);
|
|
constructor(element: JQuery, options?: dxSliderOptions);
|
|
}
|
|
export interface dxTabsOptions extends CollectionContainerWidgetOptions { }
|
|
export class dxTabs extends CollectionContainerWidget {
|
|
constructor(element: Element, options?: dxTabsOptions);
|
|
constructor(element: JQuery, options?: dxTabsOptions);
|
|
}
|
|
export interface dxTextAreaOptions extends dxTextEditorOptions {
|
|
cols?: number;
|
|
rows?: number;
|
|
}
|
|
export class dxTextArea extends dxTextEditor {
|
|
constructor(element: Element, options?: dxTextAreaOptions);
|
|
constructor(element: JQuery, options?: dxTextAreaOptions);
|
|
}
|
|
export interface dxTextBoxOptions extends dxTextEditorOptions {
|
|
maxLength?: any;
|
|
}
|
|
export class dxTextBox extends dxTextEditor {
|
|
constructor(element: Element, options?: dxTextBoxOptions);
|
|
constructor(element: JQuery, options?: dxTextBoxOptions);
|
|
}
|
|
export interface dxToastOptions extends dxOverlayOptions {
|
|
message?: string;
|
|
type?: string;
|
|
displayTime?: number;
|
|
}
|
|
export class dxToast extends dxOverlay {
|
|
constructor(element: Element, options?: dxToastOptions);
|
|
constructor(element: JQuery, options?: dxToastOptions);
|
|
}
|
|
export interface dxToolbarOptions extends CollectionContainerWidgetOptions {
|
|
menuItemRender?: Function;
|
|
menuItemTemplate?: any;
|
|
submenuType?: string;
|
|
renderAs?: string;
|
|
}
|
|
export class dxToolbar extends CollectionContainerWidget {
|
|
constructor(element: Element, options?: dxToolbarOptions);
|
|
constructor(element: JQuery, options?: dxToolbarOptions);
|
|
}
|
|
export interface dxDropDownEditorOptions extends dxTextBoxOptions {
|
|
closeAction?: any;
|
|
openAction?: any;
|
|
}
|
|
export class dxDropDownEditor extends dxTextBox {
|
|
constructor(element: Element, options?: dxDropDownEditorOptions);
|
|
constructor(element: JQuery, options?: dxDropDownEditorOptions);
|
|
}
|
|
export interface dxLoadIndicatorOptions extends WidgetOptions {
|
|
indicatorSrc?: string;
|
|
}
|
|
export class dxLoadIndicator extends Widget {
|
|
constructor(element: Element, options?: dxLoadIndicatorOptions);
|
|
constructor(element: JQuery, options?: dxLoadIndicatorOptions);
|
|
}
|
|
export interface dxMultiViewOptions extends CollectionContainerWidgetOptions {
|
|
loop?: boolean;
|
|
swipeEnabled?: boolean;
|
|
animationEnabled?: boolean;
|
|
selectedIndex?: number;
|
|
}
|
|
export class dxMultiView extends CollectionContainerWidget {
|
|
constructor(element: Element, options?: dxMultiViewOptions);
|
|
constructor(element: JQuery, options?: dxMultiViewOptions);
|
|
}
|
|
export interface dxGalleryOptions extends CollectionContainerWidgetOptions {
|
|
activeStateEnabled?: boolean;
|
|
animationDuration?: number;
|
|
loop?: boolean;
|
|
swipeEnabled?: boolean;
|
|
indicatorEnabled?: boolean;
|
|
showIndicator?: boolean;
|
|
selectedIndex?: number;
|
|
slideshowDelay?: number;
|
|
showNavButtons?: boolean;
|
|
}
|
|
export class dxGallery extends CollectionContainerWidget {
|
|
constructor(element: Element, options?: dxGalleryOptions);
|
|
constructor(element: JQuery, options?: dxGalleryOptions);
|
|
goToItem(itemIndex?: number, animation?: boolean): JQueryPromise<dxGallery>;
|
|
prevItem(animation?: boolean): JQueryPromise<dxGallery>;
|
|
nextItem(animation?: boolean): JQueryPromise<dxGallery>;
|
|
}
|
|
export interface dxDataGridFilterDescriptions {
|
|
'='?: string;
|
|
'<>'?: string;
|
|
'<'?: string;
|
|
'<='?: string;
|
|
'>'?: string;
|
|
'>='?: string;
|
|
'startswith'?: string;
|
|
'contains'?: string;
|
|
'notcontains'?: string;
|
|
'endswith'?: string;
|
|
}
|
|
export interface dxDataGridColumn {
|
|
allowSorting?: boolean;
|
|
allowFiltering?: boolean;
|
|
allowHiding?: boolean;
|
|
allowEditing?: boolean;
|
|
allowGrouping?: boolean;
|
|
allowReordering?: boolean;
|
|
allowResizing?: boolean;
|
|
visible?: boolean;
|
|
dataField?: string;
|
|
dataType?: string;
|
|
calculateCellValue?: (rowData: {}) => any;
|
|
calculateFilterExpression?: (filterValue: any, selectedFilterOperation: string) => Array<any>;
|
|
caption?: string;
|
|
width?: any; cssClass?: string;
|
|
trueText?: string;
|
|
falseText?: string;
|
|
sortOrder?: string;
|
|
sortIndex?: number;
|
|
groupIndex?: number;
|
|
alignment?: string;
|
|
format?: string;
|
|
precision?: number;
|
|
customizeText?: (options: { value: any; valueText: string }) => string;
|
|
filterOperations?: dxDataGridFilterDescriptions;
|
|
selectedFilterOperation?: string;
|
|
cellTemplate?: any; headerCellTemplate?: any; editCellTemplate?: any; groupCellTemplate?: any; lookup?: {
|
|
dataSource?: any; valueExpr?: any; displayExpr?: any; };
|
|
}
|
|
export interface dxDataGridOptions extends ui.WidgetOptions {
|
|
dataSource?: any;
|
|
dataErrorOccurred?: (errorObject: {}) => void;
|
|
showColumnHeaders?: boolean;
|
|
columnAutoWidth?: boolean;
|
|
noDataText?: string;
|
|
wordWrapEnabled?: boolean;
|
|
showColumnLines?: boolean;
|
|
showRowLines?: boolean;
|
|
rowAlternationEnabled?: boolean;
|
|
allowColumnReordering?: boolean;
|
|
allowColumnResizing?: boolean;
|
|
hoverStateEnabled?: boolean;
|
|
selectedItems?: Array<any>;
|
|
columnChooser?: {
|
|
enabled?: boolean;
|
|
width?: number;
|
|
height?: number;
|
|
title?: string;
|
|
emptyPanelText?: string;
|
|
};
|
|
selection?: {
|
|
mode?: string;
|
|
allowSelectAll?: boolean;
|
|
};
|
|
sorting?: {
|
|
mode?: string;
|
|
ascendingText?: string;
|
|
descendingText?: string;
|
|
clearText?: string;
|
|
};
|
|
searchPanel?: {
|
|
visible?: boolean;
|
|
width?: number;
|
|
placeholder?: string;
|
|
highlightSearchText?: boolean;
|
|
};
|
|
grouping?: {
|
|
autoExpandAll?: boolean;
|
|
allowCollapsing?: boolean;
|
|
groupContinuesMessage?: string;
|
|
groupContinuedMessage?: string;
|
|
};
|
|
groupPanel?: {
|
|
visible?: boolean;
|
|
emptyPanelText?: string;
|
|
allowColumnDragging?: boolean;
|
|
};
|
|
filterRow?: {
|
|
visible?: boolean;
|
|
showOperationChooser?: boolean;
|
|
showAllText?: string;
|
|
resetOperationText?: string;
|
|
operationDescriptions?: dxDataGridFilterDescriptions;
|
|
};
|
|
paging?: {
|
|
enabled?: boolean;
|
|
pageSize?: number;
|
|
pageIndex?: number;
|
|
};
|
|
pager?: {
|
|
visible?: any; showPageSizeSelector?: boolean;
|
|
allowedPageSizes?: Array<number>;
|
|
};
|
|
editing?: {
|
|
editMode?: string;
|
|
insertEnabled?: boolean;
|
|
editEnabled?: boolean;
|
|
removeEnabled?: boolean;
|
|
texts?: {
|
|
editRow?: string;
|
|
saveRowChanges?: string;
|
|
cancelRowChanges?: string;
|
|
deleteRow?: string;
|
|
recoverRow?: string;
|
|
undeleteRow?: string;
|
|
confirmDeleteMessage?: string;
|
|
confirmDeleteTitle?: string;
|
|
}
|
|
};
|
|
scrolling?: {
|
|
mode?: string;
|
|
preloadEnabled?: boolean;
|
|
useNativeScrolling?: boolean;
|
|
};
|
|
loadPanel?: {
|
|
enabled?: boolean;
|
|
text?: string;
|
|
width?: number;
|
|
height?: number;
|
|
};
|
|
stateStoring?: {
|
|
enabled?: boolean;
|
|
storageKey?: string;
|
|
type?: string;
|
|
customLoad?: () => any;
|
|
customSave?: (state: {}) => void;
|
|
};
|
|
rowTemplate?: any; columns?: Array<dxDataGridColumn>;
|
|
selectionChanged?: (options: {}) => void;
|
|
customizeColumns?: (columns: Array<dxDataGridColumn>) => void;
|
|
rowClick?: (data: {}) => void;
|
|
cellClick?: (clickedCell: {}) => void;
|
|
cellHoverChanged?: (hoveredCell: {}) => void;
|
|
}
|
|
export class dxDataGrid extends Widget {
|
|
constructor(element: Element, options?: dxDataGridOptions);
|
|
constructor(element: JQuery, options?: dxDataGridOptions);
|
|
showColumnChooser: () => void;
|
|
hideColumnChooser: () => void;
|
|
beginCustomLoading: (messageText?: string) => void;
|
|
endCustomLoading: () => void;
|
|
startSelectionWithCheckboxes: () => void;
|
|
stopSelectionWithCheckboxes: () => void;
|
|
selectAll: () => void;
|
|
clearSelection: () => void;
|
|
getSelectedRowKeys: () => Array<any>;
|
|
getSelectedRowsData: () => Array<any>;
|
|
selectRows: (keys: Array<any>) => void;
|
|
selectRowsByIndexes: (indexes: Array<any>) => void;
|
|
searchByText: (text: string) => void;
|
|
insertRow: () => void;
|
|
editRow: (rowIndex: number) => void;
|
|
editCell: (rowIndex: number, columnIndex: number) => void;
|
|
removeRow: (rowIndex: number) => void;
|
|
saveEditData: () => void;
|
|
undeleteRow: (rowIndex: number) => void;
|
|
cancelEditData: () => void;
|
|
refresh: () => void;
|
|
filter: (expr: any) => void;
|
|
clearFilter: () => void;
|
|
keyOf: (data: {}) => any;
|
|
byKey: (key: any) => {};
|
|
getDataByKeys: (rowKeys: Array<any>) => Array<{}>;
|
|
pageIndex: (value: number) => number;
|
|
totalCount: () => number;
|
|
closeEditCell: () => void;
|
|
collapseAll: (groupIndex?: number) => void;
|
|
expandAll: (groupIndex?: number) => void;
|
|
addColumn: (options: any) => void;
|
|
columnOption: (columnIndex: number, optionName?: string, optionValue?: any) => {};
|
|
isScrollbarVisible: () => boolean;
|
|
getTopVisibleRowData: () => {};
|
|
}
|
|
export interface dxMenuOptions extends CollectionContainerWidgetOptions {
|
|
orientation?: string;
|
|
submenuDirection?: string;
|
|
showFirstSubmenuMode?: string;
|
|
enableHotTrack?: boolean;
|
|
allowSelection?: boolean;
|
|
allowSelectOnClick?: boolean;
|
|
selectedItem?: any;
|
|
itemSelectAction?: any;
|
|
cssClass?: string;
|
|
}
|
|
export interface dxContextMenuOptions extends CollectionContainerWidgetOptions {
|
|
showSubmenuMode?: string;
|
|
invokeOnlyFromCode?: boolean;
|
|
cssClass?: string;
|
|
enableHotTrack?: boolean;
|
|
allowSelection?: boolean;
|
|
allowSelectOnClick?: boolean;
|
|
selectedItem?: any;
|
|
itemSelectAction?: any;
|
|
animation?: any;
|
|
position?: any;
|
|
showingAction?: any;
|
|
submenuDirection?: string;
|
|
}
|
|
export class dxMenu extends CollectionContainerWidget {
|
|
constructor(element: Element, options?: dxMenuOptions);
|
|
constructor(element: JQuery, options?: dxMenuOptions);
|
|
}
|
|
export class dxContextMenu extends CollectionContainerWidget {
|
|
constructor(element: Element, options?: dxContextMenuOptions);
|
|
constructor(element: JQuery, options?: dxContextMenuOptions);
|
|
}
|
|
export interface dxColorPickerOptions extends dxDropDownEditorOptions {
|
|
editAlphaChannel?: boolean;
|
|
applyButtonText?: string;
|
|
cancelButtonText?: string;
|
|
}
|
|
export class dxColorPicker extends dxDropDownEditor {
|
|
constructor(element: Element, options?: dxColorPickerOptions);
|
|
constructor(element: JQuery, options?: dxColorPickerOptions);
|
|
}
|
|
}
|
|
interface JQuery {
|
|
dxAutocomplete(options?: DevExpress.ui.dxAutocompleteOptions): JQuery;
|
|
dxButton(options?: DevExpress.ui.dxButtonOptions): JQuery;
|
|
dxCheckBox(options?: DevExpress.ui.dxCheckBoxOptions): JQuery;
|
|
dxCalendar(options?: DevExpress.ui.dxCalendarOptions): JQuery;
|
|
dxDateBox(options?: DevExpress.ui.dxDateBoxOptions): JQuery;
|
|
dxTextEditor(options?: DevExpress.ui.dxTextEditorOptions): JQuery;
|
|
dxList(options?: DevExpress.ui.dxListOptions): JQuery;
|
|
dxLoadPanel(options?: DevExpress.ui.dxLoadPanelOptions): JQuery;
|
|
dxLookup(options?: DevExpress.ui.dxLookupOptions): JQuery;
|
|
dxMap(options?: DevExpress.ui.dxMapOptions): JQuery;
|
|
dxNavBar(options?: DevExpress.ui.dxNavBarOptions): JQuery;
|
|
dxNumberBox(options?: DevExpress.ui.dxNumberBoxOptions): JQuery;
|
|
dxOverlay(options?: DevExpress.ui.dxOverlayOptions): JQuery;
|
|
dxPopup(options?: DevExpress.ui.dxPopupOptions): JQuery;
|
|
dxPopover(options?: DevExpress.ui.dxPopoverOptions): JQuery;
|
|
dxTooltip(options?: DevExpress.ui.dxTooltipOptions): JQuery;
|
|
dxRadioGroup(options?: DevExpress.ui.dxRadioGroupOptions): JQuery;
|
|
dxRangeSlider(options?: DevExpress.ui.dxRangeSliderOptions): JQuery;
|
|
dxScrollable(options?: DevExpress.ui.dxScrollableOptions): JQuery;
|
|
dxScrollView(options?: DevExpress.ui.dxScrollViewOptions): JQuery;
|
|
dxSelectBox(options?: DevExpress.ui.dxSelectBoxOptions): JQuery;
|
|
dxSlider(options?: DevExpress.ui.dxSliderOptions): JQuery;
|
|
dxTabs(options?: DevExpress.ui.dxTabsOptions): JQuery;
|
|
dxTextArea(options?: DevExpress.ui.dxTextAreaOptions): JQuery;
|
|
dxTextBox(options?: DevExpress.ui.dxTextBoxOptions): JQuery;
|
|
dxToast(options?: DevExpress.ui.dxToastOptions): JQuery;
|
|
dxToolbar(options?: DevExpress.ui.dxToolbarOptions): JQuery;
|
|
dxDropDownEditor(options?: DevExpress.ui.dxDropDownEditorOptions): JQuery;
|
|
dxLoadIndicator(options?: DevExpress.ui.dxLoadIndicatorOptions): JQuery;
|
|
dxMultiView(options?: DevExpress.ui.dxMultiViewOptions): JQuery;
|
|
dxGallery(options?: DevExpress.ui.dxGalleryOptions): JQuery;
|
|
dxDataGrid(options?: DevExpress.ui.dxDataGridOptions): JQuery;
|
|
dxMenu(options?: DevExpress.ui.dxMenuOptions): JQuery;
|
|
dxContextMenu(options?: DevExpress.ui.dxContextMenuOptions): JQuery;
|
|
dxColorPicker(options?: DevExpress.ui.dxColorPickerOptions): JQuery;
|
|
} |