@aemforms/af-core 0.22.67 → 0.22.69

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

@@ -0,0 +1,125 @@
+import Container from './Container';
+import { Action, BaseModel, FieldModel, FieldsetModel, FormCreationMode, FormJson, FocusOption, FormModel, IFormFieldFactory } from './types/index';
+import FormMetaData from './FormMetaData';
+import SubmitMetaData from './SubmitMetaData';
+import EventQueue from './controller/EventQueue';
+import { Logger, LogLevel } from './controller/Logger';
+import RuleEngine from './rules/RuleEngine';
+declare class Form extends Container<FormJson> implements FormModel {
+    #private;
+    private _ruleEngine;
+    private _eventQueue;
+    private _fields;
+    _ids: Generator<string, void, string>;
+    private _invalidFields;
+    constructor(n: FormJson, fieldFactory: IFormFieldFactory, _ruleEngine: RuleEngine, _eventQueue?: EventQueue, logLevel?: LogLevel, mode?: FormCreationMode);
+    private _logger;
+    get logger(): Logger;
+    private dataRefRegex;
+    get metaData(): FormMetaData;
+    get action(): string | undefined;
+    importData(dataModel: any): void;
+    exportData(): any;
+    resolveQualifiedName(qualifiedName: string): FieldModel | FieldsetModel | null;
+    exportSubmitMetaData(): SubmitMetaData;
+    setFocus(field: BaseModel, focusOption: FocusOption): void;
+    getState(forRestore?: boolean): {
+        description?: string | undefined;
+    } & import("./types/Json").RulesJson & {
+        enumNames?: string[] | import("./types/Json").EnumName[] | undefined;
+        enum?: any[] | undefined;
+    } & {
+        accept?: string[] | undefined;
+        enforceEnum?: boolean | undefined;
+        exclusiveMinimum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        format?: string | undefined;
+        maxFileSize?: string | number | undefined;
+        maxLength?: number | undefined;
+        maximum?: number | undefined;
+        maxItems?: number | undefined;
+        minOccur?: number | undefined;
+        maxOccur?: number | undefined;
+        minLength?: number | undefined;
+        minimum?: number | undefined;
+        minItems?: number | undefined;
+        pattern?: string | undefined;
+        required?: boolean | undefined;
+        step?: number | undefined;
+        type?: string | undefined;
+        validationExpression?: string | undefined;
+        uniqueItems?: boolean | undefined;
+    } & {
+        dataRef?: string | null | undefined;
+        lang?: string | undefined;
+        ':type'?: string | undefined;
+        appliedCssClassNames?: string | undefined;
+        label?: import("./types/Json").Label | undefined;
+        enabled?: boolean | undefined;
+        visible?: boolean | undefined;
+        name?: string | undefined;
+        constraintMessages?: import("./types/Json").ConstraintsMessages | undefined;
+        fieldType?: string | undefined;
+        errorMessage?: string | undefined;
+        properties?: {
+            [key: string]: any;
+        } | undefined;
+        repeatable?: boolean | undefined;
+        screenReaderText?: string | undefined;
+        tooltip?: string | undefined;
+        altText?: string | undefined;
+        viewType?: string | undefined;
+    } & {
+        items: (import("./types/Json").FieldJson | import("./types/Json").ContainerJson)[];
+        initialItems?: number | undefined;
+        activeChild?: string | undefined;
+    } & {
+        metadata?: import("./types/Json").MetaDataJson | undefined;
+        data?: any;
+        title?: string | undefined;
+        action?: string | undefined;
+        adaptiveForm?: string | undefined;
+        lang?: string | undefined;
+    } & {
+        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;
+        repeatable: boolean | undefined;
+        ':type': string;
+        id: string;
+    };
+    get type(): string;
+    isTransparent(): boolean;
+    get form(): FormModel;
+    get ruleEngine(): RuleEngine;
+    getUniqueId(): string;
+    fieldAdded(field: FieldModel | FieldsetModel): void;
+    visit(callBack: (field: FieldModel | FieldsetModel) => void): void;
+    traverseChild(container: Container<any>, callBack: (field: FieldModel | FieldsetModel) => void): void;
+    validate(): import("./types/Model").ValidationError[];
+    isValid(): boolean;
+    dispatch(action: Action): void;
+    submit(action: Action, context: any): void;
+    reset(): void;
+    getElement(id: string): FieldModel | FieldsetModel | this;
+    get qualifiedName(): string;
+    getEventQueue(): EventQueue;
+    get name(): string;
+    get value(): null;
+    get id(): string;
+    get title(): string;
+}
+export default Form;

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

