@aemforms/af-core 0.15.0

package/lib/FormInstance.js

@@ -0,0 +1,116 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchForm = exports.validateFormInstance = exports.createFormInstance = void 0;
+const Form_1 = __importStar(require("./Form"));
+const JsonUtils_1 = require("./utils/JsonUtils");
+const Fetch_1 = require("./utils/Fetch");
+const RuleEngine_1 = __importDefault(require("./rules/RuleEngine"));
+const EventQueue_1 = __importDefault(require("./controller/EventQueue"));
+/**
+ * Creates form instance using form model definition as per `adaptive form specification`
+ * @param formModel form model definition
+ * @param callback a callback that recieves the FormModel instance that gets executed before any event in the Form
+ * is executed
+ * @param logLevel Logging Level for the form. Setting it off will disable the logging
+ * @param fModel existing form model, this is additional optimization to prevent creation of form instance
+ * @returns {@link FormModel | form model}
+ */
+const createFormInstance = (formModel, callback, logLevel = 'error', fModel = undefined) => {
+    try {
+        let f = fModel;
+        if (f == null) {
+            f = new Form_1.default(Object.assign({}, formModel), new RuleEngine_1.default(), new EventQueue_1.default(new Form_1.Logger(logLevel)), logLevel);
+        }
+        const formData = formModel === null || formModel === void 0 ? void 0 : formModel.data;
+        if (formData) {
+            f.importData(formData);
+        }
+        if (typeof callback === 'function') {
+            callback(f);
+        }
+        // Once the field or panel is initialized, execute the initialization script
+        // this means initialization happens after prefill and restore
+        // Before execution of calcExp, visibleExp, enabledExp, validate, options, navigationChange, we execute init script
+        //f.queueEvent(new Initialize(undefined, true));
+        //f.queueEvent(new ExecuteRule(undefined, true));
+        f.getEventQueue().runPendingQueue();
+        return f;
+    }
+    catch (e) {
+        console.error(`Unable to create an instance of the Form ${e}`);
+        throw new Error(e);
+    }
+};
+exports.createFormInstance = createFormInstance;
+/**
+ * Validates Form model definition with the given data
+ * @param formModel     form model definition
+ * @param data          form data
+ * @returns `true`, if form is valid against the given form data, `false` otherwise
+ */
+const validateFormInstance = (formModel, data) => {
+    try {
+        const f = new Form_1.default(Object.assign({}, formModel), new RuleEngine_1.default());
+        if (data) {
+            f.importData(data);
+        }
+        return f.validate().length === 0;
+    }
+    catch (e) {
+        throw new Error(e);
+    }
+};
+exports.validateFormInstance = validateFormInstance;
+/**
+ * Helper API to fetch form model definition from an AEM instance
+ * @param url       URL of the instance
+ * @param headers   HTTP headers to pass to the aem instance
+ * @returns promise which resolves to the form model definition
+ */
+const fetchForm = (url, headers = {}) => {
+    const headerObj = new Headers();
+    Object.entries(headers).forEach(([key, value]) => {
+        headerObj.append(key, value);
+    });
+    return (0, Fetch_1.request)(`${url}.model.json`, null, { headers }).then((formObj) => {
+        if ('model' in formObj) {
+            const { model } = formObj;
+            formObj = model;
+        }
+        return (0, JsonUtils_1.jsonString)(formObj);
+    });
+};
+exports.fetchForm = fetchForm;

package/lib/FormMetaData.d.ts

@@ -0,0 +1,11 @@
+import { FormMetaDataModel, MetaDataJson } from './types';
+import Node from './Node';
+/**
+ * Defines form metadata which implements {@link FormMetaDataModel | Form MetaData Model}
+ */
+declare class FormMetaData extends Node<MetaDataJson> implements FormMetaDataModel {
+    get version(): string;
+    get locale(): string;
+    get grammar(): string;
+}
+export default FormMetaData;

package/lib/FormMetaData.js

@@ -0,0 +1,28 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("./Node"));
+/**
+ * Defines form metadata which implements {@link FormMetaDataModel | Form MetaData Model}
+ */
+class FormMetaData extends Node_1.default {
+    get version() {
+        return this.getP('version', '');
+    }
+    get locale() {
+        return this.getP('locale', '');
+    }
+    get grammar() {
+        return this.getP('grammar', '');
+    }
+}
+exports.default = FormMetaData;

