Generated from SparkleXrm project using Rosetta.ScriptSharp.Definition.BuildTask

Slick.d.ts

/**
 * File: Cell.cs
 */
declare module Slick {
  export class CellSelection {
    public row : number;
    public cell : number;
    public grid : Slick.Grid;
  }
}

/**
 * File: CheckboxSelectColumn.cs
 */
declare module Slick {
  export class CheckboxSelectColumn implements Slick.IPlugin {
    constructor(options : Slick.CheckboxSelectColumnOptions);
  
    getColumnDefinition() : Slick.Column;
    init(grid : Slick.Grid) : void;
    destroy() : void;
  }

  export class CheckboxSelectColumnOptions {
    public cssClass : string;
  }
}

/**
 * File: Aggregators.cs
 */
declare module Slick.Data.Aggregators {
  export class Aggregator {
  }

  export class Avg extends Slick.Data.Aggregators.Aggregator {
    constructor(fieldName : string);
  }

  export class Min extends Slick.Data.Aggregators.Aggregator {
    constructor(fieldName : string);
  }

  export class Max extends Slick.Data.Aggregators.Aggregator {
    constructor(fieldName : string);
  }

  export class Sum extends Slick.Data.Aggregators.Aggregator {
    constructor(fieldName : string);
  }
}

/**
 * File: DataView.cs
 */
declare module Slick.Data {
  export class DataView {
    public onRowsChanged : Slick.Event;
  
    constructor(options : Slick.Data.DataViewOptions);
  
    setGrouping(list : System.Collections.Generic.List) : void;
    setItems(data : any) : void;
    beginUpdate() : void;
    endUpdate() : void;
    setFilter(MyFilter : Slick.Data.FilterDelegate) : void;
    setFilterArgs(filterArguments : System.Collections.Generic.Dictionary) : void;
    sort(Comparer : System.Func, p : boolean) : void;
  }

  export class DataViewOptions {
    public groupItemMetadataProvider : Slick.Data.IMetadataProvider;
    public inlineFilters : boolean;
  }

  export class GroupingDefinition {
    public getter : string;
    public formatter : Slick.Data.GroupingFormatterDelegate;
    public aggregators : System.Collections.Generic.List;
    public aggregateCollapsed : boolean;
    public collapsed : boolean;
  }
}

/**
 * File: GroupItemMetadataProvider.cs
 */
declare module Slick.Data {
  export class GroupItemMetadataProvider implements Slick.Data.IMetadataProvider, Slick.IPlugin {
    init(grid : Slick.Grid) : void;
    destroy() : void;
  }
}

/**
 * File: IMetadataProvider.cs
 */
declare module Slick.Data {
  export interface IMetadataProvider {
  }
}

/**
 * File: EditController.cs
 */
declare module Slick {
  export class EditController {
    commitCurrentEdit() : boolean;
    cancelCurrentEdit() : boolean;
  }
}

/**
 * File: EditEventData.cs
 */
declare module Slick {
  export class EditEventData {
    public column : Slick.Column;
    public grid : Slick.Grid;
    public item : any;
  }

  export class OnCellChangedEventData {
    public row : number;
    public cell : number;
    public item : any;
  }

  export class SortEventData {
    public sortCols : Slick.SortColData[];
  }

  export class SortColData {
    public columnId : string;
    public sortCol : Slick.Column;
    public sortAsc : boolean;
  }
}

/**
 * File: Pager.cs
 */
declare module Slick.Controls {
  export class Pager {
    constructor(dataView : Slick.IDataView, grid : Slick.Grid, pagerElement : any);
  }
}

/**
 * File: EditorArguments.cs
 */
declare module Slick {
  export class EditorArguments {
    public container : any;
    public column : Slick.Column;
    public item : any;
  }
}

/**
 * File: CheckboxEditor.cs
 */
declare module Slick {
  export class CheckboxEditor {
  }
}

/**
 * File: DateEditor.cs
 */
declare module Slick {
  export class DateEditor {
  }
}

/**
 * File: Editor.cs
 */


/**
 * File: IntegerEditor.cs
 */
declare module Slick {
  export class IntegerEditor {
  }
}

/**
 * File: LongTextEditor.cs
 */
declare module Slick {
  export class LongTextEditor {
  }
}

/**
 * File: PercentCompleteEditor.cs
 */
declare module Slick {
  export class PercentCompleteEditor {
  }
}

/**
 * File: TextEditor.cs
 */


/**
 * File: YesNoSelectEditor.cs
 */
declare module Slick {
  export class YesNoSelectEditor {
  }
}

/**
 * File: Promise.cs
 */
declare module ES6 {
  export class Promise {
    constructor(args : System.Action);
    constructor(args : System.Action);
  
    then(resolve : System.Action) : ES6.Promise;
    then(resolve : System.Func) : ES6.Promise;
    then(resolve : System.Func) : ES6.Promise;
  }

  export class Promise {
    constructor(args : System.Action);
    constructor(args : System.Action);
    constructor(args : System.Action);
    constructor(args : System.Action);
  
    then(resolve : System.Action) : ES6.Promise;
    then(resolve : System.Action) : ES6.Promise;
    then(resolve : System.Func) : ES6.Promise;
    then(resolve : System.Func) : ES6.Promise;
    then(resolve : System.Func, reject : System.Action) : ES6.Promise;
    catch(rejected : System.Action) : ES6.Promise;
    static resolve(promise : ES6.Promise) : ES6.Promise;
    static resolve(result : T) : ES6.Promise;
    static reject(error : System.Exception) : ES6.Promise;
    static all(all : System.Collections.Generic.List) : ES6.Promise;
    static race(reace : System.Collections.Generic.List) : ES6.Promise;
  }
}

/**
 * File: GlobalEditorLock.cs
 */
declare module Slick {
  export class GlobalEditorLock {
    static cancelCurrentEdit() : void;
    static commitCurrentEdit() : void;
  }
}

/**
 * File: Group.cs
 */
declare module Slick {
  export class Group {
    public collapsed : boolean;
    public count : number;
    public level : number;
    public title : string;
    public value : any;
    public groups : any;
    public rows : System.Collections.Generic.List;
    public totals : any;
    public groupingKey : string;
  }
}

/**
 * File: IGroupedDataView.cs
 */
declare module Slick {
  export interface IGroupedDataView {
  }
}

/**
 * File: IPlugin.cs
 */
declare module Slick {
  export interface IPlugin {
  }
}

/**
 * File: ItemMetaData.cs
 */
declare module Slick {
  export class ItemMetaData {
    public selectable : boolean;
    public focusable : boolean;
    public cssClasses : string;
    public formatter : Slick.FormatterDelegate;
    public editor : Slick.EditorFactory;
    public columns : System.Collections.Generic.Dictionary;
  }
}

/**
 * File: OnRowsChangedEventArgs.cs
 */
declare module Slick {
  export class OnRowsChangedEventArgs {
    public rows : System.Collections.Generic.List;
  }
}

/**
 * File: OnSelectedRangesChangedEventArgs.cs
 */
declare module Slick {
  export class SelectedRange {
    public fromCell : number;
    public fromRow : number;
    public toCell : number;
    public toRow : number;
  
    isSingleCell() : boolean;
    isSingleRow() : boolean;
  }
}

/**
 * File: PagingInfo.cs
 */
declare module Slick {
  export class PagingInfo {
    public pageSize : number;
    public pageNum : number;
    public totalRows : number;
    public totalPages : number;
    public extraInfo : string;
    public fromRecord : number;
    public toRecord : number;
  }
}

/**
 * File: RowSelectionModel.cs
 */
declare module Slick {
  export class RowSelectionModel implements Slick.ISelectionModel {
    public onSelectedRangesChanged : Slick.Event;
  
    constructor(options : Slick.RowSelectionModelOptions);
  }

  export class RowSelectionModelOptions {
    public selectActiveRow : boolean;
    public multiRowSelect : boolean;
  }
  export interface ISelectionModel {
  }
}

/**
 * File: ViewPort.cs
 */
declare module Slick {
  export class ViewPort {
    public top : number;
    public bottom : number;
    public leftPx : number;
    public rightPx : number;
  }
}

/**
 * File: Column.cs
 */
declare module Slick {
  export enum ColumnProperties {
    Id,
    Name,
    Field,
    CssClass,
    Width,
    MinWidth,
    MaxWidth,
    Resizable,
    Selectable,
    Focusable,
    Editor,
    GroupTotalsFormatter,
    Sortable,
    Formatter,
    Options
  }

  export class Column {
    public id : string;
    public name : string;
    public field : string;
    public width : number;
    public minWidth : number;
    public maxWidth : number;
    public editor : Slick.EditorFactory;
    public formatter : Slick.FormatterDelegate;
    public validator : Slick.GridValidatorDelegate;
    public colSpan : string;
    public sortable : boolean;
    public options : any;
    public dataType : string;
    public selectable : boolean;
    public cssClass : string;
    public resizable : boolean;
    public groupTotalsFormatter : Slick.SubTotalsFormatterDelegate;
  
    constructor(nameValuePairs : any);
  }

  export class ValidationResult {
    public valid : boolean;
    public message : string;
  }

  export class ValidationEventArgs {
    public editor : any;
    public cellNode : any;
    public validationResults : Slick.ValidationResult;
    public row : number;
    public cell : number;
    public column : Slick.Column;
  }
}

/**
 * File: Event.cs
 */
declare module Slick {
  export class Event {
    notify(args : any, e : Slick.EventData, scope : any) : void;
    subscribe(callback : System.Action) : void;
    unsubscribe(callback : System.Action) : void;
  }
}

/**
 * File: EventData.cs
 */
declare module Slick {
  export class EventData {
    public srcElement : Element;
    public target : Element;
  
    stopPropagation() : void;
    isPropagationStopped() : boolean;
    stopImmediatePropagation() : void;
    preventDefault() : void;
  }
}

/**
 * File: EventHandler.cs
 */
declare module Slick {
  export class EventHandler {
  }
}

/**
 * File: IDataProvider.cs
 */
declare module Slick {
  export interface IDataProvider {
  }
}

/**
 * File: IDataView.cs
 */
declare module Slick {
  export interface IDataView {
  }
}

/**
 * File: NotifyEventArgs.cs
 */
declare module Slick {
  export class DataLoadedNotifyEventArgs {
    public from : number;
    public to : number;
    public errorMessage : string;
  }
}

/**
 * File: Options.cs
 */
declare module Slick {
  export class GridOptions {
    public enableCellNavigation : boolean;
    public enableColumnReorder : boolean;
    public forceFitColumns : boolean;
    public editable : boolean;
    public autoEdit : boolean;
    public rowHeight : number;
    public headerRowHeight : number;
    public enableAddRow : boolean;
    public multiSelect : boolean;
    public explicitInitialization : boolean;
    public defaultColumnWidth : number;
    public leaveSpaceForNewRows : number;
    public asyncEditorLoading : boolean;
    public asyncEditorLoadDelay : number;
    public enableAsyncPostRender : boolean;
    public asyncPostRenderDelay : number;
    public autoHeight : boolean;
  }
}

/**
 * File: AssemblyInfo.cs
 */


/**
 * File: Grid.cs
 */
declare module Slick {
  export class EditorLock {
    isActive() : boolean;
    cancelCurrentEdit() : void;
    commitCurrentEdit() : boolean;
    activate() : void;
    deactivate() : void;
  }

  export class Grid {
    public onViewportChanged : Slick.Event;
    public onValidationError : Slick.Event;
    public onBeforeCellEditorDestroy : Slick.Event;
    public onBeforeEditCell : Slick.Event;
    public onAddNewRow : Slick.Event;
    public onCellChange : Slick.Event;
    public onActiveCellChanged : Slick.Event;
    public onSort : Slick.Event;
    public onKeyDown : Slick.Event;
    public onClick : Slick.Event;
    public onDblClick : Slick.Event;
    public onHeaderClick : Slick.Event;
    public onHeaderCellRendered : Slick.Event;
    public onBeforeHeaderCellDestroy : Slick.Event;
  
    constructor(containerId : string, data : any, columns : System.Collections.Generic.List, options : Slick.GridOptions);
  
    setCellCssStyles(p : string, highlightCells : System.Collections.Generic.Dictionary) : void;
    getEditorLock() : Slick.EditorLock;
    getEditController() : Slick.EditController;
    setSelectedRows(rows : number) : void;
    setActiveCell(row : number, cell : number) : void;
    getSelectedRows() : number;
    getColumns() : Slick.Column[];
    registerPlugin(plugin : Slick.IPlugin) : void;
    setSelectionModel(selectionModel : Slick.ISelectionModel) : void;
    getViewport() : Slick.ViewPort;
    invalidateRow(i : number) : void;
    invalidateRows(rows : System.Collections.Generic.List) : void;
    updateRowCount() : void;
    invalidate() : void;
    render() : void;
    getActiveCell() : Slick.CellSelection;
    resizeCanvas() : void;
    getCellFromEvent(e : Slick.EventData) : any;
    getDataItem(row : number) : any;
    getData() : any;
    setSortColumn(fieldId : string, ascending : boolean) : void;
    getSortColumns() : Slick.SortColData[];
  }
}

/**
 * File: .NETFramework,Version=v4.0.AssemblyAttributes.cs
 */

SparkleXrm.d.ts

/**
 * File: ArrayEx.cs
 */
declare module SparkleXrm {
  export class ArrayEx {
    static add(list : any, item : any) : void;
    static getEnumerator(list : any) : System.Collections.IEnumerator;
    static join(list : System.Array, delimeter : string) : string;
  }
}

