namespace FeatureBlendJS {
 	export * as Data from "./Modules/DataModule.js";
	export * as Models from "./Modules/ModelsModule.js";
	export * as Namespaces from "./Namespaces.js";
}
 namespace FeatureBlendJS {
 	export declare enum FeatureBlendEvents {
	    ErrorsLoad = "fb:errors:load",
	    FeatureValueChange = "fb:feature:value:change"
	}
}
 namespace FeatureBlendJS {
 	export interface IEditorType {
	    new (...args: any[]): FeatureBlendJS.Views.EditorBase;
	}
	export interface IEditorTypeDictionary {
	    [key: string]: IEditorType;
	}
	export class FeatureBlend {
	    private static m_editorTypes;
	    private static m_errorTooltipSkin;
	    static get errorTooltipSkin(): string;
	    static set errorTooltipSkin(value: string);
	    static addEditorType(id: string, type: IEditorType): void;
	    static getEditorType(id: string): IEditorType;
	    static removeEditorType(id: string): void;
	}
}
 namespace FeatureBlendJS {
 	export {};
}
 namespace FeatureBlendJS.Context {
 	export interface IGlobalContextOptions {
	    contextId: string;
	    globalEvents: GlobalEvents;
	    globalStorage: GlobalStorage;
	}
	export class GlobalContext {
	    private m_events;
	    private m_storage;
	    constructor(options: IGlobalContextOptions);
	    get events(): GlobalEvents;
	    get storage(): GlobalStorage;
	}
	export class GroupContext {
	    private m_events;
	    private m_storage;
	    constructor(options: IGlobalContextOptions);
	    get events(): GlobalEvents;
	    get storage(): GlobalStorage;
	}
	export class Context {
	}
}
 namespace FeatureBlendJS.Context {
 	export interface IGlobalContextOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	}
	export class GlobalContext {
	    private m_parent;
	    private m_events;
	    private m_storage;
	    constructor(options: IGlobalContextOptions);
	    get events(): FeatureBlendJS.Events.GlobalEvents;
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    get storage(): FeatureBlendJS.Models.GlobalStorage;
	}
}
 namespace FeatureBlendJS.Context {
 	export interface IGlobalEnvironmentOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	}
	export class GlobalEnvironment {
	    private m_parent;
	    private m_events;
	    private m_storage;
	    constructor(options: IGlobalEnvironmentOptions);
	    get events(): FeatureBlendJS.Events.GlobalEvents;
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    get storage(): FeatureBlendJS.Models.GlobalStorage;
	}
}
 namespace FeatureBlendJS.Context {
 	export interface IGroupContextOptions {
	    parent: FeatureBlendJS.Models.GroupModel;
	}
	export class GroupContext {
	    private m_parent;
	    private m_events;
	    private m_storage;
	    constructor(options: IGroupContextOptions);
	    get events(): FeatureBlendJS.Events.GroupEvents;
	    get parent(): FeatureBlendJS.Models.GroupModel;
	    get storage(): FeatureBlendJS.Models.GroupStorage;
	}
}
 namespace FeatureBlendJS.Context {
 	export interface IGroupEnvironmentOptions {
	    parent: FeatureBlendJS.Models.GroupModel;
	}
	export class GroupEnvironment {
	    private m_parent;
	    private m_events;
	    private m_storage;
	    constructor(options: IGroupEnvironmentOptions);
	    get events(): FeatureBlendJS.Events.GroupEvents;
	    get parent(): FeatureBlendJS.Models.GroupModel;
	    get storage(): FeatureBlendJS.Models.GroupStorage;
	}
}
 namespace FeatureBlendJS.Data {
 	export interface IRootData {
	    context: IContextData;
	    editors: IEditorDictionary;
	    initialized: boolean;
	    intializers: IDictionary;
	    errors: Array<IErrorData>;
	}
	export interface IContextData {
	    arbiter: IArbiterData;
	    attributes: IDictionary;
	    featureSet: ISetData;
	}
	export interface IArbiterData {
	    attributes: IDictionary;
	    data: any;
	    errors: any;
	    id?: any;
	    json?: any;
	    properties: IDictionary;
	    innerTarget: IDictionary;
	    target: IDictionary;
	    targetType: string;
	    type: string;
	    [key: string]: any;
	}
	export interface ISetData {
	    groups: Array<IGroupData>;
	}
	export interface IGroupData {
	    id: string;
	    name: string;
	    assembler: string;
	    features: Array<IFeatureData>;
	}
	export interface IFeatureData {
	    attributes: IDictionary;
	    binding: string;
	    [key: string]: any;
	}
	export interface IEditor {
	    attributes: IDictionary;
	    script: string;
	    type: string;
	    typeId: string;
	    [key: string]: any;
	}
	export interface IEditorDictionary {
	    [key: string]: Array<IEditor>;
	}
	export interface IDictionary {
	    [key: string]: any;
	}
	export interface IErrorData {
	    key: string;
	    code: number;
	    message: string;
	    tags: IDictionary;
	}
}
 namespace FeatureBlendJS.Data {
 	export class Model {
	    private m_state;
	    constructor(data: any);
	    get state(): Jade.StateBag;
	    protected onStateChanged(): void;
	    toJSON(): any;
	}
}
 namespace FeatureBlendJS.Data {
 	export class ModelDictionary {
	    private m_data;
	    constructor(data: FeatureBlendJS.Data.IDictionary);
	    private get data();
	    get(key: string, defaultValue?: any): any;
	    set(key: string, value: any): void;
	    exists(key: string): boolean;
	    delete(key: string): void;
	    toJSON(): any;
	}
}
 namespace FeatureBlendJS.Environment {
 	export interface IGlobalEnvironmentOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	}
	export class GlobalEnvironment {
	    private m_parent;
	    private m_events;
	    private m_storage;
	    constructor(options: IGlobalEnvironmentOptions);
	    get events(): FeatureBlendJS.Events.GlobalEvents;
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    get storage(): FeatureBlendJS.Models.GlobalStorage;
	}
}
 namespace FeatureBlendJS.Environment {
 	export interface IGroupEnvironmentOptions {
	    parent: FeatureBlendJS.Models.GroupModel;
	}
	export class GroupEnvironment {
	    private m_parent;
	    private m_events;
	    private m_storage;
	    constructor(options: IGroupEnvironmentOptions);
	    get events(): FeatureBlendJS.Events.GroupEvents;
	    get parent(): FeatureBlendJS.Models.GroupModel;
	    get storage(): FeatureBlendJS.Models.GroupStorage;
	}
}
 namespace FeatureBlendJS.Events {
 	export class EventBus {
	    private m_id;
	    private m_label;
	    private m_register;
	    constructor(label?: string);
	    get id(): string;
	    get label(): string;
	    private get register();
	    subscribe(eventType: string, callback: Function): FeatureBlendJS.Events.Subscription;
	    publish(eventType: string, data?: any): void;
	}
}
 namespace FeatureBlendJS.Events {
 	export class EventRegister {
	    private m_events;
	    constructor();
	    private get events();
	    publish(eventType: string, data?: any): void;
	    subscribe(eventType: any, callback: Function): FeatureBlendJS.Events.Subscription;
	    private exists;
	    private add;
	    private remove;
	    private get;
	}
}
 namespace FeatureBlendJS.Events {
 	export declare enum Events {
	    ErrorsLoad = "fb:errors:load",
	    FeatureValueChanged = "fb:feature:value:changed",
	    GridLabelResize = "fb:group:{0}:grid:label:resize",
	    GridDescriptionResize = "fb:group:{0}:grid:description:resize",
	    GridInputSelected = "fb:group:{0}:grid:input:selected",
	    GridFilter = "fb:group:{0}:grid:filter",
	    CategoriesExpandAll = "fb:group:{0}:grid:categories:expand-all",
	    CategoriesCollapseAll = "fb:group:{0}:grid:categories:collapse-all",
	    NavigationSelect = "fb:navigation:select",
	    FeaturesLoaded = "fb:features:loaded"
	}
	export interface ITargetedArgs {
	    uid: string;
	}
	export interface IGridInputSelectedArgs {
	    model: FeatureBlendJS.Models.MicroEditorModel;
	}
	export interface IGridDescriptionResizeArgs extends ITargetedArgs {
	    height: number;
	}
	export interface IGridLabelResizeArgs extends ITargetedArgs {
	    width: number;
	}
	export interface IGridFilterArgs {
	    term: string;
	}
	export interface INavigationSelectArgs {
	    id: string;
	}
	export interface IEventsHubOptions {
	    scope?: string;
	}
	export class EventsHub {
	    private m_events;
	    private m_scope;
	    private static m_scopes;
	    private constructor();
	    protected get contexts(): Jade.ContextManager;
	    protected get global(): Jade.ContextEventBus;
	    protected get current(): Jade.ContextEventBus;
	    protected get local(): Jade.ContextEventBus;
	    protected get scope(): string;
	    errorsLoadSubscribe(callback: () => void): Jade.EventBusSubscription;
	    featuresLoadedSubscribe(callback: () => void): Jade.EventBusSubscription;
	    gridInputSelectedSubscribe(callback: (e: IGridInputSelectedArgs) => void): Jade.EventBusSubscription;
	    gridDescriptionResizeSubscribe(callback: (e: IGridDescriptionResizeArgs) => void): Jade.EventBusSubscription;
	    gridLabelResizeSubscribe(callback: (e: IGridLabelResizeArgs) => void): Jade.EventBusSubscription;
	    gridFilterSubscribe(callback: (e: IGridFilterArgs) => void): Jade.EventBusSubscription;
	    navigationSelectSubscribe(callback: (e: INavigationSelectArgs) => void): Jade.EventBusSubscription;
	    errorsLoadPublish(): void;
	    featuresLoadedPublish(): void;
	    gridInputSelectedPublish(e: IGridInputSelectedArgs): void;
	    gridDescriptionResizePublish(e: IGridDescriptionResizeArgs): void;
	    gridLabelResizePublish(e: IGridLabelResizeArgs): void;
	    gridFilterPublish(e: IGridFilterArgs): void;
	    navigationSelectPublish(e: INavigationSelectArgs): void;
	    static get(scope?: string): EventsHub;
	    private subscribeLocal;
	    private publishLocal;
	}
}
 namespace FeatureBlendJS.Events {
 	export declare enum GlobalEventTypes {
	    ErrorsLoad = "fb:errors:load",
	    FeaturesLoaded = "fb:features:loaded",
	    FeatureValueChanged = "fb:feature:value:changed",
	    NavigationSelect = "fb:navigation:select"
	}
	export interface INavigationSelectArgs {
	    id: string;
	    scrollIntoView?: boolean;
	}
	export class GlobalEvents extends Jade.EventBus {
	    errorsLoadSubscribe(callback: () => void): Jade.EventBusSubscription;
	    featuresLoadedSubscribe(callback: () => void): Jade.EventBusSubscription;
	    featureValueChangedSubscribe(callback: () => void): void;
	    navigationSelectSubscribe(callback: (e: INavigationSelectArgs) => void): Jade.EventBusSubscription;
	    errorsLoadPublish(): void;
	    featuresLoadedPublish(): void;
	    featureValueChangedPublish(): void;
	    navigationSelectPublish(e: INavigationSelectArgs): void;
	}
}
 namespace FeatureBlendJS.Events {
 	export declare enum GroupEventTypes {
	    GridLabelResize = "fb:group:{0}:grid:label:resize",
	    GridDescriptionResize = "fb:group:{0}:grid:description:resize",
	    GridInputSelected = "fb:group:{0}:grid:input:selected",
	    GridFilter = "fb:group:{0}:grid:filter",
	    CategoriesExpandAll = "fb:group:{0}:grid:categories:expand-all",
	    CategoriesCollapseAll = "fb:group:{0}:grid:categories:collapse-all",
	    CategoryToggle = "fb:group:{0}:grid:category:toggle"
	}
	export interface IGridInputSelectedArgs {
	    model: MicroEditorModel;
	}
	export interface IGridLabelResizeArgs {
	    width: number;
	}
	export interface IGridFilterArgs {
	    term: string;
	}
	export interface IGroupEventsOptions extends Jade.IEventBusOptions {
	    groupId: string;
	}
	export class GroupEvents extends Jade.EventBus {
	    private m_groupId;
	    constructor(options: IGroupEventsOptions);
	    private get groupId();
	    inputSelectedSubscribe(callback: (e: IGridInputSelectedArgs) => void): Jade.EventBusSubscription;
	    labelResizeSubscribe(callback: (e: IGridLabelResizeArgs) => void): Jade.EventBusSubscription;
	    filterSubscribe(callback: (e: IGridFilterArgs) => void): Jade.EventBusSubscription;
	    categoriesCollapseAllSubscribe(callback: () => void): Jade.EventBusSubscription;
	    categoriesExpandAllSubscribe(callback: (e: IGridFilterArgs) => void): Jade.EventBusSubscription;
	    categoryToggleSubscribe(callback: () => void): Jade.EventBusSubscription;
	    inputSelectedPublish(e: IGridInputSelectedArgs): void;
	    labelResizePublish(e: IGridLabelResizeArgs): void;
	    filterPublish(e: IGridFilterArgs): void;
	    categoriesCollapseAllPublish(): void;
	    categoriesExpandAllPublish(): void;
	    categoryTogglePublish(): void;
	    subscribe(eventName: string, callback: any): Jade.EventBusSubscription;
	    publish(eventName: string, args?: any): void;
	}
}
 namespace FeatureBlendJS.Events {
 	export interface ISubscriptionOptions {
	    subscriptionId: string;
	    callback: Function;
	    unsubscribe: (subscriptionId: string) => void;
	}
	export interface ISubscribeOptions {
	    groupId?: string;
	}
	export class Subscription {
	    private m_subscriptionId;
	    private m_callback;
	    private m_unsubscribeCallback;
	    constructor(options: ISubscriptionOptions);
	    private get subscriptionId();
	    private get callback();
	    private get unsubscribeCallback();
	    invoke(data?: any): void;
	    unsubscribe(): void;
	}
}
 namespace FeatureBlendJS.Events {
 	export interface ISubscriptionRegisterOptions {
	    empty: () => void;
	}
	export class SubscriptionRegister {
	    private m_subscriptions;
	    private m_emptyCallback;
	    constructor(options: ISubscriptionRegisterOptions);
	    private get emptyCallback();
	    private get subscriptions();
	    publish(data?: any): void;
	    subscribe(callback: Function): FeatureBlendJS.Events.Subscription;
	    private exists;
	    private add;
	    private remove;
	    private get;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IArbiterModelOptions extends FeatureBlendJS.Models.IBaseModelOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	    data: FeatureBlendJS.Data.IArbiterData;
	}
	export class ArbiterModel extends FeatureBlendJS.Models.BaseModel {
	    private m_parent;
	    constructor(options: IArbiterModelOptions);
	    get attributes(): FeatureBlendJS.Data.IDictionary;
	    get data(): FeatureBlendJS.Data.IDictionary;
	    get errors(): FeatureBlendJS.Data.IDictionary;
	    get json(): FeatureBlendJS.Data.IDictionary;
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    get properties(): FeatureBlendJS.Data.IDictionary;
	    get target(): FeatureBlendJS.Data.IDictionary;
	    get innerTarget(): FeatureBlendJS.Data.IDictionary;
	    get id(): any;
	    get targetType(): string;
	    get type(): string;
	    toJSON(): FeatureBlendJS.Data.IArbiterData;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IBaseModelOptions {
	    root: FeatureBlendJS.Models.RootModel;
	    parent: any;
	    data: any;
	}
	export class BaseModel extends FeatureBlendJS.Data.Model {
	    private m_root;
	    constructor(options: IBaseModelOptions);
	    get root(): FeatureBlendJS.Models.RootModel;
	}
}
 namespace FeatureBlendJS.Models {
 	export declare enum ContextAttributeKey {
	    ChangeSource = "changeSource",
	    LabelResizePosition = "labelResizePosition",
	    DescriptionResizePosition = "descriptionResizePosition",
	    FilterTerm = "filterTerm"
	}
	export interface IChangeSource {
	    id: string;
	    name: string;
	}
	export class ContextAttributes extends FeatureBlendJS.Data.ModelDictionary {
	    get hasChangeSource(): boolean;
	    get changeSource(): IChangeSource;
	    set changeSource(value: IChangeSource);
	    get labelResizePosition(): number;
	    set labelResizePosition(value: number);
	    get descriptionResizePosition(): number;
	    set descriptionResizePosition(value: number);
	    get filterTerm(): string;
	    set filterTerm(value: string);
	    deleteChangeSource(): void;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IContextModelOptions extends FeatureBlendJS.Models.IBaseModelOptions {
	    parent: FeatureBlendJS.Models.RootModel;
	    data: FeatureBlendJS.Data.IContextData;
	}
	export class ContextModel extends FeatureBlendJS.Models.BaseModel {
	    private m_attributes;
	    private m_arbiter;
	    private m_set;
	    private m_data;
	    private m_parent;
	    private m_environment;
	    private m_storage;
	    constructor(options: IContextModelOptions);
	    get attributes(): FeatureBlendJS.Models.ContextAttributes;
	    get arbiter(): FeatureBlendJS.Models.ArbiterModel;
	    get featureSet(): FeatureBlendJS.Models.SetModel;
	    get parent(): FeatureBlendJS.Models.RootModel;
	    get globals(): FeatureBlendJS.Environment.GlobalEnvironment;
	    get storage(): FeatureBlendJS.Models.StorageManager;
	    get data(): FeatureBlendJS.Data.IContextData;
	    toJSON(): FeatureBlendJS.Data.IContextData;
	}
}
 namespace FeatureBlendJS.Models {
 	export declare enum ContextAttributeKey {
	    ChangeSource = "changeSource"
	}
	export class ContextAttributes extends FeatureBlendJS.Data.ModelDictionary {
	    private get changeSource();
	    private set changeSource(value);
	}
}
 namespace FeatureBlendJS.Models {
 	export class ContextStorage extends StorageBase {
	    get selectedNav(): string;
	    set selectedNav(value: string);
	}
}
 namespace FeatureBlendJS.Models {
 	export interface ICommitHandler {
	    (): void;
	}
	export interface IFeatureValueChangeHandler {
	    (args: IFeatureValueChangeHandlerArgs): void;
	}
	export interface IFeatureValueChangeHandlerArgs {
	    name: string;
	    oldValue: any;
	    newValue: any;
	    cancel?: boolean;
	}
	export interface IControllerModelOptions extends FeatureBlendJS.Models.IBaseModelOptions {
	    parent: FeatureBlendJS.Models.SetModel;
	}
	export class ControllerModel extends FeatureBlendJS.Models.BaseModel {
	    private m_parent;
	    private m_events;
	    constructor(options: IControllerModelOptions);
	    get parent(): FeatureBlendJS.Models.SetModel;
	    protected onInit(): void;
	    protected onActivate(): void;
	    activate(): void;
	    commit(): void;
	    toJSON(): any;
	    onValueChanged(name: string, handler: IFeatureValueChangeHandler): void;
	    onValueChanged(names: Array<string>, handler: IFeatureValueChangeHandler): void;
	    valueChanged(args: IFeatureValueChangeHandlerArgs): void;
	    onCommit(handler: ICommitHandler): void;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IFeatureModelDictionary {
	    [key: string]: IEditorModelDictionary;
	}
	export interface IEditorModelDictionary {
	    [key: string]: Array<FeatureBlendJS.Models.EditorModel>;
	}
	export class EditorCollection {
	    private m_data;
	    private m_source;
	    constructor(data: FeatureBlendJS.Data.IEditorDictionary);
	    private get data();
	    private get source();
	    getEditorsByFeature(feature: FeatureBlendJS.Models.FeatureModel): Array<FeatureBlendJS.Models.EditorModel>;
	    getEditorsByGroup(group: FeatureBlendJS.Models.GroupModel): Array<FeatureBlendJS.Models.EditorModel>;
	    toJSON(): FeatureBlendJS.Data.IEditorDictionary;
	    loadEditors(targetFeature: FeatureBlendJS.Models.FeatureModel): void;
	    private sortEditors;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IEditorModelOptions {
	    data: FeatureBlendJS.Data.IEditor;
	    feature: FeatureModel;
	}
	export class EditorModel extends FeatureBlendJS.Data.Model {
	    private m_feature;
	    constructor(options: IEditorModelOptions);
	    get feature(): FeatureModel;
	    get group(): FeatureBlendJS.Models.GroupModel;
	    get set(): FeatureBlendJS.Models.SetModel;
	    get root(): FeatureBlendJS.Models.RootModel;
	    get controller(): FeatureBlendJS.Models.ControllerModel;
	    get attributes(): FeatureBlendJS.Data.IDictionary;
	    get script(): string;
	    get uid(): string;
	    getFeatureValue(name: string, defaultValue?: any): any;
	    setFeatureValue(name: string, value: any, options?: ISetValueOptions): void;
	    getRemoteFeatureValue(name: string, defaultValue?: any): any;
	    setRemoteFeatureValue(name: string, value: any, options?: ISetValueOptions): void;
	    private setSilence;
	    private setChangeSource;
	}
}
 namespace FeatureBlendJS.Models {
 	export class ErrorModel {
	    private m_groupIndex;
	    private m_featureIndex;
	    private m_propertyName;
	    private m_key;
	    private m_message;
	    private m_code;
	    private m_tags;
	    constructor(data: FeatureBlendJS.Data.IErrorData);
	    get code(): number;
	    get featureIndex(): number;
	    get groupIndex(): number;
	    get key(): string;
	    get message(): string;
	    get propertyName(): string;
	    get tags(): FeatureBlendJS.Data.IDictionary;
	    toJSON(): FeatureBlendJS.Data.IErrorData;
	    private parseKey;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface ISetValueOptions {
	    postback?: boolean;
	    silent?: boolean;
	}
	export interface IFeatureModelOptions extends FeatureBlendJS.Models.IBaseModelOptions {
	    parent: FeatureBlendJS.Models.GroupModel;
	    data: FeatureBlendJS.Data.IFeatureData;
	}
	export class FeatureModel extends FeatureBlendJS.Models.BaseModel {
	    private m_errors;
	    private m_index;
	    private m_parent;
	    private m_initializer;
	    private m_postbackOnChangeThrottle;
	    constructor(options: IFeatureModelOptions);
	    get id(): string;
	    get attributes(): FeatureBlendJS.Data.IDictionary;
	    get binding(): string;
	    get parent(): FeatureBlendJS.Models.GroupModel;
	    get initializers(): any;
	    get index(): number;
	    get errors(): Array<FeatureBlendJS.Models.ErrorModel>;
	    private get featureSet();
	    getEditors(): Array<FeatureBlendJS.Models.EditorModel>;
	    getValue(id: string, defaultValue?: any): any;
	    setValue(id: string, value: any, options?: ISetValueOptions): void;
	    getRemoteValue(key: string, defaultValue?: any): any;
	    setRemoteValue(key: string, value: string, options?: ISetValueOptions): void;
	    setErrors(): void;
	    toJSON(): FeatureBlendJS.Data.IFeatureData;
	    protected onStateChanged(): void;
	    private getIndex;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IGroupModelOptions extends FeatureBlendJS.Models.IBaseModelOptions {
	    parent: FeatureBlendJS.Models.SetModel;
	    data: FeatureBlendJS.Data.IGroupData;
	}
	export class GroupModel extends FeatureBlendJS.Models.BaseModel {
	    private m_errors;
	    private m_index;
	    private m_parent;
	    private m_features;
	    private m_environment;
	    constructor(options: IGroupModelOptions);
	    get locals(): FeatureBlendJS.Environment.GroupEnvironment;
	    get globals(): FeatureBlendJS.Environment.GlobalEnvironment;
	    get isMicro(): boolean;
	    get assembler(): string;
	    get features(): Array<FeatureBlendJS.Models.FeatureModel>;
	    get id(): string;
	    get name(): string;
	    get parent(): FeatureBlendJS.Models.SetModel;
	    get index(): number;
	    get errors(): Array<FeatureBlendJS.Models.ErrorModel>;
	    getEditors(): Array<FeatureBlendJS.Models.EditorModel>;
	    setErrors(): void;
	    toJSON(): FeatureBlendJS.Data.IGroupData;
	    private getIndex;
	}
}
 namespace FeatureBlendJS.Models {
 	export class GroupStorage extends StorageBase {
	    get id(): string;
	    set id(value: string);
	    get descriptionHeight(): number;
	    set descriptionHeight(value: number);
	    get expanded(): Array<string>;
	    get filter(): string;
	    set filter(value: string);
	    get labelWidth(): number;
	    set labelWidth(value: number);
	    get scroll(): number;
	    set scroll(value: number);
	}
}
 namespace FeatureBlendJS.Models {
 	export class GroupStorageCollection extends Jade.Collection<FeatureBlendJS.Models.GroupStorage> {
	    get(groupId: string): FeatureBlendJS.Models.GroupStorage;
	    toJSON(): Array<any>;
	}
}
 namespace FeatureBlendJS.Models {
 	export class MacroEditorModel extends FeatureBlendJS.Models.EditorModel {
	    private get primaryValueName();
	    get primaryValue(): any;
	    set primaryValue(value: any);
	}
}
 namespace FeatureBlendJS.Models {
 	export class MicroEditorModel extends FeatureBlendJS.Models.EditorModel {
	    get name(): string;
	    get category(): string;
	    get description(): string;
	    get order(): number;
	    get label(): string;
	    get required(): boolean;
	    get readOnly(): boolean;
	    get enabled(): boolean;
	    protected get postback(): boolean;
	    getFeaturePrimaryValue(defaultValue?: any): any;
	    setFeaturePrimaryValue(value: any, options?: FeatureBlendJS.Models.ISetValueOptions): void;
	    getFeatureValue(name: string, defaultValue?: any): any;
	    setFeatureValue(name: string, value: any, options?: FeatureBlendJS.Models.ISetValueOptions): void;
	    getFeatureValueByProp(prop: string, defaultValue?: any): any;
	    static isMicroEditor(item: FeatureBlendJS.Data.IEditor): boolean;
	}
}
 namespace FeatureBlendJS.Models {
 	export class RootModel extends FeatureBlendJS.Data.Model {
	    private m_errors;
	    private m_context;
	    private m_editorCollection;
	    private m_postbackHandlerFn;
	    constructor(options: FeatureBlendJS.Data.IRootData);
	    get context(): FeatureBlendJS.Models.ContextModel;
	    get editors(): FeatureBlendJS.Models.EditorCollection;
	    get initialized(): boolean;
	    get initializers(): FeatureBlendJS.Data.IDictionary;
	    get errors(): Array<FeatureBlendJS.Models.ErrorModel>;
	    get postbackHandler(): Function;
	    set postbackHandler(callback: Function);
	    clearErrors(): void;
	    loadErrors(errors?: Array<FeatureBlendJS.Data.IErrorData>): void;
	    toJSON(): FeatureBlendJS.Data.IRootData;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface ISetModelOptions extends FeatureBlendJS.Models.IBaseModelOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	    data: FeatureBlendJS.Data.ISetData;
	}
	export interface IValueChangedArgs {
	    group: FeatureBlendJS.Models.GroupModel;
	    feature: FeatureModel;
	    name: string;
	    value: any;
	}
	export class SetModel extends FeatureBlendJS.Models.BaseModel {
	    private m_parent;
	    private m_controller;
	    private m_groups;
	    private m_valueChangesAreSilent;
	    constructor(options: ISetModelOptions);
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    get groups(): Array<FeatureBlendJS.Models.GroupModel>;
	    get controller(): FeatureBlendJS.Models.ControllerModel;
	    private get controllerTypeName();
	    get valueChangesAreSilent(): boolean;
	    set valueChangesAreSilent(value: boolean);
	    valueChanged(args: IValueChangedArgs): void;
	    onValueChanged(subscriber: (args: IValueChangedArgs) => void): Jade.EventBusSubscription;
	    toJSON(): FeatureBlendJS.Data.ISetData;
	    hasChanges(): boolean;
	    getValue(key: string, defaultValue?: any): any;
	    setValue(key: string, value: any, options?: ISetValueOptions): any;
	    setErrors(): void;
	    private ensureController;
	    private createController;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IStorageOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	    data: any;
	}
	export class Storage extends FeatureBlendJS.Data.Model {
	    private m_parent;
	    constructor(options: IStorageOptions);
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    toJSON(): any;
	}
}
 namespace FeatureBlendJS.Models {
 	export declare enum GlobalEventTypes {
	    ErrorsLoad = "fb:errors:load",
	    FeaturesLoaded = "fb:features:loaded",
	    FeatureValueChanged = "fb:feature:value:changed",
	    NavigationSelect = "fb:navigation:select"
	}
	export interface INavigationSelectArgs {
	    id: string;
	}
	export class GlobalEvents extends Jade.EventBus {
	    errorsLoadSubscribe(callback: () => void): Jade.EventBusSubscription;
	    featuresLoadedSubscribe(callback: () => void): Jade.EventBusSubscription;
	    featureValueChangedSubscribe(callback: () => void): void;
	    navigationSelectSubscribe(callback: (e: INavigationSelectArgs) => void): Jade.EventBusSubscription;
	    errorsLoadPublish(): void;
	    featuresLoadedPublish(): void;
	    featureValueChangedPublish(): void;
	    navigationSelectPublish(e: INavigationSelectArgs): void;
	}
}
 namespace FeatureBlendJS.Models {
 	export class GlobalStorage extends FeatureBlendJS.Models.StorageBase {
	    get selectedGroupId(): string;
	    set selectedGroupId(value: string);
	    get postbackInputId(): string;
	    set postbackInputId(value: string);
	    get navScroll(): number;
	    set navScroll(value: number);
	    toJSON(): any;
	}
}
 namespace FeatureBlendJS.Models {
 	export class GroupStorage extends FeatureBlendJS.Models.StorageBase {
	    get collapsed(): Array<string>;
	    set collapsed(value: Array<string>);
	    get filter(): string;
	    set filter(value: string);
	    get focusedInputId(): string;
	    set focusedInputId(value: string);
	    get footerHeight(): number;
	    set footerHeight(value: number);
	    get id(): string;
	    set id(value: string);
	    get labelWidth(): number;
	    set labelWidth(value: number);
	    get scroll(): number;
	    set scroll(value: number);
	}
}
 namespace FeatureBlendJS.Models {
 	export class GroupStorageCollection extends Jade.Collection<FeatureBlendJS.Models.GroupStorage> {
	    get(groupId: string): FeatureBlendJS.Models.GroupStorage;
	    toJSON(): Array<any>;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IStorageOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	    [key: string]: any;
	}
	export class StorageBase extends FeatureBlendJS.Data.Model {
	    private m_parent;
	    constructor(options: IStorageOptions);
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    toJSON(): any;
	}
}
 namespace FeatureBlendJS.Models {
 	export interface IStorageManagerOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	}
	interface IStorageManagerData {
	    global: any;
	    groups: Array<any>;
	}
	export class StorageManager extends FeatureBlendJS.Data.Model {
	    private m_parent;
	    private m_global;
	    private m_groups;
	    constructor(options: IStorageManagerOptions);
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    get global(): FeatureBlendJS.Models.GlobalStorage;
	    get groups(): FeatureBlendJS.Models.GroupStorageCollection;
	    private get storageData();
	    private set storageData(value);
	    toJSON(): IStorageManagerData;
	    serialize(): void;
	    deserialize(): any;
	}
	export {};
}
 namespace FeatureBlendJS.Models {
 	export interface IStorageOptions {
	    parent: FeatureBlendJS.Models.ContextModel;
	    data: any;
	}
	export class StorageBase extends FeatureBlendJS.Data.Model {
	    private m_parent;
	    constructor(options: IStorageOptions);
	    get parent(): FeatureBlendJS.Models.ContextModel;
	    toJSON(): any;
	}
}
 namespace FeatureBlendJS.Modules {
 	export * as Interfaces from "../Data/Interfaces.js";
	export * as Model from "../Data/Model.js";
}
 namespace FeatureBlendJS.Modules {
 	export * as EventBus from "../Events/EventBus.js";
	export * as EventRegister from "../Events/EventRegister.js";
	export * as Subscription from "../Events/Subscription.js";
	export * as SubscriptionRegister from "../Events/SubscriptionRegister.js";
}
 namespace FeatureBlendJS.Modules {
 	export * as AribterModel from "../Models/ArbiterModel.js";
	export * as BaseModel from "../Models/BaseModel.js";
	export * as ContextModel from "../Models/ContextModel.js";
	export * as EditorCollection from "../Models/EditorCollection.js";
	export * as EditorModel from "../Models/EditorModel.js";
	export * as ErrorModel from "../Models/ErrorModel.js";
	export * as FeatureModel from "../Models/ArbiterModel.js";
	export * as GroupModel from "../Models/ArbiterModel.js";
	export * as MacroEditorModel from "../Models/ArbiterModel.js";
	export * as MicroEditorModel from "../Models/ArbiterModel.js";
	export * as RootModel from "../Models/RootModel.js";
	export * as SetModel from "../models/SetModel.js";
}
 namespace FeatureBlendJS.Modules {
 	export {};
}
 namespace FeatureBlendJS.Views {
 	export interface IAssemblerViewOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.GroupModel;
	    visible?: boolean;
	    isDefaultView?: boolean;
	}
	export class AssemblerView extends FeatureBlendJS.Views.BaseView {
	    private m_initialRender;
	    constructor(options: IAssemblerViewOptions);
	    get visible(): boolean;
	    get source(): FeatureBlendJS.Models.GroupModel;
	    get globals(): FeatureBlendJS.Environment.GlobalEnvironment;
	    private get isDefaultView();
	    private get hasBeenViewed();
	    private set hasBeenViewed(value);
	    protected get hasFocus(): boolean;
	    protected set hasFocus(value: boolean);
	    template(): string | Array<string> | JQuery;
	    show(): void;
	    hide(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onComplete(e: Jade.UI.ControlEventArgs): void;
	    protected focusView(): void;
	    protected onInitialView(): void;
	    protected onFocusedView(): void;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface ICategoryViewOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    label: string;
	    editors: Array<FeatureBlendJS.Models.EditorModel>;
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export class CategoryView extends FeatureBlendJS.Views.BaseView {
	    private m_editors;
	    constructor(options: ICategoryViewOptions);
	    protected get source(): FeatureBlendJS.Models.GroupModel;
	    get label(): string;
	    private get editors();
	    private get header();
	    private get content();
	    private get toggle();
	    get inputs(): Jade.Collection<FeatureBlendJS.Views.InputView>;
	    get visible(): boolean;
	    get isExpanded(): boolean;
	    template(): string | Array<string> | JQuery;
	    expand(): void;
	    collapse(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private populate;
	    private toggle_onClick;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IContentViewOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export interface IResizeColumnEventArgs {
	    width: number;
	}
	export class ContentView extends FeatureBlendJS.Views.BaseView {
	    constructor(options: IContentViewOptions);
	    protected get source(): FeatureBlendJS.Models.GroupModel;
	    get categories(): Jade.Collection<FeatureBlendJS.Views.CategoryView>;
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onComplete(e: Jade.UI.ControlEventArgs): void;
	    private onScroll;
	    private populate;
	    private addEventSubscriptions;
	    private addCategoryCollapseStateToStorage;
	}
}
 namespace FeatureBlendJS.Views {
 }
 namespace FeatureBlendJS.Views {
 	export class FilterCommand {
	    static invoke(content: FeatureBlendJS.Views.ContentView, term: string): void;
	    private static filterCategories;
	    private static filterInputs;
	    private static clearMessage;
	    private static writeMessage;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IGridDescriptionResizerOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    grid: FeatureBlendJS.Views.GridView;
	    footer: FeatureBlendJS.Views.FooterView;
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export class FooterResizer extends FeatureBlendJS.Views.BaseView {
	    private m_footer;
	    private m_grid;
	    constructor(options: IGridDescriptionResizerOptions);
	    protected get source(): FeatureBlendJS.Models.GroupModel;
	    private get footer();
	    private get grid();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onDestroy(e: Jade.UI.ControlEventArgs): void;
	    private draggable_init;
	    private setPosition;
	    private dragStart;
	    private dragStop;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IFooterViewOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    parent: FeatureBlendJS.Views.GridView;
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export class FooterView extends FeatureBlendJS.Views.BaseView {
	    private m_parent;
	    private m_resizer;
	    constructor(options: IFooterViewOptions);
	    get parent(): FeatureBlendJS.Views.GridView;
	    protected get source(): FeatureBlendJS.Models.GroupModel;
	    get descriptionNode(): JQuery;
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private resizer_init;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IGridDescriptionResizerOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    parent: FeatureBlendJS.Views.GridView;
	    footer: FeatureBlendJS.Views.FooterView;
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export class GridDescriptionResizer extends FeatureBlendJS.Views.BaseView {
	    private m_parent;
	    constructor(options: IGridDescriptionResizerOptions);
	    protected get source(): FeatureBlendJS.Models.GroupModel;
	    private get parent();
	    private get footer();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onBrowserResize(): void;
	    protected onDestroy(e: Jade.UI.ControlEventArgs): void;
	    private setResizerTopOnDrag;
	    private setResizerTopOnContainerResize;
	    private getDescriptionTop;
	    private setPosition;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IGridLabelResizerOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    parent: FeatureBlendJS.Views.ContentView;
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export class GridLabelResizer extends FeatureBlendJS.Views.BaseView {
	    private m_parent;
	    constructor(options: IGridLabelResizerOptions);
	    private get parent();
	    protected get source(): FeatureBlendJS.Models.GroupModel;
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onDestroy(e: Jade.UI.ControlEventArgs): void;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IGridViewOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export class GridView extends FeatureBlendJS.Views.BaseView {
	    private m_header;
	    private m_content;
	    private m_footer;
	    constructor(options: IGridViewOptions);
	    get content(): FeatureBlendJS.Views.ContentView;
	    protected get source(): FeatureBlendJS.Models.GroupModel;
	    get header(): FeatureBlendJS.Views.HeaderView;
	    get footer(): FeatureBlendJS.Views.FooterView;
	    template(): string | Array<string> | JQuery;
	    forEachInput(callback: (input: FeatureBlendJS.Views.InputView) => void): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IHeaderViewOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export class HeaderView extends FeatureBlendJS.Views.BaseView {
	    constructor(options: IHeaderViewOptions);
	    protected get source(): FeatureBlendJS.Models.GroupModel;
	    private get filterNode();
	    private get rightGroupNode();
	    private get leftGroupNode();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onComplete(e: Jade.UI.ControlEventArgs): void;
	    private filter_init;
	    private buttons_init;
	    private addButton;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IInputEditorViewOptions {
	    focus: Function;
	    editor: FeatureBlendJS.Models.MicroEditorModel;
	}
	export class InputEditorView extends Jade.UI.Control {
	    private m_editorView;
	    private m_editorModel;
	    constructor(options: IInputEditorViewOptions);
	    get editorModel(): FeatureBlendJS.Models.MicroEditorModel;
	    private get editorView();
	    private get focusCallback();
	    template(): string | Array<string> | JQuery;
	    focus(): void;
	    show(): void;
	    hide(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private editor_init;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IInputVariablePopUpOptions extends Jade.UI.IControlOptions {
	    handle: JQuery;
	}
	export class InputVariablePopUp extends Jade.UI.Control {
	    private m_handle;
	    constructor(options: IInputVariablePopUpOptions);
	    private get handle();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private popup_init;
	    private popup_onShow;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IInputVariableViewOptions {
	    focus: Function;
	    editor: FeatureBlendJS.Models.MicroEditorModel;
	    variableUsed: boolean;
	}
	export class InputVariableView extends Jade.UI.Control {
	    private m_editorModel;
	    constructor(options: IInputVariableViewOptions);
	    get editorModel(): FeatureBlendJS.Models.MicroEditorModel;
	    get inputNode(): JQuery;
	    private get focusCallback();
	    private get variableUsed();
	    private get buttonNode();
	    get imgNode(): JQuery;
	    template(): string | Array<string> | JQuery;
	    show(): void;
	    hide(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private popup_init;
	    private input_onFocus;
	}
}
 namespace FeatureBlendJS.Views {
 	export declare enum DynamicVariableType {
	    None = 0,
	    Context = 1
	}
	export declare enum DynamicVariableCss {
	    None = "-fb-dynamics-none",
	    Context = "-fb-dynamics-datatag"
	}
	export interface IInputViewOptions extends Jade.UI.IControlOptions {
	    editor: FeatureBlendJS.Models.MicroEditorModel;
	}
	export class InputView extends Jade.UI.Control {
	    private m_editorView;
	    private m_editorModel;
	    private m_variableView;
	    private m_variableUsed;
	    private m_variableSupported;
	    constructor(options: IInputViewOptions);
	    get group(): FeatureBlendJS.Models.GroupModel;
	    get editorModel(): FeatureBlendJS.Models.MicroEditorModel;
	    get editorView(): FeatureBlendJS.Views.InputEditorView;
	    private get variableView();
	    private get contentNode();
	    private get labelNode();
	    private get deckNode();
	    get visible(): boolean;
	    get variableSupported(): boolean;
	    get variableUsed(): boolean;
	    get variableButtonNode(): JQuery;
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private editor_init;
	    private variable_init;
	    private labelNode_onClick;
	    private contentNode_onClick;
	    private contentNode_onFocus;
	    private contentNode_onBlur;
	    private highlightLabel;
	    private getGridTemplateColumns;
	    private setVariableState;
	    private variableButton_click;
	    private showVariableInput;
	    private showEditorInput;
	    private processValidationErrors;
	    private commitFocusToStorage;
	}
}
 namespace FeatureBlendJS.Views {
 	export class MacroView extends FeatureBlendJS.Views.AssemblerView {
	    private m_editorModels;
	    private m_editorViews;
	    protected get editorModels(): Array<FeatureBlendJS.Models.EditorModel>;
	    protected get editorViews(): Array<FeatureBlendJS.Views.MacroEditorBase>;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onInitialView(): void;
	    protected onFocusedView(): void;
	    private addEditorsToControlCollection;
	    private createEditors;
	    private createEditor;
	    private triggerEditorViewsResize;
	}
}
 namespace FeatureBlendJS.Views {
 	export class MicroView extends FeatureBlendJS.Views.AssemblerView {
	    private m_grid;
	    private get grid();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: any): void;
	    protected onInitialView(): void;
	    protected onFocusedView(): void;
	    private focusInput;
	    private focusPostbackInput;
	    private focusLastFocusedInput;
	    private focusFirstFocusableInput;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IBaseViewOptions extends Jade.UI.IControlOptions {
	    source: FeatureBlendJS.Models.BaseModel;
	}
	export class BaseView extends Jade.UI.Control {
	    private m_source;
	    private m_subscribers;
	    constructor(options: IBaseViewOptions);
	    protected get source(): FeatureBlendJS.Models.BaseModel;
	    protected set source(value: FeatureBlendJS.Models.BaseModel);
	    protected get globals(): FeatureBlendJS.Environment.GlobalEnvironment;
	    protected get subscribers(): Array<Jade.EventBusSubscription>;
	    protected onDestroy(e: any): void;
	    private ensureSubscribers;
	}
}
 namespace FeatureBlendJS.Views {
 	export declare enum CssClass {
	    InputSelected = "-fb-input-selected"
	}
}
 namespace FeatureBlendJS.Views {
 	declare let Jade: typeof globalThis.Jade;
	export interface IEditorBaseOptions extends Jade.UI.IControlOptions {
	    focus: () => void;
	}
	export class EditorBase extends Jade.UI.Control {
	    constructor(options: IEditorBaseOptions);
	    private get focusCallback();
	    focus(): void;
	    protected onValidationErrors(): void;
	}
	export interface IEditorBaseOfOptions extends IEditorBaseOptions {
	    source: FeatureBlendJS.Models.EditorModel;
	}
	export class EditorBaseOf<TModel extends FeatureBlendJS.Models.EditorModel> extends EditorBase {
	    private m_source;
	    constructor(options: IEditorBaseOfOptions);
	    get source(): TModel;
	    protected get feature(): FeatureBlendJS.Models.FeatureModel;
	    protected get featureGroup(): FeatureBlendJS.Models.GroupModel;
	    protected get featureSet(): FeatureBlendJS.Models.SetModel;
	    protected get globals(): FeatureBlendJS.Environment.GlobalEnvironment;
	    protected get locals(): FeatureBlendJS.Environment.GroupEnvironment;
	    protected onCreated(): void;
	}
	export {};
}
 namespace FeatureBlendJS.Views {
 	export interface IMacroEditorBaseOptions extends FeatureBlendJS.Views.IEditorBaseOfOptions {
	    fill?: boolean;
	}
	export class MacroEditorBase extends FeatureBlendJS.Views.EditorBaseOf<FeatureBlendJS.Models.MacroEditorModel> {
	    constructor(options: IMacroEditorBaseOptions);
	    protected get fill(): boolean;
	    protected get isPrimaryEditor(): boolean;
	    resize(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onCommit(): void;
	    protected onResized(): void;
	}
}
 namespace FeatureBlendJS.Views {
 	export class MicroEditorBase extends FeatureBlendJS.Views.EditorBaseOf<FeatureBlendJS.Models.MicroEditorModel> {
	    constructor(options: FeatureBlendJS.Views.IEditorBaseOfOptions);
	    focus(): void;
	    protected onCommit(): void;
	}
}
 namespace FeatureBlendJS.Views {
 	export declare enum FeatureBlendLayoutType {
	    Panels = "Panels",
	    Tabbed = "Tabbed",
	    Simple = "Simple"
	}
	export interface IFeatureBlendViewOptions {
	    layout: FeatureBlendLayoutType;
	}
	export class FeatureBlendView extends Jade.UI.Control {
	    private m_layout;
	    private m_source;
	    constructor(options: IFeatureBlendViewOptions);
	    private get layout();
	    private set layout(value);
	    private get layoutType();
	    protected get source(): FeatureBlendJS.Models.RootModel;
	    protected set source(value: FeatureBlendJS.Models.RootModel);
	    loadModel(model: FeatureBlendJS.Models.RootModel): void;
	    commit(): void;
	    loadErrors(errors?: Array<FeatureBlendJS.Data.IErrorData>): void;
	    private layout_init;
	    private ensureLayout;
	}
}
 namespace FeatureBlendJS.Views {
 	export interface IBaseViewOptions extends Jade.UI.IControlOptions {
	    eventBus?: GlobalEvents;
	}
	export class BaseView extends Jade.UI.Control {
	    private m_eventBus;
	    constructor(options: IBaseViewOptions);
	    protected get eventBus(): GlobalEvents;
	}
}
 namespace FeatureBlendJS.Views {
 	export declare function inject(id: string, path: string): void;
}
 namespace FeatureBlendJS.Views {
 	export declare function containsTags(text: string): boolean;
	export declare function replaceTags(text: string): string;
}
 namespace FeatureBlendJS.Views.Editors {
 	export declare enum RichTextEditorEvents {
	    BackgroundColorNeeded = "background-color/needed",
	    BackgroundColorUpdate = "background-color/update"
	}
	export class RichTextEditor extends FeatureBlendJS.Views.MacroEditorBase {
	    private m_mce;
	    private get containerNode();
	    private get mceNode();
	    private get mce();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    focus(): void;
	    onViewResized(): void;
	    private editor_init;
	    private editor_loadContent;
	    private editor_onChange;
	    private setMceBackgroundColor;
	    private setMceInitialBackgroundColor;
	    private editor_size;
	}
}
 namespace FeatureBlendJS.Views.Editors {
 	export class ColorEditor extends FeatureBlendJS.Views.MicroEditorBase {
	    private m_popup;
	    private get buttonNode();
	    private get inputNode();
	    private get swatchNode();
	    private get popup();
	    get value(): string;
	    set value(value: string);
	    get inputValue(): string;
	    template(): string | Array<string> | JQuery;
	    focus(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private popup_init;
	    private onColorChange;
	}
	export declare function isValidColor(value: string): boolean;
}
 namespace FeatureBlendJS.Views.Editors {
 	export interface IColorChangeEventArgs {
	    color: string;
	}
	export interface IColorEditorPopUpOptions extends Jade.UI.IControlOptions {
	    handle: JQuery;
	    editor: FeatureBlendJS.Views.Editors.ColorEditor;
	    change?: (e: IColorChangeEventArgs) => void;
	}
	export class ColorEditorPopUp extends Jade.UI.Control {
	    private m_handle;
	    private m_editor;
	    constructor(options: IColorEditorPopUpOptions);
	    private get editor();
	    private get handle();
	    private get colorPickerNode();
	    private get colorPicker();
	    private get changeCallback();
	    private get rInput();
	    private get gInput();
	    private get bInput();
	    private get hexInput();
	    private get editorValue();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private rInput_onChange;
	    private gInput_onChange;
	    private bInput_onChange;
	    private hexInput_onChange;
	    private popup_init;
	    private popup_onShow;
	    private colorpicker_init;
	    private colorpicker_onChange;
	    private updateColorInputs;
	    private updateHex;
	    private updateRGB;
	}
}
 namespace FeatureBlendJS.Views.Editors {
 	export class FormatEditor extends FeatureBlendJS.Views.MicroEditorBase {
	    private get inputNode();
	    private get sampleNode();
	    private get formatType();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private input_onKeyUp;
	    private input_onBlur;
	    private getSampleValue;
	    private getSampleValueFormatted;
	    private hideError;
	    private showError;
	}
}
 namespace FeatureBlendJS.Views.Editors {
 	export class IconEditor {
	}
}
 namespace FeatureBlendJS.Views.Editors {
 	export class IntegerEditor extends FeatureBlendJS.Views.MicroEditorBase {
	    private get inputNode();
	    private get inputValue();
	    private get inputRawValue();
	    template(): string | Array<string> | JQuery;
	    focus(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	}
}
 namespace FeatureBlendJS.Views.Editors {
 	interface IListItem {
	    name: string;
	    value: any;
	}
	export class ListEditorBase extends FeatureBlendJS.Views.MicroEditorBase {
	    protected get items(): Array<IListItem>;
	    protected get listId(): string;
	}
	export class ListEditor extends ListEditorBase {
	    get selectNode(): JQuery;
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    focus(): void;
	}
	export {};
}
 namespace FeatureBlendJS.Views.Editors {
 	export class SelectionListEditor {
	}
}
 namespace FeatureBlendJS.Views.Editors {
 	export class TextAreaEditor extends FeatureBlendJS.Views.MicroEditorBase {
	    private get allowsTags();
	    private get inputNode();
	    private get maskInputNode();
	    template(): string | Array<string> | JQuery;
	    focus(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected syncScrollPositions(): void;
	}
}
 namespace FeatureBlendJS.Views.Editors {
 	export class ViewEditor extends FeatureBlendJS.Views.MicroEditorBase {
	    private get buttonNode();
	    private get inputNode();
	    get inputValue(): string;
	    set inputValue(value: string);
	    template(): string | Array<string> | JQuery;
	    focus(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private showViewEditorDialog;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface IContentOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.ContextModel;
	}
	export class Content extends FeatureBlendJS.Views.BaseView {
	    constructor(options: IContentOptions);
	    protected get source(): FeatureBlendJS.Models.ContextModel;
	    protected get assemblers(): Jade.Collection<FeatureBlendJS.Views.AssemblerView>;
	    template(): string | Array<string> | JQuery;
	    selectGroup(groupId: string): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private generateGroupViews;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export class LayoutView extends FeatureBlendJS.Views.Layout.LayoutViewBase {
	    private m_navigation;
	    private m_content;
	    template(): string | Array<string> | JQuery;
	    protected onLoadModel(): void;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export declare type NavigationOrientation = "horizontal" | "vertical";
	export interface INavigationOptions extends Jade.UI.IControlOptions {
	    source: FeatureBlendJS.Models.ContextModel;
	    orientation?: NavigationOrientation;
	}
	export class Navigation extends FeatureBlendJS.Views.BaseView {
	    private m_observer;
	    private m_overflow;
	    constructor(options: INavigationOptions);
	    protected get source(): FeatureBlendJS.Models.ContextModel;
	    private get orientation();
	    private get itemsNode();
	    private get items();
	    protected get overflowNode(): JQuery;
	    protected get overflow(): FeatureBlendJS.Views.Layout.NavigationOverflow;
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: any): void;
	    protected onComplete(e: any): void;
	    protected onDestroy(e: any): void;
	    private onResize;
	    private overflow_init;
	    private addResizeObserver;
	    private selectDefaultNavigation;
	    private scrollIntoView;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface INavigationItemOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.GroupModel;
	}
	export class NavigationItem extends FeatureBlendJS.Views.BaseView {
	    private m_selectEventSubscription;
	    constructor(options: INavigationItemOptions);
	    get source(): FeatureBlendJS.Models.GroupModel;
	    template(): string | Array<string> | JQuery;
	    select(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onDestroy(e: Jade.UI.ControlEventArgs): void;
	    private processValidationErrors;
	    private addValidationErrorSummary;
	    private onSelect;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface IToolbarOverflowOptions extends Jade.UI.IControlOptions {
	}
	export class NavigationOverflow extends Jade.UI.Control {
	    private m_menu;
	    constructor(options: IToolbarOverflowOptions);
	    get anchor(): JQuery;
	    get imageNode(): JQuery;
	    protected get menu(): FeatureBlendJS.Views.Layout.PopUp;
	    protected set menu(value: FeatureBlendJS.Views.Layout.PopUp);
	    protected get menuNode(): JQuery;
	    template(): string;
	    onActivate(e: any): void;
	    update(items: Array<FeatureBlendJS.Views.Layout.NavigationItem>): void;
	    show(): void;
	    hide(): void;
	    protected onDestroy(e: any): void;
	    private createMenu;
	    private onClick;
	    private getIcon;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface IToolbarOverflowItemOptions extends IPopUpItemOptions {
	    source: GroupModel;
	}
	export class NavigationOverflowItem extends PopUpItem {
	    private m_selectEventSubscription;
	    private m_source;
	    constructor(options: IToolbarOverflowItemOptions);
	    get source(): GroupModel;
	    template(): string;
	    protected onActivate(e: any): void;
	    private onSelect;
	    private processValidationErrors;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface ILayoutViewBaseOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    cssClass?: string;
	}
	export class LayoutViewBase extends FeatureBlendJS.Views.BaseView {
	    constructor(options: ILayoutViewBaseOptions);
	    protected get source(): FeatureBlendJS.Models.ContextModel;
	    protected set source(value: FeatureBlendJS.Models.ContextModel);
	    protected get cssClass(): string;
	    protected get controller(): FeatureBlendJS.Models.ControllerModel;
	    protected onLoadModel(): void;
	    loadModel(model: FeatureBlendJS.Models.RootModel): void;
	    commit(): void;
	    loadErrors(errors?: Array<FeatureBlendJS.Data.IErrorData>): void;
	    clearErrors(errors?: Array<FeatureBlendJS.Data.IErrorData>): void;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface IContentOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.SetModel;
	}
	export class TabbedContent extends FeatureBlendJS.Views.BaseView {
	    constructor(options: IContentOptions);
	    protected get source(): FeatureBlendJS.Models.SetModel;
	    protected get assemblers(): Jade.Collection<FeatureBlendJS.Views.AssemblerView>;
	    template(): string | Array<string> | JQuery;
	    selectGroup(groupId: string): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private generateGroupViews;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface ILayoutOptions extends Jade.UI.IControlOptions {
	}
	export class PanelsLayoutView extends FeatureBlendJS.Views.Layout.LayoutViewBase {
	    constructor(options: ILayoutOptions);
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface ITabOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    label: string;
	    tabId: string;
	    model: FeatureBlendJS.Models.GroupModel;
	}
	export class PanelTab extends FeatureBlendJS.Views.BaseView {
	    private m_selectEventSubscription;
	    private m_groupModel;
	    constructor(options: ITabOptions);
	    private get label();
	    private get tabId();
	    private get groupModel();
	    private get imgNode();
	    template(): string | Array<string> | JQuery;
	    select(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onDestroy(e: Jade.UI.ControlEventArgs): void;
	    private processValidationErrors;
	    private addValidationErrorSummary;
	    private onSelect;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export class PanelTabStrip extends FeatureBlendJS.Views.BaseView {
	    private get tabsNode();
	    private get tabs();
	    template(): string | Array<string> | JQuery;
	    load(model: FeatureBlendJS.Models.RootModel): void;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface INavigationPopUpOptions extends Jade.UI.IControlOptions {
	    height?: number;
	    width?: number;
	    anchor: JQuery;
	    tipped?: Tipped.ITippedOptions;
	    onCreate?: Function;
	}
	export class PopUp extends Jade.UI.Control {
	    private m_popUpCreated;
	    constructor(options: INavigationPopUpOptions);
	    protected get anchor(): JQuery;
	    get height(): number;
	    get width(): number;
	    get visible(): boolean;
	    get tipped(): Tipped.ITippedOptions;
	    get onCreateCallback(): Function;
	    template(): string | Array<string> | JQuery;
	    show(): void;
	    hide(): void;
	    destroy(): void;
	    protected popUp_onCreate(): void;
	    private ensureTippedPopUp;
	    protected getPopUpOptions(options?: Tipped.ITippedOptions): Tipped.ITippedOptions;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface IPopUpItemOptions extends Jade.UI.IControlOptions {
	    uidMap?: string;
	    labelMap?: string;
	    iconMap?: string;
	    click?: Function;
	    data?: any;
	}
	export class PopUpItem extends Jade.UI.Control {
	    constructor(options: IPopUpItemOptions);
	    get data(): any;
	    get uid(): any;
	    get uidMap(): string;
	    get label(): any;
	    get labelMap(): string;
	    get icon(): any;
	    get iconMap(): string;
	    private get clickCallback();
	    template(): string | Array<string> | JQuery;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected resolveMap(id: string, defaultValue?: any): any;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface IContentOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.ContextModel;
	}
	export class SimpleContentView extends FeatureBlendJS.Views.BaseView {
	    constructor(options: IContentOptions);
	    protected get source(): FeatureBlendJS.Models.ContextModel;
	    protected get assemblers(): Jade.Collection<FeatureBlendJS.Views.AssemblerView>;
	    template(): string | Array<string> | JQuery;
	    selectGroup(groupId: string): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private generateGroupViews;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export class SimpleLayoutView extends FeatureBlendJS.Views.Layout.LayoutViewBase {
	    private m_content;
	    template(): string | Array<string> | JQuery;
	    protected onLoadModel(): void;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface ITabOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    label: string;
	    tabId: string;
	    model: FeatureBlendJS.Models.GroupModel;
	}
	export class Tab extends FeatureBlendJS.Views.BaseView {
	    private m_selectEventSubscription;
	    private m_groupModel;
	    constructor(options: ITabOptions);
	    private get label();
	    private get tabId();
	    private get groupModel();
	    private get imgNode();
	    template(): string | Array<string> | JQuery;
	    select(): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    protected onDestroy(e: Jade.UI.ControlEventArgs): void;
	    private processValidationErrors;
	    private addValidationErrorSummary;
	    private onSelect;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export interface IContentOptions extends FeatureBlendJS.Views.IBaseViewOptions {
	    source: FeatureBlendJS.Models.SetModel;
	}
	export class TabbedContent extends FeatureBlendJS.Views.BaseView {
	    constructor(options: IContentOptions);
	    protected get source(): FeatureBlendJS.Models.SetModel;
	    protected get assemblers(): Jade.Collection<FeatureBlendJS.Views.AssemblerView>;
	    template(): string | Array<string> | JQuery;
	    selectGroup(groupId: string): void;
	    protected onActivate(e: Jade.UI.ControlEventArgs): void;
	    private generateGroupViews;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export class TabbedLayoutView extends FeatureBlendJS.Views.Layout.LayoutViewBase {
	    private m_tabStrip;
	    private m_content;
	    template(): string | Array<string> | JQuery;
	    protected onLoadModel(): void;
	}
}
 namespace FeatureBlendJS.Views.Layout {
 	export class TabStrip extends FeatureBlendJS.Views.BaseView {
	    private get tabsNode();
	    private get tabs();
	    template(): string | Array<string> | JQuery;
	    load(model: FeatureBlendJS.Models.RootModel): void;
	}
}
 