@aemforms/af-core 0.22.68 → 0.22.69

package/esm/types/src/types/Model.d.ts

@@ -0,0 +1,141 @@
+import { ConstraintsJson, ContainerJson, FieldJson, FieldsetJson, FormJson, Label, MetaDataJson } from './Json';
+import RuleEngine from '../rules/RuleEngine';
+import EventQueue from '../controller/EventQueue';
+import DataGroup from '../data/DataGroup';
+import { Logger } from '../controller/Logger';
+export interface ScriptableField {
+    rules?: {
+        [key: string]: string;
+    };
+    events?: {
+        [key: string]: string;
+    };
+    ruleEngine: RuleEngine;
+}
+interface WithState<T> {
+    getState: () => any;
+}
+type stateProps = {
+    id: string;
+    index: number;
+    ':type': string;
+};
+export type State<T> = stateProps & (T extends ContainerJson ? T & {
+    items: Array<State<FieldJson | ContainerJson>>;
+} : T);
+export type Subscription = {
+    unsubscribe(): void;
+};
+export interface Action {
+    type: string;
+    payload: any;
+    metadata: any;
+    readonly isCustomEvent: boolean;
+    readonly target: FormModel | FieldModel | FieldsetModel;
+    readonly originalAction?: Action;
+}
+export type callbackFn = (action: Action) => void;
+export interface WithController {
+    subscribe(callback: callbackFn, eventName?: string): Subscription;
+    dispatch(action: Action): void;
+}
+export type FormCreationMode = 'create' | 'restore';
+export interface BaseModel extends ConstraintsJson, WithController {
+    readonly lang?: string;
+    readonly name?: string;
+    readonly dataRef?: string | null;
+    readonly id: string;
+    readonly index: number;
+    readonly qualifiedName: string;
+    label?: Label;
+    description?: string;
+    readOnly?: boolean;
+    enabled?: boolean;
+    visible?: boolean;
+    placeholder?: string;
+    valid?: boolean;
+    readonly ':type': string;
+    readonly 'fieldType': string;
+    properties: {
+        [key: string]: any;
+    };
+    readonly isContainer: boolean;
+    readonly parent: ContainerModel | null;
+    readonly items?: Array<FieldsetModel | FieldModel>;
+    value: any;
+    readonly default?: any;
+    readonly repeatable?: boolean;
+    validate(): Array<ValidationError>;
+    reset(): any;
+    importData(a?: DataGroup): any;
+    getRuleNode(): any;
+    ruleNodeReference(): any;
+    _initialize(mode?: FormCreationMode): any;
+    _addDependent(dependent: BaseModel): any;
+}
+export interface FieldModel extends BaseModel, ScriptableField, WithState<FieldJson> {
+    parent: ContainerModel;
+    readonly editFormat?: string;
+    readonly displayFormat?: string;
+    readonly displayValue?: string;
+    readonly editValue?: string;
+}
+export interface FormMetaDataModel {
+    readonly version: string;
+    readonly grammar: string;
+}
+export interface SubmitMetaDataModel {
+    lang: string;
+    captchaInfo: Record<string, any>;
+}
+export interface ContainerModel extends BaseModel, ScriptableField {
+    items: Array<FieldsetModel | FieldModel>;
+    parent: ContainerModel;
+    indexOf(f: FieldModel | FieldsetModel): number;
+    isTransparent(): boolean;
+    activeChild: BaseModel | null;
+}
+export interface FieldsetModel extends ContainerModel, WithState<FieldsetJson> {
+    type?: 'array' | 'object';
+}
+export interface FormModel extends ContainerModel, WithState<FormJson> {
+    readonly id: string;
+    readonly data?: any;
+    readonly metadata?: MetaDataJson;
+    readonly title: string;
+    readonly logger: Logger;
+    importData(data: any): any;
+    exportData(): any;
+    getElement(id: string): FieldModel | FormModel | FieldsetModel;
+    getUniqueId(): string;
+    getEventQueue(): EventQueue;
+    visit(callBack: (field: FieldModel | FieldsetModel) => void): void;
+    resolveQualifiedName(qualifiedName: string): FieldModel | FieldsetModel | null;
+    fieldAdded(field: FieldModel | FieldsetModel): void;
+}
+export interface IFormFieldFactory {
+    createField(child: FieldsetJson | FieldJson, options: {
+        form: FormModel;
+        parent: ContainerModel;
+    }): FieldModel | FieldsetModel;
+}
+export interface IFileObject {
+    name: string;
+    mediaType: string;
+    data?: any;
+    size?: number;
+}
+export interface IValidationError {
+    fieldName: string;
+    errorMessages: Array<string>;
+}
+export declare class ValidationError implements IValidationError {
+    fieldName: string;
+    errorMessages: Array<string>;
+    constructor(fieldName?: string, errorMessages?: Array<any>);
+}
+export declare enum FocusOption {
+    NEXT_ITEM = "nextItem",
+    PREVIOUS_ITEM = "previousItem"
+}
+export {};