/**
 * File: INotifyPropertyChanged.cs
 */
declare module Xrm.ComponentModel {
  export class PropertyChangedEventArgs extends System.EventArgs {
    public propertyName : string;
  
    constructor();
  }
}
declare module SparkleXrm.ComponentModel {
  export interface INotifyPropertyChanged {
  }
}

/**
 * File: DelegateItterator.cs
 */
declare module SparkleXrm {
  export class DelegateItterator {
    static callbackItterate(action : SparkleXrm.ItteratorAction, numberOfTimes : number, completeCallBack : System.Action, errorCallBack : SparkleXrm.ErrorCallBack) : void;
  }
}

/**
 * File: NumberEx.cs
 */
declare module Xrm {
  export class NumberFormatInfo {
    public precision : number;
    public minValue : System.Number;
    public maxValue : System.Number;
    public decimalSymbol : string;
    public numberGroupFormat : string;
    public numberSepartor : string;
    public negativeFormatCode : number;
    public currencySymbol : string;
  }
}
declare module SparkleXrm {
  export class NumberEx {
    static parse(value : string, format : Xrm.NumberFormatInfo) : System.Number;
    static getNumberFormatInfo() : Xrm.NumberFormatInfo;
    static getCurrencyEditFormatInfo() : Xrm.NumberFormatInfo;
    static getCurrencyFormatInfo() : Xrm.NumberFormatInfo;
    static format(actualValue : System.Number, format : Xrm.NumberFormatInfo) : string;
    static round(numericValue : System.Number, precision : number) : System.Number;
    static getCurrencySymbol(currencyId : Xrm.Sdk.Guid) : string;
  }
}

/**
 * File: Attribute.cs
 */
declare module SparkleXrm.Sdk {
  export class Attribute {
    public attributeName : string;
    public typeName : string;
    public formattedValue : string;
    public value : any;
    public id : string;
    public logicalName : string;
    public name : string;
  
    constructor(attributeName : string, typeName : string);
  
    static deSerialise(node : XmlNode, overrideType : string) : any;
    static serialise(attributeName : string, value : any, metaData : System.Collections.Generic.Dictionary) : string;
    static serialiseValue(value : any, overrideTypeName : string) : string;
  }
}

/**
 * File: AttributeTypes.cs
 */
declare module SparkleXrm.Sdk {
  export class AttributeTypes {
    public string_ : string;
    public decimal_ : string;
    public int_ : string;
    public double_ : string;
    public dateTime_ : string;
    public boolean_ : string;
    public entityReference : string;
    public guid_ : string;
    public optionSetValue : string;
    public aliasedValue : string;
    public entityCollection : string;
    public money : string;
  }
}

/**
 * File: OrganizationSettings.cs
 */
declare module SparkleXrm.Sdk {
  export class OrganizationSettings extends SparkleXrm.Sdk.Entity {
    public static entityLogicalName : string;
    public weekStartDayCode : SparkleXrm.Sdk.OptionSetValue;
  
    constructor();
  }
}

/**
 * File: UserSettings.cs
 */
declare module SparkleXrm.Sdk {
  export class UserSettingsAttributes {
    public static userSettingsId : string;
    public static businessUnitId : string;
    public static calendarType : string;
    public static currencyDecimalPrecision : string;
    public static currencyFormatCode : string;
    public static currencySymbol : string;
    public static dateFormatCode : string;
    public static dateFormatString : string;
    public static dateSeparator : string;
    public static decimalSymbol : string;
    public static defaultCalendarView : string;
    public static defaultDashboardId : string;
    public static localeId : string;
    public static longDateFormatCode : string;
    public static negativeCurrencyFormatCode : string;
    public static negativeFormatCode : string;
    public static numberGroupFormat : string;
    public static numberSeparator : string;
    public static offlineSyncInterval : string;
    public static pricingDecimalPrecision : string;
    public static showWeekNumber : string;
    public static systemUserId : string;
    public static timeFormatCodestring : string;
    public static timeFormatString : string;
    public static timeSeparator : string;
    public static timeZoneBias : string;
    public static timeZoneCode : string;
    public static timeZoneDaylightBias : string;
    public static timeZoneDaylightDay : string;
    public static timeZoneDaylightDayOfWeek : string;
    public static timeZoneDaylightHour : string;
    public static timeZoneDaylightMinute : string;
    public static timeZoneDaylightMonth : string;
    public static timeZoneDaylightSecond : string;
    public static timeZoneDaylightYear : string;
    public static timeZoneStandardBias : string;
    public static timeZoneStandardDay : string;
    public static timeZoneStandardDayOfWeek : string;
    public static timeZoneStandardHour : string;
    public static timeZoneStandardMinute : string;
    public static timeZoneStandardMonth : string;
    public static timeZoneStandardSecond : string;
    public static timeZoneStandardYear : string;
    public static transactionCurrencyId : string;
    public static uILanguageId : string;
    public static workdayStartTime : string;
    public static workdayStopTime : string;
  }
}
declare module SparkleXrm.Sdk {
  export class UserSettings extends SparkleXrm.Sdk.Entity {
    public static entityLogicalName : string;
    public userSettingsId : SparkleXrm.Sdk.Guid;
    public businessUnitId : SparkleXrm.Sdk.Guid;
    public calendarType : number;
    public currencyDecimalPrecision : number;
    public currencyFormatCode : number;
    public currencySymbol : string;
    public dateFormatCode : number;
    public dateFormatString : string;
    public dateSeparator : string;
    public decimalSymbol : string;
    public defaultCalendarView : number;
    public defaultDashboardId : SparkleXrm.Sdk.Guid;
    public localeId : number;
    public longDateFormatCode : number;
    public negativeCurrencyFormatCode : number;
    public negativeFormatCode : number;
    public numberGroupFormat : string;
    public numberSeparator : string;
    public offlineSyncInterval : number;
    public pricingDecimalPrecision : number;
    public showWeekNumber : boolean;
    public systemUserId : SparkleXrm.Sdk.Guid;
    public timeFormatCodestring : number;
    public timeFormatString : string;
    public timeSeparator : string;
    public timeZoneBias : number;
    public timeZoneCode : number;
    public timeZoneDaylightBias : number;
    public timeZoneDaylightDay : number;
    public timeZoneDaylightDayOfWeek : number;
    public timeZoneDaylightHour : number;
    public timeZoneDaylightMinute : number;
    public timeZoneDaylightMonth : number;
    public timeZoneDaylightSecond : number;
    public timeZoneDaylightYear : number;
    public timeZoneStandardBias : number;
    public timeZoneStandardDay : number;
    public timeZoneStandardDayOfWeek : number;
    public timeZoneStandardHour : number;
    public timeZoneStandardMinute : number;
    public timeZoneStandardMonth : number;
    public timeZoneStandardSecond : number;
    public timeZoneStandardYear : number;
    public transactionCurrencyId : SparkleXrm.Sdk.EntityReference;
    public uILanguageId : number;
    public workdayStartTime : string;
    public workdayStopTime : string;
  
    constructor();
  
    getNumberFormatString(decimalPlaces : number) : string;
  }
}

/**
 * File: DataCollectionOfEntity.cs
 */
declare module SparkleXrm.Sdk {
  export class DataCollectionOfEntity implements System.Collections.IEnumerable {
    public _internalArray : System.Collections.Generic.List;
  
    constructor(entities : System.Collections.Generic.List);
  
    get_count() : number;
    set_count(value : number) : void;
  
    items() : System.Collections.Generic.List;
  }
}

/**
 * File: DateTime.cs
 */
declare module Xrm.Sdk {
  export class DateTime {
    constructor();
    constructor(milliseconds : number);
    constructor(date : string);
    constructor(year : number, month : number, date : number);
    constructor(year : number, month : number, date : number, hours : number);
    constructor(year : number, month : number, date : number, hours : number, minutes : number);
    constructor(year : number, month : number, date : number, hours : number, minutes : number, seconds : number);
    constructor(year : number, month : number, date : number, hours : number, minutes : number, seconds : number, milliseconds : number);
  
    static get_now() : Xrm.Sdk.DateTime;
    static set_now(value : Xrm.Sdk.DateTime) : void;
    static get_today() : Xrm.Sdk.DateTime;
    static set_today(value : Xrm.Sdk.DateTime) : void;
  
    toJSDate() : Date;
    format(format : string) : string;
    toString() : string;
    getDate() : number;
    getDay() : number;
    getFullYear() : number;
    getHours() : number;
    getMilliseconds() : number;
    getMinutes() : number;
    getMonth() : number;
    getSeconds() : number;
    getTime() : number;
    getTimezoneOffset() : number;
    getUTCDate() : number;
    getUTCDay() : number;
    getUTCFullYear() : number;
    getUTCHours() : number;
    getUTCMilliseconds() : number;
    getUTCMinutes() : number;
    getUTCMonth() : number;
    getUTCSeconds() : number;
    static isEmpty(d : Date) : boolean;
    localeFormat(format : string) : string;
    static parse(value : string) : Xrm.Sdk.DateTime;
    setDate(date : number) : void;
    setFullYear(year : number) : void;
    setFullYear(year : number, month : number) : void;
    setFullYear(year : number, month : number, day : number) : void;
    setHours(hours : number) : void;
    setMilliseconds(milliseconds : number) : void;
    setMinutes(minutes : number) : void;
    setMonth(month : number) : void;
    setSeconds(seconds : number) : void;
    setTime(milliseconds : number) : void;
    setUTCDate(date : number) : void;
    setUTCFullYear(year : number) : void;
    setUTCHours(hours : number) : void;
    setUTCMilliseconds(milliseconds : number) : void;
    setUTCMinutes(minutes : number) : void;
    setUTCMonth(month : number) : void;
    setUTCSeconds(seconds : number) : void;
    setYear(year : number) : void;
    toDateString() : string;
    toISOString() : string;
    toLocaleDateString() : string;
    toLocaleTimeString() : string;
    toTimeString() : string;
    toUTCString() : string;
    static uTC(year : number, month : number, day : number) : number;
    static uTC(year : number, month : number, day : number, hours : number) : number;
    static uTC(year : number, month : number, day : number, hours : number, minutes : number) : number;
    static uTC(year : number, month : number, day : number, hours : number, minutes : number, seconds : number) : number;
    static uTC(year : number, month : number, day : number, hours : number, minutes : number, seconds : number, milliseconds : number) : number;
  }
}

/**
 * File: DateTimeEx.cs
 */
declare module Xrm.Sdk {
  export enum DateInterval {
    Milliseconds = 0,
    Seconds = 1,
    Minutes = 2,
    Hours = 3,
    Days = 4
  }
}
declare module SparkleXrm.Sdk {
  export class DateTimeEx {
    static toXrmString(date : Xrm.Sdk.DateTime) : string;
    static toXrmStringUTC(date : Xrm.Sdk.DateTime) : string;
    static parse(dateString : string) : Xrm.Sdk.DateTime;
    static formatDuration(totalMinutes : number) : string;
    static parseDuration(duration : string) : number;
    static addTimeToDate(date : Xrm.Sdk.DateTime, time : string) : Xrm.Sdk.DateTime;
    static localTimeToUTCFromSettings(LocalTime : Xrm.Sdk.DateTime, settings : SparkleXrm.Sdk.UserSettings) : Xrm.Sdk.DateTime;
    static localTimeToUTC(LocalTime : Xrm.Sdk.DateTime, Bias : number, DaylightBias : number, DaylightYear : number, DaylightMonth : number, DaylightDay : number, DaylightHour : number, DaylightMinute : number, DaylightSecond : number, DaylightMilliseconds : number, DaylightWeekday : number, StandardBias : number, StandardYear : number, StandardMonth : number, StandardDay : number, StandardHour : number, StandardMinute : number, StandardSecond : number, StandardMilliseconds : number, StandardWeekday : number) : Xrm.Sdk.DateTime;
    static uTCToLocalTimeFromSettings(UTCTime : Xrm.Sdk.DateTime, settings : SparkleXrm.Sdk.UserSettings) : Xrm.Sdk.DateTime;
    static uTCToLocalTime(UTCTime : Xrm.Sdk.DateTime, Bias : number, DaylightBias : number, DaylightYear : number, DaylightMonth : number, DaylightDay : number, DaylightHour : number, DaylightMinute : number, DaylightSecond : number, DaylightMilliseconds : number, DaylightWeekday : number, StandardBias : number, StandardYear : number, StandardMonth : number, StandardDay : number, StandardHour : number, StandardMinute : number, StandardSecond : number, StandardMilliseconds : number, StandardWeekday : number) : Xrm.Sdk.DateTime;
    static firstDayOfMonth(date : Xrm.Sdk.DateTime, Month : number) : Xrm.Sdk.DateTime;
    static dateAdd(interval : number, value : number, date : Xrm.Sdk.DateTime) : Xrm.Sdk.DateTime;
    static firstDayOfWeek(date : Xrm.Sdk.DateTime) : Xrm.Sdk.DateTime;
    static lastDayOfWeek(date : Xrm.Sdk.DateTime) : Xrm.Sdk.DateTime;
    static formatTimeSpecific(dateValue : Xrm.Sdk.DateTime, formatString : string) : string;
    static formatDateSpecific(dateValue : Xrm.Sdk.DateTime, formatString : string) : string;
    static parseDateSpecific(dateValue : string, formatString : string) : Xrm.Sdk.DateTime;
    static setTime(date : Xrm.Sdk.DateTime, time : Xrm.Sdk.DateTime) : void;
    static setUTCTime(date : Xrm.Sdk.DateTime, time : Xrm.Sdk.DateTime) : void;
    static getTimeDuration(date : Xrm.Sdk.DateTime) : number;
  }
}

