@vixoniccom/modules 2.11.0

package/dist/lib/inputs/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var text_area_1 = require("./text-area");
+exports.TextArea = text_area_1.TextArea;
+var text_format_1 = require("./text-format");
+exports.TextFormat = text_format_1.TextFormat;
+var text_input_1 = require("./text-input");
+exports.TextInput = text_input_1.TextInput;
+var autocomplete_1 = require("./autocomplete");
+exports.Autocomplete = autocomplete_1.Autocomplete;
+var select_input_1 = require("./select-input");
+exports.SelectInput = select_input_1.SelectInput;
+var switch_1 = require("./switch");
+exports.Switch = switch_1.Switch;
+var number_input_1 = require("./number-input");
+exports.NumberInput = number_input_1.NumberInput;
+var color_picker_1 = require("./color-picker");
+exports.ColorPicker = color_picker_1.ColorPicker;
+var date_input_1 = require("./date-input");
+exports.DateInput = date_input_1.DateInput;
+var select_asset_kna_1 = require("./select-asset-kna");
+exports.SelectAssetKna = select_asset_kna_1.SelectAssetKna;
+var slider_1 = require("./slider");
+exports.Slider = slider_1.Slider;
+var service_input_1 = require("./service-input");
+exports.ServiceInput = service_input_1.ServiceInput;
+exports.allInputs = [
+    text_format_1.TextFormat,
+    text_input_1.TextInput,
+    select_input_1.SelectInput,
+    switch_1.Switch,
+    text_area_1.TextArea,
+    autocomplete_1.Autocomplete,
+    number_input_1.NumberInput,
+    color_picker_1.ColorPicker,
+    date_input_1.DateInput,
+    select_asset_kna_1.SelectAssetKna,
+    slider_1.Slider,
+    service_input_1.ServiceInput
+];
+exports.isInput = function (arg) {
+    return arg && arg.id !== undefined && arg.valueTypeDef !== undefined;
+};
+exports.isInputInstance = function (arg, type) {
+    if (typeof type === 'string')
+        return arg && arg.type === type;
+    else
+        return arg && type.indexOf(arg.type) !== -1;
+};

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

@@ -0,0 +1,29 @@
+import { Omit, Input, IInput } from '../base';
+import { NumberRangeValue } from '../values';
+import { ValueError } from '../errors';
+export interface INumberInput extends IInput {
+    description?: string;
+    required?: boolean;
+    displayFormat?: string;
+    range?: NumberRangeValue;
+}
+export interface NumberInputJSON extends Omit<INumberInput, 'range'> {
+    range?: string;
+}
+export declare namespace NumberInput {
+    type Error = ValueError.Required | ValueError.Max | ValueError.Min | ValueError.InvalidValue;
+    type Value = number | string;
+}
+export declare class NumberInput extends Input<NumberInput.Value, NumberInput.Error> {
+    static type: string;
+    type: string;
+    readonly range?: NumberRangeValue;
+    readonly description?: string;
+    readonly required?: boolean;
+    readonly displayFormat?: string;
+    constructor(options: INumberInput);
+    validateInput(value?: number): NumberInput.Error[];
+    isValidValue(value: any): value is NumberInput.Value;
+    static fromJSON(value: NumberInputJSON): NumberInput;
+    valueTypeDef: () => string;
+}

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

@@ -0,0 +1,53 @@
+"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 NumberInput = (function (_super) {
+    __extends(NumberInput, _super);
+    function NumberInput(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = NumberInput.type;
+        _this.valueTypeDef = function () { return 'number'; };
+        _this.range = options.range;
+        _this.description = options.description;
+        _this.required = options.required;
+        _this.displayFormat = options.displayFormat;
+        return _this;
+    }
+    NumberInput.prototype.validateInput = function (value) {
+        var errors = [];
+        errors = errors.concat(validation_1.Validator.required(value, this.required));
+        if (this.range && value) {
+            errors = errors.concat(validation_1.Validator.max(value, this.range.max), validation_1.Validator.min(value, this.range.min));
+        }
+        return errors;
+    };
+    NumberInput.prototype.isValidValue = function (value) {
+        return isNaN(value) === false;
+    };
+    NumberInput.fromJSON = function (value) {
+        return new NumberInput(__assign({}, value, { range: value.range && values_1.NumberRangeValue.fromJSON(value.range) || undefined }));
+    };
+    NumberInput.type = 'number-input';
+    return NumberInput;
+}(base_1.Input));
+exports.NumberInput = NumberInput;

package/dist/lib/inputs/select-asset-kna.d.ts