package/esm/types/src/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Json';
+export * from './Model';

package/esm/types/src/utils/CoercionUtils.d.ts

@@ -0,0 +1 @@
+export declare function stringToNumber(str: string, language: string): number;

package/esm/types/src/utils/DataRefParser.d.ts

@@ -0,0 +1,33 @@
+import DataGroup from '../data/DataGroup';
+import DataValue from '../data/DataValue';
+type TokenType = string;
+export declare const TOK_GLOBAL: TokenType;
+export declare const TOK_REPEATABLE: TokenType;
+export type Token = {
+    type: TokenType;
+    value: string | number;
+    start: number;
+};
+export declare const identifier: (value: string, start: number) => {
+    type: string;
+    value: string;
+    start: number;
+};
+export declare const bracket: (value: number, start: number) => {
+    type: string;
+    value: number;
+    start: number;
+};
+export declare const global$: () => {
+    type: string;
+    start: number;
+    value: string;
+};
+export declare const repeatable: () => {
+    type: string;
+    start: number;
+    value: string;
+};
+export declare const tokenize: (stream: string) => Token[];
+export declare const resolveData: <T extends DataValue>(data: DataGroup, input: Token[] | string, create?: T | undefined) => DataGroup | DataValue | undefined;
+export {};

package/esm/types/src/utils/Fetch.d.ts

@@ -0,0 +1,8 @@
+export declare const request: (url: string, data?: any, options?: RequestOptions) => any;
+export type RequestOptions = {
+    contentType?: string;
+    method?: 'POST' | 'GET';
+    headers?: any;
+    mode?: string;
+};
+export declare const convertQueryString: (endpoint: string, payload: string | null) => string;

package/esm/types/src/utils/FormCreationUtils.d.ts

@@ -0,0 +1,10 @@
+import { ContainerModel, FieldJson, FieldModel, FieldsetJson, FieldsetModel, FormCreationMode, FormModel, IFormFieldFactory } from '../types/index';
+declare class FormFieldFactoryImpl implements IFormFieldFactory {
+    createField(child: FieldsetJson | FieldJson, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+        mode: FormCreationMode;
+    }): FieldModel | FieldsetModel;
+}
+export declare const FormFieldFactory: FormFieldFactoryImpl;
+export {};

package/esm/types/src/utils/FormUtils.d.ts

@@ -0,0 +1,14 @@
+import { ContainerModel } from '../types/index';
+export declare const randomWord: (l: number) => string;
+export declare const isEmpty: (value: any) => boolean;
+export declare const getAttachments: (input: ContainerModel, excludeUnbound?: boolean) => any;
+export declare const getFileSizeInBytes: (str: any) => number;
+export declare const IdGenerator: (initial?: number) => Generator<string, void, string>;
+export declare const isDataUrl: (str: string) => boolean;
+export declare const extractFileInfo: (file: any) => any;
+export declare const dataURItoBlob: (dataURI: string) => {
+    name: string;
+    blob: Blob;
+} | null;
+export declare const sitesModelToFormModel: (sitesModel: any) => any;
+export declare const replaceTemplatePlaceholders: (str: string, values?: any[]) => string;

package/esm/types/src/utils/JsonUtils.d.ts