/**
 * File: Entity.cs
 */
declare module SparkleXrm.Sdk {
  export enum EntityStates {
    Unchanged = 0,
    Created = 1,
    Changed = 2,
    Deleted = 3,
    ReadOnly = 4
  }
}
declare module SparkleXrm.Sdk {
  export class Entity implements SparkleXrm.ComponentModel.INotifyPropertyChanged {
    protected _metaData : System.Collections.Generic.Dictionary;
    public logicalName : string;
    public id : string;
    public entityState : SparkleXrm.Sdk.EntityStates;
    public formattedValues : System.Collections.Generic.Dictionary;
    public relatedEntities : System.Collections.Generic.Dictionary;
  
    constructor(entityName : string);
  
    deSerialise(entityNode : XmlNode) : void;
    serialise(ommitRoot : boolean) : string;
    setAttributeValue(name : string, value : any) : void;
    getAttributeValue(attributeName : string) : any;
    getAttributeValueOptionSet(attributeName : string) : SparkleXrm.Sdk.OptionSetValue;
    getAttributeValueGuid(attributeName : string) : Xrm.Sdk.Guid;
    getAttributeValueInt(attributeName : string) : number;
    getAttributeValueFloat(attributeName : string) : System.Single?;
    getAttributeValueString(attributeName : string) : string;
    getAttributeValueEntityReference(attributeName : string) : SparkleXrm.Sdk.EntityReference;
    raisePropertyChanged(propertyName : string) : void;
    toEntityReference() : SparkleXrm.Sdk.EntityReference;
    static sortDelegate(attributeName : string, a : SparkleXrm.Sdk.Entity, b : SparkleXrm.Sdk.Entity) : number;
  }
}

/**
 * File: EntityBuiltInAttributes.cs
 */
declare module Xrm.Sdk {
  export class EntityBuiltInAttributes {
    public createdOn : any;
    public modifiedOn : any;
    public createdBy : any;
    public modifiedBy : any;
    public transactionCurrencyId : any;
  }
}

/**
 * File: EntityCollection.cs
 */
declare module SparkleXrm.Sdk {
  export class EntityCollection {
    constructor(entities : System.Collections.Generic.List);
  
    get_entities() : SparkleXrm.Sdk.DataCollectionOfEntity;
    set_entities(value : SparkleXrm.Sdk.DataCollectionOfEntity) : void;
    get_entityName() : string;
    set_entityName(value : string) : void;
    get_minActiveRowVersion() : string;
    set_minActiveRowVersion(value : string) : void;
    get_moreRecords() : boolean;
    set_moreRecords(value : boolean) : void;
    get_pagingCookie() : string;
    set_pagingCookie(value : string) : void;
    get_totalRecordCount() : number;
    set_totalRecordCount(value : number) : void;
    get_totalRecordCountLimitExceeded() : boolean;
    set_totalRecordCountLimitExceeded(value : boolean) : void;
  
    static serialise(value : SparkleXrm.Sdk.EntityCollection) : string;
    static deSerialise(node : XmlNode) : SparkleXrm.Sdk.EntityCollection;
  }
}

/**
 * File: EntityReference.cs
 */
declare module SparkleXrm.Sdk {
  export class EntityReference {
    public name : string;
    public id : Xrm.Sdk.Guid;
    public logicalName : string;
  
    constructor(Id : Xrm.Sdk.Guid, LogicalName : string, Name : string);
  
    toString() : string;
    toSoap(NameSpace : string) : string;
  }
}

/**
 * File: Guid.cs
 */
declare module SparkleXrm.Sdk {
  export class Guid {
    public static empty : SparkleXrm.Sdk.Guid;
    public value : string;
  
    constructor(Value : string);
  
    toString() : string;
  }
}

/**
 * File: AssignRequest.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class AssignRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    public target : SparkleXrm.Sdk.EntityReference;
    public assignee : SparkleXrm.Sdk.EntityReference;
  
    serialise() : string;
  }
}

/**
 * File: AssignResponse.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class AssignResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    constructor(response : XmlNode);
  }
}

/**
 * File: BulkDeleteRequest.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class BulkDeleteRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    public cCRecipients : System.Guid[];
    public jobName : string;
    public querySet : string;
    public recurrencePattern : string;
    public sendEmailNotification : boolean;
    public sourceImportId : System.Guid;
    public startDateTime : System.DateTime;
    public toRecipients : System.Guid[];
  
    constructor();
  
    serialise() : string;
  }
}

/**
 * File: BulkDeleteResponse.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class BulkDeleteResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    constructor(response : XmlNode);
  }
}

/**
 * File: ExecuteWorkflowRequest.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class ExecuteWorkflowRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    public entityId : string;
    public workflowId : string;
  
    serialise() : string;
  }
}

/**
 * File: ExecuteWorkflowResponse.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class ExecuteWorkflowResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    public id : string;
  
    constructor(response : XmlNode);
  }
}

/**
 * File: FetchXmlToQueryExpressionRequest.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class FetchXmlToQueryExpressionRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    public fetchXml : string;
  
    serialise() : string;
  }
}

/**
 * File: FetchXmlToQueryExpressionResponse.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class FetchXmlToQueryExpressionResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    public query : string;
  
    constructor(response : XmlNode);
  }
}

/**
 * File: OrganizationRequest.cs
 */
declare module Xrm.Sdk.Messages {
  export interface OrganizationRequest {
  }
}

/**
 * File: OrganizationResponse.cs
 */
declare module Xrm.Sdk.Messages {
  export interface OrganizationResponse {
  }
}

/**
 * File: RetrieveAllEntitiesRequest.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class RetrieveAllEntitiesRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    serialise() : string;
  }
}

/**
 * File: RetrieveAllEnttieisResponse.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class RetrieveAllEntitiesResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    public entityMetadata : Xrm.Sdk.Metadata.EntityMetadata[];
  
    constructor(response : XmlNode);
  }
}

/**
 * File: RetrieveAttributeRequest.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class RetrieveAttributeRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    public entityLogicalName : string;
    public logicalName : string;
    public retrieveAsIfPublished : boolean;
  
    serialise() : string;
  }
}

/**
 * File: RetrieveAttributeResponse.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class RetrieveAttributeResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    public attributeMetadata : Xrm.Sdk.Metadata.AttributeMetadata;
  
    constructor(response : XmlNode);
  }
}

/**
 * File: RetrieveEntityRequest.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class RetrieveEntityRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    public entityFilters : SparkleXrm.Sdk.Messages.EntityFilters;
    public logicalName : string;
    public metadataId : System.Guid;
    public retrieveAsIfPublished : boolean;
  
    serialise() : string;
  }
}
declare module SparkleXrm.Sdk.Messages {
  export enum EntityFilters {
    Default_ = 1,
    Entity = 1,
    Attributes = 2,
    Privileges = 4,
    Relationships = 8,
    All = 15
  }
}

/**
 * File: RetrieveEntityResponse.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class RetrieveEntityResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    public entityMetadata : Xrm.Sdk.Metadata.EntityMetadata;
  
    constructor(response : XmlNode);
  }
}

/**
 * File: RetrieveMetadataChangesRequest.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class RetrieveMetadataChangesRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    public clientVersionStamp : string;
    public deletedMetadataFilters : SparkleXrm.Sdk.Metadata.Query.DeletedMetadataFilters;
    public query : Xrm.Sdk.Metadata.Query.EntityQueryExpression;
  
    serialise() : string;
  }
}

/**
 * File: RetrieveMetadataChangesResponse.cs
 */
declare module SparkleXrm.Sdk.Messages {
  export class RetrieveMetadataChangesResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    public entityMetadata : System.Collections.Generic.List;
    public serverVersionStamp : string;
  
    constructor(response : XmlNode);
  }
}

/**
 * File: AttributeMetadata.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static deSerialiseAttributeMetadata(item : Xrm.Sdk.Metadata.AttributeMetadata, attribute : XmlNode) : Xrm.Sdk.Metadata.AttributeMetadata;
  }
}
declare module Xrm.Sdk.Metadata {
  export class AttributeMetadata {
    public attributeOf : string;
    public attributeType : SparkleXrm.Sdk.Metadata.AttributeTypeCode;
    public canBeSecuredForCreate : boolean;
    public canBeSecuredForRead : boolean;
    public canBeSecuredForUpdate : boolean;
    public canModifyAdditionalSettings : boolean;
    public columnNumber : number;
    public deprecatedVersion : string;
    public description : Xrm.Sdk.Metadata.Label;
    public displayName : Xrm.Sdk.Metadata.Label;
    public entityLogicalName : string;
    public isAuditEnabled : boolean;
    public isCustomAttribute : boolean;
    public isCustomizable : boolean;
    public isManaged : boolean;
    public isPrimaryId : boolean;
    public isPrimaryName : boolean;
    public isRenameable : boolean;
    public isSecured : boolean;
    public isValidForAdvancedFind : boolean;
    public isValidForCreate : boolean;
    public isValidForRead : boolean;
    public isValidForUpdate : boolean;
    public linkedAttributeId : SparkleXrm.Sdk.Guid;
    public logicalName : string;
    public requiredLevel : SparkleXrm.Sdk.Metadata.AttributeRequiredLevel;
    public schemaName : string;
  }
}

/**
 * File: AttributeRequireLevel.cs
 */
declare module SparkleXrm.Sdk.Metadata {
  export enum AttributeRequiredLevel {
    None = 0,
    SystemRequired = 1,
    ApplicationRequired = 2,
    Recommended = 3
  }
}

/**
 * File: AttributeTypeCode.cs
 */
declare module SparkleXrm.Sdk.Metadata {
  export enum AttributeTypeCode {
    Boolean_ = 0,
    Customer = 1,
    DateTime = 2,
    Decimal = 3,
    Double_ = 4,
    Integer = 5,
    Lookup = 6,
    Memo = 7,
    Money = 8,
    Owner = 9,
    PartyList = 10,
    Picklist = 11,
    State = 12,
    Status = 13,
    String = 14,
    Uniqueidentifier = 15,
    CalendarRules = 16,
    Virtual = 17,
    BigInt = 18,
    ManagedProperty = 19,
    EntityName = 20
  }
}

/**
 * File: BigIntAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class BigIntAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public maxValue : number;
    public minValue : number;
  }
}

/**
 * File: BooleanAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class BooleanAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public defaultValue : boolean;
    public optionSet : boolean;
  }
}

/**
 * File: BooleanOptionSetMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class BooleanOptionSetMetadata extends Xrm.Sdk.Metadata.OptionSetMetadataBase {
    public falseOption : Xrm.Sdk.Metadata.OptionMetadata;
    public trueOption : Xrm.Sdk.Metadata.OptionMetadata;
  }
}

/**
 * File: DateTimeAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class DateTimeAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public format : SparkleXrm.Sdk.Metadata.DateTimeFormat;
    public static maxSupportedValue : Xrm.Sdk.DateTime;
    public static minSupportedValue : Xrm.Sdk.DateTime;
  }
}

/**
 * File: DateTimeFormat.cs
 */
declare module SparkleXrm.Sdk.Metadata {
  export enum DateTimeFormat {
    DateOnly = 0,
    DateAndTime = 1
  }
}

/**
 * File: DecimalAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class DecimalAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public maxValue : System.Decimal?;
    public minValue : System.Decimal?;
    public precision : number;
  }
}

/**
 * File: DoubleAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class DoubleAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public maxValue : number;
    public minValue : number;
    public precision : number;
  }
}

/**
 * File: EntityMetadata.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static deSerialiseEntityMetadata(item : Xrm.Sdk.Metadata.EntityMetadata, entity : XmlNode) : Xrm.Sdk.Metadata.EntityMetadata;
  }
}
declare module Xrm.Sdk.Metadata {
  export class EntityMetadata {
    public activityTypeMask : number;
    public attributes : System.Collections.Generic.List;
    public autoRouteToOwnerQueue : boolean;
    public canBeInManyToMany : boolean;
    public canBePrimaryEntityInRelationship : boolean;
    public canBeRelatedEntityInRelationship : boolean;
    public canCreateAttributes : boolean;
    public canCreateCharts : boolean;
    public canCreateForms : boolean;
    public canCreateViews : boolean;
    public canModifyAdditionalSettings : boolean;
    public canTriggerWorkflow : boolean;
    public description : Xrm.Sdk.Metadata.Label;
    public displayCollectionName : Xrm.Sdk.Metadata.Label;
    public displayName : Xrm.Sdk.Metadata.Label;
    public iconLargeName : string;
    public iconMediumName : string;
    public iconSmallName : string;
    public isActivity : boolean;
    public isActivityParty : boolean;
    public isAuditEnabled : boolean;
    public isAvailableOffline : boolean;
    public isChildEntity : boolean;
    public isConnectionsEnabled : boolean;
    public isCustomEntity : boolean;
    public isCustomizable : boolean;
    public isDocumentManagementEnabled : boolean;
    public isDuplicateDetectionEnabled : boolean;
    public isEnabledForCharts : boolean;
    public isImportable : boolean;
    public isIntersect : boolean;
    public isMailMergeEnabled : boolean;
    public isManaged : boolean;
    public isMappable : boolean;
    public isReadingPaneEnabled : boolean;
    public isRenameable : boolean;
    public isValidForAdvancedFind : boolean;
    public isValidForQueue : boolean;
    public isVisibleInMobile : boolean;
    public logicalName : string;
    public objectTypeCode : number;
    public primaryIdAttribute : string;
    public primaryNameAttribute : string;
    public recurrenceBaseEntityLogicalName : string;
    public reportViewName : string;
    public schemaName : string;
    public primaryImageAttribute : string;
  
    constructor();
  }
}

/**
 * File: EntityNameAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class EntityNameAttributeMetadata extends Xrm.Sdk.Metadata.EnumAttributeMetadata {
  }
}

/**
 * File: EnumAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class EnumAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public defaultFormValue : number;
    public optionSet : Xrm.Sdk.Metadata.OptionSetMetadata;
  }
}

/**
 * File: IntegerAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class IntegerAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public format : number;
    public maxValue : number;
    public minValue : number;
  }
}

/**
 * File: IntegerFormat.cs
 */