@@ -0,0 +1,34 @@
+import { Input, IInput } from '../base';
+import { ValueError } from '../errors';
+export interface ISelectAssetKna extends IInput {
+    description?: string;
+    required?: boolean;
+    extensions?: string[];
+    multiple?: boolean;
+}
+export declare namespace SelectAssetKna {
+    type Error = ValueError.Required | {
+        type: 'NotFound';
+    };
+    type Value = AssetValue | AssetValue[];
+    type AssetValue = {
+        id: string;
+        filename: string;
+        extension?: string;
+        __isAsset: true;
+        __notFound?: boolean;
+    };
+}
+export declare class SelectAssetKna extends Input<SelectAssetKna.Value, SelectAssetKna.Error> {
+    static type: string;
+    type: string;
+    readonly description?: string;
+    readonly required?: boolean;
+    readonly extensions?: string[];
+    readonly multiple: boolean;
+    constructor(options: ISelectAssetKna);
+    validateInput(value: SelectAssetKna.Value): SelectAssetKna.Error[];
+    isValidValue(v: any): v is SelectAssetKna.Value;
+    static fromJSON: (value: ISelectAssetKna) => SelectAssetKna;
+    valueTypeDef: () => string;
+}

package/dist/lib/inputs/select-asset-kna.js

@@ -0,0 +1,50 @@
+"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 SelectAssetKna = (function (_super) {
+    __extends(SelectAssetKna, _super);
+    function SelectAssetKna(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = SelectAssetKna.type;
+        _this.valueTypeDef = function () {
+            return "{id?: string, filename?: string, extension?: string}" + (_this.multiple ? '[]' : '');
+        };
+        _this.description = options.description;
+        _this.required = options.required;
+        _this.extensions = options.extensions;
+        _this.multiple = options.multiple === true;
+        return _this;
+    }
+    SelectAssetKna.prototype.validateInput = function (value) {
+        var errors = [];
+        errors = errors.concat(validation_1.Validator.required(value, this.required));
+        if (value) {
+            var values = Array.isArray(value) ? value : [value];
+            if (values.some(function (x) { return x.__notFound === true; })) {
+                errors = errors.concat({ type: 'NotFound' });
+            }
+        }
+        return errors;
+    };
+    SelectAssetKna.prototype.isValidValue = function (v) {
+        var values = Array.isArray(v) ? v : [v];
+        return values.some(function (x) { return x.__isAsset !== true; }) === false;
+    };
+    SelectAssetKna.type = 'select-asset-kna-input';
+    SelectAssetKna.fromJSON = function (value) {
+        return new SelectAssetKna(value);
+    };
+    return SelectAssetKna;
+}(base_1.Input));
+exports.SelectAssetKna = SelectAssetKna;

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

@@ -0,0 +1,18 @@
+import { Autocomplete, IAutocomplete } from './autocomplete';
+import { ValueError } from '../errors';
+export interface ISelectInput<T extends number | string> extends IAutocomplete<T> {
+    multiple?: boolean;
+    searchEnabled?: boolean;
+}
+export declare namespace SelectInput {
+    type Error = ValueError.Required;
+    type Value = number | string | number[] | string[];
+}
+export declare class SelectInput<T extends number | string> extends Autocomplete<T> {
+    static type: string;
+    type: string;
+    readonly multiple?: boolean;
+    readonly searchEnabled?: boolean;
+    constructor(options: ISelectInput<T>);
+    static fromJSON(value: ISelectInput<any>): SelectInput<any>;
+}

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

@@ -0,0 +1,29 @@
+"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 autocomplete_1 = require("./autocomplete");
+var SelectInput = (function (_super) {
+    __extends(SelectInput, _super);
+    function SelectInput(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = SelectInput.type;
+        _this.multiple = options.multiple;
+        _this.searchEnabled = options.searchEnabled;
+        return _this;
+    }
+    SelectInput.fromJSON = function (value) {
+        return new SelectInput(value);
+    };
+    SelectInput.type = 'select-input';
+    return SelectInput;
+}(autocomplete_1.Autocomplete));
+exports.SelectInput = SelectInput;

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

@@ -0,0 +1,27 @@
+import { Input, IInput } from '../base';
+import { ValueError } from '../errors';
+export declare type ServiceType = 'RSSService' | 'InstagramMediaService' | 'LinkedInCompanyMediaService' | 'FacebookPageService' | 'WeatherService';
+export interface IServiceInput extends IInput {
+    serviceType: ServiceType;
+    required?: boolean;
+}
+export declare namespace ServiceInput {
+    type Error = ValueError.Required;
+    type Value = {
+        id: string;
+        __isService: true;
+    };
+}
+export declare class ServiceInput extends Input<ServiceInput.Value, ServiceInput.Error> {
+    static type: string;
+    type: string;
+    readonly serviceType: ServiceType;
+    readonly required?: boolean;
+    constructor(options: IServiceInput);
+    validateInput(value?: {
+        id: string;
+    }): ServiceInput.Error[];
+    isValidValue(v: any): v is ServiceInput.Value;
+    static fromJSON: (value: IServiceInput) => ServiceInput;
+    valueTypeDef: () => string;
+}

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

