@vixoniccom/modules 2.11.0

package/dist/lib/containers/list.d.ts

@@ -0,0 +1,66 @@
+import { Omit, BaseElement, IBaseElement } from '../base';
+import { RangeValue } from '../values';
+import { InputComponent } from '../inputs';
+import { UIComponent } from '../ui';
+import { TypeDefMap } from '../utils/typeDefs';
+import { ErrorsMap, Errors } from '../errors';
+import { Configuration } from '..';
+export declare type DisplayClass = '2-lines' | '1-line';
+export declare type DisplayAttributes = {
+    title: string;
+    subtitle?: string;
+};
+export interface IList extends IBaseElement {
+    id: string;
+    label: string;
+    itemSchema: (InputComponent | UIComponent)[];
+    itemDisplayClass: DisplayClass;
+    itemDisplayAttributes: DisplayAttributes;
+    description?: string;
+    range?: RangeValue;
+    sortable?: boolean;
+    showItemId?: boolean;
+}
+export interface ListJSON extends Omit<IList, 'itemSchema' | 'range'> {
+    range?: string;
+    itemSchema: {
+        type: string;
+    }[];
+}
+export declare type ListItem = {
+    [key: string]: any;
+    __id: string | undefined;
+};
+export declare namespace List {
+    type Value = ListItem[];
+    type ItemValue = ListItem;
+    type Error = {
+        type: 'ItemHasNoUniqueId';
+    } | {
+        type: 'InvalidListValue';
+    } | {
+        type: 'Min';
+        payload: number;
+    } | {
+        type: 'Max';
+        payload: number;
+    };
+}
+export declare class List extends BaseElement {
+    static readonly type: string;
+    type: string;
+    readonly itemSchema: (InputComponent | UIComponent)[];
+    readonly itemDisplayClass: DisplayClass;
+    readonly itemDisplayAttributes: DisplayAttributes;
+    readonly description?: string;
+    readonly range?: RangeValue;
+    readonly sortable?: boolean;
+    readonly showItemId?: boolean;
+    constructor(options: IList);
+    validate(value: List.Value | undefined, ctx: Configuration.Value): ErrorsMap | List.Error[];
+    validateItem(value: List.ItemValue, ctx: Configuration.Value): Errors<List.Error>;
+    isValidValue(v: any): v is List.Value;
+    valueTypeDef: () => TypeDefMap;
+    static fromJSON(value: ListJSON): List;
+    static isInstance(instance: any): instance is List;
+}

package/dist/lib/containers/list.js