@@ -0,0 +1,16 @@
+import { FormModel } from './types/index';
+import { LogLevel } from './controller/Logger';
+import { CustomFunction, FunctionDefinition } from './rules/FunctionRuntime';
+export declare const createFormInstance: (formModel: any, callback?: ((f: FormModel) => any) | undefined, logLevel?: LogLevel, fModel?: any) => FormModel;
+export declare const restoreFormInstance: (formModel: any, { logLevel }?: {
+    logLevel: LogLevel;
+}) => FormModel;
+export declare const validateFormInstance: (formModel: any, data: any) => boolean;
+export declare const validateFormData: (formModel: any, data: any) => {
+    messages: any[];
+    valid: boolean;
+};
+export declare const fetchForm: (url: string, headers?: any) => Promise<string>;
+export declare const registerFunctions: (functions: {
+    [key: string]: Function | FunctionDefinition;
+}) => void;

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

@@ -0,0 +1,7 @@
+import { FormMetaDataModel, MetaDataJson } from './types/index';
+import Node from './Node';
+declare class FormMetaData extends Node<MetaDataJson> implements FormMetaDataModel {
+    get version(): string;
+    get grammar(): string;
+}
+export default FormMetaData;

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

@@ -0,0 +1,9 @@
+import { Action, FieldsetModel } from './types/index';
+import { Fieldset } from './Fieldset';
+export declare class InstanceManager extends Fieldset implements FieldsetModel {
+    get maxOccur(): number;
+    set maxOccur(m: number);
+    get minOccur(): number;
+    addInstance(action: Action): void;
+    removeInstance(action: Action): void;
+}

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

@@ -0,0 +1,7 @@
+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/esm/types/src/Scriptable.d.ts

@@ -0,0 +1,17 @@
+import { Action, RulesJson, ScriptableField } from './types/index';
+import { BaseNode } from './BaseNode';
+declare abstract class Scriptable<T extends RulesJson> extends BaseNode<T> implements ScriptableField {
+    private _events;
+    private _rules;
+    getRules(): import("./types/Json").Items<string>;
+    private getCompiledRule;
+    private getCompiledEvent;
+    private applyUpdates;
+    protected executeAllRules(context: any): void;
+    private getExpressionScope;
+    private executeEvent;
+    executeRule(event: Action, context: any): void;
+    executeExpression(expr: string): any;
+    executeAction(action: Action): void;
+}
+export default Scriptable;

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

@@ -0,0 +1,7 @@
+import { SubmitMetaDataModel } from './types/index';
+declare class SubmitMetaData implements SubmitMetaDataModel {
+    lang: string;
+    captchaInfo: Record<string, any>;
+    constructor(lang: string | undefined, captchaInfo: Record<string, any>);
+}
+export default SubmitMetaData;

package/esm/types/src/controller/EventQueue.d.ts

@@ -0,0 +1,18 @@
+import { Action, BaseJson } from '../types/index';
+import { BaseNode } from '../BaseNode';
+import { Logger } from './Logger';
+declare class EventQueue {
+    private logger;
+    static readonly MAX_EVENT_CYCLE_COUNT = 10;
+    private _runningEventCount;
+    private _isProcessing;
+    private _pendingEvents;
+    constructor(logger?: Logger);
+    get length(): number;
+    get isProcessing(): boolean;
+    isQueued<T extends BaseJson>(node: BaseNode<T>, event: Action): boolean;
+    queue<T extends BaseJson>(node: BaseNode<T>, events: Action | Action[], priority?: boolean): void;
+    empty(): void;
+    runPendingQueue(): void;
+}
+export default EventQueue;

package/esm/types/src/controller/Events.d.ts

