@omnia/velcron 7.0.36-preview

package/models/ViewModelAndContext.d.ts

@@ -0,0 +1,4 @@
+import { VelcronAppDefinition } from "./VelcronDefinitions";
+export interface AppJson {
+    app: VelcronAppDefinition;
+}

package/models/ViewModelAndContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/models/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./VelcronDefinitions";
+export * from "./ViewModelAndContext";
+export * from "./VelcronDescriptors";
+export * from "./VelcronEvents";
+export * from "./VelcronTypes";
+export * from "./Enums";
+export * from "./VelcronUnitProvider";

package/models/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./VelcronDefinitions"), exports);
+tslib_1.__exportStar(require("./ViewModelAndContext"), exports);
+tslib_1.__exportStar(require("./VelcronDescriptors"), exports);
+tslib_1.__exportStar(require("./VelcronEvents"), exports);
+tslib_1.__exportStar(require("./VelcronTypes"), exports);
+tslib_1.__exportStar(require("./Enums"), exports);
+tslib_1.__exportStar(require("./VelcronUnitProvider"), exports);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@omnia/velcron",
+  "license": "MIT",
+  "version": "7.0.36-preview",
+  "description": "Provide Omnia Velcron Stuffs.",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/preciofishbone/OmniaFx"
+  },
+  "keywords": [
+    "omnia",
+    "omniafx",
+    "extension",
+    "office365",
+    "sharepoint"
+  ],
+  "author": "Precio Fishbone",
+  "dependencies": {},
+  "typings": "./index.d.ts",
+  "bugs": {
+    "url": "https://github.com/preciofishbone/OmniaFx/issues"
+  },
+  "homepage": "https://github.com/preciofishbone/OmniaFx#readme"
+}

package/parser/TextValue.d.ts

@@ -0,0 +1,4 @@
+export declare class TextValue {
+    value: string;
+    constructor(val: any);
+}

package/parser/TextValue.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextValue = void 0;
+class TextValue {
+    constructor(val) {
+        this.value = val;
+    }
+}
+exports.TextValue = TextValue;

package/parser/VelcronActions.d.ts

@@ -0,0 +1,36 @@
+import { VelcronAction, VelcronActionWithAutoAwait, VelcronRenderContext, DeferredPromise } from "../models";
+import { IActionHandler } from "../actions";
+export declare class VelcronActions {
+    static _actionHandlers: {
+        [name: string]: IActionHandler;
+    } | null;
+    static registerAction(name: string, handler: IActionHandler): void;
+    static parseAndExecuteActions(templates: Array<string>, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): void;
+    static parseFunction(target: {
+        [name: string]: [];
+    }, template: string, renderContext: VelcronRenderContext, params: Array<VelcronActionParameterValue>, foundCb: (name: string, params: {}) => void): void;
+    static getActionFromTemplate(partialTemplate: string, eventId: string, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): VelcronAction;
+    static valueIsAction(value: string): boolean;
+    static executeActions(arr: any, x: any, customActionContext?: VelcronCustomActionExecutionContext): void;
+    static executeAction(awAction: VelcronActionWithAutoAwait, callback: (continueExecution: boolean) => void): void;
+    static dataBindComputed(renderContext: VelcronRenderContext, template: string): string;
+    static parseAndExecuteComputed(renderContext: VelcronRenderContext, template: string): string;
+    private static extractParameterValues;
+}
+interface VelcronActionParameterValue {
+    dataType: VelcronActionParameterDataType;
+    value: any;
+}
+export declare enum VelcronActionParameterDataType {
+    text = 0,
+    number = 1,
+    boolean = 2,
+    pointer = 3
+}
+interface VelcronCustomActionExecutionContext {
+    customAction: VelcronAction | null;
+    parentAction: VelcronAction | VelcronRenderContext;
+    variables: object;
+    returnValue: DeferredPromise<any>;
+}
+export {};

package/parser/VelcronActions.js

