@aemforms/af-core 0.22.19 → 0.22.20

package/lib/{data → esm/data}/DataValue.d.ts

@@ -1,10 +1,4 @@
-/**
- * Defines data value
- */
-import { FieldModel } from '../types';
-/**
- * @private
- */
+import { FieldModel } from '../types/index.js';
 export default class DataValue {
     private $_name;
     private $_value;

package/lib/esm/data/DataValue.js

@@ -0,0 +1,46 @@
+export default class DataValue {
+    $_name;
+    $_value;
+    $_type;
+    $_fields = [];
+    constructor($_name, $_value, $_type = typeof $_value) {
+        this.$_name = $_name;
+        this.$_value = $_value;
+        this.$_type = $_type;
+    }
+    valueOf() {
+        return this.$_value;
+    }
+    get $name() {
+        return this.$_name;
+    }
+    get $value() {
+        const enabled = this.$_fields.find(x => x.enabled !== false);
+        if (!enabled && this.$_fields.length) {
+            return undefined;
+        }
+        return this.$_value;
+    }
+    setValue(typedValue, originalValue, fromField) {
+        this.$_value = typedValue;
+        this.$_fields.forEach(x => {
+            if (fromField !== x) {
+                x.value = originalValue;
+            }
+        });
+    }
+    get $type() {
+        return this.$_type;
+    }
+    $bindToField(field) {
+        if (this.$_fields.indexOf(field) === -1) {
+            this.$_fields.push(field);
+        }
+    }
+    $convertToDataValue() {
+        return this;
+    }
+    get $isDataGroup() {
+        return false;
+    }
+}

package/lib/{data → esm/data}/EmptyDataValue.d.ts

@@ -1,4 +1,4 @@
-import DataValue from './DataValue';
+import DataValue from './DataValue.js';
 declare class NullDataValueClass extends DataValue {
     constructor();
     setValue(): void;

package/lib/esm/data/EmptyDataValue.js

@@ -0,0 +1,29 @@
+import DataValue from './DataValue.js';
+const value = Symbol('NullValue');
+class NullDataValueClass extends DataValue {
+    constructor() {
+        super('', value, 'null');
+    }
+    setValue() {
+    }
+    $bindToField() {
+    }
+    $length() {
+        return 0;
+    }
+    $convertToDataValue() {
+        return this;
+    }
+    $addDataNode() {
+    }
+    $removeDataNode() {
+    }
+    $getDataNode() {
+        return this;
+    }
+    $containsDataNode() {
+        return false;
+    }
+}
+const NullDataValue = new NullDataValueClass();
+export default NullDataValue;

package/lib/esm/index.d.ts

@@ -0,0 +1,21 @@
+export * from './FormInstance.js';
+export * from './types/index.js';
+export * from './controller/Events.js';
+export * from './utils/TranslationUtils.js';
+export * from './utils/JsonUtils.js';
+export * from './utils/SchemaUtils.js';
+import { getFileSizeInBytes, extractFileInfo, isEmpty } from './utils/FormUtils.js';
+import { BaseNode } from './BaseNode.js';
+import Checkbox from './Checkbox.js';
+import CheckboxGroup from './CheckboxGroup.js';
+import Container from './Container.js';
+import Field from './Field.js';
+import { Fieldset } from './Fieldset.js';
+import { FileObject } from './FileObject.js';
+import FileUpload from './FileUpload.js';
+import FormMetaData from './FormMetaData.js';
+import Node from './Node.js';
+import Scriptable from './Scriptable.js';
+import Form from './Form.js';
+import { FunctionRuntime, request } from './rules/FunctionRuntime.js';
+export { Form, BaseNode, Checkbox, CheckboxGroup, Container, Field, Fieldset, FileObject, FileUpload, FormMetaData, Node, Scriptable, getFileSizeInBytes, extractFileInfo, FunctionRuntime, request, isEmpty };

package/lib/esm/index.js

@@ -0,0 +1,21 @@
+export * from './FormInstance.js';
+export * from './types/index.js';
+export * from './controller/Events.js';
+export * from './utils/TranslationUtils.js';
+export * from './utils/JsonUtils.js';
+export * from './utils/SchemaUtils.js';
+import { getFileSizeInBytes, extractFileInfo, isEmpty } from './utils/FormUtils.js';
+import { BaseNode } from './BaseNode.js';
+import Checkbox from './Checkbox.js';
+import CheckboxGroup from './CheckboxGroup.js';
+import Container from './Container.js';
+import Field from './Field.js';
+import { Fieldset } from './Fieldset.js';
+import { FileObject } from './FileObject.js';
+import FileUpload from './FileUpload.js';
+import FormMetaData from './FormMetaData.js';
+import Node from './Node.js';
+import Scriptable from './Scriptable.js';
+import Form from './Form.js';
+import { FunctionRuntime, request } from './rules/FunctionRuntime.js';
+export { Form, BaseNode, Checkbox, CheckboxGroup, Container, Field, Fieldset, FileObject, FileUpload, FormMetaData, Node, Scriptable, getFileSizeInBytes, extractFileInfo, FunctionRuntime, request, isEmpty };

package/lib/{rules → esm/rules}/FunctionRuntime.d.ts

@@ -1,26 +1,11 @@
 declare type HTTP_VERB = 'GET' | 'POST';
-/**
- * Implementation of generic request API. This API can be used to make external web request
- * @param context                   expression execution context(consists of current form, current field, current event)
- * @param uri                       request URI
- * @param httpVerb                  http verb (for example, GET or POST)
- * @param payload                   request payload
- * @param success                   success handler
- * @param error                     error handler
- * @param headers                   headers
- * @private
- */
 export declare const request: (context: any, uri: string, httpVerb: HTTP_VERB, payload: any, success: string, error: string, headers: any) => Promise<void>;
 export declare const submit: (context: any, success: string, error: string, submitAs?: 'application/json' | 'multipart/form-data', input_data?: any) => Promise<void>;
-declare type CustomFunction = Function;
-declare type FunctionDefinition = {
+export declare type CustomFunction = Function;
+export declare type FunctionDefinition = {
     _func: CustomFunction;
     _signature: Array<any>;
 };
-/**
- * Implementation of function runtime
- * @private
- */
 declare class FunctionRuntimeImpl {
     private customFunctions;
     registerFunctions(functions: {
@@ -56,13 +41,6 @@ declare class FunctionRuntimeImpl {
             _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
             _signature: never[];
         };
-        /**
-         *
-         * @name dispatchEvent
-         * @param [element] element on which to trigger the event. If not defined the event will be triggered on entire form
-         * @param eventName name of the event to trigger
-         * @param payload payload to pass in the event
-         */
         dispatchEvent: {
             _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
             _signature: never[];

package/lib/{rules → esm/rules}/FunctionRuntime.js

@@ -1,31 +1,8 @@
-"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionRuntime = exports.submit = exports.request = void 0;
-/**
- * Implementation of function runtime in rule engine
- */
-//import {jsonString} from '../utils/JsonUtils';
-const Controller_1 = require("../controller/Controller");
-const Fetch_1 = require("../utils/Fetch");
-const FileObject_1 = require("../FileObject");
-const FormUtils_1 = require("../utils/FormUtils");
-const JsonUtils_1 = require("../utils/JsonUtils");
+import { AddInstance, AddItem, Change, Click, CustomEvent, RemoveInstance, RemoveItem, Reset, Submit } from '../controller/Events.js';
+import { request as fRequest } from '../utils/Fetch.js';
+import { FileObject } from '../FileObject.js';
+import { getAttachments } from '../utils/FormUtils.js';
+import { jsonString } from '../utils/JsonUtils.js';
 const getCustomEventName = (name) => {
     const eName = name;
     if (eName.length > 0 && eName.startsWith('custom:')) {
@@ -33,19 +10,7 @@ const getCustomEventName = (name) => {
     }
     return eName;
 };
-/**
- * Implementation of generic request API. This API can be used to make external web request
- * @param context                   expression execution context(consists of current form, current field, current event)
- * @param uri                       request URI
- * @param httpVerb                  http verb (for example, GET or POST)
- * @param payload                   request payload
- * @param success                   success handler
- * @param error                     error handler
- * @param headers                   headers
- * @private
- */
-const request = (context, uri, httpVerb, payload, success, error, headers) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+export const request = async (context, uri, httpVerb, payload, success, error, headers) => {
     const endpoint = uri;
     const requestOptions = {
         method: httpVerb
@@ -53,8 +18,7 @@ const request = (context, uri, httpVerb, payload, success, error, headers) => __
     let result;
     let inputPayload;
     try {
-        if (payload && payload instanceof FileObject_1.FileObject && payload.data instanceof File) {
-            // todo: have to implement array type
+        if (payload && payload instanceof FileObject && payload.data instanceof File) {
             const formData = new FormData();
             formData.append(payload.name, payload.data);
             inputPayload = formData;
@@ -65,13 +29,15 @@ const request = (context, uri, httpVerb, payload, success, error, headers) => __
         else if (payload && typeof payload === 'object' && Object.keys(payload).length > 0) {
             const headerNames = Object.keys(headers);
             if (headerNames.length > 0) {
-                requestOptions.headers = Object.assign(Object.assign({}, headers), (headerNames.indexOf('Content-Type') === -1 ? { 'Content-Type': 'application/json' } : {}) // this should match content type of the payload
-                );
+                requestOptions.headers = {
+                    ...headers,
+                    ...(headerNames.indexOf('Content-Type') === -1 ? { 'Content-Type': 'application/json' } : {})
+                };
             }
             else {
                 requestOptions.headers = { 'Content-Type': 'application/json' };
             }
-            const contentType = ((_a = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers) === null || _a === void 0 ? void 0 : _a['Content-Type']) || 'application/json';
+            const contentType = requestOptions?.headers?.['Content-Type'] || 'application/json';
             if (contentType === 'application/json') {
                 inputPayload = JSON.stringify(payload);
             }
@@ -82,24 +48,22 @@ const request = (context, uri, httpVerb, payload, success, error, headers) => __
                 inputPayload = urlEncoded(payload);
             }
         }
-        result = yield (0, Fetch_1.request)(endpoint, inputPayload, requestOptions);
+        result = await fRequest(endpoint, inputPayload, requestOptions);
     }
     catch (e) {
-        //todo: define error payload
         context.form.logger.error('Error invoking a rest API');
         const eName = getCustomEventName(error);
-        context.form.dispatch(new Controller_1.CustomEvent(eName, {}, true));
+        context.form.dispatch(new CustomEvent(eName, {}, true));
         return;
     }
     const eName = getCustomEventName(success);
-    context.form.dispatch(new Controller_1.CustomEvent(eName, result, true));
-});
-exports.request = request;
+    context.form.dispatch(new CustomEvent(eName, result, true));
+};
 const urlEncoded = (data) => {
     const formData = new URLSearchParams();
     Object.entries(data).forEach(([key, value]) => {
         if (value != null && typeof value === 'object') {
-            formData.append(key, (0, JsonUtils_1.jsonString)(value));
+            formData.append(key, jsonString(value));
         }
         else {
             formData.append(key, value);
@@ -107,26 +71,19 @@ const urlEncoded = (data) => {
     });
     return formData;
 };
-/**
- * Create multi part form data using form data and form attachments
- * @param data              form data
- * @param attachments       form events
- * @private
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const multipartFormData = (data, attachments) => {
     const formData = new FormData();
     Object.entries(data).forEach(([key, value]) => {
         if (value != null && typeof value === 'object') {
-            formData.append(key, (0, JsonUtils_1.jsonString)(value));
+            formData.append(key, jsonString(value));
         }
         else {
             formData.append(key, value);
         }
     });
     const addAttachmentToFormData = (objValue, formData) => {
-        if ((objValue === null || objValue === void 0 ? void 0 : objValue.data) instanceof File) {
-            let attIdentifier = `${objValue === null || objValue === void 0 ? void 0 : objValue.dataRef}/${objValue === null || objValue === void 0 ? void 0 : objValue.name}`;
+        if (objValue?.data instanceof File) {
+            let attIdentifier = `${objValue?.dataRef}/${objValue?.name}`;
             if (!attIdentifier.startsWith('/')) {
                 attIdentifier = `/${attIdentifier}`;
             }
@@ -134,7 +91,6 @@ const multipartFormData = (data, attachments) => {
         }
     };
     if (attachments) {
-        // @ts-ignore
         Object.keys(attachments).reduce((acc, curr) => {
             const objValue = attachments[curr];
             if (objValue && objValue instanceof Array) {
@@ -147,75 +103,54 @@ const multipartFormData = (data, attachments) => {
     }
     return formData;
 };
-const submit = (context, success, error, submitAs = 'multipart/form-data', input_data = null) => __awaiter(void 0, void 0, void 0, function* () {
+export const submit = async (context, success, error, submitAs = 'multipart/form-data', input_data = null) => {
     const endpoint = context.form.action;
     let data = input_data;
     if (typeof data != 'object' || data == null) {
         data = context.form.exportData();
     }
-    // todo: have to implement sending of attachments here
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const attachments = (0, FormUtils_1.getAttachments)(context.form);
+    const attachments = getAttachments(context.form);
     let submitContentType = submitAs;
-    let formData;
+    const submitDataAndMetaData = { 'data': data, 'submitMetadata': { 'lang': context.form.lang } };
+    let formData = submitDataAndMetaData;
     if (Object.keys(attachments).length > 0 || submitAs === 'multipart/form-data') {
-        formData = multipartFormData({ 'data': data }, attachments);
+        formData = multipartFormData(submitDataAndMetaData, attachments);
         submitContentType = 'multipart/form-data';
     }
-    else {
-        formData = { 'data': data };
-    }
-    // submitContentType = submitAs;
-    // note: don't send multipart/form-data let browser decide on the content type
-    yield (0, exports.request)(context, endpoint, 'POST', formData, success, error, {
+    await request(context, endpoint, 'POST', formData, success, error, {
         'Content-Type': submitContentType
     });
-});
-exports.submit = submit;
-/**
- * Helper function to create an action
- * @param name          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
- * @private
- */
+};
 const createAction = (name, payload = {}) => {
     switch (name) {
         case 'change':
-            return new Controller_1.Change(payload);
+            return new Change(payload);
         case 'submit':
-            return new Controller_1.Submit(payload);
+            return new Submit(payload);
         case 'click':
-            return new Controller_1.Click(payload);
+            return new Click(payload);
         case 'addItem':
-            return new Controller_1.AddItem(payload);
+            return new AddItem(payload);
         case 'removeItem':
-            return new Controller_1.RemoveItem(payload);
+            return new RemoveItem(payload);
         case 'reset':
-            return new Controller_1.Reset(payload);
+            return new Reset(payload);
         case 'addInstance':
-            return new Controller_1.AddInstance(payload);
+            return new AddInstance(payload);
         case 'removeInstance':
-            return new Controller_1.RemoveInstance(payload);
+            return new RemoveInstance(payload);
         default:
             console.error('invalid action');
     }
 };
-/**
- * Implementation of function runtime
- * @private
- */
 class FunctionRuntimeImpl {
-    constructor() {
-        this.customFunctions = {};
-    }
+    customFunctions = {};
     registerFunctions(functions) {
         Object.entries(functions).forEach(([name, funcDef]) => {
             let finalFunction = funcDef;
             if (typeof funcDef === 'function') {
                 finalFunction = {
                     _func: (args) => {
-                        // eslint-disable-next-line @typescript-eslint/ban-types
                         return funcDef(...args);
                     },
                     _signature: []
@@ -236,7 +171,6 @@ class FunctionRuntimeImpl {
         });
     }
     getFunctions() {
-        // todo: remove these once json-formula exposes a way to call them from custom functions
         function isArray(obj) {
             if (obj !== null) {
                 return Object.prototype.toString.call(obj) === '[object Array]';
@@ -291,7 +225,6 @@ class FunctionRuntimeImpl {
             },
             getData: {
                 _func: (args, data, interpreter) => {
-                    // deprecated. left for backward compatability.
                     interpreter.globals.form.logger.warn('The `getData` function is depricated. Use `exportData` instead.');
                     return interpreter.globals.form.exportData();
                 },
@@ -315,12 +248,11 @@ class FunctionRuntimeImpl {
             },
             submitForm: {
                 _func: (args, data, interpreter) => {
-                    // success: string, error: string, submit_as: 'json' | 'multipart' = 'json', data: any = null
                     const success = toString(args[0]);
                     const error = toString(args[1]);
                     const submit_as = args.length > 2 ? toString(args[2]) : 'multipart/form-data';
                     const submit_data = args.length > 3 ? valueOf(args[3]) : null;
-                    interpreter.globals.form.dispatch(new Controller_1.Submit({
+                    interpreter.globals.form.dispatch(new Submit({
                         success,
                         error,
                         submit_as,
@@ -330,7 +262,6 @@ class FunctionRuntimeImpl {
                 },
                 _signature: []
             },
-            // todo: only supports application/json for now
             request: {
                 _func: (args, data, interpreter) => {
                     const uri = toString(args[0]);
@@ -347,18 +278,11 @@ class FunctionRuntimeImpl {
                         success = valueOf(args[4]);
                         error = valueOf(args[5]);
                     }
-                    (0, exports.request)(interpreter.globals, uri, httpVerb, payload, success, error, headers);
+                    request(interpreter.globals, uri, httpVerb, payload, success, error, headers);
                     return {};
                 },
                 _signature: []
             },
-            /**
-             *
-             * @name dispatchEvent
-             * @param [element] element on which to trigger the event. If not defined the event will be triggered on entire form
-             * @param eventName name of the event to trigger
-             * @param payload payload to pass in the event
-             */
             dispatchEvent: {
                 _func: (args, data, interpreter) => {
                     const element = args[0];
@@ -372,7 +296,7 @@ class FunctionRuntimeImpl {
                     }
                     let event;
                     if (eventName.startsWith('custom:')) {
-                        event = new Controller_1.CustomEvent(eventName.substring('custom:'.length), payload, dispatch);
+                        event = new CustomEvent(eventName.substring('custom:'.length), payload, dispatch);
                     }
                     else {
                         event = createAction(eventName, payload);
@@ -390,7 +314,7 @@ class FunctionRuntimeImpl {
                 _signature: []
             }
         };
-        return Object.assign(Object.assign({}, defaultFunctions), this.customFunctions);
+        return { ...defaultFunctions, ...this.customFunctions };
     }
 }
-exports.FunctionRuntime = new FunctionRuntimeImpl();
+export const FunctionRuntime = new FunctionRuntimeImpl();

package/lib/esm/rules/RuleEngine.d.ts

@@ -0,0 +1,12 @@
+import { BaseModel } from '../types/index.js';
+declare class RuleEngine {
+    private _context;
+    private _globalNames;
+    private formulaEngine;
+    private debugInfo;
+    constructor();
+    compileRule(rule: string): any;
+    execute(node: any, data: any, globals: any, useValueOf?: boolean): any;
+    trackDependency(subscriber: BaseModel): void;
+}
+export default RuleEngine;

package/lib/esm/rules/RuleEngine.js

@@ -0,0 +1,47 @@
+import Formula from '@adobe/json-formula';
+import { FunctionRuntime } from './FunctionRuntime.js';
+class RuleEngine {
+    _context;
+    _globalNames = [
+        '$form',
+        '$field',
+        '$event'
+    ];
+    formulaEngine;
+    debugInfo = [];
+    constructor() {
+        const customFunctions = FunctionRuntime.getFunctions();
+        this.formulaEngine = new Formula(customFunctions, undefined, this.debugInfo);
+    }
+    compileRule(rule) {
+        return this.formulaEngine.compile(rule, this._globalNames);
+    }
+    execute(node, data, globals, useValueOf = false) {
+        const oldContext = this._context;
+        this._context = globals;
+        let res = undefined;
+        try {
+            res = this.formulaEngine.run(node, data, 'en-US', globals);
+        }
+        catch (err) {
+            this._context?.form?.logger?.error(err);
+        }
+        while (this.debugInfo.length > 0) {
+            this._context?.form?.logger?.debug(this.debugInfo.pop());
+        }
+        let finalRes = res;
+        if (useValueOf) {
+            if (typeof res === 'object' && res !== null) {
+                finalRes = Object.getPrototypeOf(res).valueOf.call(res);
+            }
+        }
+        this._context = oldContext;
+        return finalRes;
+    }
+    trackDependency(subscriber) {
+        if (this._context && this._context.field !== undefined && this._context.field !== subscriber) {
+            subscriber._addDependent(this._context.field);
+        }
+    }
+}
+export default RuleEngine;

package/lib/{types → esm/types}/Json.d.ts

@@ -1,24 +1,16 @@
-/**
- * Defines generic types based on `adaptive form specification`
- */
-/** Type for `items property` based on `adaptive form specification` */
 export declare type Items<T> = {
     [key: string]: T;
 };
-/** Type alias for primitive types */
 export declare type Primitives = string | number | boolean | null | undefined;
-/** Type for `label` based on `adaptive form specification` */
 export declare type Label = {
     value: string;
     richText?: boolean;
     visible?: boolean;
 };
-/** Type for `constraint properties` which can be translated based on `adaptive form specification` */
 declare type TranslationConstraintsJson = {
     enumNames?: string[];
     enum?: any[];
 };
-/** Type for `constraint properties` based on `adaptive form specification` */
 export declare type ConstraintsJson = TranslationConstraintsJson & {
     accept?: string[];
     enforceEnum?: boolean;
@@ -41,7 +33,6 @@ export declare type ConstraintsJson = TranslationConstraintsJson & {
     validationExpression?: string;
     uniqueItems?: boolean;
 };
-/** Type for `constraint messages` based on `adaptive form specification` */
 export declare type ConstraintsMessages = {
     accept?: string;
     enum?: string;
@@ -55,22 +46,20 @@ export declare type ConstraintsMessages = {
     minLength?: string;
     minimum?: string;
     minItems?: string;
+    uniqueItems?: string;
     pattern?: string;
     required?: string;
     step?: string;
     type?: string;
     validationExpression?: string;
 };
-/** Type for `constraint messages` based on `adaptive form specification` */
 export declare type RulesJson = {
     rules?: Items<string>;
     events?: Items<string[] | string | undefined>;
 };
-/** Type for `generic form properties` which can be translated based on `adaptive form specification` */
 declare type TranslationBaseJson = {
     description?: string;
 };
-/** Type for `generic form properties` based on `adaptive form specification` */
 export declare type BaseJson = TranslationBaseJson & RulesJson & ConstraintsJson & {
     dataRef?: string | null;
     ':type'?: string;
@@ -88,12 +77,11 @@ export declare type BaseJson = TranslationBaseJson & RulesJson & ConstraintsJson
     screenReaderText?: string;
     tooltip?: string;
     altText?: string;
+    viewType?: string;
 };
-/** Type for `form field properties`which can be translated based on `adaptive form specification` */
 declare type TranslationFieldJson = {
     placeholder?: string;
 };
-/** Type for `form field properties` based on `adaptive form specification` */
 export declare type FieldJson = BaseJson & TranslationFieldJson & {
     readOnly?: boolean;
     valid?: boolean;
@@ -105,34 +93,27 @@ export declare type FieldJson = BaseJson & TranslationFieldJson & {
     displayValue?: string;
     emptyValue?: 'null' | 'undefined' | '';
 };
-/** Type for `form container properties` based on `adaptive form specification` */
 export declare type ContainerJson = BaseJson & {
     items: Array<FieldJson | ContainerJson>;
     initialItems?: number;
     activeChild?: string;
 };
-/** Type for `form metadata` based on `adaptive form specification` */
 export declare type MetaDataJson = {
     version?: string;
     grammar?: string;
-    locale?: string;
 };
-/** Type for `form fieldset` based on `adaptive form specification` */
 export declare type FieldsetJson = ContainerJson & {
     'type'?: 'array' | 'object';
 };
-/** Type for `form model` based on `adaptive form specification` */
 export declare type FormJson = ContainerJson & {
     metadata?: MetaDataJson;
     data?: any;
     title?: string;
     action?: string;
     adaptiveForm?: string;
+    lang?: string;
 };
-/** Type for all properties which can be translated based on `adaptive form specification` */
 export declare type TranslationJson = TranslationBaseJson & TranslationFieldJson & TranslationConstraintsJson;
-/** Constant for all properties which can be translated based on `adaptive form specification` */
 export declare const translationProps: string[];
-/** Constant for all properties which are constraints based on `adaptive form specification` */
 export declare const constraintProps: string[];
 export {};