declare module SparkleXrm.Sdk.Metadata {
  export enum IntegerFormat {
    None = 0,
    Duration = 1,
    TimeZone = 2,
    Language = 3,
    Locale = 4
  }
}

/**
 * File: Label.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static deSerialiseLabel(item : Xrm.Sdk.Metadata.Label, metaData : XmlNode) : Xrm.Sdk.Metadata.Label;
  }
}
declare module Xrm.Sdk.Metadata {
  export class Label {
    public localizedLabels : System.Collections.Generic.List;
    public userLocalizedLabel : Xrm.Sdk.Metadata.LocalizedLabel;
  }
}

/**
 * File: LocalizedLabel.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static deSerialiseLocalizedLabel(item : Xrm.Sdk.Metadata.LocalizedLabel, metaData : XmlNode) : Xrm.Sdk.Metadata.LocalizedLabel;
  }
}
declare module Xrm.Sdk.Metadata {
  export class LocalizedLabel {
    public label : string;
    public languageCode : number;
  }
}

/**
 * File: LookupAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class LookupAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public targets : string;
  }
}

/**
 * File: ManagedPropertyAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class ManagedPropertyAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public managedPropertyLogicalName : string;
    public parentAttributeName : string;
    public parentComponentType : number;
    public valueAttributeTypeCode : SparkleXrm.Sdk.Metadata.AttributeTypeCode;
  }
}

/**
 * File: ManyToManyRelationshipMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class ManyToManyRelationshipMetadata extends Xrm.Sdk.Metadata.RelationshipMetadataBase {
    public entity1IntersectAttribute : string;
    public entity1LogicalName : string;
    public entity2IntersectAttribute : string;
    public entity2LogicalName : string;
    public intersectEntityName : string;
  
    constructor();
  }
}

/**
 * File: MemoAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class MemoAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public format : string;
    public maxLength : number;
  }
}

/**
 * File: MetadataBase.cs
 */
declare module Xrm.Sdk.Metadata {
  export class MetadataBase {
    public hasChanged : boolean;
    public metadataId : SparkleXrm.Sdk.Guid;
  }
}

/**
 * File: MetadataCache.cs
 */
declare module Xrm.Sdk.Metadata {
  export class OptionSetItem {
    public name : string;
    public value : number;
  }
}
declare module SparkleXrm.Sdk.Metadata {
  export class MetadataCache {
    static get_entityMetaData() : System.Collections.Generic.Dictionary;
    static set_entityMetaData(value : System.Collections.Generic.Dictionary) : void;
    static get_attributeMetaData() : System.Collections.Generic.Dictionary;
    static set_attributeMetaData(value : System.Collections.Generic.Dictionary) : void;
    static get_optionsetMetaData() : System.Collections.Generic.Dictionary;
    static set_optionsetMetaData(value : System.Collections.Generic.Dictionary) : void;
  
    static getOptionSetValues(entityLogicalName : string, attributeLogicalName : string, allowEmpty : boolean) : System.Collections.Generic.List;
    static getEntityTypeCodeFromName(typeName : string) : number;
    static getSmallIconUrl(typeName : string) : string;
    static addOptionsetMetadata(entityLogicalName : string, attributeLogicalName : string, allowEmpty : boolean, metatdata : System.Collections.Generic.List) : void;
  }
}

/**
 * File: MoneyAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class MoneyAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public calculationOf : string;
    public maxValue : number;
    public minValue : number;
    public precision : number;
    public precisionSource : number;
  }
}

/**
 * File: OneToManyRelationshipMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class OneToManyRelationshipMetadata extends Xrm.Sdk.Metadata.RelationshipMetadataBase {
    public referencedAttribute : string;
    public referencedEntity : string;
    public referencingAttribute : string;
    public referencingEntity : string;
  }
}

/**
 * File: OptionSetMetadataBase.cs
 */
declare module Xrm.Sdk.Metadata {
  export class OptionSetMetadataBase extends Xrm.Sdk.Metadata.MetadataBase {
    public description : Xrm.Sdk.Metadata.Label;
    public displayName : Xrm.Sdk.Metadata.Label;
    public isCustomizable : boolean;
    public isCustomOptionSet : boolean;
    public isGlobal : boolean;
    public isManaged : boolean;
    public name : string;
    public optionSetType : SparkleXrm.Sdk.Metadata.OptionSetType;
  }
}

/**
 * File: OptionSetType.cs
 */
declare module SparkleXrm.Sdk.Metadata {
  export enum OptionSetType {
    Picklist = 0,
    State = 1,
    Status = 2,
    Boolean_ = 3
  }
}

/**
 * File: AttributeQueryExpression.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static serialiseAttributeQueryExpression(item : Xrm.Sdk.Metadata.Query.AttributeQueryExpression) : string;
  }
}
declare module Xrm.Sdk.Metadata.Query {
  export class AttributeQueryExpression extends Xrm.Sdk.Metadata.Query.MetadataQueryExpression {
  }
}

/**
 * File: DeletedMetadataFilters.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export enum DeletedMetadataFilters {
    Default_ = 1,
    Entity = 1,
    Attribute = 2,
    Relationship = 4,
    Label = 8,
    OptionSet = 16,
    All = 31
  }
}

/**
 * File: EntityQueryExpression.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static serialiseEntityQueryExpression(item : Xrm.Sdk.Metadata.Query.EntityQueryExpression) : string;
  }
}
declare module Xrm.Sdk.Metadata.Query {
  export class EntityQueryExpression extends Xrm.Sdk.Metadata.Query.MetadataQueryExpression {
    public attributeQuery : Xrm.Sdk.Metadata.Query.AttributeQueryExpression;
    public labelQuery : Xrm.Sdk.Metadata.Query.LabelQueryExpression;
    public relationshipQuery : Xrm.Sdk.Metadata.Query.RelationshipQueryExpression;
  }
}

/**
 * File: LabelQueryExpression.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static serialiseLabelQueryExpression(item : Xrm.Sdk.Metadata.Query.LabelQueryExpression) : string;
  }
}
declare module Xrm.Sdk.Metadata.Query {
  export class LabelQueryExpression {
    public filterLanguages : System.Collections.Generic.List;
  }
}

/**
 * File: MetadataConditionExpression.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static serialiseMetadataConditionExpression(item : Xrm.Sdk.Metadata.Query.MetadataConditionExpression) : string;
  }
}
declare module Xrm.Sdk.Metadata.Query {
  export class MetadataConditionExpression {
    public conditionOperator : SparkleXrm.Sdk.Metadata.Query.MetadataConditionOperator;
    public propertyName : string;
    public value : any;
  }
}
declare module SparkleXrm.Sdk.Metadata.Query {
  export enum MetadataConditionOperator {
    Equals = 0,
    NotEquals = 1,
    In_ = 2,
    NotIn = 3,
    GreaterThan = 4,
    LessThan = 5
  }
}

/**
 * File: MetadataFilterExpression.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static serialiseMetadataFilterExpression(item : Xrm.Sdk.Metadata.Query.MetadataFilterExpression) : string;
  }
}
declare module Xrm.Sdk.Metadata.Query {
  export class MetadataFilterExpression {
    public conditions : System.Collections.Generic.List;
    public filterOperator : SparkleXrm.Sdk.Metadata.Query.LogicalOperator;
    public filters : System.Collections.Generic.List;
  }
}
declare module SparkleXrm.Sdk.Metadata.Query {
  export enum LogicalOperator {
    And = 0,
    Or = 1
  }
}

/**
 * File: MetadataPropertiesExpression.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static serialiseMetadataPropertiesExpression(item : Xrm.Sdk.Metadata.Query.MetadataPropertiesExpression) : string;
  }
}
declare module Xrm.Sdk.Metadata.Query {
  export class MetadataPropertiesExpression {
    public allProperties : boolean;
    public propertyNames : System.Collections.Generic.List;
  }
}

/**
 * File: MetadataQueryBuilder.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataQueryBuilder {
    public request : SparkleXrm.Sdk.Messages.RetrieveMetadataChangesRequest;
  
    constructor();
  
    addEntities(entityLogicalNames : System.Collections.Generic.List, propertiesToReturn : System.Collections.Generic.List) : void;
    addAttributes(attributeLogicalNames : System.Collections.Generic.List, propertiesToReturn : System.Collections.Generic.List) : void;
    setLanguage(lcid : number) : void;
  }
}

/**
 * File: MetadataQueryExpression.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static serialiseMetadataQueryExpression(item : Xrm.Sdk.Metadata.Query.MetadataQueryExpression) : string;
  }
}
declare module Xrm.Sdk.Metadata.Query {
  export class MetadataQueryExpression {
    public criteria : Xrm.Sdk.Metadata.Query.MetadataFilterExpression;
    public properties : Xrm.Sdk.Metadata.Query.MetadataPropertiesExpression;
  }
}

/**
 * File: RelationshipQueryExpression.cs
 */
declare module Xrm.Sdk.Metadata.Query {
  export class RelationshipQueryExpression extends Xrm.Sdk.Metadata.Query.MetadataQueryExpression {
  }
}

/**
 * File: RelationshipMetadataBase.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static deSerialiseRelationshipMetadata(attribute : XmlNode) : Xrm.Sdk.Metadata.RelationshipMetadataBase;
  }
}
declare module Xrm.Sdk.Metadata {
  export class RelationshipMetadataBase {
    public isCustomRelationship : boolean;
    public isManaged : boolean;
    public isValidForAdvancedFind : boolean;
    public relationshipType : SparkleXrm.Sdk.Metadata.RelationshipType;
    public schemaName : string;
  }
}
declare module SparkleXrm.Sdk.Metadata {
  export enum RelationshipType {
    OneToManyRelationship = 0,
    Default_ = 0,
    ManyToManyRelationship = 1
  }
}

/**
 * File: StateAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class StateAttributeMetadata extends Xrm.Sdk.Metadata.EnumAttributeMetadata {
  }
}

/**
 * File: StatusAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class StatusAttributeMetadata extends Xrm.Sdk.Metadata.EnumAttributeMetadata {
  }
}

/**
 * File: StringAttributeMetadata.cs
 */
declare module Xrm.Sdk.Metadata {
  export class StringAttributeMetadata extends Xrm.Sdk.Metadata.AttributeMetadata {
    public format : string;
    public maxLength : number;
    public yomiOf : string;
  }
}

/**
 * File: StringFormat.cs
 */
declare module SparkleXrm.Sdk.Metadata {
  export enum StringFormat {
    Email = 0,
    Text = 1,
    TextArea = 2,
    Url = 3,
    TickerSymbol = 4,
    PhoneticGuide = 5,
    VersionNumber = 6,
    Phone = 7
  }
}

/**
 * File: Money.cs
 */
declare module SparkleXrm.Sdk {
  export class Money {
    public value : System.Decimal;
  
    constructor(value : System.Decimal);
  }
}

/**
 * File: OptionMetadata.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static deSerialiseOptionMetadata(item : Xrm.Sdk.Metadata.OptionMetadata, metaData : XmlNode) : Xrm.Sdk.Metadata.OptionMetadata;
  }
}
declare module Xrm.Sdk.Metadata {
  export class OptionMetadata {
    public value : number;
    public label : Xrm.Sdk.Metadata.Label;
  }
}

/**
 * File: OptionSetMetadata.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static deSerialiseOptionSetMetadata(item : Xrm.Sdk.Metadata.OptionSetMetadata, metaData : XmlNode) : Xrm.Sdk.Metadata.OptionSetMetadata;
  }
}
declare module Xrm.Sdk.Metadata {
  export class OptionSetMetadata {
    public options : System.Collections.Generic.List;
  }
}

/**
 * File: OptionSetValue.cs
 */
declare module SparkleXrm.Sdk {
  export class OptionSetValue {
    public name : string;
    public value : number;
  
    constructor(value : number);
  
    static parse(value : string) : SparkleXrm.Sdk.OptionSetValue;
  }
}

/**
 * File: OrganizationServiceProxy.cs
 */
declare module SparkleXrm.Sdk {
  export class OrganizationServiceProxy {
    public static withCredentials : boolean;
    public static userSettings : SparkleXrm.Sdk.UserSettings;
    public static executeMessageResponseTypes : System.Collections.Generic.Dictionary;
    public static organizationSettings : SparkleXrm.Sdk.OrganizationSettings;
  