@@ -0,0 +1,91 @@
+import { Action, BaseJson, FieldModel, FieldsetModel, FormModel, ValidationError } from '../types/index';
+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;
+}
+export type ChangePayload = {
+    changes: Array<{
+        propertyName: string;
+        prevValue?: any;
+        currentValue: any;
+    }>;
+};
+export declare class Change extends ActionImpl {
+    constructor(payload: ChangePayload, dispatch?: boolean);
+    withAdditionalChange(change: Change): Change;
+}
+export declare class Invalid extends ActionImpl {
+    constructor(payload?: any);
+}
+export declare class Valid extends ActionImpl {
+    constructor(payload?: any);
+}
+export declare class ExecuteRule extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare const propertyChange: (propertyName: string, currentValue: any, prevValue?: any) => Change;
+export declare class Initialize extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class FormLoad extends ActionImpl {
+    constructor();
+}
+export declare class Click extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class Blur extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class ValidationComplete extends ActionImpl {
+    constructor(payload?: Array<ValidationError>, dispatch?: boolean);
+}
+export declare class Focus extends ActionImpl {
+    constructor();
+}
+export declare class Submit extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class SubmitSuccess extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class SubmitFailure extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class Reset extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class FieldChanged extends ActionImpl {
+    constructor(changes: ChangePayload, field: BaseJson);
+}
+export declare class CustomEvent extends ActionImpl {
+    constructor(eventName: string, payload?: any, dispatch?: boolean);
+    get isCustomEvent(): boolean;
+}
+export declare class AddItem extends ActionImpl {
+    constructor(payload?: number);
+}
+export declare class RemoveItem extends ActionImpl {
+    constructor(payload?: number);
+}
+export declare class AddInstance extends ActionImpl {
+    constructor(payload?: number);
+}
+export declare class RemoveInstance extends ActionImpl {
+    constructor(payload?: number);
+}
+export {};

package/esm/types/src/controller/Logger.d.ts

@@ -0,0 +1,11 @@
+export type LogFunction = 'info' | 'warn' | 'error' | 'debug';
+export type LogLevel = 'off' | LogFunction;
+export declare class Logger {
+    debug(msg: string): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    log(msg: string, level: LogFunction): void;
+    private logLevel;
+    constructor(logLevel?: LogLevel);
+}

package/esm/types/src/data/DataGroup.d.ts

@@ -0,0 +1,20 @@
+import DataValue from './DataValue';
+export default class DataGroup extends DataValue {
+    $_items: {
+        [key: string]: DataValue | DataGroup;
+    } | DataValue[] | DataGroup[];
+    private createEntry;
+    constructor(_name: string | number, _value: {
+        [key: string]: any;
+    } | any[], _type?: string);
+    get $value(): Array<any> | {
+        [key: string]: any;
+    };
+    get $length(): number;
+    $convertToDataValue(): DataValue;
+    $addDataNode(name: string | number, value: DataGroup | DataValue, override?: boolean): void;
+    $removeDataNode(name: string | number): void;
+    $getDataNode(name: string | number): any;
+    $containsDataNode(name: string | number): boolean;
+    get $isDataGroup(): boolean;
+}

package/esm/types/src/data/DataValue.d.ts

@@ -0,0 +1,16 @@
+import { FieldModel } from '../types/index';
+export default class DataValue {
+    private $_name;
+    private $_value;
+    private $_type;
+    $_fields: Array<FieldModel>;
+    constructor($_name: string | number, $_value: any, $_type?: string);
+    valueOf(): any;
+    get $name(): string | number;
+    get $value(): any;
+    setValue(typedValue: any, originalValue: any, fromField: FieldModel): void;
+    get $type(): string;
+    $bindToField(field: FieldModel): void;
+    $convertToDataValue(): DataValue;
+    get $isDataGroup(): boolean;
+}

package/esm/types/src/data/EmptyDataValue.d.ts

@@ -0,0 +1,14 @@
+import DataValue from './DataValue';
+declare class NullDataValueClass extends DataValue {
+    constructor();
+    setValue(): void;
+    $bindToField(): void;
+    $length(): number;
+    $convertToDataValue(): DataValue;
+    $addDataNode(): void;
+    $removeDataNode(): void;
+    $getDataNode(): this;
+    $containsDataNode(): boolean;
+}
+declare const NullDataValue: NullDataValueClass;
+export default NullDataValue;

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

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

package/esm/types/src/rules/FunctionRuntime.d.ts