@@ -0,0 +1,105 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+    }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var base_1 = require("../base");
+var values_1 = require("../values");
+var inputs_1 = require("../inputs");
+var utils_1 = require("../utils");
+var typeDefs_1 = require("../utils/typeDefs");
+var List = (function (_super) {
+    __extends(List, _super);
+    function List(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = List.type;
+        _this.valueTypeDef = function () {
+            var declarations = [];
+            declarations = declarations.concat(typeDefs_1.getDefsFromInputs(_this.itemSchema.filter(inputs_1.isInput)));
+            return {
+                id: _this.id,
+                typeDef: "{" + typeDefs_1.defsMapToString(declarations) + ", __id: string | undefined}[]"
+            };
+        };
+        _this.itemSchema = options.itemSchema;
+        _this.description = options.description;
+        _this.range = options.range;
+        _this.itemDisplayClass = options.itemDisplayClass;
+        _this.itemDisplayAttributes = options.itemDisplayAttributes;
+        _this.sortable = options.sortable;
+        _this.showItemId = options.showItemId;
+        return _this;
+    }
+    List.prototype.validate = function (value, ctx) {
+        var _this = this;
+        // Min
+        if (this.range && this.range.min) {
+            if (!value || value.length < this.range.min) {
+                return [{ type: 'Min', payload: this.range.min }];
+            }
+        }
+        // Max
+        if (this.range && this.range.max) {
+            if (value && value.length > this.range.max) {
+                return [{ type: 'Max', payload: this.range.max }];
+            }
+        }
+        // No value, then is valid.
+        if (!value)
+            return {};
+        // Not a valid value.
+        if (!this.isValidValue(value))
+            return [{ type: 'InvalidListValue' }];
+        var itemsErrors = {};
+        value && value.map(function (item, index) {
+            var itemErrors = _this.validateItem(item, ctx);
+            var itemId = item.__id || index;
+            itemsErrors[itemId] = itemErrors;
+        });
+        return itemsErrors;
+    };
+    List.prototype.validateItem = function (value, ctx) {
+        var itemError = {};
+        if (value.__id) {
+            var itemErrors_1 = {};
+            this.itemSchema.forEach(function (input) {
+                if (inputs_1.isInput(input)) {
+                    itemErrors_1[input.id] = input.validate(value[input.id], ctx);
+                }
+            });
+            return itemErrors_1;
+        }
+        else {
+            return [{ type: 'ItemHasNoUniqueId' }];
+        }
+    };
+    List.prototype.isValidValue = function (v) {
+        return v && Array.isArray(v);
+    };
+    List.fromJSON = function (value) {
+        return new List(__assign({}, value, { range: value.range && values_1.RangeValue.fromJSON(value.range) || undefined, itemSchema: value.itemSchema.map(function (i) {
+                return utils_1.createComponentFromJSON(i.type, i);
+            }) }));
+    };
+    List.isInstance = function (instance) {
+        return instance.type === List.type;
+    };
+    List.type = 'list';
+    return List;
+}(base_1.BaseElement));
+exports.List = List;

package/dist/lib/errors.d.ts

@@ -0,0 +1,22 @@
+export declare namespace ValueError {
+    type Required = SimpleValueError<'required'>;
+    type Min = PayloadValueError<'min', number>;
+    type Max = PayloadValueError<'max', number>;
+    type InvalidValue = SimpleValueError<'invalidValue'>;
+}
+export interface SimpleValueError<E extends string> {
+    type: E;
+}
+export interface PayloadValueError<E extends string, P> extends SimpleValueError<E> {
+    payload: P;
+}
+export declare type ValueError<E extends string = string, P = {}> = SimpleValueError<E> | PayloadValueError<E, P>;
+export declare namespace Errors {
+    const isMap: (errors: Errors<ValueError<string, {}>>) => errors is ErrorsMap<ValueError<string, {}>>;
+    const isArray: (errors: Errors<ValueError<string, {}>>) => errors is ValueError<string, {}>[];
+    const any: (errors: ErrorsMap<ValueError<string, {}>> | ValueError<string, {}>[] | undefined) => boolean;
+}
+export declare type Errors<E extends ValueError = ValueError> = E[] | ErrorsMap;
+export interface ErrorsMap<E extends ValueError = ValueError> {
+    [id: string]: Errors | undefined;
+}

package/dist/lib/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Errors;
+(function (Errors) {
+    Errors.isMap = function (errors) {
+        return !Array.isArray(errors);
+    };
+    Errors.isArray = function (errors) {
+        return Array.isArray(errors);
+    };
+    Errors.any = function (errors) {
+        if (!errors)
+            return false;
+        if (Array.isArray(errors)) {
+            return errors.length > 0;
+        }
+        else {
+            return Object.keys(errors).some(function (k) {
+                return Errors.any(errors[k]);
+            });
+        }
+    };
+})(Errors = exports.Errors || (exports.Errors = {}));

package/dist/lib/index.d.ts