@@ -0,0 +1,13 @@
+import { FieldsetJson, FieldJson } from '../types/index';
+export declare const getProperty: <P>(data: any, key: string, def: P) => P;
+export declare const isFile: (item: FieldsetJson | FieldJson) => boolean;
+export declare const checkIfConstraintsArePresent: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isCheckbox: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isCheckboxGroup: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isEmailInput: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isDateField: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isCaptcha: (item: FieldsetJson | FieldJson) => boolean;
+export declare function deepClone(obj: any, idGenerator?: () => string): any;
+export declare function checkIfKeyAdded(currentObj: any, prevObj: any, objKey: string): boolean;
+export declare const jsonString: (obj: any) => string;
+export declare const isRepeatable: (obj: FieldsetJson | FieldJson) => boolean;

package/esm/types/src/utils/LogUtils.d.ts

@@ -0,0 +1,4 @@
+import { callbackFn } from '../types/index';
+export declare const logFormCallbacks: (callbacks: {
+    [key: string]: callbackFn[];
+}) => void;

package/esm/types/src/utils/SchemaUtils.d.ts

@@ -0,0 +1,3 @@
+import { FormJson } from '../types/index';
+export declare const defaultFieldTypes: (schema: any) => string;
+export declare const exportDataSchema: (form: FormJson) => any;

package/esm/types/src/utils/TranslationUtils.d.ts

@@ -0,0 +1,11 @@
+import { FieldJson, FieldsetJson, FormJson } from '../types/index';
+export declare const TRANSLATION_TOKEN = "##";
+export declare const TRANSLATION_ID = "afs:translationIds";
+export declare const CUSTOM_PROPS_KEY = "properties";
+type formElementJson = FieldJson | FieldsetJson | FormJson | any;
+export declare const invalidateTranslation: (input: formElementJson, updates: any) => void;
+export declare const addTranslationId: (input: formElementJson, additionalTranslationProps?: string[]) => formElementJson;
+export declare const getOrElse: (input: any, key: string | string[], defaultValue?: any) => any;
+export declare const createTranslationObj: (input: formElementJson, additionalTranslationProps?: string[]) => any;
+export declare const createTranslationObject: (input: formElementJson, additionalTranslationProps?: string[], bcp47LangTags?: string[]) => any;
+export {};

package/esm/types/src/utils/ValidationUtils.d.ts

@@ -0,0 +1,20 @@
+type ValidationResult = {
+    valid: boolean;
+    value: any;
+};
+export declare const coerceType: (param: any, type: 'string' | 'number' | 'boolean') => string | number | boolean;
+type ValidConstraintsType = {
+    date: ValidationConstraints[];
+    string: ValidationConstraints[];
+    number: ValidationConstraints[];
+    array: ValidationConstraints[];
+    file: ValidationConstraints[];
+    email: ValidationConstraints[];
+};
+export declare const ValidConstraints: ValidConstraintsType;
+export type ValidationConstraints = 'type' | 'format' | 'minimum' | 'maximum' | 'exclusiveMinimum' | 'exclusiveMaximum' | 'minItems' | 'maxItems' | 'uniqueItems' | 'minLength' | 'maxLength' | 'pattern' | 'required' | 'enum' | 'accept' | 'maxFileSize';
+type ConstraintsObject = {
+    [key in ValidationConstraints]: (constraint: any, inputVal: any) => ValidationResult;
+};
+export declare const Constraints: ConstraintsObject;
+export {};

package/lib/BaseNode.d.ts

@@ -1,4 +1,4 @@
-import { Action, BaseJson, BaseModel, callbackFn, ContainerModel, FormModel, Primitives, ValidationError } from './types/index';
+import { Action, BaseJson, BaseModel, callbackFn, ContainerModel, FormCreationMode, FormModel, Primitives, ValidationError } from './types/index';
 import DataGroup from './data/DataGroup';
 import DataValue from './data/DataValue';
 export declare const editableProperties: string[];
@@ -49,15 +49,18 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     set label(l: import("./types/Json").Label | undefined);
     get uniqueItems(): boolean | undefined;
     isTransparent(): boolean;