package/lib/Node.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Defines generic form object class which any form runtime model (like textbox, checkbox etc)
+ * should extend from.
+ * @typeparam T type of the node (for example, {@link MetaDataJson | form meta data}
+ */
+declare class Node<T> {
+    protected _jsonModel: T;
+    constructor(inputModel: T);
+    protected getP<S>(key: string, def: S): S;
+    get isContainer(): boolean;
+}
+export default Node;

package/lib/Node.js

@@ -0,0 +1,27 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const JsonUtils_1 = require("./utils/JsonUtils");
+/**
+ * Defines generic form object class which any form runtime model (like textbox, checkbox etc)
+ * should extend from.
+ * @typeparam T type of the node (for example, {@link MetaDataJson | form meta data}
+ */
+class Node {
+    constructor(inputModel) {
+        this._jsonModel = Object.assign({}, inputModel);
+    }
+    getP(key, def) {
+        return (0, JsonUtils_1.getProperty)(this._jsonModel, key, def);
+    }
+    get isContainer() {
+        return false;
+    }
+}
+exports.default = Node;

package/lib/Scriptable.d.ts

@@ -0,0 +1,27 @@
+import { Action, RulesJson, ScriptableField } from './types';
+import { BaseNode } from './BaseNode';
+declare abstract class Scriptable<T extends RulesJson> extends BaseNode<T> implements ScriptableField {
+    private _events;
+    private _rules;
+    get rules(): import("./types").Items<string>;
+    private getCompiledRule;
+    private getCompiledEvent;
+    private applyUpdates;
+    protected executeAllRules(context: any): void;
+    private getExpressionScope;
+    private executeEvent;
+    /**
+     * Executes the given rule
+     * @param event
+     * @param context
+     * @private
+     */
+    executeRule(event: Action, context: any): void;
+    executeExpression(expr: string): any;
+    /**
+     * Executes the given action
+     * @param action    {@link Action | event object}
+     */
+    executeAction(action: Action): void;
+}
+export default Scriptable;

package/lib/Scriptable.js

@@ -0,0 +1,216 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseNode_1 = require("./BaseNode");
+/**
+ * Defines scriptable aspects (ie rules, events) of form runtime model. Any form runtime object which requires
+ * execution of rules/events should extend from this class.
+ */
+const dynamicProps = ['label',
+    'enum',
+    'enumNames',
+    'enforceEnum',
+    'exclusiveMinimum',
+    'exclusiveMaximum',
+    'maxLength',
+    'maximum',
+    'maxItems',
+    'minLength',
+    'minimum',
+    'minItems',
+    'required',
+    'step',
+    'description',
+    'properties',
+    'readOnly',
+    'value',
+    'visible',
+    'enabled',
+    'placeholder'];
+class Scriptable extends BaseNode_1.BaseNode {
+    constructor() {
+        super(...arguments);
+        this._events = {};
+        this._rules = {};
+    }
+    get rules() {
+        return this._jsonModel.rules || {};
+    }
+    getCompiledRule(eName, rule) {
+        if (!(eName in this._rules)) {
+            const eString = rule || this.rules[eName];
+            if (typeof eString === 'string' && eString.length > 0) {
+                try {
+                    this._rules[eName] = this.ruleEngine.compileRule(eString);
+                }
+                catch (e) {
+                    this.form.logger.error(`Unable to compile rule \`"${eName}" : "${eString}"\` Exception : ${e}`);
+                }
+            }
+            else {
+                throw new Error(`only expression strings are supported. ${typeof (eString)} types are not supported`);
+            }
+        }
+        return this._rules[eName];
+    }
+    getCompiledEvent(eName) {
+        var _a;
+        if (!(eName in this._events)) {
+            let eString = (_a = this._jsonModel.events) === null || _a === void 0 ? void 0 : _a[eName];
+            if (typeof eString === 'string' && eString.length > 0) {
+                eString = [eString];
+            }
+            if (typeof eString !== 'undefined' && eString.length > 0) {
+                this._events[eName] = eString.map(x => {
+                    try {
+                        return this.ruleEngine.compileRule(x);
+                    }
+                    catch (e) {
+                        this.form.logger.error(`Unable to compile expression \`"${eName}" : "${eString}"\` Exception : ${e}`);
+                    }
+                    return null;
+                }).filter(x => x !== null);
+            }
+        }
+        return this._events[eName] || [];
+    }
+    applyUpdates(updates) {
+        Object.entries(updates).forEach(([key, value]) => {
+            // @ts-ignore
+            // the first check is to disable accessing this.value & this.items property
+            // otherwise that will trigger dependency tracking
+            if (key in dynamicProps || (key in this && typeof this[key] !== 'function')) {
+                try {
+                    // @ts-ignore
+                    this[key] = value;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        });
+    }
+    executeAllRules(context) {
+        const entries = Object.entries(this.rules);
+        if (entries.length > 0) {
+            const scope = this.getExpressionScope();
+            const values = entries.map(([prop, rule]) => {
+                const node = this.getCompiledRule(prop, rule);
+                let newVal;
+                if (node) {
+                    newVal = this.ruleEngine.execute(node, scope, context, true);
+                    if (dynamicProps.indexOf(prop) > -1) {
+                        //@ts-ignore
+                        this[prop] = newVal;
+                    }
+                }
+                return [];
+            }).filter(x => x.length == 2);
+            this.applyUpdates(Object.fromEntries(values));
+        }
+    }
+    getExpressionScope() {
+        var _a;
+        const target = {
+            self: this.getRuleNode(),
+            siblings: ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.ruleNodeReference()) || {}
+        };
+        const scope = new Proxy(target, {
+            get: (target, prop) => {
+                if (prop === Symbol.toStringTag) {
+                    return 'Object';
+                }
+                prop = prop;
+                // The order of resolution is
+                // 1. property
+                // 2. sibling
+                // 3. child
+                if (prop.startsWith('$')) {
+                    //this returns children as well, so adding an explicit check for property name
+                    return target.self[prop];
+                }
+                else {
+                    if (prop in target.siblings) {
+                        return target.siblings[prop];
+                    }
+                    else {
+                        return target.self[prop];
+                    }
+                }
+            },
+            has: (target, prop) => {
+                prop = prop;
+                const selfPropertyOrChild = target.self[prop];
+                const sibling = target.siblings[prop];
+                return typeof selfPropertyOrChild != 'undefined' || typeof sibling != 'undefined';
+            }
+        });
+        return scope;
+    }
+    executeEvent(context, node) {
+        let updates;
+        if (node) {
+            updates = this.ruleEngine.execute(node, this.getExpressionScope(), context);
+        }
+        if (typeof updates !== 'undefined') {
+            this.applyUpdates(updates);
+        }
+    }
+    /**
+     * Executes the given rule
+     * @param event
+     * @param context
+     * @private
+     */
+    executeRule(event, context) {
+        if (typeof event.payload.ruleName === 'undefined') {
+            this.executeAllRules(context);
+        }
+    }
+    executeExpression(expr) {
+        const ruleContext = {
+            'form': this.form,
+            '$form': this.form.getRuleNode(),
+            '$field': this.getRuleNode(),
+            'field': this
+        };
+        const node = this.ruleEngine.compileRule(expr);
+        return this.ruleEngine.execute(node, this.getExpressionScope(), ruleContext);
+    }
+    /**
+     * Executes the given action
+     * @param action    {@link Action | event object}
+     */
+    executeAction(action) {
+        const context = {
+            'form': this.form,
+            '$form': this.form.getRuleNode(),
+            '$field': this.getRuleNode(),
+            'field': this,
+            '$event': {
+                type: action.type,
+                payload: action.payload,
+                target: this.getRuleNode()
+            }
+        };
+        const eventName = action.isCustomEvent ? `custom:${action.type}` : action.type;
+        const funcName = action.isCustomEvent ? `custom_${action.type}` : action.type;
+        const node = this.getCompiledEvent(eventName);
+        //todo: apply all the updates at the end  or
+        // not trigger the change event until the execution is finished
+        node.forEach((n) => this.executeEvent(context, n));
+        // @ts-ignore
+        if (funcName in this && typeof this[funcName] === 'function') {
+            //@ts-ignore
+            this[funcName](action, context);
+        }
+        this.notifyDependents(action);
+    }
+}
+exports.default = Scriptable;

package/lib/controller/Controller.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Defines all form events
+ */
+import { Action, BaseJson, FieldModel, FieldsetModel, FormModel, ValidationError } from '../types';
+/**
+ * Implementation of generic event
+ * @private
+ */
+export declare class ActionImpl implements Action {
+    private _metadata?;
+    protected _type: string;
+    private _payload?;
+    private _target;
+    constructor(payload: any, type: string, _metadata?: any);
+    get type(): string;
+    get payload(): any;
+    get metadata(): any;
+    get target(): FormModel | FieldModel | FieldsetModel;
+    get isCustomEvent(): boolean;
+    protected payloadToJson(): any;
+    toJson(): {
+        payload: any;
+        type: string;
+        isCustomEvent: boolean;
+    };
+    toString(): string;
+}
+/**
+ * Payload of change event
+ */
+export declare type ChangePayload = {
+    /**
+     * List of changes
+     */
+    changes: Array<{
+        /**
+         * Name of the property which has changed
+         */
+        propertyName: string;
+        /**
+         * Previous value of the property changed
+         */
+        prevValue?: any;
+        /**
+         * Current value of the property changed
+         */
+        currentValue: any;
+    }>;
+};
+/**
+ * Implementation of `change` event. The change event is triggered on the field whenever the value of the field is changed
+ */
+export declare class Change extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     * @param [dispatch] true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+     */
+    constructor(payload: ChangePayload, dispatch?: boolean);
+}
+/**
+ * Implementation of `invalid` event. The invalid event is triggered when a Field’s value becomes invalid after a change event or whenever its value property change
+ */
+export declare class Invalid extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     */
+    constructor(payload?: any);
+}
+/**
+ * Implementation of `valid` event. The valid event is triggered whenever the field’s valid state is changed from invalid to valid.
+ */
+export declare class Valid extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     */
+    constructor(payload?: any);
+}
+/**
+ * Implementation of an ExecuteRule event.
+ * @private
+ */
+export declare class ExecuteRule extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     * @param [dispatch] true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+     */
+    constructor(payload?: any, dispatch?: boolean);
+}
+/**
+ * Creates a change event
+ * @param propertyName  name of the form field property
+ * @param currentValue  current value
+ * @param prevValue     previous value
+ * @returns {@link Change} change event
+ */
+export declare const propertyChange: (propertyName: string, currentValue: any, prevValue?: any) => Change;
+/**
+ * Implementation of `initialize` event. The event is triggered on all the fields when the form initialisation is complete
+ */
+export declare class Initialize extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     * @param [dispatch] true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+     */
+    constructor(payload?: any, dispatch?: boolean);
+}
+/**
+ * Implementation of `click` event. The event is triggered when user clicks on an element.
+ */
+export declare class Click extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     * @param [dispatch] true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+     */
+    constructor(payload?: any, dispatch?: boolean);
+}
+/**
+ * Implementation of `blur` event. The event is triggered when the element loses focus.
+ */
+export declare class Blur extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     * @param [dispatch] true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+     */
+    constructor(payload?: any, dispatch?: boolean);
+}
+/**
+ * Implementation of `ValidationComplete` event. The ValidationComplete event is triggered once validation is completed
+ * on the form.
+ *
+ * An example of using this event,
+ * ```
+ * function onValidationComplete(event) {
+ *	 const x = event.payload[0].id;
+ *	 // do something with the invalid field
+ * }
+ * ```
+ */
+export declare class ValidationComplete extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload (ie) list of {@link ValidationError | validation errors}
+     * @param [dispatch] true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+     */
+    constructor(payload?: Array<ValidationError>, dispatch?: boolean);
+}
+/**
+ * Implementation of `submit` event. The submit event is triggered on the Form.
+ * To trigger the submit event, submit function needs to be invoked or one can invoke dispatchEvent API.
+ */
+export declare class Submit extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     * @param [dispatch] true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+     */
+    constructor(payload?: any, dispatch?: boolean);
+}
+/**
+ * Implementation of `fieldChanged` event. The field changed event is triggered on the field which it has changed.
+ */
+export declare class FieldChanged extends ActionImpl {
+    constructor(changes: ChangePayload, field: BaseJson);
+}
+/**
+ * Implementation of `custom event`.
+ */
+export declare class CustomEvent extends ActionImpl {
+    /**
+     * @constructor
+     * @param [eventName] name of the event
+     * @param [payload] event payload
+     * @param [dispatch] true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+     */
+    constructor(eventName: string, payload?: any, dispatch?: boolean);
+    /**
+     * Defines if the event is custom
+     */
+    get isCustomEvent(): boolean;
+}
+/**
+ * Implementation of `addItem` event. The event is triggered on a panel to add a new instance of items inside it.
+ */
+export declare class AddItem extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     */
+    constructor(payload?: number);
+}
+/**
+ * Implementation of `removeItem` event. The event is triggered on a panel to remove an instance of items inside it.
+ */
+export declare class RemoveItem extends ActionImpl {
+    /**
+     * @constructor
+     * @param [payload] event payload
+     */
+    constructor(payload?: number);
+}