@@ -0,0 +1,41 @@
+"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 ServiceInput = (function (_super) {
+    __extends(ServiceInput, _super);
+    function ServiceInput(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = ServiceInput.type;
+        _this.valueTypeDef = function () {
+            return "{ id: string }";
+        };
+        _this.serviceType = options.serviceType;
+        _this.required = options.required;
+        return _this;
+    }
+    ServiceInput.prototype.validateInput = function (value) {
+        var errors = [];
+        errors = errors.concat(validation_1.Validator.required(value, this.required));
+        return errors;
+    };
+    ServiceInput.prototype.isValidValue = function (v) {
+        return v && v.__isService;
+    };
+    ServiceInput.type = 'service-input';
+    ServiceInput.fromJSON = function (value) {
+        return new ServiceInput(value);
+    };
+    return ServiceInput;
+}(base_1.Input));
+exports.ServiceInput = ServiceInput;

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

@@ -0,0 +1,33 @@
+import { Input, IInput } from '../base';
+import { ValueError } from '../errors';
+export interface ISlider extends IInput {
+    required?: boolean;
+    min: number;
+    max: number;
+    step?: number;
+    defaultValue?: number;
+    description?: string;
+    leftTip?: string;
+    rightTip?: string;
+}
+export declare namespace Slider {
+    type Error = ValueError.Required | ValueError.Max | ValueError.Min;
+    type Value = number;
+}
+export declare class Slider extends Input<Slider.Value, Slider.Error> {
+    static type: string;
+    type: string;
+    readonly required?: boolean;
+    readonly min: number;
+    readonly max: number;
+    readonly step?: number;
+    readonly defaultValue?: number;
+    readonly leftTip?: string;
+    readonly rightTip?: string;
+    readonly description?: string;
+    constructor(options: ISlider);
+    validateInput(value: Slider.Value): Slider.Error[];
+    isValidValue(v: any): v is Slider.Value;
+    static fromJSON: (value: ISlider) => Slider;
+    valueTypeDef: () => string;
+}

package/dist/lib/inputs/slider.js

@@ -0,0 +1,51 @@
+"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 Slider = (function (_super) {
+    __extends(Slider, _super);
+    function Slider(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = Slider.type;
+        _this.valueTypeDef = function () {
+            return "number";
+        };
+        _this.required = options.required;
+        _this.min = options.min;
+        _this.max = options.max;
+        _this.step = options.step;
+        _this.defaultValue = options.defaultValue;
+        _this.leftTip = options.leftTip;
+        _this.rightTip = options.rightTip;
+        _this.description = options.description;
+        return _this;
+    }
+    Slider.prototype.validateInput = function (value) {
+        var errors = [];
+        if (value === undefined && this.required)
+            errors.push({ type: 'required' });
+        if (value > this.max)
+            errors.push({ type: 'max', payload: this.max });
+        if (value < this.min)
+            errors.push({ type: 'min', payload: this.min });
+        return errors;
+    };
+    Slider.prototype.isValidValue = function (v) {
+        return typeof v === 'number';
+    };
+    Slider.type = 'slider';
+    Slider.fromJSON = function (value) {
+        return new Slider(value);
+    };
+    return Slider;
+}(base_1.Input));
+exports.Slider = Slider;

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

@@ -0,0 +1,21 @@
+import { Input, IInput } from '../base';
+export interface ISwitch extends IInput {
+    defaultValue?: boolean;
+    displayOnTrue?: string;
+    displayOnFalse?: string;
+}
+export declare namespace Switch {
+    type Value = boolean;
+}
+export declare class Switch extends Input<Switch.Value> {
+    static type: string;
+    type: string;
+    readonly defaultValue?: boolean;
+    readonly displayOnTrue?: string;
+    readonly displayOnFalse?: string;
+    constructor(options: ISwitch);
+    validateInput(): never[];
+    isValidValue(v: any): v is Switch.Value;
+    static fromJSON: (value: ISwitch) => Switch;
+    valueTypeDef: () => string;
+}

package/dist/lib/inputs/switch.js

@@ -0,0 +1,39 @@
+"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 Switch = (function (_super) {
+    __extends(Switch, _super);
+    function Switch(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = Switch.type;
+        _this.valueTypeDef = function () {
+            return "boolean";
+        };
+        _this.defaultValue = options.defaultValue;
+        _this.displayOnTrue = options.displayOnTrue;
+        _this.displayOnFalse = options.displayOnFalse;
+        return _this;
+    }
+    Switch.prototype.validateInput = function () {
+        return [];
+    };
+    Switch.prototype.isValidValue = function (v) {
+        return typeof v === 'boolean';
+    };
+    Switch.type = 'switch';
+    Switch.fromJSON = function (value) {
+        return new Switch(value);
+    };
+    return Switch;
+}(base_1.Input));
+exports.Switch = Switch;

