@ukhomeoffice/formio-gds-template 2.0.1 → 3.0.0-alpha

package/lib/components/datetime/GDSDatetimeComponent.js

@@ -1,105 +1,83 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var formiojs_1 = require("formiojs");
-var utils_1 = require("formiojs/utils");
-var _ = require("lodash");
-var moment = require("moment");
-var TimeHelper_1 = require("../util/TimeHelper");
-var Field = formiojs_1.Components.components.field;
-var Day = formiojs_1.Components.components.day;
-// @ts-ignore
-var GDSDatetimeComponent = /** @class */ (function (_super) {
-    __extends(GDSDatetimeComponent, _super);
-    function GDSDatetimeComponent() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.timeHelper = new TimeHelper_1.default();
-        return _this;
+const js_1 = require("@formio/js");
+const js_2 = require("@formio/js");
+const _ = __importStar(require("lodash"));
+const moment_1 = __importDefault(require("moment"));
+const TimeHelper_1 = __importDefault(require("../util/TimeHelper"));
+const Field = js_1.Components.components.field;
+const Day = js_1.Components.components.day;
+class GDSDatetimeComponent extends Day {
+    constructor() {
+        super(...arguments);
+        this.timeHelper = new TimeHelper_1.default();
     }
-    Object.defineProperty(GDSDatetimeComponent.prototype, "format", {
-        get: function () {
-            return 'DD-MM-YYYY';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GDSDatetimeComponent.prototype, "defaultValue", {
-        // @ts-ignore
-        get: function () {
-            var defaultValue = this.component.defaultValue;
-            if (!defaultValue && this.component.defaultDate) {
-                defaultValue = utils_1.default.getDateSetting(this.component.defaultDate);
-                defaultValue = defaultValue ? moment(defaultValue).format() : '';
-            }
-            return defaultValue;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GDSDatetimeComponent.prototype, "emptyValue", {
-        // @ts-ignore
-        get: function () {
-            return null;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GDSDatetimeComponent.prototype, "parts", {
-        get: function () {
-            return {
-                day: this.getFieldValue('day'),
-                month: this.getFieldValue('month'),
-                year: this.getFieldValue('year'),
-                hour: this.getFieldValue('hour'),
-                minute: this.getFieldValue('minute'),
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    GDSDatetimeComponent.prototype.attach = function (element) {
-        var _this = this;
+    get format() {
+        return 'DD-MM-YYYY';
+    }
+    get defaultValue() {
+        let defaultValue = this.component.defaultValue;
+        if (!defaultValue && this.component.defaultDate) {
+            defaultValue = js_2.Utils.getDateSetting(this.component.defaultDate);
+            defaultValue = defaultValue ? (0, moment_1.default)(defaultValue).format() : '';
+        }
+        return defaultValue !== null && defaultValue !== void 0 ? defaultValue : '';
+    }
+    get emptyValue() {
+        return null;
+    }
+    get parts() {
+        return {
+            day: this.getFieldValue('day'),
+            month: this.getFieldValue('month'),
+            year: this.getFieldValue('year'),
+            hour: this.getFieldValue('hour'),
+            minute: this.getFieldValue('minute'),
+        };
+    }
+    // element typed as `any` to match the base Day.attach(element: any) override signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    attach(element) {
         this.loadRefs(element, { hour: 'single', minute: 'single' });
-        this.addEventListener(this.refs.hour, 'input', function () {
-            _this.timeHelper.checkAndValidateHour(_this.refs.hour);
-            _this.setPristine(false);
-            _this.checkComponentValidity(_this.data, true);
-            _this.updateValue(null, {
-                modified: true,
-            });
-            _this.triggerChange();
+        this.addEventListener(this.refs.hour, 'input', () => {
+            this.timeHelper.checkAndValidateHour(this.refs.hour);
+            this.setPristine(false);
+            this.checkComponentValidity(this.data, true);
+            this.updateValue(null, { modified: true });
+            this.triggerChange();
         });
-        this.addEventListener(this.refs.minute, 'input', function () {
-            _this.timeHelper.checkAndValidateMinutes(_this.refs.minute);
-            _this.setPristine(false);
-            _this.checkComponentValidity(_this.data, true);
-            _this.updateValue(null, {
-                modified: true,
-            });
-            _this.triggerChange();
+        this.addEventListener(this.refs.minute, 'input', () => {
+            this.timeHelper.checkAndValidateMinutes(this.refs.minute);
+            this.setPristine(false);
+            this.checkComponentValidity(this.data, true);
+            this.updateValue(null, { modified: true });
+            this.triggerChange();
         });
         this.addEventListener(this.refs.hour, 'keypress', this.timeHelper.preventNonNumericKeyPress);
         this.addEventListener(this.refs.minute, 'keypress', this.timeHelper.preventNonNumericKeyPress);
@@ -107,48 +85,54 @@ var GDSDatetimeComponent = /** @class */ (function (_super) {
             this.setDisabled(this.refs.hour, true);
             this.setDisabled(this.refs.minute, true);
         }
-        var superAttach = _super.prototype.attach.call(this, element);
+        const superAttach = super.attach(element);
         this.addEventListener(this.refs.year, 'keypress', this.timeHelper.preventNonNumericKeyPress);
         this.addEventListener(this.refs.month, 'keypress', this.timeHelper.preventNonNumericKeyPress);
         this.addEventListener(this.refs.day, 'keypress', this.timeHelper.preventNonNumericKeyPress);
-        this.addEventListener(this.refs.year, 'input', function () {
-            _this.timeHelper.validateDateInput(_this.refs.year, 4);
+        this.addEventListener(this.refs.year, 'input', () => {
+            this.timeHelper.validateDateInput(this.refs.year, 4);
         });
-        this.addEventListener(this.refs.day, 'input', function () {
-            _this.timeHelper.validateDateInput(_this.refs.day, 2);
+        this.addEventListener(this.refs.day, 'input', () => {
+            this.timeHelper.validateDateInput(this.refs.day, 2);
         });
-        this.addEventListener(this.refs.month, 'input', function () {
-            _this.timeHelper.validateDateInput(_this.refs.month, 2);
+        this.addEventListener(this.refs.month, 'input', () => {
+            this.timeHelper.validateDateInput(this.refs.month, 2);
         });
         return superAttach;
-    };
-    GDSDatetimeComponent.prototype.init = function () {
-        _super.prototype.init.call(this);
-        this.validators = this.validators.filter(function (v) { return v !== 'day'; }).concat(['date']);
-        this.component.maxDate = this.component.datePicker.maxDate;
-        this.component.minDate = this.component.datePicker.minDate;
+    }
+    init() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        super.init();
+        // @formio/js@5.x: this.validators is not pre-populated by the base class; guard before filtering
+        this.validators = (this.validators || []).filter((v) => v !== 'day').concat(['date']);
+        this.component.maxDate = (_b = (_a = this.component.datePicker) === null || _a === void 0 ? void 0 : _a.maxDate) !== null && _b !== void 0 ? _b : undefined;
+        this.component.minDate = (_d = (_c = this.component.datePicker) === null || _c === void 0 ? void 0 : _c.minDate) !== null && _d !== void 0 ? _d : undefined;
         this.component.suffix = null;
-        this.component.fields.day.required = this.component.validate.required;
-        this.component.fields.month.required = this.component.validate.required;
-        this.component.fields.year.required = this.component.validate.required;
+        this.component.fields.day.required = (_e = this.component.validate) === null || _e === void 0 ? void 0 : _e.required;
+        this.component.fields.month.required = (_f = this.component.validate) === null || _f === void 0 ? void 0 : _f.required;
+        this.component.fields.year.required = (_g = this.component.validate) === null || _g === void 0 ? void 0 : _g.required;
         this.component.fields.hour = {
-            type: 'number', placeholder: 'HH',
-            required: this.component.validate.required,
+            type: 'number',
+            placeholder: 'HH',
+            required: (_h = this.component.validate) === null || _h === void 0 ? void 0 : _h.required,
         };
         this.component.fields.minute = {
-            type: 'number', placeholder: 'MM',
-            required: this.component.validate.required,
+            type: 'number',
+            placeholder: 'MM',
+            required: (_j = this.component.validate) === null || _j === void 0 ? void 0 : _j.required,
         };
-    };
-    GDSDatetimeComponent.prototype.setErrorClasses = function (elements, dirty, hasError) {
-        // @ts-ignore
-        _super.prototype.setErrorClasses.call(this, __spreadArray([this.refs.hour, this.refs.minute], elements, true), dirty, hasError);
-    };
-    GDSDatetimeComponent.prototype.removeInputError = function (elements) {
-        // @ts-ignore
-        _super.prototype.removeInputError.call(this, __spreadArray([this.refs.hour, this.refs.minute], elements, true));
-    };
-    GDSDatetimeComponent.prototype.render = function () {
+    }
+    // elements typed as `any` to match the base Day.setErrorClasses(elements: any, ...) override signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setErrorClasses(elements, dirty, hasError) {
+        super.setErrorClasses([this.refs.hour, this.refs.minute, ...elements], dirty, hasError);
+    }
+    // elements typed as `any` to match the base Component.removeInputError(elements: any) signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    removeInputError(elements) {
+        super.removeInputError([this.refs.hour, this.refs.minute, ...elements]);
+    }
+    render() {
         return Field.prototype.render.call(this, this.renderTemplate('datetime', {
             component: this.component,
             dataValue: this.dataValue,
@@ -160,45 +144,49 @@ var GDSDatetimeComponent = /** @class */ (function (_super) {
             hour: this.renderField('hour'),
             minute: this.renderField('minute'),
         }));
-    };
-    GDSDatetimeComponent.prototype.getDate = function (value) {
-        var defaults = [];
-        var _a = [0, 1, 2, 3, 4], DAY = _a[0], MONTH = _a[1], YEAR = _a[2], HOUR = _a[3], MINUTE = _a[4];
-        var defaultValue = value || this.component.defaultValue;
+    }
+    // value typed as `any` to match the base Day.getDate(value: any): null | string signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getDate(value) {
+        const defaults = [];
+        const [DAY, MONTH, YEAR, HOUR, MINUTE] = [0, 1, 2, 3, 4];
+        const defaultValue = value || this.component.defaultValue;
         if (defaultValue) {
             try {
-                var defaultDate = moment(defaultValue);
+                const defaultDate = (0, moment_1.default)(defaultValue);
                 defaults[DAY] = defaultDate.format('DD');
                 defaults[MONTH] = defaultDate.format('MM');
                 defaults[YEAR] = defaultDate.format('YYYY');
                 defaults[HOUR] = defaultDate.format('HH');
                 defaults[MINUTE] = defaultDate.format('mm');
             }
-            catch (e) {
+            catch (_a) {
                 // ignored
             }
         }
-        var day = this.processField('day', defaults, DAY);
-        var month = this.processField('month', defaults, MONTH);
-        var year = this.processField('year', defaults, YEAR);
-        var hour = this.processField('hour', defaults, HOUR);
-        var minute = this.processField('minute', defaults, MINUTE);
+        const day = this.processField('day', defaults, DAY);
+        const month = this.processField('month', defaults, MONTH);
+        const year = this.processField('year', defaults, YEAR);
+        const hour = this.processField('hour', defaults, HOUR);
+        const minute = this.processField('minute', defaults, MINUTE);
         if (!day && !month && !year && (!hour && !minute)) {
             return null;
         }
-        day = day.toString().padStart(2, 0);
-        month = month.toString().padStart(2, 0);
-        year = year.toString().padStart(4, 0);
-        hour = hour.toString().padStart(2, 0);
-        minute = minute.toString().padStart(2, 0);
-        var toMoment = moment("".concat(year, "-").concat(month, "-").concat(day, " ").concat(hour, ":").concat(minute), 'YYYY-MM-DD HH:mm');
+        const dayStr = day.toString().padStart(2, '0');
+        const monthStr = month.toString().padStart(2, '0');
+        const yearStr = year.toString().padStart(4, '0');
+        const hourStr = hour.toString().padStart(2, '0');
+        const minuteStr = minute.toString().padStart(2, '0');
+        const toMoment = (0, moment_1.default)(`${yearStr}-${monthStr}-${dayStr} ${hourStr}:${minuteStr}`, 'YYYY-MM-DD HH:mm');
         return toMoment.format();
-    };
-    GDSDatetimeComponent.prototype.getFieldValue = function (name) {
+    }
+    // name typed as `any` to match the base Day.getFieldValue(name: any): number signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getFieldValue(name) {
         if (this.dataValue && this.dataValue !== 'Invalid date') {
             try {
-                var val = null;
-                var date = moment(this.dataValue, 'YYYY-MM-DD HH:mm');
+                let val = null;
+                const date = (0, moment_1.default)(this.dataValue, 'YYYY-MM-DD HH:mm');
                 switch (name) {
                     case 'month':
                         val = date.format('MM');
@@ -218,13 +206,13 @@ var GDSDatetimeComponent = /** @class */ (function (_super) {
                 }
                 return val;
             }
-            catch (e) {
+            catch (_a) {
                 return null;
             }
         }
         return null;
-    };
-    GDSDatetimeComponent.prototype.boolValue = function (value) {
+    }
+    boolValue(value) {
         if (_.isBoolean(value)) {
             return value;
         }
@@ -234,14 +222,15 @@ var GDSDatetimeComponent = /** @class */ (function (_super) {
         else {
             return !!value;
         }
-    };
-    GDSDatetimeComponent.prototype.setValueAt = function (index, value) {
-        // temporary solution to avoid input reset
-        // on invalid date.
+    }
+    // value typed as `any` to match the base Day.setValueAt(index: number, value: any) signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setValueAt(index, value) {
+        // temporary solution to avoid input reset on invalid date.
         if (!value || value === 'Invalid date') {
             return;
         }
-        var date = moment(value, moment.ISO_8601);
+        const date = (0, moment_1.default)(value, moment_1.default.ISO_8601);
         if (date.isValid()) {
             if (this.refs.day) {
                 this.refs.day.value = date.format('DD');
@@ -259,10 +248,10 @@ var GDSDatetimeComponent = /** @class */ (function (_super) {
                 this.refs.minute.value = date.format('mm');
             }
         }
-    };
-    GDSDatetimeComponent.prototype.getValueAt = function (index) {
-        // @ts-ignore
-        var date = this.date;
+    }
+    getValueAt(index) {
+        // `date` is a public getter declared on DayComponent: get date(): string | null
+        const date = this.date;
         if (date) {
             this.refs.input[index].value = date;
             return this.refs.input[index].value;
@@ -271,39 +260,46 @@ var GDSDatetimeComponent = /** @class */ (function (_super) {
             this.refs.input[index].value = '';
             return null;
         }
-    };
-    GDSDatetimeComponent.prototype.normalizeValue = function (value) {
+    }
+    // value typed as `any` to match the base Component.normalizeValue(value: any): any signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    normalizeValue(value) {
         return value;
-    };
-    GDSDatetimeComponent.prototype.validateRequired = function (setting, value) {
-        var _a = this.parts, day = _a.day, month = _a.month, year = _a.year, minute = _a.minute, hour = _a.hour;
-        if (this.component.validate.required && (!day || parseInt(day, 10) === 0)) {
+    }
+    // setting/value typed as `any` to match the base Day.validateRequired(setting: any, value: any) signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    validateRequired(setting, value) {
+        var _a, _b, _c, _d, _e;
+        const { day, month, year, minute, hour } = this.parts;
+        if (((_a = this.component.validate) === null || _a === void 0 ? void 0 : _a.required) && (!day || parseInt(day, 10) === 0)) {
             return false;
         }
-        if (this.component.validate.required && (!month || parseInt(month, 10) === 0)) {
+        if (((_b = this.component.validate) === null || _b === void 0 ? void 0 : _b.required) && (!month || parseInt(month, 10) === 0)) {
             return false;
         }
-        if (this.component.validate.required && (!year || parseInt(year, 10) === 0)) {
+        if (((_c = this.component.validate) === null || _c === void 0 ? void 0 : _c.required) && (!year || parseInt(year, 10) === 0)) {
             return false;
         }
-        if (this.component.validate.required && ((this.refs.minute && this.refs.minute.value === '') || !minute)) {
+        if (((_d = this.component.validate) === null || _d === void 0 ? void 0 : _d.required) && (this.refs.minute.value === '' || !minute)) {
             return false;
         }
-        if (this.component.validate.required && ((this.refs.hour && this.refs.hour.value === '') || !hour)) {
+        if (((_e = this.component.validate) === null || _e === void 0 ? void 0 : _e.required) && (this.refs.hour.value === '' || !hour)) {
             return false;
         }
         if (!this.boolValue(setting)) {
             return true;
         }
         return !this.isEmpty(value);
-    };
-    GDSDatetimeComponent.prototype.processField = function (field, defaults, fieldIndex) {
-        var fieldValue = this.refs["".concat(field)] ? parseInt(this.refs["".concat(field)].value, 10) : undefined;
+    }
+    processField(field, defaults, fieldIndex) {
+        const refKey = field;
+        const ref = this.refs[refKey];
+        const inputRef = ref instanceof HTMLInputElement ? ref : undefined;
+        let fieldValue = inputRef ? parseInt(inputRef.value, 10) : undefined;
         if (fieldValue === undefined || _.isNaN(fieldValue)) {
-            fieldValue = defaults[fieldIndex] && !_.isNaN(defaults[fieldIndex]) ? defaults[fieldIndex] : 0;
+            fieldValue = defaults[fieldIndex] && !_.isNaN(defaults[fieldIndex]) ? Number(defaults[fieldIndex]) : 0;
         }
         return fieldValue;
-    };
-    return GDSDatetimeComponent;
-}(Day));
+    }
+}
 exports.default = GDSDatetimeComponent;

package/lib/components/index.js

@@ -1,9 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var GDSDataMap_1 = require("./datamap/GDSDataMap");
-var GDSDatetimeComponent_1 = require("./datetime/GDSDatetimeComponent");
-var GDSCheckBoxes_1 = require("./selectboxes/GDSCheckBoxes");
-var GDSTimeComponent_1 = require("./time/GDSTimeComponent");
+const GDSDataMap_1 = __importDefault(require("./datamap/GDSDataMap"));
+const GDSDatetimeComponent_1 = __importDefault(require("./datetime/GDSDatetimeComponent"));
+const GDSCheckBoxes_1 = __importDefault(require("./selectboxes/GDSCheckBoxes"));
+const GDSTimeComponent_1 = __importDefault(require("./time/GDSTimeComponent"));
 exports.default = {
     datamap: GDSDataMap_1.default,
     datetime: GDSDatetimeComponent_1.default,

package/lib/components/selectboxes/GDSCheckBoxes.d.ts

@@ -1,5 +1,7 @@
-declare const SelectBoxes: import("formiojs").ClassWithEditForm<typeof import("formiojs/types/components/_classes/field/field").Field>;
+import { SelectBoxesComponent } from '../../types';
+declare const SelectBoxes: any;
 export default class GDSCheckBoxes extends SelectBoxes {
-    render(): any;
+    component: SelectBoxesComponent;
+    render(): string;
 }
 export {};

package/lib/components/selectboxes/GDSCheckBoxes.js

@@ -1,43 +1,17 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        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 formiojs_1 = require("formiojs");
-var Field = formiojs_1.Components.components.field;
-var SelectBoxes = formiojs_1.Components.components.selectboxes;
-var GDSCheckBoxes = /** @class */ (function (_super) {
-    __extends(GDSCheckBoxes, _super);
-    function GDSCheckBoxes() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    GDSCheckBoxes.prototype.render = function () {
-        // @ts-ignore
+const js_1 = require("@formio/js");
+const Field = js_1.Components.components.field;
+const SelectBoxes = js_1.Components.components.selectboxes;
+class GDSCheckBoxes extends SelectBoxes {
+    render() {
         return Field.prototype.render.call(this, this.renderTemplate('selectboxes', {
-            // @ts-ignore
             input: this.inputInfo,
-            // @ts-ignore
             inline: this.component.inline,
-            // @ts-ignore
             values: this.component.values,
-            // @ts-ignore
             value: this.dataValue,
-            // @ts-ignore
             row: this.row,
         }));
-    };
-    return GDSCheckBoxes;
-}(SelectBoxes));
+    }
+}
 exports.default = GDSCheckBoxes;

package/lib/components/time/GDSTimeComponent.d.ts

@@ -1,18 +1,20 @@
-declare const Time: import("formiojs").ClassWithEditForm<typeof import("formiojs/types/components/_classes/widgetcomponent/widgetComponent").WidgetComponent>;
+import { CoreTimeComponent } from '../../types';
+declare const Time: any;
 export default class GDSTimeComponent extends Time {
     static MAX_LENGTH: number;
-    private refs;
-    private component;
-    private loadRefs;
-    private checkComponentValidity;
-    private updateValue;
+    component: CoreTimeComponent;
+    refs: {
+        hour: HTMLInputElement;
+        minute: HTMLInputElement;
+    };
+    data: Record<string, unknown>;
     private timeHelper;
-    attach(element: any): any;
+    attach(element: any): Promise<void>;
     setErrorClasses(elements: any, dirty: any, hasError: any): void;
-    addInputError(message: any, dirty: boolean, element: any): void;
+    addInputError(message: any, dirty: any, element: any): void;
     removeInputError(elements: any): void;
     getValue(): string;
-    setValue(value: any, flags: any): boolean;
-    render(): any;
+    setValue(value: any, _flags: any): boolean;
+    render(): string;
 }
 export {};