-    getState(isRepeatableChild?: boolean): T & {
+    getState(forRestore?: boolean): T & {
+        _dependents?: string[] | undefined;
+        allowedComponents?: undefined;
+        columnClassNames?: undefined;
+        columnCount?: undefined;
+        gridClassNames?: undefined;
         properties: {
             [key: string]: any;
         };
         index: number;
         parent: undefined;
         qualifiedName: any;
-        events: {};
-        rules: {};
         repeatable: boolean | undefined;
         ':type': string;
         id: string;
@@ -87,7 +90,7 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     abstract defaultDataModel(name: string | number): DataValue | undefined;
     abstract importData(a: DataGroup): any;
     getNonTransparentParent(): ContainerModel;
-    _initialize(): void;
+    _initialize(mode?: FormCreationMode): void;
     protected _applyUpdates(propNames: string[], updates: any): any;
     get qualifiedName(): any;
     focus(): void;

package/lib/BaseNode.js

@@ -238,8 +238,14 @@ class BaseNode {
         const isNonTransparent = ((_a = this.parent) === null || _a === void 0 ? void 0 : _a._jsonModel.type) === 'array';
         return !this._jsonModel.name && !isNonTransparent;
     }
-    getState(isRepeatableChild = false) {
-        return Object.assign(Object.assign({}, this._jsonModel), { properties: this.properties, index: this.index, parent: undefined, qualifiedName: this.qualifiedName, events: {}, rules: {}, repeatable: this.repeatable === true ? true : undefined, ':type': this[':type'] });
+    getState(forRestore = false) {
+        return Object.assign(Object.assign(Object.assign({}, this._jsonModel), { properties: this.properties, index: this.index, parent: undefined, qualifiedName: this.qualifiedName, repeatable: this.repeatable === true ? true : undefined, ':type': this[':type'] }), (forRestore ? {
+            _dependents: this._dependents.length ? this._dependents.map(x => x.node.id) : undefined,
+            allowedComponents: undefined,
+            columnClassNames: undefined,
+            columnCount: undefined,
+            gridClassNames: undefined
+        } : {}));
     }
     subscribe(callback, eventName = 'change') {
         this._callbacks[eventName] = this._callbacks[eventName] || [];
@@ -281,6 +287,16 @@ class BaseNode {
         this.form.getEventQueue().runPendingQueue();
     }
     notifyDependents(action) {
+        const depsToRestore = this._jsonModel._dependents;
+        if (depsToRestore) {
+            depsToRestore.forEach((x) => {
+                const node = this.form.getElement(x);
+                if (node) {
+                    this._addDependent(node);
+                }
+            });
+            this._jsonModel._dependents = undefined;
+        }
         const handlers = this._callbacks[action.type] || [];
         handlers.forEach(x => {
             x(new ActionImplWithTarget(action, this));
@@ -403,7 +419,7 @@ class BaseNode {
         }
         return nonTransparentParent;
     }
-    _initialize() {
+    _initialize(mode) {
         if (typeof this._data === 'undefined') {
             let dataNode, parent = this.parent;
             do {

package/lib/Container.d.ts

@@ -1,4 +1,4 @@
-import { Action, BaseModel, ContainerJson, ContainerModel, FieldModel, FieldsetModel, FormModel, IFormFieldFactory, RulesJson } from './types/index';
+import { Action, BaseModel, ContainerJson, ContainerModel, FieldModel, FieldsetModel, FormCreationMode, FormModel, IFormFieldFactory, RulesJson } from './types/index';
 import Scriptable from './Scriptable';
 import DataGroup from './data/DataGroup';
 declare abstract class Container<T extends ContainerJson & RulesJson> extends Scriptable<T> implements ContainerModel {
@@ -10,6 +10,7 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
         form: FormModel;
         parent: ContainerModel;
         fieldFactory: IFormFieldFactory;
+        mode: 'create' | 'restore';
     });
     protected _getDefaults(): any;
     ruleNodeReference(): any;
@@ -25,18 +26,23 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
     private isAFormField;
     private _getFormAndSitesState;
     private getItemsState;
-    getState(isRepeatableChild?: boolean): T & {
+    getState(isRepeatableChild?: boolean, forRestore?: boolean): T & {
         items: any[];
         enabled: boolean | undefined;
         readOnly: any;
+        ':items'?: undefined;
+        ':itemsOrder'?: undefined;
+        _dependents?: string[] | undefined;
+        allowedComponents?: undefined;
+        columnClassNames?: undefined;
+        columnCount?: undefined;
+        gridClassNames?: undefined;
         properties: {
             [key: string]: any;
         };
         index: number;
         parent: undefined;
         qualifiedName: any;
-        events: {};
-        rules: {};
         repeatable: boolean | undefined;
         ':type': string;
         id: string;
@@ -47,7 +53,8 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
     private _addChild;
     indexOf(f: FieldModel | FieldsetModel): number;
     defaultDataModel(name: string): DataGroup | undefined;
-    _initialize(): void;
+    _canHaveRepeatingChildren(mode?: FormCreationMode): boolean;
+    _initialize(mode?: FormCreationMode): void;
     private _initializeSiteContainer;
     addItem(action: Action): void;
     removeItem(action: Action): void;

package/lib/Container.js

@@ -79,37 +79,40 @@ class Container extends Scriptable_1.default {
     isAFormField(item) {
         return ('fieldType' in item || 'id' in item || 'name' in item || 'dataRef' in item || 'type' in item);
     }
-    _getFormAndSitesState(isRepeatableChild = false) {
+    _getFormAndSitesState(isRepeatableChild = false, forRestore = false) {
         return this._jsonModel.items ? this._jsonModel.items.map((x) => {
             if (this.isSiteContainer(x)) {
                 const newObjWithId = Object.assign({}, ((x === null || x === void 0 ? void 0 : x.id) ? { id: this.form.getUniqueId() } : {}));
                 return Object.assign(Object.assign(Object.assign({}, x), newObjWithId), { ':items': this.walkSiteContainerItems(x) });
             }
             else if (this.isAFormField(x)) {
-                return Object.assign({}, this.form.getElement(x === null || x === void 0 ? void 0 : x.id).getState(isRepeatableChild));
+                return Object.assign({}, this.form.getElement(x === null || x === void 0 ? void 0 : x.id).getState(isRepeatableChild, forRestore));
             }
             else {
                 return x;
             }
         }) : [];
     }
-    getItemsState(isRepeatableChild = false) {
+    getItemsState(isRepeatableChild = false, forRestore = false) {
         if (this._jsonModel.type === 'array' || (0, JsonUtils_1.isRepeatable)(this._jsonModel) || isRepeatableChild) {
             if (isRepeatableChild) {
-                return this._getFormAndSitesState(isRepeatableChild);
+                return this._getFormAndSitesState(isRepeatableChild, forRestore);
             }
             else {
                 return this._children.map(x => {
-                    return Object.assign({}, x.getState(true));
+                    return Object.assign({}, x.getState(true, forRestore));
                 });
             }
         }
         else {
-            return this._getFormAndSitesState(isRepeatableChild);
+            return this._getFormAndSitesState(isRepeatableChild, forRestore);
         }
     }
-    getState(isRepeatableChild = false) {
-        return Object.assign(Object.assign({}, super.getState(isRepeatableChild)), { items: this.getItemsState(isRepeatableChild), enabled: this.enabled, readOnly: this.readOnly });
+    getState(isRepeatableChild = false, forRestore = false) {
+        return Object.assign(Object.assign(Object.assign({}, super.getState(forRestore)), (forRestore ? {
+            ':items': undefined,
+            ':itemsOrder': undefined
+        } : {})), { items: this.getItemsState(isRepeatableChild, forRestore), enabled: this.enabled, readOnly: this.readOnly });
     }
     _createChild(child, options) {
         const { parent = this } = options;
@@ -128,7 +131,7 @@ class Container extends Scriptable_1.default {
             }
             else {
                 if (typeof value === 'object') {
-                    const newObjWithId = Object.assign({}, ((value === null || value === void 0 ? void 0 : value.id) ? { 'id': this.form.getUniqueId() } : {}));
+                    const newObjWithId = Object.assign({}, ((value === null || value === void 0 ? void 0 : value.id) ? { id: this.form.getUniqueId() } : {}));
                     return [key, Object.assign(Object.assign({}, value), newObjWithId)];
                 }
                 else {
@@ -197,12 +200,20 @@ class Container extends Scriptable_1.default {
             return new DataGroup_1.default(name, instance, type);
         }
     }
-    _initialize() {
-        super._initialize();
+    _canHaveRepeatingChildren(mode = 'create') {
+        const items = this._jsonModel.items;
+        return this._jsonModel.type == 'array' && this.getDataNode() != null &&
+            (items.length === 1 || (items[0].repeatable == true && mode === 'restore'));
+    }
+    _initialize(mode) {
+        super._initialize(mode);
         const items = this._jsonModel.items || [];
         this._childrenReference = this._jsonModel.type == 'array' ? [] : {};
-        if (this._jsonModel.type == 'array' && items.length === 1 && this.getDataNode() != null) {
+        if (this._canHaveRepeatingChildren(mode)) {
             this._itemTemplate = (0, JsonUtils_1.deepClone)(items[0]);
+            if (mode === 'restore') {
+                this._itemTemplate.repeatable = undefined;
+            }
             if (typeof (this._jsonModel.minItems) !== 'number') {
                 this._jsonModel.minItems = 0;
             }
@@ -213,9 +224,22 @@ class Container extends Scriptable_1.default {
                 this._jsonModel.initialItems = Math.max(1, this._jsonModel.minItems);
             }
             for (let i = 0; i < this._jsonModel.initialItems; i++) {
-                const child = this._addChild(this._itemTemplate, null, i > 0);
-                items[0].id = child.id;
-                child._initialize();
+                let child;
+                if (mode === 'restore') {
+                    let itemTemplate = this._itemTemplate;
+                    if (i < this._jsonModel.items.length) {
+                        itemTemplate = (0, JsonUtils_1.deepClone)(items[i]);
+                        itemTemplate.repeatable = undefined;
+                    }
+                    child = this._addChild(itemTemplate, undefined, i > this._jsonModel.items.length - 1);
+                }
+                else {
+                    child = this._addChild(this._itemTemplate, undefined, i > this._jsonModel.items.length - 1);
+                }
+                if (mode === 'create') {
+                    items[0].id = child.id;
+                }
+                child._initialize(mode);
             }
         }
         else if (items.length > 0) {
@@ -225,10 +249,10 @@ class Container extends Scriptable_1.default {
                 }
                 else if (this.isAFormField(item)) {
                     const child = this._addChild(item);
-                    child._initialize();
+                    child._initialize(mode);
                 }
                 else {
-                    this.form.logger.warn('A container item was not initialized.');
+                    this.form.logger.warn(`A container item was not initialized. ${item}`);
                 }
             });
             this._jsonModel.minItems = this._children.length;
@@ -264,7 +288,7 @@ class Container extends Scriptable_1.default {
                 if (_data) {
                     dataNode.$addDataNode(instanceIndex, _data);
                 }
-                retVal._initialize();
+                retVal._initialize('create');
                 this.notifyDependents((0, Events_1.propertyChange)('items', retVal.getState(), null));
                 retVal.dispatch(new Events_1.Initialize());
                 retVal.dispatch(new Events_1.ExecuteRule());
@@ -341,7 +365,7 @@ class Container extends Scriptable_1.default {
             while (items2Add > 0) {
                 items2Add--;
                 const child = this._addChild(this._itemTemplate);
-                child._initialize();
+                child._initialize('create');
             }
             if (items2Remove > 0) {
                 this._children.splice(dataLength, items2Remove);

package/lib/Field.d.ts

@@ -151,7 +151,7 @@ declare class Field extends Scriptable<FieldJson> implements FieldModel {
     validate(): ValidationError[];
     importData(contextualDataModel: DataGroup): void;
     defaultDataModel(name: string | number): DataValue;
-    getState(): {
+    getState(isRepeatableChild?: boolean, forRestore?: boolean): {
         editFormat: string | undefined;
         displayFormat: string | undefined;
         editValue: any;
@@ -159,8 +159,8 @@ declare class Field extends Scriptable<FieldJson> implements FieldModel {
         enabled: boolean | undefined;
         readOnly: boolean | undefined;
         description?: string | undefined;
-        rules: import("./types").Items<string> & {};
-        events: import("./types").Items<string | string[] | undefined> & {};
+        rules?: import("./types").Items<string> | undefined;
+        events?: import("./types").Items<string | string[] | undefined> | undefined;
         enumNames?: string[] | import("./types").EnumName[] | undefined;
         enum?: any[] | undefined;
         accept?: string[] | undefined;
@@ -208,6 +208,11 @@ declare class Field extends Scriptable<FieldJson> implements FieldModel {
         default?: any;
         value?: any;
         emptyValue?: "" | "undefined" | "null" | undefined;
+        _dependents?: string[] | undefined;
+        allowedComponents?: undefined;
+        columnClassNames?: undefined;
+        columnCount?: undefined;
+        gridClassNames?: undefined;
         index: number;
         parent: undefined;
         qualifiedName: any;

package/lib/Field.js

@@ -143,11 +143,11 @@ class Field extends Scriptable_1.default {
         }
         this.coerceParam('minLength', 'number');
         this.coerceParam('maxLength', 'number');
-        if (this._jsonModel.type !== 'number' && this._jsonModel.format !== 'date') {
+        if (this._jsonModel.type !== 'number' && this._jsonModel.format !== 'date' && this._jsonModel.type !== 'integer') {
             this.unset('step', ...props);
         }
         props.forEach(c => {
-            this.coerceParam(c, this._jsonModel.type);
+            this.coerceParam(c, this._jsonModel.type === 'integer' ? 'number' : this._jsonModel.type);
         });
         if (typeof this._jsonModel.step !== 'number') {
             this.coerceParam('step', 'number');
@@ -244,22 +244,22 @@ class Field extends Scriptable_1.default {
         this._setProperty('required', r);
     }
     get maximum() {
-        if (this.type === 'number' || this.format === 'date') {
+        if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {
             return this._jsonModel.maximum;
         }
     }
     set maximum(m) {
-        if (this.type === 'number' || this.format === 'date') {
+        if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {
             this._setProperty('maximum', m);
         }
     }
     get minimum() {
-        if (this.type === 'number' || this.format === 'date') {
+        if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {
             return this._jsonModel.minimum;
         }
     }
     set minimum(m) {
-        if (this.type === 'number' || this.format === 'date') {
+        if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {
             this._setProperty('minimum', m);
         }
     }
@@ -545,22 +545,22 @@ class Field extends Scriptable_1.default {
         }
     }
     get exclusiveMinimum() {
-        if (this.type === 'number' || this.format === 'date') {
+        if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {
             return this._jsonModel.exclusiveMinimum;
         }
     }
     set exclusiveMinimum(eM) {
-        if (this.type === 'number' || this.format === 'date') {
+        if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {
             this._jsonModel.exclusiveMinimum = eM;
         }
     }
     get exclusiveMaximum() {
-        if (this.type === 'number' || this.format === 'date') {
+        if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {
             return this._jsonModel.exclusiveMaximum;
         }
     }
     set exclusiveMaximum(eM) {
-        if (this.type === 'number' || this.format === 'date') {
+        if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {
             this._jsonModel.exclusiveMaximum = eM;
         }
     }
@@ -666,8 +666,8 @@ class Field extends Scriptable_1.default {
         const value = BaseNode_1.staticFields.indexOf(this.fieldType) > -1 ? undefined : this.getDataNodeValue(this._jsonModel.value);
         return new DataValue_1.default(name, value, this.type || 'string');
     }
-    getState() {
-        return Object.assign(Object.assign({}, super.getState()), { editFormat: this.editFormat, displayFormat: this.displayFormat, editValue: this.editValue, displayValue: this.displayValue, enabled: this.enabled, readOnly: this.readOnly });
+    getState(isRepeatableChild = false, forRestore = false) {
+        return Object.assign(Object.assign({}, super.getState(forRestore)), { editFormat: this.editFormat, displayFormat: this.displayFormat, editValue: this.editValue, displayValue: this.displayValue, enabled: this.enabled, readOnly: this.readOnly });
     }
     markAsInvalid(message, constraint = null) {
         const changes = {