package/dist/lib/inputs/text-area.d.ts

@@ -0,0 +1,20 @@
+import { TextInput, ITextInput, TextInputJSON } from './text-input';
+import { ValueError } from '../errors';
+export interface ITextArea {
+    rows?: number;
+}
+export interface TextAreaJSON extends ITextArea, TextInputJSON {
+}
+export declare namespace TextArea {
+    type Error = ValueError.Required | ValueError.Max | ValueError.Min | {
+        type: 'pattern';
+    };
+    type Value = string;
+}
+export declare class TextArea extends TextInput {
+    static type: string;
+    type: string;
+    readonly rows?: number;
+    constructor(options: ITextArea & ITextInput);
+    static fromJSON(value: TextAreaJSON): TextArea;
+}

package/dist/lib/inputs/text-area.js

@@ -0,0 +1,37 @@
+"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 text_input_1 = require("./text-input");
+var TextArea = (function (_super) {
+    __extends(TextArea, _super);
+    function TextArea(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = TextArea.type;
+        _this.rows = options.rows;
+        return _this;
+    }
+    TextArea.fromJSON = function (value) {
+        var parsed = text_input_1.TextInput.parseJSON(value);
+        return new TextArea(__assign({}, parsed, { rows: value.rows }));
+    };
+    TextArea.type = 'text-area';
+    return TextArea;
+}(text_input_1.TextInput));
+exports.TextArea = TextArea;

package/dist/lib/inputs/text-format.d.ts

@@ -0,0 +1,28 @@
+import { Input, IInput } from '../base';
+export interface ITextFormat extends IInput {
+    description?: string;
+}
+export declare namespace TextFormat {
+    type Value = {
+        fontSize?: number;
+        fontColor?: string;
+        alignment?: {
+            horizontal?: 'left' | 'right' | 'center';
+        };
+        font?: {
+            filename: string;
+            id: string;
+            __isAsset: true;
+        };
+    };
+}
+export declare class TextFormat extends Input<TextFormat.Value> {
+    static type: string;
+    type: string;
+    readonly description?: string;
+    constructor(options: ITextFormat);
+    validateInput(): never[];
+    isValidValue(v: any): v is TextFormat.Value;
+    static fromJSON: (value: ITextFormat) => TextFormat;
+    valueTypeDef: () => string;
+}

package/dist/lib/inputs/text-format.js

@@ -0,0 +1,37 @@
+"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 TextFormat = (function (_super) {
+    __extends(TextFormat, _super);
+    function TextFormat(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = TextFormat.type;
+        _this.valueTypeDef = function () {
+            return "{ fontSize?: number, fontColor?: string, alignment?: { horizontal?: 'left' | 'right' | 'center' }, font?: { filename: string, id: string, __isAsset: true } }";
+        };
+        _this.description = options.description;
+        return _this;
+    }
+    TextFormat.prototype.validateInput = function () {
+        return [];
+    };
+    TextFormat.prototype.isValidValue = function (v) {
+        return typeof v === 'object';
+    };
+    TextFormat.type = 'text-format';
+    TextFormat.fromJSON = function (value) {
+        return new TextFormat(value);
+    };
+    return TextFormat;
+}(base_1.Input));
+exports.TextFormat = TextFormat;

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

@@ -0,0 +1,34 @@
+import { Input, IInput, Omit } from '../base';
+import { RangeValue } from '../values';
+import { ValueError } from '../errors';
+export interface ITextInput extends IInput {
+    description?: string;
+    required?: boolean;
+    pattern?: string;
+    displayFormat?: string;
+    range?: RangeValue;
+}
+export interface TextInputJSON extends Omit<ITextInput, 'range'> {
+    range?: string;
+}
+export declare namespace TextInput {
+    type Error = ValueError.Required | ValueError.Max | ValueError.Min | {
+        type: 'pattern';
+    };
+    type Value = string;
+}
+export declare class TextInput extends Input<TextInput.Value, TextInput.Error> {
+    static type: string;
+    type: string;
+    readonly description?: string;
+    readonly required?: boolean;
+    readonly pattern?: string;
+    readonly displayFormat?: string;
+    readonly range?: RangeValue | undefined;
+    constructor(options: ITextInput);
+    validateInput(value?: string): TextInput.Error[];
+    isValidValue(v: any): v is TextInput.Value;
+    static fromJSON(value: TextInputJSON): TextInput;
+    protected static parseJSON(value: TextInputJSON): ITextInput;
+    valueTypeDef: () => string;
+}