@@ -0,0 +1,29 @@
+import { List, Group, DynamicMatrix } from './containers';
+export { Group, List, DynamicMatrix };
+import { InputValue } from './inputs';
+import { ErrorsMap } from './errors';
+export declare namespace Configuration {
+    type Value = {
+        [key: string]: InputValue;
+    };
+    type Options = {
+        schema: (Group | List | DynamicMatrix)[];
+        durationFormula?: string;
+    };
+}
+export declare class Configuration {
+    readonly schema: (Group | List | DynamicMatrix)[];
+    readonly durationFormula: string | undefined;
+    constructor(options: Configuration.Options);
+    validate(state: Configuration.Value): ErrorsMap;
+    toJSON(): {
+        durationFormula: string | undefined;
+        schema: (Group | List | DynamicMatrix)[];
+    };
+    getDuration(_values: Configuration.Value): number | undefined;
+    static fromJSON(input: any): Configuration;
+    readonly declarationFileString: string;
+}
+export * from './inputs';
+export * from './ui';
+export * from './values';

package/dist/lib/index.js

@@ -0,0 +1,128 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var containers_1 = require("./containers");
+exports.List = containers_1.List;
+exports.Group = containers_1.Group;
+exports.DynamicMatrix = containers_1.DynamicMatrix;
+var typeDefs_1 = require("./utils/typeDefs");
+var inputs_1 = require("./inputs");
+var Configuration = (function () {
+    function Configuration(options) {
+        this.schema = options.schema;
+        this.durationFormula = options.durationFormula;
+    }
+    Configuration.prototype.validate = function (state) {
+        var errors = {};
+        this.schema.forEach(function (container) {
+            var visible = container.shouldShow(state);
+            if (visible === false)
+                return;
+            if (containers_1.Group.isInstance(container)) {
+                var groupErrors_1 = {};
+                // Validate each input in a group.
+                container.items.forEach(function (input) {
+                    if (inputs_1.isInput(input)) {
+                        var inputErrors = input.validate(state[input.id], state);
+                        groupErrors_1[input.id] = inputErrors;
+                    }
+                });
+                errors[container.id] = groupErrors_1;
+            }
+            else if (containers_1.List.isInstance(container)) {
+                // Validate the list.
+                errors[container.id] = container.validate(state[container.id], state);
+            }
+            else {
+                // Validate the dynamic matrix.
+                errors[container.id] = container.validate(state[container.id], state);
+            }
+        });
+        return errors;
+    };
+    Configuration.prototype.toJSON = function () {
+        var allIds = [];
+        this.schema.forEach(function (cont) {
+            allIds.push(cont.id);
+            if (containers_1.Group.isInstance(cont)) {
+                cont.items.forEach(function (item) {
+                    if (item.hasOwnProperty('id'))
+                        allIds.push(item.id);
+                });
+            }
+        });
+        var duplicatedIds = allIds.filter(function (e, i, s) { return s.indexOf(e) !== i; });
+        if (duplicatedIds.length > 0)
+            console.warn("Attention, your configuration has duplicated ids [\"" + duplicatedIds.join('", "') + "\"]. If it is not intentional please check it.");
+        return {
+            durationFormula: this.durationFormula,
+            schema: this.schema
+        };
+    };
+    Configuration.prototype.getDuration = function (_values) {
+        if (!this.durationFormula)
+            return undefined;
+        var jsEval = this.durationFormula;
+        try {
+            var regexp = new RegExp('{{(.*?)}}', 'ig');
+            jsEval = jsEval.replace(regexp, "_values.$1");
+            // tslint:disable-next-line
+            var time = eval(jsEval);
+            if (typeof time === 'number') {
+                // validate number
+                if (isNaN(time) || time < 4 || time >= 86400) {
+                    console.warn("Computed time error: Number is not valid [" + time + "]");
+                    return undefined;
+                }
+                return time;
+            }
+            else {
+                console.warn("Computed time error: Time expression result is not a number [\"" + typeof time + "\"]");
+                return undefined;
+            }
+        }
+        catch (e) {
+            console.warn('Computed time error: Unable to parse time expression:', jsEval, e);
+            return undefined;
+        }
+    };
+    Configuration.fromJSON = function (input) {
+        var schema = input.schema;
+        var durationFormula = input.durationFormula;
+        return new Configuration({
+            durationFormula: durationFormula,
+            schema: schema.map(function (i) {
+                switch (i.type) {
+                    case containers_1.List.type:
+                        return containers_1.List.fromJSON(i);
+                    case containers_1.Group.type:
+                        return containers_1.Group.fromJSON(i);
+                    case containers_1.DynamicMatrix.type:
+                        return containers_1.DynamicMatrix.fromJSON(i);
+                }
+                throw new Error("Invalid component type \"" + i.type + "\" in root configuration.");
+            })
+        });
+    };
+    Object.defineProperty(Configuration.prototype, "declarationFileString", {
+        get: function () {
+            var declarations = [];
+            this.schema.forEach(function (g) {
+                declarations = declarations.concat(g.valueTypeDef());
+            });
+            return "declare type VixonicData = {\n  downloadsPath: string\n  services: { [key: string]: { data?: any, updatedAt?: number } }\n  parameters: VixonicParameters\n}\n\ndeclare type VixonicParameters = Partial<{\n  " + typeDefs_1.defsMapToString(declarations) + "\n}>";
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return Configuration;
+}());
+exports.Configuration = Configuration;
+// Input components
+__export(require("./inputs"));
+// UI components
+__export(require("./ui"));
+// Values
+__export(require("./values"));

package/dist/lib/inputs/autocomplete.d.ts

@@ -0,0 +1,31 @@
+import { Input, IInput } from '../base';
+import { ValueError } from '../errors';
+export interface IAutocomplete<T extends Autocomplete.Value> extends IInput {
+    items: AutocompleteItem<T>[];
+    description?: string;
+    required?: boolean;
+    defaultValue?: T;
+}
+export declare type AutocompleteItem<T> = {
+    label: string;
+    value: T;
+};
+export declare namespace Autocomplete {
+    type Error = ValueError.Required | ValueError.InvalidValue;
+    type Value = number | string;
+}
+export declare class Autocomplete<T extends Autocomplete.Value> extends Input<Autocomplete.Value, Autocomplete.Error> {
+    static type: string;
+    type: string;
+    readonly items: AutocompleteItem<T>[];
+    readonly description?: string;
+    readonly required?: boolean;
+    readonly multiple?: boolean;
+    readonly searchEnabled?: boolean;
+    readonly defaultValue?: T;
+    constructor(options: IAutocomplete<T>);
+    validateInput(value: T): Autocomplete.Error[];
+    isValidValue(value: any): value is T;
+    static fromJSON(value: IAutocomplete<any>): Autocomplete<any>;
+    valueTypeDef: () => string;
+}

package/dist/lib/inputs/autocomplete.js

@@ -0,0 +1,49 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var base_1 = require("../base");
+var validation_1 = require("../utils/validation");
+var Autocomplete = (function (_super) {
+    __extends(Autocomplete, _super);
+    function Autocomplete(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = Autocomplete.type;
+        _this.valueTypeDef = function () {
+            var options = _this.items.map(function (i) {
+                if (typeof i.value === 'string')
+                    return "'" + i.value + "'";
+                else
+                    return i.value.toString();
+            }).join(' | ');
+            return _this.multiple ? "(" + options + ")[]" : options;
+        };
+        _this.description = options.description;
+        _this.items = options.items;
+        _this.required = options.required;
+        _this.defaultValue = options.defaultValue;
+        return _this;
+    }
+    Autocomplete.prototype.validateInput = function (value) {
+        var errors = [];
+        errors = errors.concat(validation_1.Validator.required(value, this.required, true));
+        return errors;
+    };
+    Autocomplete.prototype.isValidValue = function (value) {
+        return Array.isArray(value) || typeof value === 'string' || typeof value === 'number';
+    };
+    Autocomplete.fromJSON = function (value) {
+        return new Autocomplete(value);
+    };
+    Autocomplete.type = 'autocomplete';
+    return Autocomplete;
+}(base_1.Input));
+exports.Autocomplete = Autocomplete;

package/dist/lib/inputs/color-picker.d.ts

@@ -0,0 +1,23 @@
+import { Input, IInput } from '../base';
+import { ValueError, SimpleValueError } from '../errors';
+export interface IColorPicker extends IInput {
+    description?: string;
+    required?: boolean;
+    output?: 'hex' | 'rgba';
+}
+export declare namespace ColorPicker {
+    type Error = ValueError.Required | ValueError.InvalidValue;
+    type Value = string;
+}
+export declare class ColorPicker extends Input<ColorPicker.Value, ColorPicker.Error> {
+    static type: string;
+    type: string;
+    readonly description?: string;
+    readonly required?: boolean;
+    readonly output: 'hex' | 'rgba' | 'auto';
+    constructor(options: IColorPicker);
+    validateInput(value: string): (SimpleValueError<"required"> | SimpleValueError<"invalidValue">)[];
+    isValidValue(value: any): value is ColorPicker.Value;
+    static fromJSON: (value: IColorPicker) => ColorPicker;
+    valueTypeDef: () => string;
+}

package/dist/lib/inputs/color-picker.js

@@ -0,0 +1,42 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var base_1 = require("../base");
+var validation_1 = require("../utils/validation");
+var ColorPicker = (function (_super) {
+    __extends(ColorPicker, _super);
+    function ColorPicker(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = ColorPicker.type;
+        _this.valueTypeDef = function () {
+            return "string";
+        };
+        _this.description = options.description;
+        _this.required = options.required;
+        _this.output = options.output || 'auto';
+        return _this;
+    }
+    ColorPicker.prototype.validateInput = function (value) {
+        var errors = [];
+        errors = errors.concat(validation_1.Validator.required(value, this.required));
+        return errors;
+    };
+    ColorPicker.prototype.isValidValue = function (value) {
+        return typeof value === 'string';
+    };
+    ColorPicker.type = 'color-picker';
+    ColorPicker.fromJSON = function (value) {
+        return new ColorPicker(value);
+    };
+    return ColorPicker;
+}(base_1.Input));
+exports.ColorPicker = ColorPicker;

package/dist/lib/inputs/date-input.d.ts

@@ -0,0 +1,35 @@
+import { Input, IInput, Omit } from '../base';
+import { DateRangeValue } from '../values';
+import { ValueError } from '../errors';
+export interface IDateInput extends IInput {
+    description?: string;
+    required?: boolean;
+    range?: DateRangeValue;
+    mode?: Mode;
+    displayClass?: DisplayClass;
+    displayFormat?: string;
+}
+export declare type Mode = 'date' | 'datetime-local' | 'time';
+export declare type DisplayClass = 'fromNow' | 'toNow' | 'default';
+export interface DateInputJSON extends Omit<IDateInput, 'range'> {
+    range?: string;
+}
+export declare namespace DateInput {
+    type Error = ValueError.Required | ValueError.Max | ValueError.Min | ValueError.InvalidValue;
+    type Value = string;
+}
+export declare class DateInput extends Input<DateInput.Value, DateInput.Error> {
+    static type: string;
+    type: string;
+    readonly description?: string;
+    readonly required?: boolean;
+    readonly range?: DateRangeValue | undefined;
+    readonly mode?: Mode;
+    readonly displayClass?: DisplayClass;
+    readonly displayFormat?: string;
+    constructor(options: IDateInput);
+    validateInput(value: string): DateInput.Error[];
+    isValidValue(value: any): value is DateInput.Value;
+    static fromJSON(value: DateInputJSON): DateInput;
+    valueTypeDef: () => string;
+}

package/dist/lib/inputs/date-input.js

@@ -0,0 +1,78 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+    }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var base_1 = require("../base");
+var values_1 = require("../values");
+var validation_1 = require("../utils/validation");
+var DateInput = (function (_super) {
+    __extends(DateInput, _super);
+    function DateInput(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = DateInput.type;
+        _this.valueTypeDef = function () { return 'string'; };
+        _this.description = options.description;
+        _this.required = options.required;
+        _this.range = options.range;
+        _this.mode = options.mode;
+        _this.displayClass = options.displayClass;
+        _this.displayFormat = options.displayFormat;
+        return _this;
+    }
+    DateInput.prototype.validateInput = function (value) {
+        var errors = [];
+        errors = errors.concat(validation_1.Validator.required(value, this.required));
+        if (this.range) {
+            if (this.mode !== 'time') {
+                var dateValue = new Date(value);
+                if (this.range.max) {
+                    var max = new Date(this.range.max);
+                    errors = errors.concat(validation_1.Validator.max(dateValue.getTime(), max.getTime()));
+                }
+                if (this.range.min) {
+                    var min = new Date(this.range.min);
+                    errors = errors.concat(validation_1.Validator.min(dateValue.getTime(), min.getTime()));
+                }
+            }
+            else {
+                var dateValue = value && Number(value.replace(':', ''));
+                if (typeof dateValue === 'number' && !isNaN(dateValue)) {
+                    var min = this.range.min && Number(this.range.min.replace(':', ''));
+                    if (typeof min === 'number' && !isNaN(min))
+                        errors = errors.concat(validation_1.Validator.min(dateValue, min));
+                    var max = this.range.max && Number(this.range.max.replace(':', ''));
+                    if (typeof max === 'number' && !isNaN(max))
+                        errors = errors.concat(validation_1.Validator.max(dateValue, max));
+                }
+            }
+        }
+        return errors;
+    };
+    DateInput.prototype.isValidValue = function (value) {
+        return this.mode === 'time'
+            ? typeof value === 'string'
+            : !isNaN(Date.parse(value));
+    };
+    DateInput.fromJSON = function (value) {
+        return new DateInput(__assign({}, value, { range: value.range && values_1.DateRangeValue.fromJSON(value.range) || undefined }));
+    };
+    DateInput.type = 'date-input';
+    return DateInput;
+}(base_1.Input));
+exports.DateInput = DateInput;

package/dist/lib/inputs/index.d.ts

@@ -0,0 +1,24 @@
+import { TextArea } from './text-area';
+import { TextFormat } from './text-format';
+import { TextInput } from './text-input';
+import { Autocomplete } from './autocomplete';
+import { SelectInput } from './select-input';
+import { Switch } from './switch';
+import { NumberInput } from './number-input';
+import { ColorPicker } from './color-picker';
+import { DateInput } from './date-input';
+import { SelectAssetKna } from './select-asset-kna';
+import { Slider } from './slider';
+import { ServiceInput } from './service-input';
+export { TextFormat, TextInput, SelectInput, Switch, TextArea, Autocomplete, NumberInput, ColorPicker, DateInput, SelectAssetKna, Slider, ServiceInput };
+export declare type AnyJson = boolean | number | string | null | JsonArray | JsonMap | undefined;
+export interface JsonMap {
+    [key: string]: AnyJson | undefined;
+}
+export interface JsonArray extends Array<AnyJson> {
+}
+export declare type InputValue = AnyJson;
+export declare type InputComponent = TextInput | TextFormat | SelectInput<string | number> | TextArea | Switch | Autocomplete<string | number> | NumberInput | ColorPicker | DateInput | SelectAssetKna | Slider | ServiceInput;
+export declare const allInputs: (typeof TextInput | typeof TextFormat | typeof Autocomplete | typeof Switch | typeof NumberInput | typeof ColorPicker | typeof DateInput | typeof SelectAssetKna | typeof Slider | typeof ServiceInput)[];
+export declare const isInput: (arg: any) => arg is InputComponent;
+export declare const isInputInstance: <T>(arg: any, type: string | string[]) => arg is T;