@@ -0,0 +1,443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronActionParameterDataType = exports.VelcronActions = void 0;
+const tslib_1 = require("tslib");
+const models_1 = require("../models");
+const VelcronConstants_1 = require("./VelcronConstants");
+const VelcronData_1 = require("./VelcronData");
+const builtInHandlers = tslib_1.__importStar(require("../actions"));
+const ActionResults_1 = require("../actions/ActionResults");
+const VelcronLogger_1 = require("./VelcronLogger");
+class VelcronActions {
+    static registerAction(name, handler) {
+        name = name.toLowerCase();
+        if (this._actionHandlers && this._actionHandlers[name]) {
+            VelcronLogger_1.VelcronLogger.logActionError(`The action handler with name ${name} is already registered`);
+        }
+        else if (this._actionHandlers) {
+            this._actionHandlers[name] = handler;
+        }
+    }
+    static parseAndExecuteActions(templates, renderContext, customActionContext) {
+        if (!templates) {
+            VelcronLogger_1.VelcronLogger.logActionError("The event template is empty");
+            return;
+        }
+        const actions = [];
+        let template = "";
+        let count = 1;
+        templates.forEach((temp) => {
+            temp = temp.trim();
+            if (temp.startsWith("=>")) {
+                temp = temp.substring(2);
+            }
+            template = template + temp + (count === templates.length ? "" : " => ");
+            count++;
+        });
+        const evIdEnd = template.indexOf(VelcronConstants_1.VelcronConstants.events.idTokenEnd);
+        const evId = template.substring(VelcronConstants_1.VelcronConstants.events.idTokenStart.length, evIdEnd);
+        template = template.substring(evIdEnd + 1);
+        for (const partialTemplate of template.split("=>")) {
+            if (partialTemplate) {
+                const res = VelcronActions.getActionFromTemplate(partialTemplate, evId, renderContext, customActionContext);
+                if (res) {
+                    actions.push(res);
+                }
+            }
+        }
+        if (actions.length > 0) {
+            if (customActionContext) {
+                customActionContext.customAction = renderContext;
+                if (customActionContext.variables) {
+                    VelcronData_1.VelcronData.setVariables(evId, customActionContext.variables);
+                }
+            }
+            VelcronActions.executeActions(actions, 0, customActionContext);
+            //Clean up temp variables after execution
+            VelcronData_1.VelcronData.deleteVariables(evId);
+        }
+    }
+    static parseFunction(target, template, renderContext, params, foundCb) {
+        //Supports parsing Action or Computed functions
+        let actionExists = false;
+        //Support custom actions
+        if (target) {
+            Object.keys(target).forEach((acName) => {
+                const actionMustMatch = `${template}(`;
+                if (actionMustMatch === acName.substring(0, actionMustMatch.length)) {
+                    actionExists = true;
+                    let actionName = acName;
+                    const funcParams = {};
+                    if (actionName.indexOf("(")) {
+                        //Action having params @myAction(text,isTrue)
+                        actionName = acName.substring(0, actionName.indexOf("("));
+                        const paramTemplate = acName.substring(actionName.length + 1).replace(")", "");
+                        if (paramTemplate.indexOf(",")) {
+                            const par = paramTemplate.split(",");
+                            let index = 0;
+                            par.forEach((parVal) => {
+                                parVal = parVal.replace(" /g", "").replace("\"/g", "");
+                                parVal = parVal.trim();
+                                if (funcParams[parVal]) {
+                                    VelcronLogger_1.VelcronLogger.logActionError(`A parameter with name ${parVal} on action with name ${actionName} already exists. Parameters must be unique`);
+                                }
+                                funcParams[parVal] = params[index];
+                                index++;
+                            });
+                        }
+                    }
+                    if (template.indexOf(actionName.substring(1)) > -1) {
+                        foundCb(acName, funcParams);
+                    }
+                }
+            });
+        }
+        if (!actionExists) {
+            VelcronLogger_1.VelcronLogger.logActionError(`Cant find a built-in action, custom action or computed matching name ${template}`);
+        }
+    }
+    static getActionFromTemplate(partialTemplate, eventId, renderContext, customActionContext) {
+        let path = "";
+        let val = "";
+        const result = {
+            id: eventId,
+            type: models_1.VelcronActionTypes.getOrSetValue,
+            ...renderContext
+        };
+        partialTemplate = partialTemplate.trim();
+        if (partialTemplate.trim() === "") {
+            throw "partialTemplate is empty";
+        }
+        //Handle conditional actions e.g unsplashCurrentPage === 1 ? $state.unsplash = res : $state.unsplash.results = @arrayAppend(res.results)
+        let pattern = /\?(?=([^']*'[^']*')*[^']*$)/;
+        let re = new RegExp(pattern);
+        let match = re.exec(partialTemplate);
+        //If we have ? its a conditional but if we have =? its not
+        if (match && partialTemplate.substring(match.index - 1, match.index) !== "=") {
+            result.type = models_1.VelcronActionTypes.condition;
+            result.condition = partialTemplate.substring(0, match.index);
+            //var res = false//VelcronData.evaluateBoolean(evalBoolean, renderContext);
+            const questionMarkIndex = match.index;
+            const subActions = partialTemplate.substring(questionMarkIndex + 1);
+            pattern = /\:(?=([^']*'[^']*')*[^']*$)/;
+            re = new RegExp(pattern);
+            match = re.exec(subActions);
+            if (match) {
+                //Take the second in the conditional match : othervalue = bla
+                result.trueAction =
+                    VelcronActions.getActionFromTemplate(subActions.substring(1, match.index), eventId, renderContext);
+                result.falseAction =
+                    VelcronActions.getActionFromTemplate(subActions.substring(match.index + 1), eventId, renderContext);
+            }
+            else {
+                result.trueAction =
+                    VelcronActions.getActionFromTemplate(subActions, eventId, renderContext);
+            }
+        }
+        if (result.type !== models_1.VelcronActionTypes.condition) {
+            let operator = null;
+            if (!VelcronActions.valueIsAction(partialTemplate)) {
+                let assignOpIndex = -1;
+                let length = 2;
+                if (partialTemplate.indexOf(models_1.AssignOperators.plusEquals) > -1) {
+                    assignOpIndex = partialTemplate.indexOf(models_1.AssignOperators.plusEquals);
+                }
+                else if (partialTemplate.indexOf(models_1.AssignOperators.equalsPlus) > -1) {
+                    assignOpIndex = partialTemplate.indexOf(models_1.AssignOperators.equalsPlus);
+                }
+                else if (partialTemplate.indexOf(models_1.AssignOperators.equalsQuestion) > -1) {
+                    assignOpIndex = partialTemplate.indexOf(models_1.AssignOperators.equalsQuestion);
+                }
+                else if (partialTemplate.indexOf(models_1.AssignOperators.equalsExclamation) > -1) {
+                    assignOpIndex = partialTemplate.indexOf(models_1.AssignOperators.equalsExclamation);
+                }
+                else if (partialTemplate.indexOf(models_1.AssignOperators.equals) > -1) {
+                    length = 1;
+                    assignOpIndex = partialTemplate.indexOf(models_1.AssignOperators.equals);
+                }
+                else {
+                    path = partialTemplate;
+                }
+                if (assignOpIndex > -1) {
+                    //Direct assignment e.g ${loading} = true 
+                    path = partialTemplate.substring(0, assignOpIndex + length).trim();
+                    val = partialTemplate.substring(assignOpIndex + length).trim();
+                    operator = partialTemplate.substring(assignOpIndex, assignOpIndex + length);
+                }
+                else {
+                    path = partialTemplate;
+                }
+            }
+            else {
+                //Not setting a var just calling an action like await @delay(5000)
+                val = partialTemplate;
+            }
+            if (VelcronActions.valueIsAction(val)) {
+                //Action e.g await @http.get('https://localhost:4455/api/weather')
+                //All actions is auto awaited by default which i think should be the normal case 
+                //in a modern language :) you can use => nowait @http.get to not wait for the async
+                //operation to complete.
+                if (val.startsWith("nowait")) {
+                    result.nowait = true;
+                    val = val.substring(6);
+                }
+                result.type = models_1.VelcronActionTypes.promise;
+                result.path = path;
+                result.action = val;
+                result.assignOperator = operator;
+            }
+            else if (partialTemplate.startsWith("return")) {
+                result.type = models_1.VelcronActionTypes.returnsValue;
+                result.value = partialTemplate.substring(6).trim();
+            }
+            else {
+                result.type = models_1.VelcronActionTypes.getOrSetValue;
+                result.path = path;
+                result.value = val;
+                result.assignOperator = operator;
+            }
+        }
+        if (customActionContext?.parentAction) {
+            result.parent = customActionContext.parentAction;
+        }
+        return result;
+    }
+    static valueIsAction(value) {
+        return value.startsWith("@") || value.startsWith("await");
+    }
+    static executeActions(arr, x, customActionContext) {
+        //The Callback approach is to be able to wait for a promise to be finished
+        //before the loop continues = await support
+        VelcronActions.executeAction(arr[x], (continueExecution) => {
+            if (continueExecution) {
+                x++;
+            }
+            else {
+                x = arr.length;
+            }
+            if (x < arr.length) {
+                VelcronActions.executeActions(arr, x, customActionContext);
+            }
+            else {
+                //To support waiting for custom actions to finish before continueing
+                if (customActionContext && customActionContext.customAction) {
+                    const returnVal = VelcronData_1.VelcronData.getVariable(VelcronConstants_1.VelcronConstants.events.returnValueVariableName, customActionContext.customAction);
+                    if (returnVal.is) {
+                        customActionContext.returnValue.resolve(returnVal.value);
+                    }
+                    else {
+                        customActionContext.returnValue.resolve(null);
+                    }
+                }
+            }
+        });
+    }
+    static executeAction(awAction, callback) {
+        //Handles actions and support async using callback of promise
+        if (awAction.type === models_1.VelcronActionTypes.condition) {
+            const awAc = awAction;
+            const res = VelcronData_1.VelcronData.evaluateBoolean(awAc.condition, awAc);
+            if (res) {
+                awAction = awAc.trueAction;
+            }
+            else {
+                awAction = awAc.falseAction;
+            }
+        }
+        if (awAction.action) {
+            if (!awAction.action.endsWith(")")) {
+                throw (`Velcron error parsing action: ${awAction.action} it must end with a close parenthesis)`);
+            }
+            if ((awAction.action.split("(").length - 1) + (awAction.action.split(")").length - 1) !== 2) {
+                throw ("Actions must not contain more then 2 parenthesis, e.g @delay(5000)");
+            }
+            const val = awAction.action.substring(awAction.action.indexOf("(") + 1).replace(")", "").trim();
+            const params = VelcronActions.extractParameterValues(val, awAction);
+            let promise = null;
+            const actionName = awAction.action.substring(0, awAction.action.indexOf("(")).trim().toLowerCase();
+            //promise = VelcronActions.runHandler(awAction, actionName, params);
+            if (!VelcronActions._actionHandlers) {
+                VelcronActions._actionHandlers = {};
+                Object.keys(builtInHandlers).forEach((key) => {
+                    const handler = builtInHandlers[key];
+                    if (handler && handler.name && VelcronActions._actionHandlers) {
+                        VelcronActions._actionHandlers[handler.name] = handler;
+                    }
+                });
+            }
+            const paramValues = [];
+            params.forEach(param => paramValues.push(param.value));
+            let hasCustomActionValue = false;
+            if (VelcronActions._actionHandlers[actionName]) {
+                //Built in handler
+                promise = VelcronActions._actionHandlers[actionName].action(awAction, ...paramValues);
+            }
+            else {
+                //Custom handler
+                VelcronActions.parseFunction(awAction.actions, actionName, awAction, paramValues, (acName, params) => {
+                    if (!acName.startsWith("@")) {
+                        throw "Custom action names must start with @";
+                    }
+                    const acArr = awAction.actions[acName];
+                    acArr[0] = VelcronData_1.VelcronData.ensureEventId(acArr[0]);
+                    const customActionContext = {
+                        parentAction: awAction,
+                        customAction: null,
+                        variables: params,
+                        returnValue: VelcronData_1.VelcronData.createDeferredPromise()
+                    };
+                    VelcronActions.parseAndExecuteActions(acArr, awAction, customActionContext);
+                    promise = customActionContext.returnValue.promise;
+                    hasCustomActionValue = true;
+                });
+            }
+            if (!awAction.nowait && promise || hasCustomActionValue && promise) {
+                promise.then((val) => {
+                    let continueExecution = true;
+                    //If action returns StopProcedingActions class in promise we will not continue executing actions
+                    if (val && val instanceof ActionResults_1.CancelProcedingActions) {
+                        continueExecution = false;
+                    }
+                    else if (val && val instanceof ActionResults_1.SkipSetValue) {
+                        //Dont run evaluateSet, it has bee done inside the action
+                    }
+                    else {
+                        if (val) {
+                            VelcronData_1.VelcronData.evaluateSet(awAction.path, val, awAction);
+                        }
+                    }
+                    callback(continueExecution);
+                });
+            }
+            else {
+                callback(true);
+            }
+        }
+        else if (awAction.type === models_1.VelcronActionTypes.returnsValue) {
+            VelcronData_1.VelcronData.evaluateSet(VelcronConstants_1.VelcronConstants.events.returnValueVariableName, awAction.value, awAction);
+            callback(true);
+        }
+        else {
+            VelcronData_1.VelcronData.evaluateSet(awAction.path, awAction.value, awAction);
+            callback(true);
+        }
+    }
+    static dataBindComputed(renderContext, template) {
+        if (typeof template === typeof undefined || template === null) {
+            return;
+        }
+        let text = VelcronActions.parseAndExecuteComputed(renderContext, template);
+        text = VelcronData_1.VelcronData.dataBind(renderContext, text);
+        return text;
+    }
+    static parseAndExecuteComputed(renderContext, template) {
+        VelcronData_1.VelcronData.getTokens(template).forEach(token => {
+            const paramValues = [];
+            VelcronActions.parseFunction(renderContext.computed, token, renderContext, paramValues, (acName, params) => {
+                const funcContent = renderContext.computed[acName];
+                Object.keys(params).forEach((key) => {
+                    params[key] = "currentCtx";
+                });
+                const toReplace = VelcronConstants_1.VelcronConstants.properties.tokenStart + token + VelcronConstants_1.VelcronConstants.properties.tokenEnd;
+                funcContent.forEach((c) => {
+                    //const toEval = `return ${c}`;
+                    const result = VelcronData_1.VelcronData.evauluateJs(c, renderContext, params);
+                    template = template.replace(toReplace, result);
+                });
+            });
+        });
+        return template;
+    }
+    static extractParameterValues(template, action) {
+        const params = [];
+        let hasMoreParams = true;
+        let badCodeDetection = 0;
+        if (!template) {
+            return params;
+        }
+        while (hasMoreParams) {
+            template = template.trim();
+            if (template.startsWith(",")) {
+                template = template.substring(1);
+            }
+            template = template.trim();
+            if (template.startsWith("'")) {
+                //String parameter
+                template = template.substring(1);
+                if (template.indexOf("'") > -1) {
+                    const subVal = template.substring(0, template.indexOf("'"));
+                    params.push({ dataType: 0, value: VelcronData_1.VelcronData.dataBind(action, subVal) });
+                    template = template.substring(subVal.length + 2);
+                }
+                else {
+                    VelcronLogger_1.VelcronLogger.logActionError(`Found an action parameter with a opening ' indicating string but did not find the ending ' on parameter: ${template}`);
+                }
+            }
+            else {
+                let subVal = template;
+                let castedValue;
+                if (subVal.indexOf("'") > -1 || subVal.indexOf(",") > -1) {
+                    subVal = subVal.substring(0, subVal.indexOf(","));
+                }
+                let dataType;
+                subVal = subVal.trim();
+                if (VelcronData_1.VelcronData.isNumber(subVal)) {
+                    dataType = VelcronActionParameterDataType.number;
+                    castedValue = Number.parseInt(subVal);
+                }
+                else if (VelcronData_1.VelcronData.tryParseBoolean(subVal).is) {
+                    dataType = VelcronActionParameterDataType.boolean;
+                    castedValue = VelcronData_1.VelcronData.tryParseBoolean(subVal).value;
+                }
+                else {
+                    //Variable or DataContext binding
+                    dataType = VelcronActionParameterDataType.pointer;
+                    castedValue = subVal;
+                    let rootName = "";
+                    let procedingPath = "";
+                    if (castedValue.indexOf(".") > -1) {
+                        rootName = castedValue.substring(0, castedValue.indexOf("."));
+                        procedingPath = castedValue.substring(castedValue.indexOf(".") + 1);
+                    }
+                    else {
+                        rootName = castedValue;
+                    }
+                    const isVar = VelcronData_1.VelcronData.getVariable(rootName, action);
+                    if (isVar.is) {
+                        //Its a variable
+                        if (procedingPath) {
+                            castedValue = VelcronData_1.VelcronData.getOrSetObjectByPath(isVar.value, procedingPath);
+                        }
+                        else {
+                            castedValue = isVar.value;
+                        }
+                    }
+                    else {
+                        //Try get it from ViewModel
+                        castedValue = VelcronData_1.VelcronData.getOrSetObjectByPathUsingRenderContext(action, castedValue);
+                    }
+                }
+                params.push({ dataType: dataType, value: castedValue });
+                template = template.substring(subVal.length);
+            }
+            if (template.length < 2) {
+                hasMoreParams = false;
+            }
+            if (badCodeDetection > 50) {
+                hasMoreParams = false;
+                VelcronLogger_1.VelcronLogger.logActionError("Bad parameter code detected! If you see this error please contact Andii :)");
+            }
+            badCodeDetection++;
+        }
+        return params;
+    }
+}
+exports.VelcronActions = VelcronActions;
+VelcronActions._actionHandlers = null;
+var VelcronActionParameterDataType;
+(function (VelcronActionParameterDataType) {
+    VelcronActionParameterDataType[VelcronActionParameterDataType["text"] = 0] = "text";
+    VelcronActionParameterDataType[VelcronActionParameterDataType["number"] = 1] = "number";
+    VelcronActionParameterDataType[VelcronActionParameterDataType["boolean"] = 2] = "boolean";
+    VelcronActionParameterDataType[VelcronActionParameterDataType["pointer"] = 3] = "pointer";
+})(VelcronActionParameterDataType = exports.VelcronActionParameterDataType || (exports.VelcronActionParameterDataType = {}));

package/parser/VelcronConstants.d.ts

@@ -0,0 +1,29 @@
+export declare const VelcronConstants: {
+    components: {
+        app: string;
+        view: string;
+        card: string;
+        text: string;
+        image: string;
+        button: string;
+        textInput: string;
+        progressCircle: string;
+        webView: string;
+        dialog: string;
+        flexView: string;
+        icon: string;
+        chip: string;
+    };
+    events: {
+        idTokenStart: string;
+        idTokenEnd: string;
+        returnValueVariableName: string;
+    };
+    state: {
+        stateRootToken: string;
+    };
+    properties: {
+        tokenStart: string;
+        tokenEnd: string;
+    };
+};

package/parser/VelcronConstants.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronConstants = void 0;
+exports.VelcronConstants = {
+    components: {
+        app: "App",
+        view: "View",
+        card: "Card",
+        text: "Text",
+        image: "Image",
+        button: "Button",
+        textInput: "TextInput",
+        progressCircle: "ProgressCircle",
+        webView: "WebView",
+        dialog: "Dialog",
+        flexView: "FlexView",
+        icon: "Icon",
+        chip: "Chip"
+    },
+    events: {
+        idTokenStart: "$ev{",
+        idTokenEnd: "}",
+        returnValueVariableName: "$returnValue"
+    },
+    state: {
+        stateRootToken: "$state"
+    },
+    properties: {
+        tokenStart: "${",
+        tokenEnd: "}"
+    }
+};

package/parser/VelcronData.d.ts

@@ -0,0 +1,39 @@
+import { VelcronAppDefinition, VelcronDefinition, VelcronRenderContext, DeferredPromise } from "../models";
+export interface ParseResult<T> {
+    is: boolean;
+    value: T;
+}
+export declare class VelcronData {
+    static dataBind(renderContext: VelcronRenderContext, text: string): string;
+    static addCtxToVariableNames(template: string, skipIfNameStartsWith?: string, skipIfNameMatches?: Array<string>, overridePrefixWhenNameMatches?: {
+        [name: string]: string;
+    }): string;
+    static evauluateJs(template: string, renderContext: VelcronRenderContext, overrideNamesMatching?: {}): any;
+    private static variables;
+    static deleteVariables(id: string): void;
+    static getVariable<T>(name: string, renderContext: VelcronRenderContext): ParseResult<T>;
+    static setVariables(eventId: string, varsToSet: object): void;
+    static evaluateSet(path: string, value: any, renderContext: VelcronRenderContext): void;
+    static evaluateArray(template: string, renderContext: VelcronRenderContext): Array<any> | null;
+    static evaluateBoolean(template: string | Boolean, renderContext: VelcronRenderContext): boolean | null;
+    static tryParseBoolean(bool: any): ParseResult<boolean | null>;
+    static isString(text: any): boolean;
+    static isBoolean(value: any): boolean;
+    static isNumber(value: any): boolean;
+    static isUndefined(value: any): boolean;
+    static isArray(obj: any): obj is ExtendArray;
+    static isObject(value: any): boolean;
+    static extendObject(obj: any): any;
+    static getOrSetObjectByPath<T>(object: Object, path: string, value?: any): T | null;
+    static getOrSetObjectByPathUsingRenderContext<T>(renderContext: VelcronRenderContext, path: string, value?: any): T;
+    static getTokens(template: any): string[];
+    static ensureEventId(event: string): string;
+    static ensureKeys(ui: VelcronDefinition | VelcronAppDefinition, generateNewKeys?: boolean): void;
+    static removeKeys(ui: VelcronDefinition | VelcronAppDefinition): void;
+    static generateId(): string;
+    static createDeferredPromise<T>(): DeferredPromise<T>;
+}
+interface ExtendArray extends Array<any> {
+    take: (amount: number) => Array<any>;
+}
+export {};