@@ -0,0 +1,62 @@
+type HTTP_VERB = 'GET' | 'POST';
+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' | 'application/x-www-form-urlencoded', input_data?: any) => Promise<void>;
+export type CustomFunction = Function;
+export type FunctionDefinition = {
+    _func: CustomFunction;
+    _signature: Array<any>;
+};
+declare class FunctionRuntimeImpl {
+    private static instance;
+    private customFunctions;
+    private constructor();
+    static getInstance(): FunctionRuntimeImpl;
+    registerFunctions(functions: {
+        [key: string]: FunctionDefinition | CustomFunction;
+    }): void;
+    unregisterFunctions(...names: string[]): void;
+    getFunctions(): {
+        validate: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => any;
+            _signature: never[];
+        };
+        setFocus: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => void;
+            _signature: never[];
+        };
+        getData: {
+            _func: (args: unknown, data: unknown, interpreter: any) => any;
+            _signature: never[];
+        };
+        exportData: {
+            _func: (args: unknown, data: unknown, interpreter: any) => any;
+            _signature: never[];
+        };
+        importData: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
+            _signature: never[];
+        };
+        submitForm: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
+            _signature: never[];
+        };
+        request: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
+            _signature: never[];
+        };
+        addInstance: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => void;
+            _signature: never[];
+        };
+        removeInstance: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => void;
+            _signature: never[];
+        };
+        dispatchEvent: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
+            _signature: never[];
+        };
+    };
+}
+export declare const FunctionRuntime: FunctionRuntimeImpl;
+export {};

package/esm/types/src/rules/RuleEngine.d.ts

@@ -0,0 +1,16 @@
+import { BaseModel } from '../types/index';
+import Formula from '@adobe/json-formula';
+declare class RuleEngine {
+    private _context;
+    private _globalNames;
+    private readonly customFunctions;
+    private debugInfo;
+    constructor();
+    compileRule(rule: string, locale?: string): {
+        formula: Formula;
+        ast: any;
+    };
+    execute(node: any, data: any, globals: any, useValueOf?: boolean): any;
+    trackDependency(subscriber: BaseModel): void;
+}
+export default RuleEngine;

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