    static registerExecuteMessageResponseType(responseTypeName : string, organizationResponseType : System.Type) : void;
    static getUserSettings() : SparkleXrm.Sdk.UserSettings;
    static doesNNAssociationExist(relationship : SparkleXrm.Sdk.Relationship, Entity1 : SparkleXrm.Sdk.EntityReference, Entity2 : SparkleXrm.Sdk.EntityReference) : boolean;
    static associate(entityName : string, entityId : Xrm.Sdk.Guid, relationship : SparkleXrm.Sdk.Relationship, relatedEntities : System.Collections.Generic.List) : void;
    static beginAssociate(entityName : string, entityId : Xrm.Sdk.Guid, relationship : SparkleXrm.Sdk.Relationship, relatedEntities : System.Collections.Generic.List, callBack : System.Action) : void;
    static endAssociate(asyncState : any) : void;
    static disassociate(entityName : string, entityId : Xrm.Sdk.Guid, relationship : SparkleXrm.Sdk.Relationship, relatedEntities : System.Collections.Generic.List) : void;
    static beginDisassociate(entityName : string, entityId : Xrm.Sdk.Guid, relationship : SparkleXrm.Sdk.Relationship, relatedEntities : System.Collections.Generic.List, callBack : System.Action) : void;
    static endDisassociate(asyncState : any) : void;
    static retrieveMultiple(fetchXml : string) : SparkleXrm.Sdk.EntityCollection;
    static beginRetrieveMultiple(fetchXml : string, callBack : System.Action) : void;
    static endRetrieveMultiple(asyncState : any, entityType : System.Type) : SparkleXrm.Sdk.EntityCollection;
    static retrieve(entityName : string, entityId : string, attributesList : string) : SparkleXrm.Sdk.Entity;
    static beginRetrieve(entityName : string, entityId : string, attributesList : string, callBack : System.Action) : void;
    static endRetrieve(asyncState : any, entityType : System.Type) : SparkleXrm.Sdk.Entity;
    static create(entity : SparkleXrm.Sdk.Entity) : Xrm.Sdk.Guid;
    static beginCreate(entity : SparkleXrm.Sdk.Entity, callBack : System.Action) : void;
    static endCreate(asyncState : any) : Xrm.Sdk.Guid;
    static setState(id : Xrm.Sdk.Guid, entityName : string, stateCode : number, statusCode : number) : void;
    static beginSetState(id : Xrm.Sdk.Guid, entityName : string, stateCode : number, statusCode : number, callBack : System.Action) : void;
    static endSetState(asyncState : any) : void;
    static delete_(entityName : string, id : Xrm.Sdk.Guid) : string;
    static beginDelete(entityName : string, id : Xrm.Sdk.Guid, callBack : System.Action) : void;
    static endDelete(asyncState : any) : void;
    static update(entity : SparkleXrm.Sdk.Entity) : void;
    static beginUpdate(entity : SparkleXrm.Sdk.Entity, callBack : System.Action) : void;
    static endUpdate(asyncState : any) : void;
    static execute(request : Xrm.Sdk.Messages.OrganizationRequest) : Xrm.Sdk.Messages.OrganizationResponse;
    static beginExecute(request : Xrm.Sdk.Messages.OrganizationRequest, callBack : System.Action) : void;
    static endExecute(asyncState : any) : Xrm.Sdk.Messages.OrganizationResponse;
  }
}

/**
 * File: PicklistAttributeMetadata.cs
 */
declare module SparkleXrm.Sdk.Metadata.Query {
  export class MetadataSerialiser {
    static deSerialisePicklistAttributeMetadata(item : Xrm.Sdk.Metadata.PicklistAttributeMetadata, metaData : XmlNode) : Xrm.Sdk.Metadata.PicklistAttributeMetadata;
  }
}
declare module Xrm.Sdk.Metadata {
  export class PicklistAttributeMetadata extends Xrm.Sdk.Metadata.EnumAttributeMetadata {
  }
}

/**
 * File: RelatedEntityCollection.cs
 */


/**
 * File: Relationship.cs
 */
declare module SparkleXrm.Sdk {
  export class Relationship {
    public primaryEntityRole : SparkleXrm.Sdk.EntityRole;
    public schemaName : string;
  
    constructor(schemaName : string);
  }
}
declare module SparkleXrm.Sdk {
  export enum EntityRole {
    Referencing = 0,
    Referenced = 1
  }
}

/**
 * File: RetrieveRelationshipRequest.cs
 */
declare module SparkleXrm.Sdk {
  export class RetrieveRelationshipRequest implements Xrm.Sdk.Messages.OrganizationRequest {
    public metadataId : Xrm.Sdk.Guid;
    public name : string;
    public retrieveAsIfPublished : boolean;
  
    serialise() : string;
  }
}

/**
 * File: RetrieveRelationshipResponse.cs
 */
declare module SparkleXrm.Sdk {
  export class RetrieveRelationshipResponse implements Xrm.Sdk.Messages.OrganizationResponse {
    public relationshipMetadata : Xrm.Sdk.Metadata.RelationshipMetadataBase;
  
    constructor(response : XmlNode);
  }
}

/**
 * File: RibbonButton.cs
 */
declare module SparkleXrm.Sdk.Ribbon {
  export class RibbonButton extends SparkleXrm.Sdk.Ribbon.RibbonControl {
    constructor(Id : string, Sequence : number, LabelText : string, Command : string, Image16 : string, Image32 : string);
  
    serialiseToRibbonXml(sb : string) : void;
  }
}

/**
 * File: RibbonControl.cs
 */
declare module SparkleXrm.Sdk.Ribbon {
  export class RibbonControl {
    public id : string;
    public labelText : string;
    public sequence : number;
    public command : string;
    public image16by16 : string;
    public image32by32 : string;
  
    constructor(Id : string, Sequence : number, LabelText : string, Command : string, Image16 : string, Image32 : string);
  
    serialiseToRibbonXml(sb : string) : void;
  }
}

/**
 * File: RibbonFlyoutAnchor.cs
 */
declare module SparkleXrm.Sdk.Ribbon {
  export class RibbonFlyoutAnchor extends SparkleXrm.Sdk.Ribbon.RibbonControl {
    public menu : SparkleXrm.Sdk.Ribbon.RibbonMenu;
  
    constructor(Id : string, Sequence : number, LabelText : string, Command : string, Image16 : string, Image32 : string);
  
    serialiseToRibbonXml(sb : string) : void;
  }
}

/**
 * File: RibbonMenu.cs
 */
declare module SparkleXrm.Sdk.Ribbon {
  export class RibbonMenu {
    public id : string;
    public sections : System.Collections.Generic.List;
  
    constructor(Id : string);
  
    serialiseToRibbonXml() : string;
    addSection(section : SparkleXrm.Sdk.Ribbon.RibbonMenuSection) : SparkleXrm.Sdk.Ribbon.RibbonMenu;
  }
}

/**
 * File: RibbonMenuSection.cs
 */
declare module Xrm.Sdk.Ribbon {
  export enum RibbonDisplayMode {
    Menu16 = 0,
    Menu32 = 1
  }
}
declare module SparkleXrm.Sdk.Ribbon {
  export class RibbonMenuSection {
    public id : string;
    public title : string;
    public sequence : number;
    public displayMode : Xrm.Sdk.Ribbon.RibbonDisplayMode;
    public buttons : System.Collections.Generic.List;
  
    constructor(Id : string, LabelText : string, Sequence : number, DisplayMode : Xrm.Sdk.Ribbon.RibbonDisplayMode);
  
    serialiseToRibbonXml(sb : string) : void;
    addButton(button : SparkleXrm.Sdk.Ribbon.RibbonControl) : SparkleXrm.Sdk.Ribbon.RibbonMenuSection;
  }
}

/**
 * File: XmlHelper.cs
 */
declare module Xrm.Sdk {
  export class XPathEvaluator {
    evaluate(xpathExpression : string, node : XmlNode, nsResolver : System.Func, resultType : number, result : Xrm.Sdk.XPathResult) : Xrm.Sdk.XPathResult;
  }

  export class XPathResult {
    public singleNodeValue : XmlNode;
  }

  export class DOMParser {
    parseFromString(xml : string, type : string) : XmlDocument;
  }
}
declare module SparkleXrm.Sdk {
  export class XmlHelper {
    public static _encode_map : Dictionary;
    public static _decode_map : Dictionary;
  
    static encode(value : string) : string;
    static serialiseNode(node : XmlNode) : string;
    static decode(value : string) : string;
    static replaceCallBackEncode(item : string) : string;
    static replaceCallBackDecode(item : string) : string;
    static selectSingleNodeValue(doc : XmlNode, baseName : string) : string;
    static selectSingleNode(doc : XmlNode, baseName : string) : XmlNode;
    static getLocalName(node : XmlNode) : string;
    static selectSingleNodeValueDeep(doc : XmlNode, baseName : string) : string;
    static selectSingleNodeDeep(doc : XmlNode, baseName : string) : XmlNode;
    static nSResolver(prefix : string) : string;
    static isSelectSingleNodeUndefined(value : any) : boolean;
    static loadXml(xml : string) : XmlDocument;
    static selectSingleNodeXpath(node : XmlNode, xpath : string) : XmlNode;
    static getNodeTextValue(node : XmlNode) : string;
    static getAttributeValue(node : XmlNode, attributeName : string) : string;
  }
}

/**
 * File: CachedOrganizationService.cs
 */
declare module SparkleXrm.Services {
  export class CachedOrganizationService {
    public static cache : SparkleXrm.Services.OrganizationServiceCache;
  
    static retrieve(entityName : string, entityId : string, attributesList : string) : SparkleXrm.Sdk.Entity;
    static retrieveMultiple(fetchXml : string) : SparkleXrm.Sdk.EntityCollection;
  }
}

/**
 * File: OrganizationServiceCache.cs
 */
declare module SparkleXrm.Services {
  export class OrganizationServiceCache {
    remove(entityName : string, id : Xrm.Sdk.Guid) : void;
    insert(key : string, query : string, results : any) : void;
    get(key : string, query : string) : any;
  }
}

/**
 * File: Page.cs
 */
declare module SparkleXrm.Xrm {
  export class PageEx {
    public static majorVersion : number;
  
    static getCacheKey() : string;
    static getWebResourceData() : System.Collections.Generic.Dictionary;
  }
}

/**
 * File: StringEx.cs
 */
declare module SparkleXrm {
  export class StringEx {
    static iN(value : string, values : string) : boolean;
  }
}

/**
 * File: TaskIterrator.cs
 */
declare module SparkleXrm {
  export class TaskIterrator {
    constructor();
  
    addTask(task : SparkleXrm.TaskIteratorTask) : void;
    start(successCallBack : System.Action, errorCallBack : System.Action) : void;
  }
}

/**
 * File: QUnitImports.cs
 */
declare module QUnitApi {
  export class QUnit {
    static test(name : string, callback : System.Action) : void;
    static begin(callback : System.Action) : void;
    static done(callback : System.Action) : void;
    static log(callback : System.Action) : void;
    static module(name : string, hooks : QUnitApi.ModuleInfo) : void;
  }

  export class Assert {
    async() : System.Action;
    expect(amount : System.Number) : void;
    deepEqual(actual : any, expected : any, message : string) : void;
    equal(actual : any, expected : any, message : string) : void;
    notDeepEqual(actual : any, expected : any, message : string) : void;
    notEqual(actual : any, expected : any, message : string) : void;
    notOk(state : any, message : string) : void;
    notPropEqual(actual : any, expected : any, message : string) : void;
    notStrictEqual(actual : any, expected : any, message : string) : void;
    ok(state : any, message : string) : void;
    propEqual(actual : any, expected : any, message : string) : void;
    push(result : boolean, action : any, expected : any, message : string) : void;
    strictEqual(actual : any, expected : any, message : string) : void;
    throws(block : System.Action, expected : System.Func, message : string) : void;
  }

  export class BeginInfo {
    public totalTests : System.Number;
  }

  export class ModuleInfo {
    public beforeEach : System.Action;
    public afterEach : System.Action;
  }

  export class DoneInfo {
    public failed : System.Number;
    public passed : System.Number;
    public total : System.Number;
    public runtime : System.Number;
  }

  export class LogInfo {
    public result : boolean;
    public actual : any;
    public expected : any;
    public message : string;
    public source : string;
    public module : string;
    public name : string;
    public runtime : System.Number;
  }
}

/**
 * File: Client.cs
 */
declare module Xrm {
  export class Client {
    getClient() : Xrm.ClientType;
    getClientState() : Xrm.ClientStateType;
  }
}

/**
 * File: ClientStateType.cs
 */
declare module Xrm {
  export enum ClientStateType {
    Online,
    Offline
  }
}

/**
 * File: ClientType.cs
 */
declare module Xrm {
  export enum ClientType {
    Web,
    Outlook,
    Mobile
  }
}

/**
 * File: AutocompleteResultsSet.cs
 */
declare module Xrm.XrmImport.Page.Ui {
  export class AutocompleteResultSet {
    public results : System.Collections.Generic.List;
    public commands : Xrm.XrmImport.Page.Ui.AutocompleteAction;
  }

  export class AutocompleteResult {
    public id : string;
    public icon : string;
    public fields : string;
  }

  export class AutocompleteAction {
    public id : string;
    public icon : string;
    public label : string;
    public action : System.Action;
  }
}

/**
 * File: Category.cs
 */
declare module Xrm {
  export class Category {
    getValue() : number;
  }
}

/**
 * File: ClientCollection.cs
 */
