@govbr-ds/webcomponents 2.1.0 → 2.1.1

package/dist/collection/components/checkbox/checkbox.js

@@ -0,0 +1,823 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { Host, h, } from "@stencil/core";
+import { redispatchNativeFormEvent } from "../../shared/utils/event";
+import { getCheckableFormValue, getCheckableRestoreState, getFormValidationState, isFormControlDisabled, safeSetFormValue, syncNativeFormValidity, } from "../../shared/utils/form";
+import { hasAssignedSlotContent, hasDefaultLightDomContent } from "../../shared/utils/slot";
+import { resolveFormValidator, runFormValidator } from "../../shared/utils/validator";
+/**
+ * ## Design System
+ *
+ * Para a documentação completa de design, incluindo diretrizes de uso, acessibilidade e exemplos visuais, consulte o [Design System do GovBR](https://www.gov.br/ds/components/checkbox?tab=designer).
+ *
+ * @category Formulários
+ * @status stable
+ * @slot default - Slot para o rótulo do checkbox, como alternativa à propriedade label.
+ * @slot feedback - Mensagem de validação, normalmente um `br-message`.
+ *
+ * @part container - Contêiner visual do checkbox.
+ * @part input - Elemento input nativo do checkbox.
+ * @part label - Rótulo do checkbox.
+ * @part feedback - Contêiner da mensagem de validação.
+ */
+export class Checkbox {
+    constructor() {
+        /**
+         * Controla o estado de disabled herdado do form/fieldset pai.
+         */
+        this.formDisabled = false;
+        /**
+         * Define o número de checkboxes filhos em um grupo de checkboxes.
+         */
+        this.numberOfChildren = 0;
+        /**
+         * Indica se o slot default possui conteúdo.
+         */
+        this.slotDefault = false;
+        /** Indica se o slot de feedback possui conteúdo fornecido pelo consumidor. */
+        this.hasFeedbackSlot = false;
+        /** Mensagem definida pela Constraint Validation API. */
+        this.manualValidationMessage = '';
+        this.validatorMessage = null;
+        this.isValidating = false;
+        /**
+         * Define o estado intermediário do checkbox.
+         * Quando verdadeiro, exibe uma marcação parcial visual que indica seleção parcial.
+         * Útil para representar grupos onde alguns itens estão selecionados, mas não todos.
+         * Ao clicar no checkbox neste estado, ele será automaticamente alterado para marcado.
+         */
+        this.indeterminate = false;
+        /**
+         * Define o estado de seleção do checkbox.
+         * Se definido como verdadeiro, o checkbox estará marcado. Caso contrário, estará desmarcado.
+         */
+        this.checked = false;
+        /**
+         * Identificador único.
+         * Caso não seja fornecido, um ID gerado automaticamente será usado.
+         */
+        this.customId = `br-checkbox-${checkboxId++}`;
+        /**
+         * Desativa o checkbox, tornando-o não interativo.
+         */
+        this.disabled = false;
+        /**
+         * Se verdadeiro, o checkbox é obrigatório e deve ser marcado antes que o formulário possa ser enviado.
+         */
+        this.required = false;
+        /**
+         * Define se o label associado ao checkbox deve ser oculto.
+         * Se definido como verdadeiro, o texto do label será oculto, mas o checkbox ainda estará visível e funcional.
+         * @deprecated Use `labelHidden`.
+         */
+        this.hasHiddenLabel = false;
+        /**
+         * Indica se o checkbox é pai de um grupo de checkboxes.
+         * @deprecated Configure seleção coletiva em `br-checkbox-group`/`br-checkgroup`.
+         */
+        this.isFather = false;
+        this.initialChecked = false;
+        this.initialIndeterminate = false;
+        this.validationRunId = 0;
+        this.handleCheckedInput = (event) => {
+            if (this.isDisabled()) {
+                return;
+            }
+            if (this.indeterminate) {
+                // Sai do estado indeterminado ao clicar e define como marcado
+                this.indeterminate = false;
+                this.checked = true;
+                this.indeterminateChange.emit(this.indeterminate);
+            }
+            else {
+                this.checked = this.nativeInput?.checked ?? !this.checked;
+                this.indeterminate = false;
+            }
+            this.checkedChange.emit(this.checked);
+            redispatchNativeFormEvent(this.el, event, 'input');
+        };
+        this.handleCheckedChange = (event) => {
+            redispatchNativeFormEvent(this.el, event, 'change');
+            void this.validate();
+        };
+    }
+    formDisabledCallback(disabled) {
+        this.formDisabled = disabled;
+    }
+    formResetCallback() {
+        if (this.nativeInput) {
+            this.nativeInput.setCustomValidity('');
+        }
+        this.manualValidationMessage = '';
+        this.validatorMessage = null;
+        this.validationRunId++;
+        this.checked = this.initialChecked;
+        this.indeterminate = this.initialIndeterminate;
+        this.syncFormState();
+    }
+    formStateRestoreCallback(state) {
+        this.checked = state === 'checked';
+        this.indeterminate = false;
+        this.syncFormState();
+    }
+    handleIndeterminateWatch(newValue) {
+        const input = this.el.shadowRoot.querySelector('input');
+        if (input !== null) {
+            input.indeterminate = newValue;
+            input.setAttribute('aria-checked', this.getAriaCheckedValue());
+        }
+    }
+    handleCheckedWatch() {
+        this.syncFormState();
+    }
+    componentWillLoad() {
+        this.hasSlotContentDefault();
+        this.initialChecked = this.checked;
+        this.initialIndeterminate = this.indeterminate;
+        this.syncFormState();
+    }
+    componentDidLoad() {
+        this.hasFeedbackSlot = this.el.querySelector('[slot="feedback"]') !== null;
+        this.updateValidity();
+    }
+    componentDidUpdate() {
+        this.updateValidity();
+    }
+    /**
+     * Retorna `true` se o valor do checkbox for válido, caso contrário `false`.
+     * Se o checkbox for inválido, dispara um evento 'invalid'.
+     */
+    async checkValidity() {
+        return this.elementInternals?.checkValidity?.() ?? true;
+    }
+    /**
+     * Retorna `true` se o valor do checkbox for válido, caso contrário `false`.
+     * Se for inválido, exibe a mensagem de erro padrão do navegador.
+     */
+    async reportValidity() {
+        return this.elementInternals?.reportValidity?.() ?? true;
+    }
+    /**
+     * Define uma mensagem de validação customizada para o checkbox.
+     * Se a mensagem for uma string vazia, o erro customizado é limpo.
+     */
+    async setCustomValidity(message) {
+        this.manualValidationMessage = message;
+        if (this.nativeInput) {
+            this.nativeInput.setCustomValidity(message);
+            this.updateValidity();
+        }
+    }
+    /** Executa o validator do checkbox e retorna se o valor atual é válido. */
+    async validate() {
+        const validator = resolveFormValidator(this.validator);
+        if (!validator || this.isDisabled())
+            return this.checkValidity();
+        const runId = ++this.validationRunId;
+        this.isValidating = true;
+        this.validatorMessage = null;
+        this.updateValidity();
+        this.brCheckboxValidationChange.emit({ validating: true, valid: null, message: null });
+        const message = await runFormValidator(validator, this.checked);
+        if (runId !== this.validationRunId)
+            return false;
+        this.validatorMessage = message;
+        this.isValidating = false;
+        this.updateValidity();
+        const valid = message === null && (await this.checkValidity());
+        this.brCheckboxValidationChange.emit({ validating: false, valid, message });
+        return valid;
+    }
+    /** Retorna um snapshot serializável da Constraint Validation API. */
+    async getValidationState() {
+        return getFormValidationState(this.elementInternals);
+    }
+    /**
+     * Define o estado indeterminado do checkbox.
+     * @param value Novo valor para o estado indeterminado.
+     */
+    async setIndeterminate(value) {
+        this.indeterminate = value;
+        this.handleIndeterminateWatch(value);
+        this.indeterminateChange.emit(this.indeterminate);
+    }
+    /**
+     * Inverte o valor da prop `checked`
+     * @deprecated Atualize a propriedade `checked` diretamente.
+     */
+    async toggleChecked() {
+        if (this.isDisabled()) {
+            return;
+        }
+        if (this.indeterminate) {
+            this.indeterminate = false;
+            this.indeterminateChange.emit(this.indeterminate);
+        }
+        this.checked = !this.checked;
+    }
+    /**
+     * Define o número de checkboxes filhos em um grupo de checkboxes.
+     * @param value Número de checkboxes filhos.
+     */
+    async setNumberOfChildren(value) {
+        this.numberOfChildren = value;
+    }
+    syncFormState() {
+        safeSetFormValue(this.elementInternals, getCheckableFormValue(this.checked, this.value), getCheckableRestoreState(this.checked));
+        this.updateValidity();
+    }
+    isDisabled() {
+        return isFormControlDisabled(this.disabled, this.formDisabled);
+    }
+    updateValidity() {
+        if (this.nativeInput)
+            this.nativeInput.setCustomValidity(this.manualValidationMessage || this.validatorMessage || '');
+        syncNativeFormValidity(this.elementInternals, this.nativeInput);
+    }
+    hasSlotContentDefault() {
+        this.slotDefault = hasDefaultLightDomContent(this.el);
+    }
+    getCssClassMap() {
+        return {
+            'br-checkbox': true,
+            valid: (this.feedbackState ?? this.state) === 'valid',
+            invalid: (this.feedbackState ?? this.state) === 'invalid' || Boolean(this.manualValidationMessage),
+            disabled: this.isDisabled(),
+            'hidden-label': this.labelHidden ?? this.hasHiddenLabel,
+        };
+    }
+    getAriaCheckedValue() {
+        if (this.indeterminate) {
+            return 'mixed';
+        }
+        return this.checked ? 'true' : 'false';
+    }
+    render() {
+        return (h(Host, { key: 'b395601d52d837a29e207e0f32c0531c74af027b' }, h("div", { key: '0eb4e7de71190b4de4d6b2ca66734c1011f6690c', class: this.getCssClassMap(), part: "container" }, h("input", { key: 'babbd5e4879400f2ba0f9b8f7130e9bc5bd76602', part: "input", ref: (el) => {
+                this.nativeInput = el;
+                if (el)
+                    el.indeterminate = this.indeterminate;
+            }, type: "checkbox", id: this.customId, name: this.name, checked: this.checked, disabled: this.isDisabled(), required: this.required, value: this.value, onInput: this.handleCheckedInput, onChange: this.handleCheckedChange, "aria-checked": this.getAriaCheckedValue(), "aria-busy": this.isValidating ? 'true' : null, "aria-describedby": [
+                this.numberOfChildren > 0 ? 'children-number' : '',
+                this.hasFeedbackSlot || this.manualValidationMessage || this.validatorMessage
+                    ? `${this.customId}-feedback`
+                    : '',
+            ]
+                .filter(Boolean)
+                .join(' ') || null, "aria-errormessage": this.manualValidationMessage || this.validatorMessage || this.hasFeedbackSlot
+                ? `${this.customId}-feedback`
+                : null }), h("label", { key: 'eac647139f0a37ab33c8951e20d782daeb70d0ab', part: "label", htmlFor: this.customId, class: (this.labelHidden ?? this.hasHiddenLabel) ? 'visually-hidden' : undefined }, this.slotDefault ? h("slot", null) : this.label)), this.isFather ? (h("span", { id: "children-number", class: "sr-only" }, "N\u00FAmero de op\u00E7\u00F5es: ", this.numberOfChildren)) : null, h("div", { key: '3d755ed1411c62fb5b06127987097b871f108f90', id: `${this.customId}-feedback`, part: "feedback", hidden: !this.hasFeedbackSlot && !this.manualValidationMessage && !this.validatorMessage }, h("slot", { key: '9003005df404ab62b2e47e41132bb632ffb64176', name: "feedback", onSlotchange: (event) => (this.hasFeedbackSlot = hasAssignedSlotContent(event.currentTarget)) }), !this.hasFeedbackSlot && (this.manualValidationMessage || this.validatorMessage) ? (h("br-message", { state: "danger", message: this.manualValidationMessage || this.validatorMessage })) : null)));
+    }
+    static get is() { return "br-checkbox"; }
+    static get encapsulation() { return "shadow"; }
+    static get delegatesFocus() { return true; }
+    static get formAssociated() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["checkbox.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["checkbox.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "indeterminate": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define o estado intermedi\u00E1rio do checkbox.\nQuando verdadeiro, exibe uma marca\u00E7\u00E3o parcial visual que indica sele\u00E7\u00E3o parcial.\n\u00DAtil para representar grupos onde alguns itens est\u00E3o selecionados, mas n\u00E3o todos.\nAo clicar no checkbox neste estado, ele ser\u00E1 automaticamente alterado para marcado."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "indeterminate",
+                "defaultValue": "false"
+            },
+            "checked": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define o estado de sele\u00E7\u00E3o do checkbox.\nSe definido como verdadeiro, o checkbox estar\u00E1 marcado. Caso contr\u00E1rio, estar\u00E1 desmarcado."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "checked",
+                "defaultValue": "false"
+            },
+            "customId": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Identificador \u00FAnico.\nCaso n\u00E3o seja fornecido, um ID gerado automaticamente ser\u00E1 usado."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "custom-id",
+                "defaultValue": "`br-checkbox-${checkboxId++}`"
+            },
+            "disabled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Desativa o checkbox, tornando-o n\u00E3o interativo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "disabled",
+                "defaultValue": "false"
+            },
+            "required": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Se verdadeiro, o checkbox \u00E9 obrigat\u00F3rio e deve ser marcado antes que o formul\u00E1rio possa ser enviado."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "required",
+                "defaultValue": "false"
+            },
+            "validator": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "CheckboxValidator",
+                    "resolved": "(value: boolean) => string | Promise<string>",
+                    "references": {
+                        "CheckboxValidator": {
+                            "location": "import",
+                            "path": "./checkbox.types",
+                            "id": "src/components/checkbox/checkbox.types.ts::CheckboxValidator",
+                            "referenceLocation": "CheckboxValidator"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Regra s\u00EDncrona ou ass\u00EDncrona aplicada ao estado booleano do checkbox."
+                },
+                "getter": false,
+                "setter": false
+            },
+            "hasHiddenLabel": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use `labelHidden`."
+                        }],
+                    "text": "Define se o label associado ao checkbox deve ser oculto.\nSe definido como verdadeiro, o texto do label ser\u00E1 oculto, mas o checkbox ainda estar\u00E1 vis\u00EDvel e funcional."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "has-hidden-label",
+                "defaultValue": "false"
+            },
+            "labelHidden": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Oculta visualmente o r\u00F3tulo. Quando informada, tem preced\u00EAncia sobre `hasHiddenLabel`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "label-hidden"
+            },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto descritivo exibido \u00E0 direita do checkbox.\nCaso um slot seja utilizado para fornecer um texto alternativo, o valor desta propriedade ser\u00E1 ignorado."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "label"
+            },
+            "name": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define o nome do checkbox, que \u00E9 utilizado para agrupar checkboxes em formul\u00E1rios e identificar o campo.\nO valor \u00E9 obrigat\u00F3rio e deve ser fornecido para garantir o correto funcionamento em formul\u00E1rios."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "name"
+            },
+            "state": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "'valid' | 'invalid'",
+                    "resolved": "\"invalid\" | \"valid\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Indica a validade do checkbox.\nSe n\u00E3o for especificado, o valor padr\u00E3o \u00E9 `null`, indicando que a validade n\u00E3o foi definida."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "state"
+            },
+            "feedbackState": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "'valid' | 'invalid'",
+                    "resolved": "\"invalid\" | \"valid\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Estado de feedback can\u00F4nico. Quando informado, tem preced\u00EAncia sobre `state`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "feedback-state"
+            },
+            "value": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define o valor associado ao checkbox quando ele faz parte de um formul\u00E1rio nativo (`<form>`).\nEsse valor \u00E9 enviado com o formul\u00E1rio quando o checkbox est\u00E1 selecionado.\n**Nota:** Esta propriedade n\u00E3o deve ser utilizada para determinar se o checkbox est\u00E1 selecionado; para verificar o estado de sele\u00E7\u00E3o, use a propriedade `checked`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "value"
+            },
+            "isFather": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Configure sele\u00E7\u00E3o coletiva em `br-checkbox-group`/`br-checkgroup`."
+                        }],
+                    "text": "Indica se o checkbox \u00E9 pai de um grupo de checkboxes."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "is-father",
+                "defaultValue": "false"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "formDisabled": {},
+            "numberOfChildren": {},
+            "slotDefault": {},
+            "hasFeedbackSlot": {},
+            "manualValidationMessage": {},
+            "validatorMessage": {},
+            "isValidating": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "checkedChange",
+                "name": "checkedChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use `input`/`change` e leia `event.target.checked`."
+                        }],
+                    "text": "Disparado depois que o valor do `checked` foi alterado."
+                },
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                }
+            }, {
+                "method": "indeterminateChange",
+                "name": "indeterminateChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Disparado depois que o valor do `indeterminate` foi alterado."
+                },
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                }
+            }, {
+                "method": "brCheckboxValidationChange",
+                "name": "brCheckboxValidationChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido ao iniciar e concluir a valida\u00E7\u00E3o customizada."
+                },
+                "complexType": {
+                    "original": "FormValidationChangeDetail",
+                    "resolved": "FormValidationChangeDetail",
+                    "references": {
+                        "FormValidationChangeDetail": {
+                            "location": "import",
+                            "path": "../../shared/utils/validator",
+                            "id": "src/shared/utils/validator.ts::FormValidationChangeDetail",
+                            "referenceLocation": "FormValidationChangeDetail"
+                        }
+                    }
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "checkValidity": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Retorna `true` se o valor do checkbox for v\u00E1lido, caso contr\u00E1rio `false`.\nSe o checkbox for inv\u00E1lido, dispara um evento 'invalid'.",
+                    "tags": []
+                }
+            },
+            "reportValidity": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Retorna `true` se o valor do checkbox for v\u00E1lido, caso contr\u00E1rio `false`.\nSe for inv\u00E1lido, exibe a mensagem de erro padr\u00E3o do navegador.",
+                    "tags": []
+                }
+            },
+            "setCustomValidity": {
+                "complexType": {
+                    "signature": "(message: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "message",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Define uma mensagem de valida\u00E7\u00E3o customizada para o checkbox.\nSe a mensagem for uma string vazia, o erro customizado \u00E9 limpo.",
+                    "tags": []
+                }
+            },
+            "validate": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Executa o validator do checkbox e retorna se o valor atual \u00E9 v\u00E1lido.",
+                    "tags": []
+                }
+            },
+            "getValidationState": {
+                "complexType": {
+                    "signature": "() => Promise<FormValidationState>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "FormValidationState": {
+                            "location": "import",
+                            "path": "../../shared/utils/form",
+                            "id": "src/shared/utils/form.ts::FormValidationState",
+                            "referenceLocation": "FormValidationState"
+                        }
+                    },
+                    "return": "Promise<FormValidationState>"
+                },
+                "docs": {
+                    "text": "Retorna um snapshot serializ\u00E1vel da Constraint Validation API.",
+                    "tags": []
+                }
+            },
+            "setIndeterminate": {
+                "complexType": {
+                    "signature": "(value: boolean) => Promise<void>",
+                    "parameters": [{
+                            "name": "value",
+                            "type": "boolean",
+                            "docs": "Novo valor para o estado indeterminado."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Define o estado indeterminado do checkbox.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "value Novo valor para o estado indeterminado."
+                        }]
+                }
+            },
+            "toggleChecked": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Inverte o valor da prop `checked`",
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Atualize a propriedade `checked` diretamente."
+                        }]
+                }
+            },
+            "setNumberOfChildren": {
+                "complexType": {
+                    "signature": "(value: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "value",
+                            "type": "number",
+                            "docs": "N\u00FAmero de checkboxes filhos."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Define o n\u00FAmero de checkboxes filhos em um grupo de checkboxes.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "value N\u00FAmero de checkboxes filhos."
+                        }]
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "indeterminate",
+                "methodName": "handleIndeterminateWatch"
+            }, {
+                "propName": "checked",
+                "methodName": "handleCheckedWatch"
+            }];
+    }
+    static get attachInternalsMemberName() { return "elementInternals"; }
+}
+let checkboxId = 0;