@@ -0,0 +1,180 @@
+export type Items<T> = {
+    [key: string]: T;
+};
+export type Primitives = string | number | boolean | null | undefined;
+export type Label = {
+    value: string;
+    richText?: boolean;
+    visible?: boolean;
+};
+export type EnumName = {
+    value: string;
+    richText?: boolean;
+};
+type TranslationConstraintsJson = {
+    enumNames?: string[] | EnumName[];
+    enum?: any[];
+};
+export type ConstraintsJson = TranslationConstraintsJson & {
+    accept?: string[];
+    enforceEnum?: boolean;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    format?: string;
+    maxFileSize?: number | string;
+    maxLength?: number;
+    maximum?: number;
+    maxItems?: number;
+    minOccur?: number;
+    maxOccur?: number;
+    minLength?: number;
+    minimum?: number;
+    minItems?: number;
+    pattern?: string;
+    required?: boolean;
+    step?: number;
+    type?: string;
+    validationExpression?: string;
+    uniqueItems?: boolean;
+};
+export type ConstraintsMessages = {
+    accept?: string;
+    enum?: string;
+    exclusiveMinimum?: string;
+    exclusiveMaximum?: string;
+    format?: string;
+    maxFileSize?: string;
+    maxLength?: string;
+    maximum?: string;
+    maxItems?: string;
+    minLength?: string;
+    minimum?: string;
+    minItems?: string;
+    uniqueItems?: string;
+    pattern?: string;
+    required?: string;
+    step?: string;
+    type?: string;
+    validationExpression?: string;
+};
+export type RulesJson = {
+    rules?: Items<string>;
+    events?: Items<string[] | string | undefined>;
+};
+type TranslationBaseJson = {
+    description?: string;
+};
+export type BaseJson = TranslationBaseJson & RulesJson & ConstraintsJson & {
+    dataRef?: string | null;
+    lang?: string;
+    ':type'?: string;
+    appliedCssClassNames?: string;
+    label?: Label;
+    enabled?: boolean;
+    visible?: boolean;
+    name?: string;
+    constraintMessages?: ConstraintsMessages;
+    fieldType?: string;
+    errorMessage?: string;
+    properties?: {
+        [key: string]: any;
+    };
+    repeatable?: boolean;
+    screenReaderText?: string;
+    tooltip?: string;
+    altText?: string;
+    viewType?: string;
+};
+type TranslationFieldJson = {
+    placeholder?: string;
+};
+export type FieldJson = BaseJson & TranslationFieldJson & {
+    readOnly?: boolean;
+    valid?: boolean;
+    validity?: any;
+    validationMessage?: string;
+    default?: any;
+    value?: any;
+    displayFormat?: string;
+    editFormat?: string;
+    editValue?: string;
+    displayValue?: string;
+    emptyValue?: 'null' | 'undefined' | '';
+};
+export type ContainerJson = BaseJson & {
+    items: Array<FieldJson | ContainerJson>;
+    initialItems?: number;
+    activeChild?: string;
+};
+export type MetaDataJson = {
+    version?: string;
+    grammar?: string;
+};
+export type FieldsetJson = ContainerJson & {
+    'type'?: 'array' | 'object';
+    readOnly?: boolean;
+};
+export type FormJson = ContainerJson & {
+    metadata?: MetaDataJson;
+    data?: any;
+    title?: string;
+    action?: string;
+    adaptiveForm?: string;
+    lang?: string;
+};
+export type TranslationJson = TranslationBaseJson & TranslationFieldJson & TranslationConstraintsJson;
+export declare const translationProps: string[];
+export declare const constraintProps: string[];
+export declare const ConstraintType: Readonly<{
+    PATTERN_MISMATCH: "patternMismatch";
+    TOO_SHORT: "tooShort";
+    TOO_LONG: "tooLong";
+    RANGE_OVERFLOW: "rangeOverflow";
+    RANGE_UNDERFLOW: "rangeUnderflow";
+    TYPE_MISMATCH: "typeMismatch";
+    VALUE_MISSING: "valueMissing";
+    STEP_MISMATCH: "stepMismatch";
+    FORMAT_MISMATCH: "formatMismatch";
+    ACCEPT_MISMATCH: "acceptMismatch";
+    FILE_SIZE_MISMATCH: "fileSizeMismatch";
+    UNIQUE_ITEMS_MISMATCH: "uniqueItemsMismatch";
+    MIN_ITEMS_MISMATCH: "minItemsMismatch";
+    MAX_ITEMS_MISMATCH: "maxItemsMismatch";
+    EXPRESSION_MISMATCH: "expressionMismatch";
+}>;
+export declare const constraintKeys: Readonly<{
+    pattern: "patternMismatch";
+    minLength: "tooShort";
+    maxLength: "tooLong";
+    maximum: "rangeOverflow";
+    minimum: "rangeUnderflow";
+    type: "typeMismatch";
+    required: "valueMissing";
+    step: "stepMismatch";
+    format: "formatMismatch";
+    accept: "acceptMismatch";
+    maxFileSize: "fileSizeMismatch";
+    uniqueItems: "uniqueItemsMismatch";
+    minItems: "minItemsMismatch";
+    maxItems: "maxItemsMismatch";
+    validationExpression: "expressionMismatch";
+}>;
+export declare const setCustomDefaultConstraintTypeMessages: (messages: Record<string, string>) => void;
+export declare const getConstraintTypeMessages: () => {
+    patternMismatch: "Please match the format requested.";
+    tooShort: "Please lengthen this text to ${0} characters or more.";
+    tooLong: "Please shorten this text to ${0} characters or less.";
+    rangeOverflow: "Value must be less than or equal to ${0}.";
+    rangeUnderflow: "Value must be greater than or equal to ${0}.";
+    typeMismatch: "Please enter a valid value.";
+    valueMissing: "Please fill in this field.";
+    stepMismatch: "Please enter a valid value.";
+    formatMismatch: "Specify the value in allowed format : ${0}.";
+    acceptMismatch: "The specified file type not supported.";
+    fileSizeMismatch: "File too large. Reduce size and try again.";
+    uniqueItemsMismatch: "All the items must be unique.";
+    minItemsMismatch: "Specify a number of items equal to or greater than ${0}.";
+    maxItemsMismatch: "Specify a number of items equal to or less than ${0}.";
+    expressionMismatch: "Please enter a valid value.";
+};
+export {};