declare module Xrm {
  export class ClientCollectionStage {
    forEach(function : Xrm.GetItemHandlerStage) : void;
    get() : Xrm.Stage[];
    get(name : string) : Xrm.Stage;
    get(position : number) : Xrm.Stage;
    get(function : Xrm.GetItemHandlerStage) : Xrm.Stage[];
    getLength() : number;
  }

  export class ClientCollectionStep {
    forEach(function : Xrm.GetItemHandlerStep) : void;
    get() : Xrm.Step[];
    get(name : string) : Xrm.Step;
    get(position : number) : Xrm.Step;
    get(function : Xrm.GetItemHandlerStep) : Xrm.Step[];
    getLength() : number;
  }
}

/**
 * File: DataProcess.cs
 */
declare module Xrm {
  export enum MoveStepResult {
    Success,
    CrossEntity,
    End,
    Beginning,
    Invalid
  }

  export enum SetActiveProcessResult {
    Success,
    Invalid
  }

  export enum SetActiveStageResult {
    CrossEntity,
    Invalid,
    Unreachable
  }

  export class DataProcess {
    getActiveProcess() : Xrm.Process;
    setActiveProcess(processId : string, callbackFunction : System.Action) : void;
    getActiveStage() : Xrm.Stage;
    setActiveStage(stageId : string, callbackFunction : System.Action) : void;
    getActivePath() : System.Collections.Generic.List;
    getEnabledProcesses(callbackFunction : System.Action) : void;
    addOnStageChange(handler : Xrm.AddRemoveOnChangeHandler) : void;
    removeOnStageChange(handler : Xrm.AddRemoveOnChangeHandler) : void;
    addOnStageSelected(handler : Xrm.AddRemoveOnChangeHandler) : void;
    removeOnStageSelected(handler : Xrm.AddRemoveOnChangeHandler) : void;
    moveNext(callbackFunction : System.Action) : void;
    movePrevious(callbackFunction : System.Action) : void;
  }
}

/**
 * File: Process.cs
 */
declare module Xrm {
  export class Process {
    getId() : string;
    getName() : string;
    getStages() : Xrm.ClientCollectionStage;
    isRendered() : boolean;
  }
}

/**
 * File: Stage.cs
 */
declare module Xrm {
  export enum ProcesStage {
    Active,
    Inactive
  }

  export class Stage {
    getCategory() : Xrm.Category;
    getEntityName() : string;
    getId() : string;
    getName() : string;
    getStatus() : Xrm.ProcesStage;
    getSteps() : Xrm.ClientCollectionStep;
  }
}

/**
 * File: Step.cs
 */
declare module Xrm {
  export class Step {
    getAttribute() : string;
    getName() : string;
    isRequired() : boolean;
  }
}

/**
 * File: UiProcess.cs
 */
declare module Xrm {
  export enum ProcessExpanded {
    Expanded,
    Collapsed
  }

  export class UiProcess {
    setDisplayState(strExpanded : Xrm.ProcessExpanded) : void;
    setVisible(boolVisible : boolean) : void;
  }
}

/**
 * File: Theme.cs
 */
declare module Xrm {
  export enum Theme {
    Default,
    Office12Blue,
    Office14Silver
  }
}

/**
 * File: AsyncCallback.cs
 */
declare module Xrm {
  export class AsyncCallback {
    then(SuccessCallbackHandler : Xrm.ParameterlessFunctionHandler, ErrorCallbackHandler : Xrm.ErrorCallbackHandler) : void;
  }
}

/**
 * File: AttributeFormat.cs
 */
declare module Xrm {
  export enum AttributeFormat {
    Date,
    DateTime,
    Duration,
    Email,
    Language,
    None,
    Phone,
    Text,
    TextArea,
    TickerSymbol,
    Timezone,
    Url
  }
}

/**
 * File: AttributeRequiredLevel.cs
 */
declare module Xrm {
  export enum AttributeRequiredLevel {
    None,
    Required,
    Recommended
  }
}

/**
 * File: AttributeSubmitMode.cs
 */
declare module Xrm {
  export enum AttributeSubmitMode {
    Always,
    Never,
    Dirty
  }
}

/**
 * File: AttributeType.cs
 */
declare module Xrm {
  export enum AttributeType {
    Boolean,
    DateTime,
    Decimal,
    Double,
    Integer,
    Lookup,
    Memo,
    Money,
    OptionSet,
    String
  }
}

/**
 * File: SaveOption.cs
 */
declare module Xrm {
  export enum SaveOption {
    SaveAndClose,
    SaveAndNew
  }
}

/**
 * File: FormNotificationLevel.cs
 */
declare module Xrm {
  export enum FormNotificationLevel {
    Information,
    Warning,
    Error
  }
}

/**
 * File: TabDisplayState.cs
 */
declare module Xrm {
  export enum DisplayState {
    Expanded,
    Collapsed
  }
}

/**
 * File: XrmDelegates.cs
 */


/**
 * File: Page.cs
 */
declare module Xrm {
  export class Page {
    public static ui : Xrm.UI;
    public static context : Xrm.Context;
    public static data : Xrm.Data;
  
    static getGlobalContext() : Xrm.Context;
    static getControl(name : string) : Xrm.Control;
    static getControl(position : number) : Xrm.Control;
    static getControl() : Xrm.Control[];
    static getControl(function : Xrm.GetControlHandler) : Xrm.Control[];
    static getAttribute(name : string) : Xrm.XrmAttribute;
    static getAttribute(position : number) : Xrm.XrmAttribute;
    static getAttribute() : Xrm.XrmAttribute[];
    static getAttribute(function : Xrm.GetAttributeHandler) : Xrm.XrmAttribute[];
  }

  export class ParentPage {
    public static ui : Xrm.UI;
    public static context : Xrm.Context;
    public static data : Xrm.Data;
  
    static getGlobalContext() : Xrm.Context;
    static getControl(name : string) : Xrm.Control;
    static getControl(position : number) : Xrm.Control;
    static getControl(function : Xrm.GetControlHandler) : Xrm.Control[];
    static getAttribute(name : string) : Xrm.XrmAttribute;
    static getAttribute(position : number) : Xrm.XrmAttribute;
    static getAttribute(function : Xrm.GetAttributeHandler) : Xrm.XrmAttribute[];
  }
}

/**
 * File: Context.cs
 */
declare module Xrm {
  export class Context {
    public client : Xrm.Client;
  
    getClientUrl() : string;
    getAuthenticationHeader() : string;
    getCurrentTheme() : Xrm.Theme;
    getOrgLcid() : number;
    getOrgUniqueName() : string;
    getQueryStringParameters() : System.Collections.Generic.Dictionary;
    getServerUrl() : string;
    getUserId() : string;
    getUserName() : string;
    getUserLcid() : number;
    getUserRoles() : string;
    isOutlookClient() : boolean;
    isOutlookOnline() : boolean;
    prependOrgName(sPath : string) : string;
  }
}

/**
 * File: ExecutionContext.cs
 */
declare module Xrm {
  export class ExecutionContext {
    getFormContext() : Xrm.Page;
    getContext() : Xrm.Context;
    getDepth() : number;
    getEventArgs() : Xrm.SaveEventArgs;
    getEventSource() : Xrm.XrmAttribute;
    setSharedVariable(key : string, value : T) : void;
    getSharedVariable(key : string) : any;
  }
}

/**
 * File: SaveEventArgs.cs
 */
declare module Xrm {
  export class SaveEventArgs {
    getSaveMode() : number;
    isDefaultPrevented() : boolean;
    preventDefault() : void;
  }
}

/**
 * File: Ui.cs
 */
declare module Xrm {
  export enum FormTypes {
    Undefined = 0,
    Create = 1,
    Update = 2,
    ReadOnly = 3,
    Disabled = 4,
    QuickCreate = 5,
    BulkEdit = 6
  }

  export class UI {
    public controls : Xrm.Controls;
    public navigation : Xrm.Navigation;
    public formSelector : Xrm.FormSelector;
    public tabs : Xrm.Tabs;
    public process : Xrm.UiProcess;
  
    close() : void;
    getCurrentControl() : Xrm.Control;
    getFormType() : Xrm.FormTypes;
    getViewPortHeight() : number;
    getViewPortWidth() : number;
    refreshRibbon() : void;
    setFormNotification(message : string, level : Xrm.FormNotificationLevel, uniqueId : string) : boolean;
    clearFormNotification(uniqueId : string) : boolean;
  }
}

/**
 * File: Control.cs
 */
declare module Xrm {
  export class Control {
    public originalIsDisabled : boolean;
  
    addOnChange(function : Xrm.AddRemoveOnChangeHandler) : void;
    addCustomView(viewId : string, entityName : string, viewDisplayName : string, fetchXml : string, layoutXml : string, isDefault : boolean) : void;
    addCustomFilter(filter : string, entityLogicaName : string) : void;
    addCustomFilter(filter : string) : void;
    addPreSearch(AddPreSearchHandler : Xrm.ParameterlessFunctionHandler) : void;
    addOption(option : Xrm.Option, index : number) : void;
    addOption(option : Xrm.Option) : void;
    clearOptions() : void;
    getAttribute() : Xrm.XrmAttribute;
    getControlType() : string;
    getData() : string;
    getDefaultView() : string;
    getDisabled() : boolean;
    getLabel() : string;
    getName() : string;
    getParent() : Xrm.Control;
    getSrc() : string;
    getInitialUrl() : string;
    getObject() : any;
    getVisible() : boolean;
    refresh() : void;
    removeOption(value : number) : void;
    setData(data : string) : void;
    setDefaultView(viewId : string) : void;
    setDisabled(disable : boolean) : void;
    setFocus() : void;
    setShowTime(showTime : boolean) : void;
    setLabel(label : string) : void;
    setNotification(message : string) : void;
    clearNotification() : boolean;
    setSrc(src : string) : void;
    setVisible(visible : boolean) : void;
    addOnKeyPress(keyPressFunction : Xrm.ExecutionContextFunctionHandler) : void;
    removeOnKeyPress(keyPressFunction : Xrm.ExecutionContextFunctionHandler) : void;
    fireOnKeyPress() : void;
    getValue() : any;
    getValue() : T;
  }
}

/**
 * File: Controls.cs
 */
declare module Xrm {
  export class Controls {
    forEach(function : Xrm.GetControlHandler) : void;
    get() : Xrm.Control[];
    get(name : string) : Xrm.Control;
    get(position : number) : Xrm.Control;
    get(function : Xrm.GetControlHandler) : Xrm.Control[];
    getLength() : number;
  }
}

/**
 * File: Data.cs
 */
declare module Xrm {
  export class Data {
    public entity : Xrm.XrmEntity;
    public process : Xrm.DataProcess;
  
    refresh(save : boolean) : Xrm.AsyncCallback;
    save() : Xrm.AsyncCallback;
  }
}

/**
 * File: Entity.cs
 */
declare module Xrm {
  export class XrmEntity {
    public attributes : Xrm.Attributes;
  
    addOnSave(function : Xrm.AddRemoveOnSaveHandler) : void;
    addOnSave(function : Xrm.ParameterlessFunctionHandler) : void;
    removeOnSave(function : Xrm.AddRemoveOnSaveHandler) : void;
    removeOnSave(function : Xrm.ParameterlessFunctionHandler) : void;
    getDataXml() : string;
    getEntityName() : string;
    getId() : string;
    getIsDirty() : boolean;
    save() : void;
    save(option : string) : void;
    save(SaveOption : Xrm.SaveOption) : void;
  }
}

/**
 * File: Attribute.cs
 */
declare module Xrm {
  export class XrmAttribute {
    public controls : Xrm.Controls;
  
    addOnChange(function : Xrm.AddRemoveOnChangeHandler) : void;
    addOnChange(function : Xrm.ParameterlessFunctionHandler) : void;
    fireOnChange() : void;
    getAttributeType() : string;
    getAttributeTypeEnum() : Xrm.AttributeType;
    getFormat() : string;
    getFormatEnum() : Xrm.AttributeFormat;
    getInitialValue() : any;
    getIsDirty() : boolean;
    getIsPartyList() : boolean;
    getMax() : number;
    getMaxLength() : number;
    getMin() : number;
    getOption(value : string) : Xrm.Option;
    getOption(value : number) : Xrm.Option;
    getOptions() : Xrm.Option[];
    getParent() : Xrm.XrmEntity;
    getPrecision() : number;
    getRequiredLevel() : Xrm.AttributeRequiredLevel;
    getSelectedOption() : Xrm.Option;
    getSubmitMode() : string;
    getSubmitModeEnum() : Xrm.AttributeSubmitMode;
    getName() : string;
    getText() : string;
    getUserPrivilege() : Xrm.UserPrivilege;
    getValue() : any;
    getValue() : T;
    removeOnChange(function : Xrm.AddRemoveOnChangeHandler) : void;
    setRequiredLevel(requirementLevel : string) : void;
    setRequiredLevel(requirementLevel : Xrm.AttributeRequiredLevel) : void;
    setSubmitMode(mode : string) : void;
    setSubmitMode(mode : Xrm.AttributeSubmitMode) : void;
    setValue(value : T) : void;
    showAutoComplete(results : Xrm.XrmImport.Page.Ui.AutocompleteResultSet) : void;
    hideAutoComplete() : void;
  }
}

/**
 * File: Attributes.cs
 */
