@bryntum/taskboard-angular 7.1.1

package/esm2015/lib/bryntum-checkbox.component.js

@@ -0,0 +1,805 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Angular wrapper for Bryntum Checkbox
+ */
+import { Component, EventEmitter, Output, Input } from '@angular/core';
+import WrapperHelper from './wrapper.helper';
+import { Checkbox, Widget } from '@bryntum/taskboard';
+import * as i0 from "@angular/core";
+export class BryntumCheckboxComponent {
+    constructor(element) {
+        this.bryntumConfig = {
+            adopt: undefined,
+            appendTo: undefined,
+            href: undefined,
+            angularComponent: this,
+            features: {},
+            listeners: {}
+        };
+        // Events emitters
+        /**
+         * User performed the default action (toggled the checkbox)
+         * @param {object} event Event object
+         * @param {Core.widget.Checkbox} event.source Checkbox
+         * @param {boolean} event.checked Checked state (=value)
+         * @param {boolean} event.value This field's value
+         * @param {boolean} event.valid True if this field is in a valid state
+         * @param {boolean} event.oldValue This field's previous value
+         * @param {boolean} event.userAction Triggered by user taking an action (`true`) or by setting a value (`false`)
+         * @param {Event} event.event The triggering DOM event if any
+         */
+        this.onAction = new EventEmitter();
+        /**
+         * Fired before checkbox is toggled. Returning false from a listener prevents the checkbox from being toggled.
+         * @param {object} event Event object
+         * @param {Core.widget.Checkbox} event.source Checkbox
+         * @param {boolean} event.checked Checked state (=value)
+         * @param {boolean} event.value This field's value
+         * @param {boolean} event.oldValue This field's previous value
+         * @param {boolean} event.userAction Triggered by user taking an action (`true`) or by setting a value (`false`)
+         * @param {boolean} event.valid True if this field is in a valid state.
+         * @param {Event} event.event The triggering DOM event if any
+         */
+        this.onBeforeChange = new EventEmitter();
+        /**
+         * Fires before an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onBeforeDestroy = new EventEmitter();
+        /**
+         * Triggered before a widget is hidden. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being hidden.
+         */
+        this.onBeforeHide = new EventEmitter();
+        /**
+         * Triggered before a widget is shown. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget,any} event.source The widget being shown
+         */
+        this.onBeforeShow = new EventEmitter();
+        /**
+         * Fires when any other event is fired from the object.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#event-catchAll)
+         * @param {object} event Event object
+         * @param {{[key: string]: any, type: string}} event.event The Object that contains event details
+         * @param {string} event.event.type The type of the event which is caught by the listener
+         */
+        this.onCatchAll = new EventEmitter();
+        /**
+         * Fired when checkbox is toggled
+         * @param {object} event Event object
+         * @param {Core.widget.Checkbox} event.source Checkbox
+         * @param {boolean} event.checked Checked state (=value)
+         * @param {boolean} event.value This field's value
+         * @param {boolean} event.oldValue This field's previous value
+         * @param {boolean} event.userAction Triggered by user taking an action (`true`) or by setting a value (`false`)
+         * @param {boolean} event.valid True if this field is in a valid state.
+         * @param {Event} event.event The triggering DOM event if any
+         */
+        this.onChange = new EventEmitter();
+        /**
+         * Fired when this field is [cleared](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#function-clear).
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#event-clear)
+         * @param {object} event Event object
+         * @param {Core.widget.Field,any} event.source This Field
+         */
+        this.onClear = new EventEmitter();
+        /**
+         * Fires when the checkbox is clicked
+         * @param {object} event Event object
+         * @param {Core.widget.Checkbox} event.source The checkbox
+         * @param {Event} event.event DOM event
+         */
+        this.onClick = new EventEmitter();
+        /**
+         * Fires when an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onDestroy = new EventEmitter();
+        /**
+         * Triggered when a widget's [element](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#property-element) is available.
+         * @param {object} event Event object
+         * @param {HTMLElement} event.element The Widget's element.
+         */
+        this.onElementCreated = new EventEmitter();
+        /**
+         * Fired when focus enters this Widget.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {HTMLElement} event.fromElement The element which lost focus.
+         * @param {HTMLElement} event.toElement The element which gained focus.
+         * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.
+         * @param {Core.widget.Widget} event.toWidget The widget which gained focus.
+         * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.
+         */
+        this.onFocusIn = new EventEmitter();
+        /**
+         * Fired when focus exits this Widget's ownership tree. This is different from a `blur` event.
+         * focus moving from within this Widget's ownership tree, even if there are floating widgets
+         * will not trigger this event. This is when focus exits this widget completely.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {HTMLElement} event.fromElement The element which lost focus.
+         * @param {HTMLElement} event.toElement The element which gained focus.
+         * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.
+         * @param {Core.widget.Widget} event.toWidget The widget which gained focus.
+         * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.
+         */
+        this.onFocusOut = new EventEmitter();
+        /**
+         * Triggered after a widget was hidden
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget
+         */
+        this.onHide = new EventEmitter();
+        /**
+         * Fired when the user types into this field.
+         * @param {object} event Event object
+         * @param {Core.widget.Field,any} event.source This field
+         * @param {string,number,boolean,any} event.value This field's value
+         * @param {Event} event.event The triggering DOM event
+         */
+        this.onInput = new EventEmitter();
+        /**
+         * Triggered when a widget which had been in a non-visible state for any reason
+         * achieves visibility.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#event-paint)
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being painted.
+         * @param {boolean} event.firstPaint `true` if this is the first paint.
+         */
+        this.onPaint = new EventEmitter();
+        /**
+         * Fired when a Widget's read only state is toggled
+         * @param {object} event Event object
+         * @param {boolean} event.readOnly Read only or not
+         */
+        this.onReadOnly = new EventEmitter();
+        /**
+         * This event is fired after a widget's elements have been synchronized due to a direct or indirect call
+         * to [recompose](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#function-recompose), if this results in some change to the widget's rendered DOM elements.
+         */
+        this.onRecompose = new EventEmitter();
+        /**
+         * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-monitorResize) is `true`*.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {number} event.width The new width
+         * @param {number} event.height The new height
+         * @param {number} event.oldWidth The old width
+         * @param {number} event.oldHeight The old height
+         */
+        this.onResize = new EventEmitter();
+        /**
+         * Triggered after a widget is shown.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget
+         */
+        this.onShow = new EventEmitter();
+        /**
+         * User clicked one of this field's [triggers](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#property-triggers)
+         * @param {object} event Event object
+         * @param {Core.widget.Field,any} event.source This field
+         * @param {Core.widget.Widget} event.trigger The trigger activated by click or touch tap.
+         */
+        this.onTrigger = new EventEmitter();
+        this.elementRef = element;
+    }
+    /**
+     * Create and append the underlying widget
+     */
+    ngOnInit() {
+        const me = this, { elementRef, bryntumConfig } = me, { instanceClass, instanceName, bryntumConfigs, bryntumEvents } = BryntumCheckboxComponent;
+        bryntumConfigs.filter(prop => prop in this).forEach(prop => {
+            // @ts-ignore
+            WrapperHelper.applyPropValue(bryntumConfig, prop, this[prop]);
+            if (['features', 'config'].includes(prop)) {
+                WrapperHelper.devWarningConfigProp(instanceName, prop);
+            }
+        });
+        // @ts-ignore
+        bryntumEvents.filter(event => this[event] && this[event].observers.length > 0).forEach(event => {
+            const uncapitalize = (str) => str.charAt(0).toLowerCase() + str.slice(1), eventName = (str) => uncapitalize(str.slice(2));
+            // @ts-ignore
+            bryntumConfig.listeners[eventName(event)] = e => {
+                // @ts-ignore
+                me[event].emit(e);
+                // EventEmitter does not return values in the normal way, work around it by setting `returnValue` flag
+                // in Angular listeners
+                return e.returnValue;
+            };
+        });
+        // If component has no container specified in config then use adopt to Wrapper's element
+        const containerParam = [
+            'adopt',
+            'appendTo',
+            'insertAfter',
+            'insertBefore'
+            // @ts-ignore
+        ].find(prop => bryntumConfig[prop]);
+        if (!containerParam) {
+            if (instanceName === 'Button' || elementRef.nativeElement.getRootNode() instanceof ShadowRoot) {
+                // Button should always be <a> or <button> inside owner element
+                bryntumConfig.appendTo = elementRef.nativeElement;
+            }
+            else {
+                bryntumConfig.adopt = elementRef.nativeElement;
+            }
+        }
+        else {
+            WrapperHelper.devWarningContainer(instanceName, containerParam);
+        }
+        // @ts-ignore
+        me.instance = instanceName === 'Widget' ? Widget.create(bryntumConfig) : new instanceClass(bryntumConfig);
+    }
+    /**
+     * Watch for changes
+     * @param changes
+     */
+    ngOnChanges(changes) {
+        const { instance } = this, { instanceName } = BryntumCheckboxComponent;
+        if (!instance) {
+            return;
+        }
+        // Iterate over all changes
+        Object.entries(changes).forEach(([prop, change]) => {
+            const newValue = change.currentValue, { instance } = this, { bryntumConfigsOnly, bryntumProps } = BryntumCheckboxComponent;
+            if (bryntumProps.includes(prop)) {
+                WrapperHelper.applyPropValue(instance, prop, newValue, false);
+                if (bryntumConfigsOnly.includes(prop)) {
+                    WrapperHelper.devWarningUpdateProp(instanceName, prop);
+                }
+            }
+        });
+    }
+    /**
+     * Destroy the component
+     */
+    ngOnDestroy() {
+        // @ts-ignore
+        if (this.instance && this.instance.destroy) {
+            this.instance.destroy();
+        }
+    }
+}
+BryntumCheckboxComponent.instanceClass = Checkbox;
+BryntumCheckboxComponent.instanceName = 'Checkbox';
+BryntumCheckboxComponent.bryntumEvents = [
+    'onAction',
+    'onBeforeChange',
+    'onBeforeDestroy',
+    'onBeforeHide',
+    'onBeforeShow',
+    'onCatchAll',
+    'onChange',
+    'onClear',
+    'onClick',
+    'onDestroy',
+    'onElementCreated',
+    'onFocusIn',
+    'onFocusOut',
+    'onHide',
+    'onInput',
+    'onPaint',
+    'onReadOnly',
+    'onRecompose',
+    'onResize',
+    'onShow',
+    'onTrigger'
+];
+BryntumCheckboxComponent.bryntumFeatureNames = [];
+BryntumCheckboxComponent.bryntumConfigs = BryntumCheckboxComponent.bryntumFeatureNames.concat([
+    'adopt',
+    'align',
+    'alignSelf',
+    'anchor',
+    'appendTo',
+    'ariaDescription',
+    'ariaLabel',
+    'autoCollapse',
+    'autoComplete',
+    'autoSelect',
+    'badge',
+    'bubbleEvents',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'centered',
+    'checked',
+    'checkedValue',
+    'cls',
+    'color',
+    'column',
+    'config',
+    'constrainTo',
+    'container',
+    'containValues',
+    'contentElementCls',
+    'dataField',
+    'dataset',
+    'defaultBindProperty',
+    'detectCSSCompatibilityIssues',
+    'disabled',
+    'dock',
+    'draggable',
+    'elementAttributes',
+    'extraData',
+    'flex',
+    'floating',
+    'height',
+    'hidden',
+    'hideAnimation',
+    'highlightExternalChange',
+    'hint',
+    'hintHtml',
+    'id',
+    'ignoreParentReadOnly',
+    'inline',
+    'inputAlign',
+    'inputAttributes',
+    'inputTag',
+    'inputType',
+    'inputWidth',
+    'insertBefore',
+    'insertFirst',
+    'keyMap',
+    'keyStrokeChangeDelay',
+    'label',
+    'labelCls',
+    'labelPosition',
+    'labels',
+    'labelWidth',
+    'listeners',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'margin',
+    'maskDefaults',
+    'masked',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxWidth',
+    'minHeight',
+    'minWidth',
+    'monitorResize',
+    'name',
+    'owner',
+    'positioned',
+    'preventTooltipOnTouch',
+    'readOnly',
+    'relayStoreEvents',
+    'required',
+    'revertOnEscape',
+    'ripple',
+    'rootElement',
+    'rtl',
+    'scrollAction',
+    'showAnimation',
+    'showRequiredIndicator',
+    'showTooltipWhenDisabled',
+    'skipValidation',
+    'span',
+    'spellCheck',
+    'tab',
+    'tabIndex',
+    'text',
+    'textAlign',
+    'title',
+    'tooltip',
+    'triggers',
+    'type',
+    'ui',
+    'uncheckedValue',
+    'validateOnInput',
+    'value',
+    'weight',
+    'width',
+    'x',
+    'y'
+]);
+BryntumCheckboxComponent.bryntumConfigsOnly = [
+    'adopt',
+    'align',
+    'anchor',
+    'ariaDescription',
+    'ariaLabel',
+    'autoCollapse',
+    'autoComplete',
+    'autoSelect',
+    'bubbleEvents',
+    'centered',
+    'checkedValue',
+    'color',
+    'config',
+    'constrainTo',
+    'container',
+    'containValues',
+    'contentElementCls',
+    'dataField',
+    'defaultBindProperty',
+    'detectCSSCompatibilityIssues',
+    'dock',
+    'draggable',
+    'elementAttributes',
+    'floating',
+    'hideAnimation',
+    'highlightExternalChange',
+    'hint',
+    'hintHtml',
+    'ignoreParentReadOnly',
+    'inline',
+    'inputAlign',
+    'inputAttributes',
+    'inputTag',
+    'inputType',
+    'inputWidth',
+    'keyStrokeChangeDelay',
+    'labelCls',
+    'labelPosition',
+    'labels',
+    'labelWidth',
+    'listeners',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'maskDefaults',
+    'masked',
+    'monitorResize',
+    'owner',
+    'positioned',
+    'preventTooltipOnTouch',
+    'relayStoreEvents',
+    'revertOnEscape',
+    'ripple',
+    'rootElement',
+    'scrollAction',
+    'showAnimation',
+    'showTooltipWhenDisabled',
+    'skipValidation',
+    'spellCheck',
+    'tab',
+    'tabIndex',
+    'text',
+    'textAlign',
+    'title',
+    'type',
+    'ui',
+    'uncheckedValue',
+    'validateOnInput',
+    'weight'
+];
+BryntumCheckboxComponent.bryntumProps = BryntumCheckboxComponent.bryntumFeatureNames.concat([
+    'alignSelf',
+    'anchorSize',
+    'appendTo',
+    'badge',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'checked',
+    'cls',
+    'column',
+    'content',
+    'dataset',
+    'disabled',
+    'editable',
+    'extraData',
+    'flex',
+    'focusVisible',
+    'height',
+    'hidden',
+    'html',
+    'id',
+    'input',
+    'insertBefore',
+    'insertFirst',
+    'keyMap',
+    'label',
+    'margin',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxWidth',
+    'minHeight',
+    'minWidth',
+    'name',
+    'parent',
+    'placeholder',
+    'readOnly',
+    'required',
+    'rtl',
+    'scrollable',
+    'showRequiredIndicator',
+    'span',
+    'tooltip',
+    'triggers',
+    'value',
+    'width',
+    'x',
+    'y'
+]);
+BryntumCheckboxComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumCheckboxComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+BryntumCheckboxComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.0", type: BryntumCheckboxComponent, selector: "bryntum-checkbox", inputs: { adopt: "adopt", align: "align", anchor: "anchor", ariaDescription: "ariaDescription", ariaLabel: "ariaLabel", autoCollapse: "autoCollapse", autoComplete: "autoComplete", autoSelect: "autoSelect", bubbleEvents: "bubbleEvents", centered: "centered", checkedValue: "checkedValue", color: "color", config: "config", constrainTo: "constrainTo", container: "container", containValues: "containValues", contentElementCls: "contentElementCls", dataField: "dataField", defaultBindProperty: "defaultBindProperty", detectCSSCompatibilityIssues: "detectCSSCompatibilityIssues", dock: "dock", draggable: "draggable", elementAttributes: "elementAttributes", floating: "floating", hideAnimation: "hideAnimation", highlightExternalChange: "highlightExternalChange", hint: "hint", hintHtml: "hintHtml", ignoreParentReadOnly: "ignoreParentReadOnly", inline: "inline", inputAlign: "inputAlign", inputAttributes: "inputAttributes", inputTag: "inputTag", inputType: "inputType", inputWidth: "inputWidth", keyStrokeChangeDelay: "keyStrokeChangeDelay", labelCls: "labelCls", labelPosition: "labelPosition", labels: "labels", labelWidth: "labelWidth", listeners: "listeners", localeClass: "localeClass", localizable: "localizable", localizableProperties: "localizableProperties", maskDefaults: "maskDefaults", masked: "masked", monitorResize: "monitorResize", owner: "owner", positioned: "positioned", preventTooltipOnTouch: "preventTooltipOnTouch", relayStoreEvents: "relayStoreEvents", revertOnEscape: "revertOnEscape", ripple: "ripple", rootElement: "rootElement", scrollAction: "scrollAction", showAnimation: "showAnimation", showTooltipWhenDisabled: "showTooltipWhenDisabled", skipValidation: "skipValidation", spellCheck: "spellCheck", tab: "tab", tabIndex: "tabIndex", text: "text", textAlign: "textAlign", title: "title", type: "type", ui: "ui", uncheckedValue: "uncheckedValue", validateOnInput: "validateOnInput", weight: "weight", alignSelf: "alignSelf", appendTo: "appendTo", badge: "badge", callOnFunctions: "callOnFunctions", catchEventHandlerExceptions: "catchEventHandlerExceptions", checked: "checked", cls: "cls", column: "column", dataset: "dataset", disabled: "disabled", extraData: "extraData", flex: "flex", height: "height", hidden: "hidden", id: "id", insertBefore: "insertBefore", insertFirst: "insertFirst", keyMap: "keyMap", label: "label", margin: "margin", maxHeight: "maxHeight", maximizeOnMobile: "maximizeOnMobile", maxWidth: "maxWidth", minHeight: "minHeight", minWidth: "minWidth", name: "name", readOnly: "readOnly", required: "required", rtl: "rtl", showRequiredIndicator: "showRequiredIndicator", span: "span", tooltip: "tooltip", triggers: "triggers", value: "value", width: "width", x: "x", y: "y", anchorSize: "anchorSize", content: "content", editable: "editable", focusVisible: "focusVisible", html: "html", input: "input", parent: "parent", placeholder: "placeholder", scrollable: "scrollable" }, outputs: { onAction: "onAction", onBeforeChange: "onBeforeChange", onBeforeDestroy: "onBeforeDestroy", onBeforeHide: "onBeforeHide", onBeforeShow: "onBeforeShow", onCatchAll: "onCatchAll", onChange: "onChange", onClear: "onClear", onClick: "onClick", onDestroy: "onDestroy", onElementCreated: "onElementCreated", onFocusIn: "onFocusIn", onFocusOut: "onFocusOut", onHide: "onHide", onInput: "onInput", onPaint: "onPaint", onReadOnly: "onReadOnly", onRecompose: "onRecompose", onResize: "onResize", onShow: "onShow", onTrigger: "onTrigger" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumCheckboxComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bryntum-checkbox',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { adopt: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], anchor: [{
+                type: Input
+            }], ariaDescription: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], autoCollapse: [{
+                type: Input
+            }], autoComplete: [{
+                type: Input
+            }], autoSelect: [{
+                type: Input
+            }], bubbleEvents: [{
+                type: Input
+            }], centered: [{
+                type: Input
+            }], checkedValue: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], constrainTo: [{
+                type: Input
+            }], container: [{
+                type: Input
+            }], containValues: [{
+                type: Input
+            }], contentElementCls: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], defaultBindProperty: [{
+                type: Input
+            }], detectCSSCompatibilityIssues: [{
+                type: Input
+            }], dock: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], elementAttributes: [{
+                type: Input
+            }], floating: [{
+                type: Input
+            }], hideAnimation: [{
+                type: Input
+            }], highlightExternalChange: [{
+                type: Input
+            }], hint: [{
+                type: Input
+            }], hintHtml: [{
+                type: Input
+            }], ignoreParentReadOnly: [{
+                type: Input
+            }], inline: [{
+                type: Input
+            }], inputAlign: [{
+                type: Input
+            }], inputAttributes: [{
+                type: Input
+            }], inputTag: [{
+                type: Input
+            }], inputType: [{
+                type: Input
+            }], inputWidth: [{
+                type: Input
+            }], keyStrokeChangeDelay: [{
+                type: Input
+            }], labelCls: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], labels: [{
+                type: Input
+            }], labelWidth: [{
+                type: Input
+            }], listeners: [{
+                type: Input
+            }], localeClass: [{
+                type: Input
+            }], localizable: [{
+                type: Input
+            }], localizableProperties: [{
+                type: Input
+            }], maskDefaults: [{
+                type: Input
+            }], masked: [{
+                type: Input
+            }], monitorResize: [{
+                type: Input
+            }], owner: [{
+                type: Input
+            }], positioned: [{
+                type: Input
+            }], preventTooltipOnTouch: [{
+                type: Input
+            }], relayStoreEvents: [{
+                type: Input
+            }], revertOnEscape: [{
+                type: Input
+            }], ripple: [{
+                type: Input
+            }], rootElement: [{
+                type: Input
+            }], scrollAction: [{
+                type: Input
+            }], showAnimation: [{
+                type: Input
+            }], showTooltipWhenDisabled: [{
+                type: Input
+            }], skipValidation: [{
+                type: Input
+            }], spellCheck: [{
+                type: Input
+            }], tab: [{
+                type: Input
+            }], tabIndex: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], textAlign: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], ui: [{
+                type: Input
+            }], uncheckedValue: [{
+                type: Input
+            }], validateOnInput: [{
+                type: Input
+            }], weight: [{
+                type: Input
+            }], alignSelf: [{
+                type: Input
+            }], appendTo: [{
+                type: Input
+            }], badge: [{
+                type: Input
+            }], callOnFunctions: [{
+                type: Input
+            }], catchEventHandlerExceptions: [{
+                type: Input
+            }], checked: [{
+                type: Input
+            }], cls: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], dataset: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], extraData: [{
+                type: Input
+            }], flex: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], hidden: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], insertBefore: [{
+                type: Input
+            }], insertFirst: [{
+                type: Input
+            }], keyMap: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], maxHeight: [{
+                type: Input
+            }], maximizeOnMobile: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], minHeight: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], showRequiredIndicator: [{
+                type: Input
+            }], span: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], triggers: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], x: [{
+                type: Input
+            }], y: [{
+                type: Input
+            }], anchorSize: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }], focusVisible: [{
+                type: Input
+            }], html: [{
+                type: Input
+            }], input: [{
+                type: Input
+            }], parent: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], onAction: [{
+                type: Output
+            }], onBeforeChange: [{
+                type: Output
+            }], onBeforeDestroy: [{
+                type: Output
+            }], onBeforeHide: [{
+                type: Output
+            }], onBeforeShow: [{
+                type: Output
+            }], onCatchAll: [{
+                type: Output
+            }], onChange: [{
+                type: Output
+            }], onClear: [{
+                type: Output
+            }], onClick: [{
+                type: Output
+            }], onDestroy: [{
+                type: Output
+            }], onElementCreated: [{
+                type: Output
+            }], onFocusIn: [{
+                type: Output
+            }], onFocusOut: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onInput: [{
+                type: Output
+            }], onPaint: [{
+                type: Output
+            }], onReadOnly: [{
+                type: Output
+            }], onRecompose: [{
+                type: Output
+            }], onResize: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onTrigger: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bryntum-checkbox.component.js","sourceRoot":"","sources":["../../../component/src/lib/bryntum-checkbox.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/**\n * Angular wrapper for Bryntum Checkbox\n */\n\nimport { Component, ElementRef, EventEmitter, Output, Input, SimpleChange, SimpleChanges, OnDestroy, OnInit } from '@angular/core';\n\nimport WrapperHelper from './wrapper.helper';\n\nimport { AlignSpec, Base, Checkbox, CheckboxListeners, ContainerItemConfig, DomConfig, Field, FieldContainer, FieldContainerConfig, FieldTriggerConfig, KeyMapConfig, MaskConfig, Rectangle, Scroller, TabConfig, TooltipConfig, VueConfig, Widget } from '@bryntum/taskboard';\n\nimport { StringHelper } from '@bryntum/taskboard';\n\nexport type BryntumCheckboxProps = {\n    // Configs\n    /**\n     * Element (or element id) to adopt as this Widget's encapsulating element. The widget's\n     * content will be placed inside this element.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-adopt)\n     */\n    adopt ? : HTMLElement|string\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-align)\n     */\n    align ? : AlignSpec|string\n    /**\n     * When this widget is a child of a [Container](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container), it will by default be participating in a\n     * flexbox layout. This config allows you to set this widget's\n     * [align-self](https://developer.mozilla.org/en-US/docs/Web/CSS/align-self) style.\n     */\n    alignSelf ? : string\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating) and being shown through [showBy](#Core/widget/Widget#function-showBy).*\n     * `true` to show a connector arrow pointing to the align target.\n     */\n    anchor ? : boolean\n    /**\n     * Element (or the id of an element) to append this widget's element to. Can be configured, or set once at\n     * runtime. To access the element of a rendered widget, see [element](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#property-element).\n     */\n    appendTo ? : HTMLElement|string\n    /**\n     * A localizable string (May contain `'L{}'` tokens which resolve in the locale file) to inject\n     * into an element which will be linked using the `aria-describedby` attribute.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-ariaDescription)\n     */\n    ariaDescription ? : string\n    /**\n     * A localizable string (May contain `'L{}'` tokens which resolve in the locale file) to inject as\n     * the `aria-label` attribute.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-ariaLabel)\n     */\n    ariaLabel ? : string\n    /**\n     * Specify `true` to automatically [collapse](https://bryntum.com/products/taskboard/docs/api/Core/widget/FieldContainer#config-collapsed) the field's\n     * [container](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-container) when the field is not [checked](#Core/widget/Checkbox#property-checked).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-autoCollapse)\n     * @returns {boolean}\n     */\n    autoCollapse ? : boolean|(() => boolean)\n    /**\n     * Sets the native `autocomplete` property of the underlying input element. For more information, please refer to\n     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete)\n     */\n    autoComplete ? : string\n    /**\n     * Specify `true` to auto select field contents on focus\n     */\n    autoSelect ? : boolean\n    /**\n     * Initial text to show in badge.\n     */\n    badge ? : string\n    /**\n     * An object where property names with a truthy value indicate which events should bubble up the ownership\n     * hierarchy when triggered.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-bubbleEvents)\n     */\n    bubbleEvents ? : object\n    /**\n     * Set to `false` to not call onXXX method names (e.g. `onShow`, `onClick`), as an easy way to listen for events.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-callOnFunctions)\n     */\n    callOnFunctions ? : boolean\n    /**\n     * By default, if an event handler throws an exception, the error propagates up the stack and the\n     * application state is undefined. Code which follows the event handler will *not* be executed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-catchEventHandlerExceptions)\n     */\n    catchEventHandlerExceptions ? : boolean\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * Set to `true` to centre the Widget in browser viewport space.\n     */\n    centered ? : boolean\n    /**\n     * The checked state. The same as `value`.\n     */\n    checked ? : boolean\n    /**\n     * The value to provide for this widget in [values](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container#property-values) when it is\n     * [checked](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#property-checked).\n     * A value of `undefined` will cause this widget not to include its value when checked.\n     */\n    checkedValue ? : any\n    /**\n     * Custom CSS classes to add to element.\n     * May be specified as a space separated string, or as an object in which property names\n     * with truthy values are used as the class names:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-cls)\n     */\n    cls ? : string|object\n    /**\n     * Checkbox color, must have match in CSS\n     */\n    color ? : string\n    /**\n     * Programmatic control over which column to start in when used in a grid layout.\n     */\n    column ? : number\n    config ? : object\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating) or [positioned](#Core/widget/Widget#config-positioned).*\n     * Element, Widget or Rectangle to which this Widget is constrained.\n     */\n    constrainTo ? : HTMLElement|Widget|Rectangle\n    /**\n     * The configuration for additional items associated to this field. This is typically used to add contextual\n     * fields related to a [checkbox](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox) or [radio button](#Core/widget/Radio). See\n     * these classes for examples of nested fields.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-container)\n     */\n    container ? : Record<string, ContainerItemConfig>|ContainerItemConfig[]|FieldContainerConfig|FieldContainer\n    /**\n     * The config controls how the value of nested items are handled when a parent container gets or sets its\n     * [values](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container#property-values).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-containValues)\n     * @param {Core.widget.Field} field Field instance\n     * @returns {boolean}\n     */\n    containValues ? : boolean|string|((field: Field) => boolean)\n    /**\n     * Custom CSS classes to add to the [contentElement](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#property-contentElement).\n     * May be specified as a space separated string, or as an object in which property names\n     * with truthy values are used as the class names:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-contentElementCls)\n     */\n    contentElementCls ? : string|object\n    /**\n     * When this Widget configuration is used in the Grid's RowExpander feature's `widget` config, provide the\n     * field on the expanded record to use for populating this widget's store (if applicable)\n     */\n    dataField ? : string\n    /**\n     * Object to apply to elements dataset (each key will be used as a data-attribute on the element)\n     */\n    dataset ? : Record<string, string>\n    /**\n     * The name of the property to set when a single value is to be applied to this Widget. Such as when used\n     * in a grid WidgetColumn, this is the property to which the column's `field` is applied.\n     */\n    defaultBindProperty ? : string\n    /**\n     * Check for CSS compatibility issues when upgrading to v7. Performs the following checks:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-detectCSSCompatibilityIssues)\n     */\n    detectCSSCompatibilityIssues ? : boolean\n    /**\n     * Disable or enable the widget. It is similar to [readOnly](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-readOnly) except a disabled widget\n     * cannot be focused, uses a different rendition (usually greyish) and does not allow selecting its value.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-disabled)\n     */\n    disabled ? : boolean|'inert'\n    /**\n     * Controls the placement of this widget when it is added to a [panel's ](https://bryntum.com/products/taskboard/docs/api/Core/widget/Panel)\n     * [strips collection](https://bryntum.com/products/taskboard/docs/api/Core/widget/Panel#config-strips). Typical values for this config are `'top'`,\n     * `'bottom'`, `'left'`, or `'right'`, which cause the widget to be placed on that side of the panel's\n     * body. Such widgets are called \"edge strips\".\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-dock)\n     */\n    dock ? : 'top'|'bottom'|'left'|'right'|'start'|'end'|'header'|'pre-header'|object\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * Set to `true` to be able to drag a widget freely on the page. Or set to an object with a ´handleSelector´\n     * property which controls when a drag should start.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-draggable)\n     */\n    draggable ? : boolean|{\n        handleSelector?: string\n    }\n    /**\n     * An object specifying attributes to assign to the root element of this widget.\n     * Set `null` value to attribute to remove it.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-elementAttributes)\n     */\n    elementAttributes ? : Record<string, string|null>\n    extraData ? : any\n    /**\n     * When this widget is a child of a [Container](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container), it will by default be participating in a\n     * flexbox layout. This config allows you to set this widget's\n     * [flex](https://developer.mozilla.org/en-US/docs/Web/CSS/flex) style.\n     * This may be configured as a single number or a `&lt;flex-grow&gt; &lt;flex-shrink&gt; &lt;flex-basis&gt;` format string.\n     * numeric-only values are interpreted as the `flex-grow` value.\n     */\n    flex ? : number|string\n    /**\n     * Set to `true` to move the widget out of the document flow and position it\n     * absolutely in browser viewport space.\n     */\n    floating ? : boolean\n    /**\n     * Widget's height, used to set element `style.height`. Either specify a valid height string or a number,\n     * which will get 'px' appended. We recommend using CSS as the primary way to control height, but in some\n     * cases this config is convenient.\n     */\n    height ? : string|number\n    /**\n     * Configure with true to make widget initially hidden.\n     */\n    hidden ? : boolean\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-hideAnimation)\n     */\n    hideAnimation ? : boolean|object\n    /**\n     * Specify `true` to highlight field after external value changes\n     */\n    highlightExternalChange ? : boolean\n    /**\n     * An optional string to display inside the input field as an overlay. This can be useful for displaying\n     * a field's units.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-hint)\n     * @param {object} data A data object\n     * @param {Core.widget.Field} data.source A reference to the field instance\n     * @param {any} data.value The current value of the field\n     * @returns {string}\n     */\n    hint ? : string|((data: { source: Field, value: any }) => string)\n    /**\n     * This config is similar to [hint](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#config-hint) except that this config is used to display HTML content.\n     * Since this can allow malicious content to be executed, be sure not to include user-entered data or to\n     * encode such data (see [encodeHtml](https://bryntum.com/products/taskboard/docs/api/Core/helper/StringHelper#function-encodeHtml-static)).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-hintHtml)\n     * @param {object} data A data object\n     * @param {Core.widget.Field} data.source A reference to the field instance\n     * @param {any} data.value The current value of the field\n     * @returns {string}\n     */\n    hintHtml ? : string|((data: { source: Field, value: any }) => string)\n    /**\n     * Widget id, if not specified one will be generated. Also used for lookups through Widget.getById\n     */\n    id ? : string\n    /**\n     * Determines if the widgets read-only state should be controlled by its parent.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-ignoreParentReadOnly)\n     */\n    ignoreParentReadOnly ? : boolean\n    /**\n     * Set this config to `true` to always display items horizontally along with this field. This assigns an\n     * [hbox](https://bryntum.com/products/taskboard/docs/api/Core/widget/layout/Box) as the [layout](#Core/widget/Container#config-layout) to the\n     * [container](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#config-container).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-inline)\n     */\n    inline ? : boolean\n    /**\n     * Text alignment for the input field.\n     */\n    inputAlign ? : string\n    /**\n     * Sets custom attributes of the underlying input element. For more information, please refer to\n     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes)\n     */\n    inputAttributes ? : Record<string, string>\n    /**\n     * If you need to use something else than a default `input` element, as the input element, provide the tag\n     * name here. Please note that this is used for advanced usage only, for example when using WebComponents\n     * (custom elements), and that the configured element must fulfil the same contract as a regular input\n     * element.\n     */\n    inputTag ? : string\n    /**\n     * Sets the `type` attribute of the underlying input element (password, hidden, date, color, etc.).\n     */\n    inputType ? : string\n    /**\n     * The width to apply to the `.b-field-inner` element, which encompasses the `input` element and any\n     * triggers. If a number is specified, `px` will be used.\n     */\n    inputWidth ? : string|number\n    /**\n     * Element (or element id) to insert this widget before. If provided, [appendTo](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-appendTo) config is ignored.\n     */\n    insertBefore ? : HTMLElement|string\n    /**\n     * Element (or element id) to append this widget element to, as a first child. If provided, [appendTo](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-appendTo) config is ignored.\n     */\n    insertFirst ? : HTMLElement|string\n    /**\n     * An object whose keys are the [key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) name\n     * and optional modifier prefixes: `'Ctrl+'`, `'Alt+'`, `'Meta+'`, and `'Shift+'` (case-insensitive). The values\n     * are the name of the instance method to call when the keystroke is received.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-keyMap)\n     */\n    keyMap ? : Record<string, KeyMapConfig>\n    /**\n     * The delay in milliseconds to wait after the last keystroke before triggering a change event.\n     * Set to 0 to not trigger change events from keystrokes (listen for input event instead to have\n     * immediate feedback, change will still be triggered on blur).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-keyStrokeChangeDelay)\n     */\n    keyStrokeChangeDelay ? : number\n    /**\n     * Label, prepended to field\n     */\n    label ? : string\n    /**\n     * CSS class name or class names to add to any configured [label](https://bryntum.com/products/taskboard/docs/api/Core/widget/mixin/Labelable#config-label)\n     */\n    labelCls ? : string|object\n    /**\n     * Label position, either 'before' the field or 'above' the field\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-labelPosition)\n     */\n    labelPosition ? : 'before'|'above'|null\n    /**\n     * The labels to add either before or after the input field.\n     * Each label may have the following properties:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-labels)\n     */\n    labels ? : object[]\n    /**\n     * The width to apply to the `&lt;label&gt;` element. If a number is specified, `px` will be used.\n     */\n    labelWidth ? : string|number\n    /**\n     * The listener set for this object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-listeners)\n     */\n    listeners ? : CheckboxListeners\n    /**\n     * A class translations of which are used for translating this entity.\n     * This is often used when translations of an item are defined on its container class.\n     * For example:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-localeClass)\n     */\n    localeClass ? : typeof Base\n    /**\n     * Set to `false` to disable localization of this object.\n     */\n    localizable ? : boolean\n    /**\n     * List of properties which values should be translated automatically upon a locale applying.\n     * In case there is a need to localize not typical value (not a String value or a field with re-defined setter/getter),\n     * you could use 'localeKey' meta configuration.\n     * Example:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-localizableProperties)\n     */\n    localizableProperties ? : string[]\n    /**\n     * Widget's margin. This may be configured as a single number or a `TRBL` format string.\n     * numeric-only values are interpreted as pixels.\n     */\n    margin ? : number|string\n    /**\n     * This config object contains the defaults for the [Mask](https://bryntum.com/products/taskboard/docs/api/Core/widget/Mask) created for the\n     * [masked](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-masked) config. Any properties specified in the `masked` config will override these\n     * values.\n     */\n    maskDefaults ? : MaskConfig\n    /**\n     * Set to `true` to apply the default mask to the widget. Alternatively, this can be the mask message or a\n     * [Mask](https://bryntum.com/products/taskboard/docs/api/Core/widget/Mask) config object.\n     */\n    masked ? : boolean|string|MaskConfig\n    /**\n     * The element's maxHeight. Can be either a String or a Number (which will have 'px' appended). Note that\n     * like [height](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-height), *reading* the value will return the numeric value in pixels.\n     */\n    maxHeight ? : string|number\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-maximizeOnMobile)\n     */\n    maximizeOnMobile ? : number|string\n    /**\n     * The elements maxWidth. Can be either a String or a Number (which will have 'px' appended). Note that\n     * like [width](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-width), *reading* the value will return the numeric value in pixels.\n     */\n    maxWidth ? : string|number\n    /**\n     * The element's minHeight. Can be either a String or a Number (which will have 'px' appended). Note that\n     * like [height](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-height), *reading* the value will return the numeric value in pixels.\n     */\n    minHeight ? : string|number\n    /**\n     * The elements minWidth. Can be either a String or a Number (which will have 'px' appended). Note that\n     * like [width](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-width), *reading* the value will return the numeric value in pixels.\n     */\n    minWidth ? : string|number\n    /**\n     * When this is configured as `true` a [ResizeObserver](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver)\n     * is used to monitor this element for size changes caused by either style manipulation, or by CSS\n     * layout.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-monitorResize)\n     */\n    monitorResize ? : boolean|{\n        immediate?: boolean\n    }\n    /**\n     * Name of the field which is used as a key to get/set values from/to the field.\n     * Used prior to [ref](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-ref) and [id](#Core/widget/Widget#config-id) in\n     * [Container.values](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container#property-values).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-name)\n     */\n    name ? : string\n    /**\n     * The owning Widget of this Widget. If this Widget is directly contained (that is, it is one of the\n     * [items](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container#property-items) of a Container), this config will be ignored. In this case\n     * the owner is <strong>always</strong> the encapsulating Container.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-owner)\n     */\n    owner ? : Widget|any\n    /**\n     * Set to `true` when a widget is rendered into another widget's [contentElement](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#property-contentElement), but must\n     * not participate in the standard layout of that widget, and must be positioned relatively to that\n     * widget's [contentElement](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#property-contentElement).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-positioned)\n     */\n    positioned ? : boolean\n    /**\n     * Prevent tooltip from being displayed on touch devices. Useful for example for buttons that display a\n     * menu on click etc, since the tooltip would be displayed at the same time.\n     */\n    preventTooltipOnTouch ? : boolean\n    /**\n     * Makes the field unmodifiable by user action. The input area is not editable, and triggers\n     * are unresponsive.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-readOnly)\n     */\n    readOnly ? : boolean\n    relayStoreEvents ? : boolean\n    /**\n     * Configure as `true` to indicate that a `null` field value is to be marked as invalid. This will\n     * optionally append a * to the field label if [showRequiredIndicator](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#property-showRequiredIndicator) is set.\n     */\n    required ? : boolean\n    /**\n     * If this field is not [readOnly](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#config-readOnly), then setting this option means that pressing\n     * the `ESCAPE` key after editing the field will revert the field to the value it had when\n     * the user focused the field. If the field is *not* changed from when focused, the [clearable](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#config-clearable)\n     * behaviour will be activated.\n     */\n    revertOnEscape ? : boolean\n    /**\n     * Configure as `true` to have the component display a translucent ripple when its\n     * [focusElement](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#property-focusElement), or [element](#Core/widget/Widget#property-element) is tapped <em>if the\n     * current theme supports ripples</em>. Out of the box, only the Material theme supports ripples.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-ripple)\n     */\n    ripple ? : boolean|{\n        delegate?: string\n        color?: string\n        radius?: number\n        clip?: string\n    }\n    /**\n     * If you are rendering this widget to a shadow root inside a web component, set this config to the shadowRoot. If not inside a web component, set it to `document.body`\n     */\n    rootElement ? : ShadowRoot|HTMLElement\n    /**\n     * This may be configured as `true` to make the widget's element use the `direction:rtl` style.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-rtl)\n     */\n    rtl ? : boolean\n    /**\n     * Defines what to do if document is scrolled while Widget is visible (only relevant when floating is set to `true`).\n     * Valid values: ´null´: do nothing, ´hide´: hide the widget or ´realign´: realign to the target if possible.\n     */\n    scrollAction ? : 'hide'|'realign'|null\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-showAnimation)\n     */\n    showAnimation ? : boolean|object\n    /**\n     * `true` to automatically display a * after the label for this field when it is [required](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#property-required).\n     */\n    showRequiredIndicator ? : string\n    /**\n     * Set to `false` to not show the tooltip when this widget is [disabled](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#property-disabled)\n     */\n    showTooltipWhenDisabled ? : boolean\n    /**\n     * Set to `true`, completely bypasses validation logic (could be userful if your field is not `editable`\n     * to the user).\n     */\n    skipValidation ? : boolean\n    /**\n     * Programmatic control over how many columns to span when used in a grid layout.\n     */\n    span ? : number\n    /**\n     * Sets the native `spellcheck` property of the underlying input element. For more information, please refer to\n     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/spellcheck)\n     */\n    spellCheck ? : boolean\n    /**\n     * A configuration for the [tab](https://bryntum.com/products/taskboard/docs/api/Core/widget/Tab) created for this widget when it is placed in a\n     * [TabPanel](https://bryntum.com/products/taskboard/docs/api/Core/widget/TabPanel). For example, this config can be used to control the icon of the `tab` for\n     * this widget:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-tab)\n     */\n    tab ? : boolean|TabConfig\n    /**\n     * The tab index of the input field or fields, or `null` for natural tab order (recommended). Setting to `0`\n     * is equivalent to natural tab order, but is unnecessary for fields since they are naturally tabbable\n     * (i.e., accessible via the TAB key). Setting to `-1` disables tabbability but allows for focus to be set\n     * to the element programmatically.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-tabIndex)\n     */\n    tabIndex ? : number\n    /**\n     * Text to display on checkbox label\n     */\n    text ? : string\n    /**\n     * Text alignment: 'left', 'center' or 'right'. Also accepts direction neutral 'start' and 'end'.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-textAlign)\n     */\n    textAlign ? : 'left'|'center'|'right'|'start'|'end'\n    /**\n     * A title to display for the widget. Only in effect when inside a container that uses it (such as TabPanel)\n     */\n    title ? : string\n    /**\n     * Tooltip for the widget, either as a string or as a Tooltip config object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-tooltip)\n     */\n    tooltip ? : string|TooltipConfig|null\n    /**\n     * The triggers to add either before or after the input field. Each property name is the reference by which\n     * an instantiated Trigger Widget may be retrieved from the live `triggers` property.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-triggers)\n     */\n    triggers ? : Record<string, FieldTriggerConfig>|Record<string, Widget>\n    type ? : 'checkbox'|'check'\n    /**\n     * Custom CSS class name suffixes to apply to the elements rendered by this widget. This may be specified\n     * as a space separated string, an array of strings, or as an object in which property names with truthy\n     * values are used as the class names.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-ui)\n     */\n    ui ? : string|object\n    /**\n     * The value to provide for this widget in [values](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container#property-values) when it is not\n     * [checked](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#property-checked).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-uncheckedValue)\n     */\n    uncheckedValue ? : any\n    /**\n     * Set to `false` to not highlight a field as invalid while typing, to instead show it on ENTER key press\n     * or similar.\n     */\n    validateOnInput ? : boolean\n    /**\n     * The value of the checkbox. This is the same as `checked`.\n     */\n    value ? : boolean\n    /**\n     * A widgets weight determines its position among siblings when added to a [Container](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container).\n     * Higher weights go further down.\n     */\n    weight ? : number\n    /**\n     * Widget's width, used to set element `style.width`. Either specify a valid width string or a number, which\n     * will get 'px' appended. We recommend using CSS as the primary way to control width, but in some cases\n     * this config is convenient.\n     */\n    width ? : string|number\n    /**\n     * The x position for the widget.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-x)\n     */\n    x ? : number\n    /**\n     * The y position for the widget.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#config-y)\n     */\n    y ? : number\n\n}\n\n@Component({\n    selector : 'bryntum-checkbox',\n    template : ''\n})\nexport class BryntumCheckboxComponent implements OnInit, OnDestroy {\n\n    public static instanceClass = Checkbox;\n\n    public static instanceName = 'Checkbox';\n\n    private static bryntumEvents: string[] = [\n        'onAction',\n        'onBeforeChange',\n        'onBeforeDestroy',\n        'onBeforeHide',\n        'onBeforeShow',\n        'onCatchAll',\n        'onChange',\n        'onClear',\n        'onClick',\n        'onDestroy',\n        'onElementCreated',\n        'onFocusIn',\n        'onFocusOut',\n        'onHide',\n        'onInput',\n        'onPaint',\n        'onReadOnly',\n        'onRecompose',\n        'onResize',\n        'onShow',\n        'onTrigger'\n    ];\n\n    private static bryntumFeatureNames: string[] = [\n\n    ];\n\n    private static bryntumConfigs: string[] = BryntumCheckboxComponent.bryntumFeatureNames.concat([\n        'adopt',\n        'align',\n        'alignSelf',\n        'anchor',\n        'appendTo',\n        'ariaDescription',\n        'ariaLabel',\n        'autoCollapse',\n        'autoComplete',\n        'autoSelect',\n        'badge',\n        'bubbleEvents',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'centered',\n        'checked',\n        'checkedValue',\n        'cls',\n        'color',\n        'column',\n        'config',\n        'constrainTo',\n        'container',\n        'containValues',\n        'contentElementCls',\n        'dataField',\n        'dataset',\n        'defaultBindProperty',\n        'detectCSSCompatibilityIssues',\n        'disabled',\n        'dock',\n        'draggable',\n        'elementAttributes',\n        'extraData',\n        'flex',\n        'floating',\n        'height',\n        'hidden',\n        'hideAnimation',\n        'highlightExternalChange',\n        'hint',\n        'hintHtml',\n        'id',\n        'ignoreParentReadOnly',\n        'inline',\n        'inputAlign',\n        'inputAttributes',\n        'inputTag',\n        'inputType',\n        'inputWidth',\n        'insertBefore',\n        'insertFirst',\n        'keyMap',\n        'keyStrokeChangeDelay',\n        'label',\n        'labelCls',\n        'labelPosition',\n        'labels',\n        'labelWidth',\n        'listeners',\n        'localeClass',\n        'localizable',\n        'localizableProperties',\n        'margin',\n        'maskDefaults',\n        'masked',\n        'maxHeight',\n        'maximizeOnMobile',\n        'maxWidth',\n        'minHeight',\n        'minWidth',\n        'monitorResize',\n        'name',\n        'owner',\n        'positioned',\n        'preventTooltipOnTouch',\n        'readOnly',\n        'relayStoreEvents',\n        'required',\n        'revertOnEscape',\n        'ripple',\n        'rootElement',\n        'rtl',\n        'scrollAction',\n        'showAnimation',\n        'showRequiredIndicator',\n        'showTooltipWhenDisabled',\n        'skipValidation',\n        'span',\n        'spellCheck',\n        'tab',\n        'tabIndex',\n        'text',\n        'textAlign',\n        'title',\n        'tooltip',\n        'triggers',\n        'type',\n        'ui',\n        'uncheckedValue',\n        'validateOnInput',\n        'value',\n        'weight',\n        'width',\n        'x',\n        'y'\n    ]);\n\n    private static bryntumConfigsOnly: string[] = [\n        'adopt',\n        'align',\n        'anchor',\n        'ariaDescription',\n        'ariaLabel',\n        'autoCollapse',\n        'autoComplete',\n        'autoSelect',\n        'bubbleEvents',\n        'centered',\n        'checkedValue',\n        'color',\n        'config',\n        'constrainTo',\n        'container',\n        'containValues',\n        'contentElementCls',\n        'dataField',\n        'defaultBindProperty',\n        'detectCSSCompatibilityIssues',\n        'dock',\n        'draggable',\n        'elementAttributes',\n        'floating',\n        'hideAnimation',\n        'highlightExternalChange',\n        'hint',\n        'hintHtml',\n        'ignoreParentReadOnly',\n        'inline',\n        'inputAlign',\n        'inputAttributes',\n        'inputTag',\n        'inputType',\n        'inputWidth',\n        'keyStrokeChangeDelay',\n        'labelCls',\n        'labelPosition',\n        'labels',\n        'labelWidth',\n        'listeners',\n        'localeClass',\n        'localizable',\n        'localizableProperties',\n        'maskDefaults',\n        'masked',\n        'monitorResize',\n        'owner',\n        'positioned',\n        'preventTooltipOnTouch',\n        'relayStoreEvents',\n        'revertOnEscape',\n        'ripple',\n        'rootElement',\n        'scrollAction',\n        'showAnimation',\n        'showTooltipWhenDisabled',\n        'skipValidation',\n        'spellCheck',\n        'tab',\n        'tabIndex',\n        'text',\n        'textAlign',\n        'title',\n        'type',\n        'ui',\n        'uncheckedValue',\n        'validateOnInput',\n        'weight'\n    ];\n\n    private static bryntumProps: string[] = BryntumCheckboxComponent.bryntumFeatureNames.concat([\n        'alignSelf',\n        'anchorSize',\n        'appendTo',\n        'badge',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'checked',\n        'cls',\n        'column',\n        'content',\n        'dataset',\n        'disabled',\n        'editable',\n        'extraData',\n        'flex',\n        'focusVisible',\n        'height',\n        'hidden',\n        'html',\n        'id',\n        'input',\n        'insertBefore',\n        'insertFirst',\n        'keyMap',\n        'label',\n        'margin',\n        'maxHeight',\n        'maximizeOnMobile',\n        'maxWidth',\n        'minHeight',\n        'minWidth',\n        'name',\n        'parent',\n        'placeholder',\n        'readOnly',\n        'required',\n        'rtl',\n        'scrollable',\n        'showRequiredIndicator',\n        'span',\n        'tooltip',\n        'triggers',\n        'value',\n        'width',\n        'x',\n        'y'\n    ]);\n\n    private elementRef: ElementRef;\n    public instance!: Checkbox;\n\n    private bryntumConfig = {\n        adopt            : undefined,\n        appendTo         : undefined,\n        href             : undefined,\n        angularComponent : this,\n        features         : {},\n        listeners        : {}\n    };\n\n    constructor(element: ElementRef) {\n        this.elementRef = element;\n    }\n\n    // Configs only\n    @Input() adopt                        ! : HTMLElement|string;\n    @Input() align                        ! : AlignSpec|string;\n    @Input() anchor                       ! : boolean;\n    @Input() ariaDescription              ! : string;\n    @Input() ariaLabel                    ! : string;\n    @Input() autoCollapse                 ! : boolean|(() => boolean);\n    @Input() autoComplete                 ! : string;\n    @Input() autoSelect                   ! : boolean;\n    @Input() bubbleEvents                 ! : object;\n    @Input() centered                     ! : boolean;\n    @Input() checkedValue                 ! : any;\n    @Input() color                        ! : string;\n    @Input() config                       ! : object;\n    @Input() constrainTo                  ! : HTMLElement|Widget|Rectangle;\n    @Input() container                    ! : Record<string, ContainerItemConfig>|ContainerItemConfig[]|FieldContainerConfig|FieldContainer;\n    @Input() containValues                ! : boolean|string|((field: Field) => boolean);\n    @Input() contentElementCls            ! : string|object;\n    @Input() dataField                    ! : string;\n    @Input() defaultBindProperty          ! : string;\n    @Input() detectCSSCompatibilityIssues ! : boolean;\n    @Input() dock                         ! : 'top'|'bottom'|'left'|'right'|'start'|'end'|'header'|'pre-header'|object;\n    @Input() draggable                    ! : boolean|{\n        handleSelector?: string\n    };\n    @Input() elementAttributes            ! : Record<string, string|null>;\n    @Input() floating                     ! : boolean;\n    @Input() hideAnimation                ! : boolean|object;\n    @Input() highlightExternalChange      ! : boolean;\n    @Input() hint                         ! : string|((data: { source: Field, value: any }) => string);\n    @Input() hintHtml                     ! : string|((data: { source: Field, value: any }) => string);\n    @Input() ignoreParentReadOnly         ! : boolean;\n    @Input() inline                       ! : boolean;\n    @Input() inputAlign                   ! : string;\n    @Input() inputAttributes              ! : Record<string, string>;\n    @Input() inputTag                     ! : string;\n    @Input() inputType                    ! : string;\n    @Input() inputWidth                   ! : string|number;\n    @Input() keyStrokeChangeDelay         ! : number;\n    @Input() labelCls                     ! : string|object;\n    @Input() labelPosition                ! : 'before'|'above'|null;\n    @Input() labels                       ! : object[];\n    @Input() labelWidth                   ! : string|number;\n    @Input() listeners                    ! : CheckboxListeners;\n    @Input() localeClass                  ! : typeof Base;\n    @Input() localizable                  ! : boolean;\n    @Input() localizableProperties        ! : string[];\n    @Input() maskDefaults                 ! : MaskConfig;\n    @Input() masked                       ! : boolean|string|MaskConfig;\n    @Input() monitorResize                ! : boolean|{\n        immediate?: boolean\n    };\n    @Input() owner                        ! : Widget|any;\n    @Input() positioned                   ! : boolean;\n    @Input() preventTooltipOnTouch        ! : boolean;\n    @Input() relayStoreEvents             ! : boolean;\n    @Input() revertOnEscape               ! : boolean;\n    @Input() ripple                       ! : boolean|{\n        delegate?: string\n        color?: string\n        radius?: number\n        clip?: string\n    };\n    @Input() rootElement                  ! : ShadowRoot|HTMLElement;\n    @Input() scrollAction                 ! : 'hide'|'realign'|null;\n    @Input() showAnimation                ! : boolean|object;\n    @Input() showTooltipWhenDisabled      ! : boolean;\n    @Input() skipValidation               ! : boolean;\n    @Input() spellCheck                   ! : boolean;\n    @Input() tab                          ! : boolean|TabConfig;\n    @Input() tabIndex                     ! : number;\n    @Input() text                         ! : string;\n    @Input() textAlign                    ! : 'left'|'center'|'right'|'start'|'end';\n    @Input() title                        ! : string;\n    @Input() type                         ! : 'checkbox'|'check';\n    @Input() ui                           ! : string|object;\n    @Input() uncheckedValue               ! : any;\n    @Input() validateOnInput              ! : boolean;\n    @Input() weight                       ! : number;\n\n    // Configs and properties\n    @Input() alignSelf                   ! : string;\n    @Input() appendTo                    ! : HTMLElement|string;\n    @Input() badge                       ! : string;\n    @Input() callOnFunctions             ! : boolean;\n    @Input() catchEventHandlerExceptions ! : boolean;\n    @Input() checked                     ! : boolean;\n    @Input() cls                         ! : string|object;\n    @Input() column                      ! : number;\n    @Input() dataset                     ! : object|Record<string, string>;\n    @Input() disabled                    ! : boolean|'inert';\n    @Input() extraData                   ! : any;\n    @Input() flex                        ! : number|string;\n    @Input() height                      ! : number|string;\n    @Input() hidden                      ! : boolean;\n    @Input() id                          ! : string;\n    @Input() insertBefore                ! : HTMLElement|string;\n    @Input() insertFirst                 ! : HTMLElement|string;\n    @Input() keyMap                      ! : Record<string, KeyMapConfig>;\n    @Input() label                       ! : string;\n    @Input() margin                      ! : number|string;\n    @Input() maxHeight                   ! : string|number;\n    @Input() maximizeOnMobile            ! : number|string;\n    @Input() maxWidth                    ! : string|number;\n    @Input() minHeight                   ! : string|number;\n    @Input() minWidth                    ! : string|number;\n    @Input() name                        ! : string;\n    @Input() readOnly                    ! : boolean;\n    @Input() required                    ! : boolean;\n    @Input() rtl                         ! : boolean;\n    @Input() showRequiredIndicator       ! : string;\n    @Input() span                        ! : number;\n    @Input() tooltip                     ! : string|TooltipConfig|null;\n    @Input() triggers                    ! : Record<string, FieldTriggerConfig>|Record<string, Widget>;\n    @Input() value                       ! : boolean;\n    @Input() width                       ! : number|string;\n    @Input() x                           ! : number;\n    @Input() y                           ! : number;\n\n    // Properties only\n    @Input() anchorSize   ! : number[];\n    @Input() content      ! : string;\n    @Input() editable     ! : boolean;\n    @Input() focusVisible ! : boolean;\n    @Input() html         ! : string|((widget: Widget) => string)|DomConfig|DomConfig[]|VueConfig;\n    @Input() input        ! : HTMLElement;\n    @Input() parent       ! : Widget;\n    @Input() placeholder  ! : string;\n    @Input() scrollable   ! : Scroller;\n\n    // Events emitters\n    /**\n     * User performed the default action (toggled the checkbox)\n     * @param {object} event Event object\n     * @param {Core.widget.Checkbox} event.source Checkbox\n     * @param {boolean} event.checked Checked state (=value)\n     * @param {boolean} event.value This field's value\n     * @param {boolean} event.valid True if this field is in a valid state\n     * @param {boolean} event.oldValue This field's previous value\n     * @param {boolean} event.userAction Triggered by user taking an action (`true`) or by setting a value (`false`)\n     * @param {Event} event.event The triggering DOM event if any\n     */\n    @Output() onAction: any = new EventEmitter<((event: { source: Checkbox, checked: boolean, value: boolean, valid: boolean, oldValue: boolean, userAction: boolean, event: Event }) => void)|string>();\n    /**\n     * Fired before checkbox is toggled. Returning false from a listener prevents the checkbox from being toggled.\n     * @param {object} event Event object\n     * @param {Core.widget.Checkbox} event.source Checkbox\n     * @param {boolean} event.checked Checked state (=value)\n     * @param {boolean} event.value This field's value\n     * @param {boolean} event.oldValue This field's previous value\n     * @param {boolean} event.userAction Triggered by user taking an action (`true`) or by setting a value (`false`)\n     * @param {boolean} event.valid True if this field is in a valid state.\n     * @param {Event} event.event The triggering DOM event if any\n     */\n    @Output() onBeforeChange: any = new EventEmitter<((event: { source: Checkbox, checked: boolean, value: boolean, oldValue: boolean, userAction: boolean, valid: boolean, event: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before an object is destroyed.\n     * @param {object} event Event object\n     * @param {Core.Base} event.source The Object that is being destroyed.\n     */\n    @Output() onBeforeDestroy: any = new EventEmitter<((event: { source: Base }) => void)|string>();\n    /**\n     * Triggered before a widget is hidden. Return `false` to prevent the action.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget being hidden.\n     */\n    @Output() onBeforeHide: any = new EventEmitter<((event: { source: Widget }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Triggered before a widget is shown. Return `false` to prevent the action.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget,any} event.source The widget being shown\n     */\n    @Output() onBeforeShow: any = new EventEmitter<((event: { source: Widget|any }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires when any other event is fired from the object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#event-catchAll)\n     * @param {object} event Event object\n     * @param {{[key: string]: any, type: string}} event.event The Object that contains event details\n     * @param {string} event.event.type The type of the event which is caught by the listener\n     */\n    @Output() onCatchAll: any = new EventEmitter<((event: {[key: string]: any, type: string}) => void)|string>();\n    /**\n     * Fired when checkbox is toggled\n     * @param {object} event Event object\n     * @param {Core.widget.Checkbox} event.source Checkbox\n     * @param {boolean} event.checked Checked state (=value)\n     * @param {boolean} event.value This field's value\n     * @param {boolean} event.oldValue This field's previous value\n     * @param {boolean} event.userAction Triggered by user taking an action (`true`) or by setting a value (`false`)\n     * @param {boolean} event.valid True if this field is in a valid state.\n     * @param {Event} event.event The triggering DOM event if any\n     */\n    @Output() onChange: any = new EventEmitter<((event: { source: Checkbox, checked: boolean, value: boolean, oldValue: boolean, userAction: boolean, valid: boolean, event: Event }) => void)|string>();\n    /**\n     * Fired when this field is [cleared](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#function-clear).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#event-clear)\n     * @param {object} event Event object\n     * @param {Core.widget.Field,any} event.source This Field\n     */\n    @Output() onClear: any = new EventEmitter<((event: { source: Field|any }) => void)|string>();\n    /**\n     * Fires when the checkbox is clicked\n     * @param {object} event Event object\n     * @param {Core.widget.Checkbox} event.source The checkbox\n     * @param {Event} event.event DOM event\n     */\n    @Output() onClick: any = new EventEmitter<((event: { source: Checkbox, event: Event }) => void)|string>();\n    /**\n     * Fires when an object is destroyed.\n     * @param {object} event Event object\n     * @param {Core.Base} event.source The Object that is being destroyed.\n     */\n    @Output() onDestroy: any = new EventEmitter<((event: { source: Base }) => void)|string>();\n    /**\n     * Triggered when a widget's [element](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#property-element) is available.\n     * @param {object} event Event object\n     * @param {HTMLElement} event.element The Widget's element.\n     */\n    @Output() onElementCreated: any = new EventEmitter<((event: { element: HTMLElement }) => void)|string>();\n    /**\n     * Fired when focus enters this Widget.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source This Widget\n     * @param {HTMLElement} event.fromElement The element which lost focus.\n     * @param {HTMLElement} event.toElement The element which gained focus.\n     * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.\n     * @param {Core.widget.Widget} event.toWidget The widget which gained focus.\n     * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.\n     */\n    @Output() onFocusIn: any = new EventEmitter<((event: { source: Widget, fromElement: HTMLElement, toElement: HTMLElement, fromWidget: Widget, toWidget: Widget, backwards: boolean }) => void)|string>();\n    /**\n     * Fired when focus exits this Widget's ownership tree. This is different from a `blur` event.\n     * focus moving from within this Widget's ownership tree, even if there are floating widgets\n     * will not trigger this event. This is when focus exits this widget completely.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source This Widget\n     * @param {HTMLElement} event.fromElement The element which lost focus.\n     * @param {HTMLElement} event.toElement The element which gained focus.\n     * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.\n     * @param {Core.widget.Widget} event.toWidget The widget which gained focus.\n     * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.\n     */\n    @Output() onFocusOut: any = new EventEmitter<((event: { source: Widget, fromElement: HTMLElement, toElement: HTMLElement, fromWidget: Widget, toWidget: Widget, backwards: boolean }) => void)|string>();\n    /**\n     * Triggered after a widget was hidden\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget\n     */\n    @Output() onHide: any = new EventEmitter<((event: { source: Widget }) => void)|string>();\n    /**\n     * Fired when the user types into this field.\n     * @param {object} event Event object\n     * @param {Core.widget.Field,any} event.source This field\n     * @param {string,number,boolean,any} event.value This field's value\n     * @param {Event} event.event The triggering DOM event\n     */\n    @Output() onInput: any = new EventEmitter<((event: { source: Field|any, value: string|number|boolean|any, event: Event }) => void)|string>();\n    /**\n     * Triggered when a widget which had been in a non-visible state for any reason\n     * achieves visibility.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/Core/widget/Checkbox#event-paint)\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget being painted.\n     * @param {boolean} event.firstPaint `true` if this is the first paint.\n     */\n    @Output() onPaint: any = new EventEmitter<((event: { source: Widget, firstPaint: boolean }) => void)|string>();\n    /**\n     * Fired when a Widget's read only state is toggled\n     * @param {object} event Event object\n     * @param {boolean} event.readOnly Read only or not\n     */\n    @Output() onReadOnly: any = new EventEmitter<((event: { readOnly: boolean }) => void)|string>();\n    /**\n     * This event is fired after a widget's elements have been synchronized due to a direct or indirect call\n     * to [recompose](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#function-recompose), if this results in some change to the widget's rendered DOM elements.\n     */\n    @Output() onRecompose: any = new EventEmitter<(() => void)|string>();\n    /**\n     * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-monitorResize) is `true`*.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source This Widget\n     * @param {number} event.width The new width\n     * @param {number} event.height The new height\n     * @param {number} event.oldWidth The old width\n     * @param {number} event.oldHeight The old height\n     */\n    @Output() onResize: any = new EventEmitter<((event: { source: Widget, width: number, height: number, oldWidth: number, oldHeight: number }) => void)|string>();\n    /**\n     * Triggered after a widget is shown.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget\n     */\n    @Output() onShow: any = new EventEmitter<((event: { source: Widget }) => void)|string>();\n    /**\n     * User clicked one of this field's [triggers](https://bryntum.com/products/taskboard/docs/api/Core/widget/Field#property-triggers)\n     * @param {object} event Event object\n     * @param {Core.widget.Field,any} event.source This field\n     * @param {Core.widget.Widget} event.trigger The trigger activated by click or touch tap.\n     */\n    @Output() onTrigger: any = new EventEmitter<((event: { source: Field|any, trigger: Widget }) => void)|string>();\n\n    /**\n     * Create and append the underlying widget\n     */\n    ngOnInit(): void {\n        const\n            me = this,\n            {\n                elementRef,\n                bryntumConfig\n            } = me,\n            {\n                instanceClass,\n                instanceName,\n                bryntumConfigs,\n                bryntumEvents\n            } = BryntumCheckboxComponent;\n\n        bryntumConfigs.filter(prop => prop in this).forEach(prop => {\n            // @ts-ignore\n            WrapperHelper.applyPropValue(bryntumConfig, prop, this[prop]);\n            if (['features', 'config'].includes(prop)) {\n                WrapperHelper.devWarningConfigProp(instanceName, prop);\n            }\n        });\n        // @ts-ignore\n        bryntumEvents.filter(event => this[event] && this[event].observers.length > 0).forEach(event => {\n            const\n                uncapitalize = (str: string) => str.charAt(0).toLowerCase() + str.slice(1),\n                eventName = (str: string) => uncapitalize(str.slice(2));\n\n            // @ts-ignore\n            bryntumConfig.listeners[eventName(event)] = e => {\n                // @ts-ignore\n                me[event].emit(e);\n                // EventEmitter does not return values in the normal way, work around it by setting `returnValue` flag\n                // in Angular listeners\n                return e.returnValue;\n            };\n        });\n\n        // If component has no container specified in config then use adopt to Wrapper's element\n        const\n            containerParam = [\n                'adopt',\n                'appendTo',\n                'insertAfter',\n                'insertBefore'\n                // @ts-ignore\n            ].find(prop => bryntumConfig[prop]);\n        if (!containerParam) {\n            if (instanceName === 'Button' || elementRef.nativeElement.getRootNode() instanceof ShadowRoot) {\n                // Button should always be <a> or <button> inside owner element\n                bryntumConfig.appendTo = elementRef.nativeElement;\n            }\n            else {\n                bryntumConfig.adopt = elementRef.nativeElement;\n            }\n        }\n        else {\n            WrapperHelper.devWarningContainer(instanceName, containerParam);\n        }\n\n        // @ts-ignore\n        me.instance = instanceName === 'Widget' ? Widget.create(bryntumConfig) : new instanceClass(bryntumConfig);\n\n    }\n\n    /**\n     * Watch for changes\n     * @param changes\n     */\n    ngOnChanges(changes: SimpleChanges): void {\n        const\n            { instance } = this,\n            { instanceName } = BryntumCheckboxComponent;\n        if (!instance) {\n            return;\n        }\n        // Iterate over all changes\n        Object.entries(changes).forEach(([prop, change]) => {\n            const\n                newValue = (change as SimpleChange).currentValue,\n                { instance } = this,\n                { bryntumConfigsOnly, bryntumProps } = BryntumCheckboxComponent;\n            if (bryntumProps.includes(prop)) {\n                WrapperHelper.applyPropValue(instance, prop, newValue, false);\n                if (bryntumConfigsOnly.includes(prop)) {\n                    WrapperHelper.devWarningUpdateProp(instanceName, prop);\n                }\n            }\n        });\n    }\n\n    /**\n     * Destroy the component\n     */\n    ngOnDestroy(): void {\n        // @ts-ignore\n        if (this.instance && this.instance.destroy) {\n            this.instance.destroy();\n        }\n    }\n}\n"]}