declare module Xrm {
  export class Attributes {
    forEach(function : Xrm.GetAttributeHandler) : void;
    get() : Xrm.XrmAttribute[];
    get(name : string) : Xrm.XrmAttribute;
    get(position : number) : Xrm.XrmAttribute;
    get(function : Xrm.GetAttributeHandler) : Xrm.XrmAttribute[];
    getLength() : number;
  }
}

/**
 * File: Lookup.cs
 */
declare module Xrm {
  export class Lookup {
    public name : string;
    public id : string;
    public entityType : string;
    public typeName : string;
  }
}

/**
 * File: Option.cs
 */
declare module Xrm {
  export class Option {
    public text : string;
    public value : number;
  }
}

/**
 * File: UserPrivilege.cs
 */
declare module Xrm {
  export class UserPrivilege {
    public canRead : boolean;
    public canUpdate : boolean;
    public canCreate : boolean;
  }
}

/**
 * File: FormSelector.cs
 */
declare module Xrm {
  export class FormSelector {
    public items : Xrm.FormSelectorItems;
  
    getCurrentItem() : Xrm.FormSelectorItem;
  }
}

/**
 * File: FormSelectorItem.cs
 */
declare module Xrm {
  export class FormSelectorItem {
    getId() : string;
    getLabel() : string;
    navigate() : void;
  }
}

/**
 * File: FormSelectorItems.cs
 */
declare module Xrm {
  export class FormSelectorItems {
    forEach(function : Xrm.GetFormSelectorItemHandler) : void;
    get() : Xrm.FormSelectorItem[];
    get(name : string) : Xrm.FormSelectorItem;
    get(position : number) : Xrm.FormSelectorItem;
    get(function : Xrm.GetFormSelectorItemHandler) : Xrm.FormSelectorItem[];
    getLength() : number;
  }
}

/**
 * File: Navigation.cs
 */
declare module Xrm {
  export class Navigation {
    public items : Xrm.NavigationItems;
  }
}

/**
 * File: NavigationItem.cs
 */
declare module Xrm {
  export class NavigationItem {
    getId() : string;
    getLabel() : string;
    getVisible() : boolean;
    setFocus() : void;
    setLabel(label : string) : void;
    setVisible(visible : boolean) : void;
  }
}

/**
 * File: NavigationItems.cs
 */
declare module Xrm {
  export class NavigationItems {
    forEach(function : Xrm.GetNavigationItemHandler) : void;
    get() : Xrm.NavigationItem[];
    get(name : string) : Xrm.NavigationItem;
    get(position : number) : Xrm.NavigationItem;
    get(function : Xrm.GetNavigationItemHandler) : Xrm.NavigationItem[];
    getLength() : number;
  }
}

/**
 * File: Tabs.cs
 */
declare module Xrm {
  export class Tabs {
    forEach(function : Xrm.GetTabItemHandler) : void;
    get() : Xrm.TabItem[];
    get(name : string) : Xrm.TabItem;
    get(position : number) : Xrm.TabItem;
    get(function : Xrm.GetTabItemHandler) : Xrm.TabItem[];
    getLength() : number;
  }
}

/**
 * File: TabItem.cs
 */
declare module Xrm {
  export class TabItem {
    public sections : Xrm.TabSections;
  
    getDisplayState() : Xrm.DisplayState;
    getLabel() : string;
    getName() : string;
    getParent() : Xrm.UI;
    getVisible() : boolean;
    setDisplayState(state : Xrm.DisplayState) : void;
    setFocus() : void;
    setLabel(label : string) : void;
    setVisible(visible : boolean) : void;
  }
}

/**
 * File: TabSection.cs
 */
declare module Xrm {
  export class TabSection {
    public controls : Xrm.Controls;
  
    getLabel() : string;
    getName() : string;
    getParent() : Xrm.UI;
    getVisible() : boolean;
    setLabel(label : string) : void;
    setVisible(visible : boolean) : void;
  }
}

/**
 * File: TabSections.cs
 */
declare module Xrm {
  export class TabSections {
    forEach(function : Xrm.GetTabSectionHandler) : void;
    get(name : string) : Xrm.TabSection;
    get(position : number) : Xrm.TabSection;
    get(function : Xrm.GetTabSectionHandler) : Xrm.TabSection[];
    getLength() : number;
  }
}

/**
 * File: CommandEntityReference.cs
 */
declare module Xrm.XrmImport.Ribbon {
  export class CommandEntityReference {
    public id : string;
    public name : string;
    public typeName : string;
    public typeCode : number;
  }
}

/**
 * File: CommandProperties.cs
 */
declare module Xrm.XrmImport.Ribbon {
  export class CommandProperties {
    public populationXML : string;
    public sourceControlId : string;
  }
}

/**
 * File: Utility.cs
 */
declare module Xrm {
  export class Utility {
    static openEntityForm(name : string, id : string, parameters : any) : any;
    static openEntityForm2(name : string, id : string, parameters : any, windowOptions : Xrm.OpenEntityFormOptions) : any;
    static openWebResource(webResourceName : string, webResourceData : string, width : number, height : number) : any;
    static isActivityType(entityName : string) : boolean;
    static alertDialog(message : string, onCloseCallback : Xrm.ParameterlessFunctionHandler) : void;
    static confirmDialog(message : string, yesCloseCallback : Xrm.ParameterlessFunctionHandler, noCloseCallback : Xrm.ParameterlessFunctionHandler) : void;
    static getEntityMetadata(entityName : string) : Promise;
    static getGlobalContext() : Xrm.Context;
  }

  export class GlobalFunctions {
    static getGlobalContext() : Xrm.Context;
    static encodeURIComponent(values : string) : string;
  }

  export class OpenEntityFormOptions {
    public openInNewWindow : boolean;
  }
}

/**
 * File: AssemblyInfo.cs
 */


/**
 * File: .NETFramework,Version=v4.0.AssemblyAttributes.cs
 */

SparkleXrmUI.d.ts

/**
 * File: EnterKeyBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class KeyDownEventArgs extends System.EventArgs {
    public keyCode : number;
    public target : any;
  
    preventDefault() : void;
  }

  export class EnterKeyBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: ValueBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class Bindings {
    public value : any;
    public text : any;
  }
}

/**
 * File: XrmCurrencySymbolBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class XrmCurrencySymbolBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    static getCurrencySymbol(valueAccessor : System.Func) : string;
  }
}

/**
 * File: XrmMoneyBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class XrmMoneyBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: XrmNumericBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class XrmNumericBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: XrmOptionSetBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class OptionSetBindingOptions {
    public entityLogicalName : string;
    public attributeLogicalName : string;
    public allowEmpty : boolean;
    public getOptionSetsDelegate : System.Func;
  }

  export class XrmOptionSetBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: SortCol.cs
 */
declare module SparkleXrm.GridEditor {
  export class SortCol {
    public attributeName : string;
    public ascending : boolean;
  
    constructor(attributeName : string, ascending : boolean);
  }
}

/**
 * File: XrmBooleanEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmBooleanEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static booleanEditor : EditorFactory;
  
    constructor(args : EditorArguments);
  
    destroy() : void;
    focus() : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static bindColumn(column : Column, TrueOptionDisplayName : string, FalseOptionDisplayName : string) : Column;
    static bindReadOnlyColumn(column : Column, TrueOptionDisplayName : string, FalseOptionDisplayName : string) : Column;
    static formatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
  }
}

/**
 * File: XrmMoneyEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmMoneyEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static moneyEditor : EditorFactory;
  
    constructor(args : EditorArguments);
  
    destroy() : void;
    focus() : void;
    getValue() : string;
    setValue(value : string) : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static formatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    nativeValidation(newValue : any) : ValidationResult;
    static bindColumn(column : Column, minValue : number, maxValue : number) : Column;
    static bindReadOnlyColumn(column : Column) : Column;
    static getCurrencySymbol(currencyid : EntityReference) : string;
  }
}

/**
 * File: XrmNumberEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmNumberEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static numberEditor : EditorFactory;
  
    constructor(args : EditorArguments);
  
    destroy() : void;
    focus() : void;
    getValue() : string;
    setValue(value : string) : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static formatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    nativeValidation(newValue : any) : ValidationResult;
    static bindColumn(column : Column, minValue : number, maxValue : number, precision : number) : Column;
    static bindReadOnlyColumn(column : Column, precision : number) : Column;
  }
}

/**
 * File: EntityDataViewModel.cs
 */
declare module SparkleXrm.GridEditor {
  export class EntityDataViewModel extends SparkleXrm.GridEditor.DataViewBase {
    protected _suspendRefresh : boolean;
    protected _rows : Entity[];
    protected _data : System.Collections.Generic.List;
    protected _entityType : System.Type;
    protected _fetchXml : string;
    protected _sortCols : System.Collections.Generic.List;
    protected _itemAdded : boolean;
    protected _lazyLoadPages : boolean;
    public errorMessage : string;
    public deleteData : System.Collections.Generic.List;
    public newItemFactory : System.Func;
  
    constructor(pageSize : number, entityType : System.Type, lazyLoadPages : boolean);
  
    get_fetchXml() : string;
    set_fetchXml(value : string) : void;
    get_data() : System.Collections.Generic.List;
    set_data(value : System.Collections.Generic.List) : void;
  
    getItem(index : number) : any;
    reset() : void;
    resetPaging() : void;
    sort(sorting : SortColData) : void;
    getSortColumns() : SparkleXrm.GridEditor.SortCol[];
    sortBy(col : SparkleXrm.GridEditor.SortCol) : void;
    getDirtyItems() : System.Collections.Generic.List;
    contains(Item : Entity) : boolean;
    preProcessResultsData(results : EntityCollection) : void;
    refresh() : void;
    removeItem(id : any) : void;
    addItem(newItem : any) : void;
    protected applySorting() : string;
    protected clearPageCache() : void;
  }
}

/**
 * File: LocalisedContentLoader.cs
 */
declare module SparkleXrm {
  export class LocalisedContentLoader {
    public static supportedLCIDs : System.Collections.Generic.List;
    public static fallBackLCID : number;
  
    static loadContent(webresourceFileName : string, lcid : number, callback : System.Action) : void;
  }
}

/**
 * File: ResourceStrings.cs
 */
declare module SparkleXrm {
  export class SparkleResourceStrings {
    public static lookupFooter : string;
    public static noRecordsFound : string;
  }
}

/**
 * File: DurationValidation.cs
 */
declare module SparkleXrm.Validation {
  export class DurationValidation {
    static validator(val : any, otherval : any) : boolean;
  }
}

/**
 * File: TimeValidation.cs
 */
declare module SparkleXrm.Validation {
  export class TimeValidation {
    static validator(val : any, otherval : any) : boolean;
  }
}

/**
 * File: ValidationRule.cs
 */
declare module SparkleXrm.Validation {
  export class ValidationRule {
    public validator : SparkleXrm.Validation.KoValidatorDelegate;
  
    get_message() : string;
    set_message(value : string) : void;
    get_params() : any;
    set_params(value : any) : void;
  }
}

/**
 * File: ValidationRules.cs
 */
declare module SparkleXrm {
  export class ValidationOptions {
    public registerExtenders : boolean;
    public decorateElement : boolean;
    public errorClass : string;
    public errorElementClass : string;
    public messagesOnModified : boolean;
    public insertMessages : boolean;
    public parseInputAttributes : boolean;
    public messageTemplate : string;
  }

  export class ValidationApi {
    public static rules : System.Collections.Generic.Dictionary;
  
    static group(viewModel : any) : SparkleXrm.ValidationErrors;
    static configure(options : SparkleXrm.ValidationOptions) : void;
    static registerExtenders() : void;
    static makeBindingHandlerValidatable(name : string) : void;
  }

  export class ValidationRules {
    static areValid(fields : any) : boolean;
    static createRules() : SparkleXrm.ValidationRules;
    register(model : any) : void;
    addRequired() : SparkleXrm.ValidationRules;
    addRequiredMsg(message : string) : SparkleXrm.ValidationRules;
    addRule(message : string, validator : System.Func) : SparkleXrm.ValidationRules;
    addPattern(message : string, pattern : string) : SparkleXrm.ValidationRules;
    addCustom(type : string, options : any) : SparkleXrm.ValidationRules;
    static convertToGridValidation(ruleDelegate : SparkleXrm.ValidationRuleDelegate) : GridValidatorDelegate;
  }

  export class AnonymousRule {
    public validator : System.Func;
    public message : string;
  }

  export class ValidationMessage {
    public message : string;
  
    constructor(message : string);
  }

  export class PatternValidation {
    public message : string;
    public pattern : string;
  }

  export class ValidatedObservableFactory {
    static validatedObservable(viewModel : any) : any;
  }

  export class IValidatedViewModel {
    public errors : SparkleXrm.ValidationErrors;
  }

  export class ValidationErrors {
    showAllMessages(value : boolean) : void;
  }

  export class ValidationBinder {
    register(fieldName : string, rule : SparkleXrm.ValidationRuleDelegate) : void;
  }

  export class DataViewValidationBinder extends SparkleXrm.ValidationBinder {
    constructor();
  
    register(fieldName : string, rule : SparkleXrm.ValidationRuleDelegate) : void;
    gridValidationIndexer(attributeLogicalName : string) : GridValidatorDelegate;
  }

  export class ObservableValidationBinder extends SparkleXrm.ValidationBinder {
    constructor(observable : any);
  
    register(fieldName : string, ruleDelegate : SparkleXrm.ValidationRuleDelegate) : void;
  }
  export interface IValidatedObservable {
  }

  export interface IErrorsCollection {
  }
}

/**
 * File: ViewBase.cs
 */
declare module SparkleXrm {
  export class ViewBase {
    public static sparkleXrmTemplatePath : string;
  
    static registerViewModel(viewModel : any) : void;
  }
}

/**
 * File: ViewModelBase.cs
 */
declare module SparkleXrm {
  export class ViewModelBase {
    public isBusy : Observable;
    public isBusyProgress : Observable;
    public isBusyMessage : Observable;
  
    commitEdit() : boolean;
  }
}

/**
 * File: AnimateVisibleBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class AnimateVisible extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: AutocompleteBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class AutocompleteBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: XrmBooleanBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class BooleanBindingOptions {
    public trueOptionDisplayName : string;
    public falseOptionDisplayName : string;
  }

  export class XrmBooleanBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: ComputedObservable.cs
 */
declare module SparkleXrm.CustomBinding {
  export class ComputedObservable {
    public read : System.Func;
    public write : System.Action;
    public owner : any;
    public disposeWhenNodeIsRemoved : Element;
  }

  export class KnockoutEx {
    static computed(observableDelegate : SparkleXrm.CustomBinding.ComputedObservable) : any;
    static applyBindingsToNode(node : Element, bindings : Dictionary) : void;
  }
}

/**
 * File: XrmLookupBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class XrmLookupBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    static getExtraColumns(columnAttributes : string, fetchResult : EntityCollection, results : SparkleXrm.GridEditor.AutoCompleteItem[], i : number) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: XrmTextBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class XrmTextBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: XrmDatePickerBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class XrmDateBindingOptions {
    public dateAndTime : boolean;
    public hour : number;
    public minute : number;
    public overrideUserDateFormat : string;
  }

  export class XrmDatePickerBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: DoubleClickBindingHandler.cs
 */
declare module SparkleXrm {
  export class DoubleClickBindingHandler extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: XrmDurationBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class XrmDurationBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: FadeVisibleBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class FadeVisibleBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: ProgressBarBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class ProgressBarBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: XrmTimeOfDayBinding.cs
 */
declare module SparkleXrm.CustomBinding {
  export class XrmTimeOfDayBinding extends BindingHandler {
    init(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
    update(element : System.Html.Element, valueAccessor : System.Func, allBindingsAccessor : System.Func, viewModel : any, context : any) : void;
  }
}

/**
 * File: XrmDateEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmDateEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static crmDateEditor : EditorFactory;
  
    constructor(args : EditorArguments);
  
    static formatterDateOnly(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    static getDateBindingOptions(columnDef : Column) : SparkleXrm.CustomBinding.XrmDateBindingOptions;
    static getDateFormat(columnDef : Column) : string;
    static formatterDateAndTime(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    destroy() : void;
    show() : void;
    hide() : void;
    position(position : jQueryPosition) : void;
    focus() : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static bindColumn(column : Column, dateOnly : boolean) : Column;
    static bindReadOnlyColumn(column : Column, dateOnly : boolean) : Column;
  }
}

/**
 * File: XrmDurationEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmDurationEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static durationEditor : EditorFactory;
  
    constructor(args : EditorArguments);
  
    static formatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    destroy() : void;
    focus() : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static bindColumn(column : Column) : Column;
  }
}

/**
 * File: XrmLookupEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmLookupEditorOptions {
    public queryCommand : System.Action;
    public nameAttribute : string;
    public idAttribute : string;
    public typeCodeAttribute : string;
    public columns : string;
    public showImage : boolean;
    public showFooter : boolean;
    public footerButton : SparkleXrm.GridEditor.XrmLookupEditorButton;
    public useQuickCreate : boolean;
  }

  export class XrmLookupEditorButton {
    public label : string;
    public tooltip : string;
    public onClick : System.Action;
    public image : string;
  }

  export class XrmLookupEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static lookupEditor : EditorFactory;
  
    constructor(args : EditorArguments);
  
    static formatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    static addFooter(menu : any, recordCount : number) : void;
    destroy() : void;
    show() : void;
    hide() : void;
    position(position : jQueryPosition) : void;
    focus() : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static bindColumn(column : Column, queryCommand : System.Action, idAttribute : string, nameAttribute : string, typeCodeAttribute : string) : Column;
    static bindReadOnlyColumn(column : Column, typeCodeAttribute : string) : Column;
  }

  export class RenderItemDelegate extends jQueryObject {
    public _renderItem : System.Func;
    public _renderMenu : System.Func;
    public _resizeMenu : System.Action;
  }

  export class AutoCompleteItem {
    public label : string;
    public value : any;
    public image : string;
    public data : any;
    public columnValues : string;
  }

  export class AutoCompleteRequest {
    public term : string;
  }
}

/**
 * File: CrmPagerControl.cs
 */
declare module SparkleXrm.GridEditor {
  export class NavigationState {
    public canGotoFirst : boolean;
    public canGotoLast : boolean;
    public canGotoPrev : boolean;
    public canGotoNext : boolean;
    public pagingInfo : PagingInfo;
  }

  export class CrmPagerControl {
    constructor(dataView : SparkleXrm.GridEditor.DataViewBase, grid : Grid, container : any);
  
    init() : void;
    getNavState() : SparkleXrm.GridEditor.NavigationState;
    setPageSize(n : number) : void;
    gotoFirst(e : jQueryEvent) : void;
    gotoLast(e : jQueryEvent) : void;
    gotoPrev(e : jQueryEvent) : void;
    gotoNext(e : jQueryEvent) : void;
    constructPagerUI() : void;
    updatePager(pagingInfo : PagingInfo) : void;
  }
}

/**
 * File: XrmTextEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmTextEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static textEditor : EditorFactory;
  
    constructor(args : EditorArguments);
  
    destroy() : void;
    focus() : void;
    getValue() : string;
    setValue(value : string) : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static bindColumn(column : Column) : Column;
    static bindReadOnlyColumn(column : Column) : Column;
    static formatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
  }
}

/**
 * File: XrmTimeEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmTimeEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static timeEditor : EditorFactory;
  
    constructor(args : EditorArguments);
  
    static formatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    static getTimePickerAutoCompleteOptions(timeFormatString : string) : AutoCompleteOptions;
    destroy() : void;
    show() : void;
    hide() : void;
    position(position : jQueryPosition) : void;
    focus() : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static bindColumn(column : Column) : Column;
    static bindReadOnlyColumn(column : Column) : Column;
  }
}

/**
 * File: DataViewBase.cs
 */
declare module SparkleXrm.GridEditor {
  export class DataViewBase implements IDataView, IDataProvider {
    public onRowsChanged : Event;
    public onPagingInfoChanged : Event;
    public onDataLoading : Event;
    public onDataLoaded : Event;
    protected paging : PagingInfo;
    protected _selectedRows : SelectedRange[];
    public validationBinder : SparkleXrm.DataViewValidationBinder;
  
    raiseOnSelectedRowsChanged(rows : SelectedRange[]) : void;
    getSelectedRows() : SelectedRange[];
    static rangesToRows(ranges : SelectedRange[]) : System.Collections.Generic.List;
    raisePropertyChanged(propertyName : string) : void;
    getPagingInfo() : PagingInfo;
    protected calculatePaging(p : PagingInfo) : void;
    setPagingOptions(p : PagingInfo) : void;
    protected getTotalPages() : number;
    refresh() : void;
    reset() : void;
    insertItem(insertBefore : number, item : any) : void;
    addItem(item : any) : void;
    removeItem(id : any) : void;
    getLength() : number;
    getItem(index : number) : any;
    getItemMetadata(i : number) : ItemMetaData;
    sort(sorting : SortColData) : void;
    getSortColumns() : SparkleXrm.GridEditor.SortCol[];
    gridValidationIndexer() : System.Func;
    onBeforeEdit(item : any) : boolean;
  }
}

/**
 * File: Formatters.cs
 */
declare module SparkleXrm.GridEditor {
  export class Formatters {
    static defaultFormatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
  }
}

/**
 * File: GridDataViewBinder.cs
 */
declare module SparkleXrm.GridEditor {
  export class GridDataViewBinder {
    public selectActiveRow : boolean;
    public addCheckBoxSelectColumn : boolean;
    public multiSelect : boolean;
    public validationPopupUseFitPosition : boolean;
  
    dataBindXrmGrid(dataView : SparkleXrm.GridEditor.DataViewBase, columns : System.Collections.Generic.List, gridId : string, pagerId : string, editable : boolean, allowAddNewRow : boolean) : Grid;
    dataBindDataViewGrid(dataView : DataView, columns : System.Collections.Generic.List, gridId : string, pagerId : string, editable : boolean, allowAddNewRow : boolean) : Grid;
    comparer(l : any, r : any) : number;
    bindClickHandler(grid : Grid) : void;
    addValidation(grid : Grid, dataView : SparkleXrm.GridEditor.DataViewBase) : void;
    dataBindSelectionModel(grid : Grid, dataView : SparkleXrm.GridEditor.DataViewBase) : void;
    addRefreshButton(gridId : string, dataView : SparkleXrm.GridEditor.DataViewBase) : void;
    dataBindEvents(grid : Grid, dataView : SparkleXrm.GridEditor.DataViewBase, gridContainerDivId : string) : void;
    static addColumn(cols : System.Collections.Generic.List, displayName : string, width : number, field : string) : Column;
    static parseLayout(layout : string) : System.Collections.Generic.List;
    static newColumn(field : string, name : string, width : number) : Column;
    static columnFormatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    static bindRowIcon(column : Column, entityLogicalName : string) : Column;
    static rowIcon(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    static addEditIndicatorColumn(columns : System.Collections.Generic.List) : void;
    bindCommitEdit(vm : SparkleXrm.ViewModelBase) : void;
  }
}

/**
 * File: GridEditorBase.cs
 */
declare module SparkleXrm.GridEditor {
  export class GridEditorBase {
    protected _args : EditorArguments;
    protected _item : System.Collections.Generic.Dictionary;
  
    constructor(args : EditorArguments);
  
    destroy() : void;
    show() : void;
    hide() : void;
    position(position : jQueryPosition) : void;
    focus() : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    protected raiseOnChange(item : any) : void;
    isValueChanged() : boolean;
    nativeValidation(newValue : any) : ValidationResult;
    validate() : ValidationResult;
  }
}

/**
 * File: XrmOptionSetEditor.cs
 */
declare module SparkleXrm.GridEditor {
  export class XrmOptionSetEditor extends SparkleXrm.GridEditor.GridEditorBase {
    public static editorFactory : EditorFactory;
  
    constructor(args : EditorArguments);
  
    static formatter(row : number, cell : number, value : any, columnDef : Column, dataContext : any) : string;
    createSelect(self : SparkleXrm.GridEditor.XrmOptionSetEditor) : void;
    destroy() : void;
    focus() : void;
    loadValue(item : System.Collections.Generic.Dictionary) : void;
    serializeValue() : any;
    applyValue(item : System.Collections.Generic.Dictionary, state : any) : void;
    isValueChanged() : boolean;
    static bindColumn(column : Column, entityLogicalName : string, attributeLogicalName : string, allowEmpty : boolean) : Column;
    static bindColumnWithOptions(column : Column, options : SparkleXrm.CustomBinding.OptionSetBindingOptions) : Column;
  }
}

/**
 * File: BlockUI.cs
 */
declare module SparkleXrm.jQueryPlugins {
  export class jQueryBlockUI extends jQueryObject {
    block(options : SparkleXrm.jQueryPlugins.jQueryBlockUIOptions) : void;
    unblock() : void;
  }

  export class jQueryBlockUIOptions {
    public message : string;
    public fadeIn : number;
    public fadeOut : number;
    public baseZ : number;
    public ignoreIfBlocked : boolean;
    public showOverlay : boolean;
    public css : SparkleXrm.jQueryPlugins.BlockUICSS;
    public overlayCSS : SparkleXrm.jQueryPlugins.OverlayCSS;
  }

  export class OverlayCSS {
    public backgroundColor : string;
    public opacity : string;
  }

  export class BlockUICSS {
    public padding : number;
    public margin : number;
    public width : string;
    public height : string;
    public top : string;
    public left : string;
    public textAlign : string;
    public color : string;
    public border : string;
    public backgroundColor : string;
    public cursor : string;
  }
}

/**
 * File: DatePicker.cs
 */
declare module SparkleXrm {
  export class DatePickerOptions2 {
    public showOn : string;
    public firstDay : number;
    public showOtherMonths : boolean;
    public buttonImageOnly : boolean;
    public buttonImage : string;
    public beforeShow : System.Action;
    public onClose : System.Action;
    public dateFormat : string;
    public numberOfMonths : number;
    public onSelect : SparkleXrm.DatePickerOnSelect;
  
    constructor();
    constructor(nameValuePairs : any);
  }

  export enum DatePickerMethod2 {
    Destroy = 0,
    Dialog = 1,
    Disable = 2,
    Enable = 3,
    GetDate = 4,
    IsDisabled = 5,
    Option = 6,
    Refresh = 7,
    SetDate = 8,
    Widget = 9,
    Show = 10,
    Hide = 11
  }

  export class DatePickerPlugIn extends jQueryObject {
    datePicker() : any;
    datePicker(action : SparkleXrm.DatePickerMethod2) : any;
    datePicker(options : SparkleXrm.DatePickerOptions2) : any;
  }
}

/**
 * File: AssemblyInfo.cs
 */


/**
 * File: .NETFramework,Version=v4.0.AssemblyAttributes.cs
 */