@govbr-ds/webcomponents 2.1.0 → 2.1.2

package/dist/collection/components/radio-group/radio-group.js

@@ -0,0 +1,862 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { Host, h, } from "@stencil/core";
+import { dispatchNativeFormEvent } from "../../shared/utils/event";
+import { getFormValidationState, safeSetFormValue, setFormValidity, } from "../../shared/utils/form";
+import { generateUniqueId } from "../../shared/utils/id";
+import { hasAssignedSlotContent, hasNamedLightDomSlot } from "../../shared/utils/slot";
+import { resolveFormValidator, runFormValidator } from "../../shared/utils/validator";
+/**
+ * ## Design System
+ *
+ * Grupo semântico de radios que representa um único campo de formulário. Consulte também as
+ * [diretrizes do Radio no Design System GovBR](https://www.gov.br/ds/components/radio?tab=designer).
+ *
+ * @category Formulários
+ * @status stable
+ * @slot default - Radios pertencentes ao grupo.
+ * @slot label - Legenda do grupo, como alternativa à propriedade `label`.
+ * @slot description - Texto auxiliar do grupo.
+ * @slot feedback - Mensagem de validação do grupo.
+ * @slot validation-loading - Indicador exibido durante validação assíncrona.
+ * @part group - Fieldset semântico do grupo.
+ * @part legend - Legenda e nome acessível do grupo.
+ * @part options - Contêiner das opções.
+ * @part description - Área de texto auxiliar.
+ * @part feedback - Área de mensagem de validação.
+ * @part validation-loading - Área do indicador de validação assíncrona.
+ */
+export class RadioGroup {
+    constructor() {
+        this.formDisabled = false;
+        this.customValidationMessage = '';
+        this.validatorMessage = null;
+        this.isValidating = false;
+        this.hasFeedbackSlot = false;
+        this.hasInteracted = false;
+        this.hasDescriptionSlot = false;
+        this.hasLabelSlot = false;
+        this.hasValidationLoadingSlot = false;
+        /** Valor atualmente selecionado; `null` representa nenhuma seleção. */
+        this.value = null;
+        /** Exige uma opção habilitada selecionada. */
+        this.required = false;
+        /** Desabilita o grupo e seus radios. */
+        this.disabled = false;
+        /** Orientação visual das opções. */
+        this.orientation = 'vertical';
+        /** Nome acessível usado quando não há uma legenda visível. */
+        this.ariaLabel = null;
+        /** Identificador usado nas relações acessíveis internas. */
+        this.customId = generateUniqueId();
+        this.initialValue = null;
+        this.validationRunId = 0;
+        this.syncingChildren = false;
+        this.ready = false;
+        this.originalNames = new Map();
+        this.handleSlotChange = () => this.reconcileChildren();
+    }
+    formDisabledCallback(disabled) {
+        this.formDisabled = disabled;
+        if (disabled)
+            this.cancelValidation();
+        this.applyValueToChildren();
+        this.syncFormState();
+    }
+    formResetCallback() {
+        this.validationRunId++;
+        this.customValidationMessage = '';
+        this.validatorMessage = null;
+        this.isValidating = false;
+        this.hasInteracted = false;
+        this.value = this.initialValue;
+        this.applyValueToChildren();
+        this.syncFormState();
+    }
+    formStateRestoreCallback(state) {
+        this.value = typeof state === 'string' ? state : null;
+        this.applyValueToChildren();
+        this.syncFormState();
+    }
+    componentWillLoad() {
+        const checked = this.getChildren()
+            .filter((radio) => radio.checked && !radio.disabled)
+            .at(-1);
+        this.initialValue = this.defaultValue ?? this.value ?? checked?.value ?? null;
+        if (this.value === null)
+            this.value = this.initialValue;
+        this.applyValueToChildren();
+        this.syncFormState();
+    }
+    componentDidLoad() {
+        this.syncNamedSlots();
+        const slot = this.el.shadowRoot?.querySelector('slot:not([name])');
+        slot?.addEventListener('slotchange', this.handleSlotChange);
+        this.observer = new MutationObserver((records) => {
+            this.reconcileChildren(records);
+            queueMicrotask(() => this.reconcileChildren());
+        });
+        this.observeChildren();
+        this.reconcileChildren();
+        this.ready = true;
+    }
+    connectedCallback() {
+        if (!this.observer)
+            return;
+        this.observeChildren();
+        this.el.shadowRoot?.querySelector('slot:not([name])')?.addEventListener('slotchange', this.handleSlotChange);
+        this.reconcileChildren();
+    }
+    disconnectedCallback() {
+        this.observer?.disconnect();
+        const slot = this.el.shadowRoot?.querySelector('slot:not([name])');
+        slot?.removeEventListener('slotchange', this.handleSlotChange);
+        for (const radio of this.originalNames.keys())
+            this.releaseRadio(radio);
+        this.originalNames.clear();
+    }
+    handleValueChange() {
+        this.cancelValidation();
+        this.applyValueToChildren();
+        this.syncFormState();
+    }
+    handleNameChange() {
+        this.applyValueToChildren();
+        this.syncFormState();
+    }
+    handleDisabledChange(disabled) {
+        if (disabled)
+            this.cancelValidation();
+        this.applyValueToChildren();
+        this.syncFormState();
+    }
+    handleValidatorChange() {
+        this.cancelValidation();
+        this.syncFormState();
+    }
+    handleDefaultValueChange(value) {
+        this.initialValue = value ?? null;
+    }
+    handleRequiredChange() {
+        this.syncFormState();
+    }
+    handleCustomValidityChange() {
+        this.syncFormState();
+    }
+    handleChildInput(event) {
+        this.handleChildFormEvent(event, 'input');
+    }
+    handleChildChange(event) {
+        this.handleChildFormEvent(event, 'change');
+    }
+    handleChildChecked(event) {
+        const radio = event.target;
+        if (this.syncingChildren || !this.getChildren().includes(radio) || !radio.checked || this.isDisabled())
+            return;
+        this.value = radio.value ?? null;
+    }
+    handleKeyDown(event) {
+        const target = event.composedPath().find((node) => node.tagName?.toLowerCase() === 'br-radio');
+        if (!target ||
+            this.isDisabled() ||
+            !['ArrowRight', 'ArrowDown', 'ArrowLeft', 'ArrowUp', 'Home', 'End'].includes(event.key))
+            return;
+        const radios = this.getChildren().filter((radio) => !radio.disabled);
+        const index = radios.indexOf(target);
+        if (index < 0 || radios.length === 0)
+            return;
+        event.preventDefault();
+        event.stopPropagation();
+        const nextIndex = event.key === 'Home'
+            ? 0
+            : event.key === 'End'
+                ? radios.length - 1
+                : ['ArrowRight', 'ArrowDown'].includes(event.key)
+                    ? (index + 1) % radios.length
+                    : (index - 1 + radios.length) % radios.length;
+        const next = radios[nextIndex];
+        if (!next)
+            return;
+        next.checked = true;
+        this.value = next.value ?? null;
+        void next.setFocus();
+        dispatchNativeFormEvent(this.el, 'input');
+        dispatchNativeFormEvent(this.el, 'change');
+        void this.validate();
+    }
+    /** Verifica a validade do grupo. */
+    async checkValidity() {
+        return this.elementInternals.checkValidity();
+    }
+    /** Verifica a validade e apresenta a mensagem do grupo. */
+    async reportValidity() {
+        this.hasInteracted = true;
+        this.syncFormState();
+        const valid = this.elementInternals.reportValidity();
+        if (!valid)
+            await this.setFocus();
+        return valid;
+    }
+    /** Define a mensagem de validade customizada do grupo. */
+    async setCustomValidity(message) {
+        this.customValidationMessage = message;
+        this.syncFormState();
+    }
+    /** Executa o validator do grupo. */
+    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.syncFormState();
+        this.brRadioGroupValidationChange.emit({ validating: true, valid: null, message: null });
+        const message = await runFormValidator(validator, this.value);
+        if (runId !== this.validationRunId)
+            return false;
+        this.validatorMessage = message;
+        this.isValidating = false;
+        this.syncFormState();
+        const valid = message === null && (await this.checkValidity());
+        this.brRadioGroupValidationChange.emit({ validating: false, valid, message });
+        return valid;
+    }
+    /** Retorna o snapshot de validade do grupo. */
+    async getValidationState() {
+        return getFormValidationState(this.elementInternals);
+    }
+    /** Move o foco para o radio marcado ou para o primeiro radio habilitado. */
+    async setFocus() {
+        const radio = this.getChildren().find((item) => item.checked && !item.disabled) ??
+            this.getChildren().find((item) => !item.disabled);
+        await radio?.setFocus?.();
+    }
+    getChildren() {
+        return Array.from(this.el.children).filter((element) => element.tagName.toLowerCase() === 'br-radio');
+    }
+    isDisabled() {
+        return this.disabled || this.formDisabled;
+    }
+    handleChildFormEvent(event, type) {
+        const radio = event.composedPath().find((node) => node.tagName?.toLowerCase() === 'br-radio');
+        if (!radio || this.isDisabled())
+            return;
+        if (this.ready && event.isTrusted)
+            this.hasInteracted = true;
+        event.stopImmediatePropagation();
+        this.value = radio.checked ? (radio.value ?? null) : null;
+        dispatchNativeFormEvent(this.el, type);
+        if (type === 'change')
+            void this.validate();
+    }
+    syncManagedState(children) {
+        const enabled = children.filter((radio) => !radio.disabled);
+        const selected = enabled.find((radio) => radio.checked);
+        if (this.syncingChildren)
+            return;
+        this.syncingChildren = true;
+        children.forEach((radio) => {
+            this.manageRadio(radio, selected, enabled[0]);
+        });
+        for (const radio of this.originalNames.keys()) {
+            if (!children.includes(radio)) {
+                this.releaseRadio(radio);
+                this.originalNames.delete(radio);
+            }
+        }
+        this.syncingChildren = false;
+    }
+    manageRadio(radio, selected, firstEnabled) {
+        if (!this.originalNames.has(radio))
+            this.originalNames.set(radio, radio.name);
+        radio.name = this.name;
+        const tabIndex = this.isDisabled() || radio.disabled
+            ? -1
+            : selected
+                ? radio === selected
+                    ? 0
+                    : -1
+                : radio === firstEnabled
+                    ? 0
+                    : -1;
+        radio.dispatchEvent(new CustomEvent('brRadioGroupState', {
+            detail: { managed: true, disabled: this.isDisabled(), tabIndex },
+        }));
+    }
+    releaseRadio(radio) {
+        const originalName = this.originalNames.get(radio);
+        if (originalName === undefined)
+            radio.removeAttribute('name');
+        else
+            radio.name = originalName;
+        radio.dispatchEvent(new CustomEvent('brRadioGroupState', {
+            detail: { managed: false, disabled: false, tabIndex: 0 },
+        }));
+    }
+    observeChildren() {
+        this.observer?.observe(this.el, {
+            childList: true,
+            attributes: true,
+            subtree: true,
+            attributeFilter: ['checked', 'disabled', 'slot', 'value'],
+        });
+    }
+    syncNamedSlots() {
+        this.hasFeedbackSlot = hasNamedLightDomSlot(this.el, 'feedback');
+        this.hasDescriptionSlot = hasNamedLightDomSlot(this.el, 'description');
+        this.hasLabelSlot = hasNamedLightDomSlot(this.el, 'label');
+        this.hasValidationLoadingSlot = hasNamedLightDomSlot(this.el, 'validation-loading');
+    }
+    applyValueToChildren() {
+        if (this.syncingChildren)
+            return;
+        const children = this.getChildren();
+        const selected = this.value === null ? undefined : children.find((radio) => radio.value === this.value && !radio.disabled);
+        this.syncingChildren = true;
+        children.forEach((radio) => {
+            radio.checked = radio === selected;
+        });
+        this.syncingChildren = false;
+        if (this.value !== null && !selected) {
+            this.value = null;
+            return;
+        }
+        this.syncManagedState(children);
+    }
+    reconcileChildren(records = []) {
+        if (this.syncingChildren)
+            return;
+        this.syncNamedSlots();
+        const children = this.getChildren();
+        const checked = children.filter((radio) => radio.checked && !radio.disabled);
+        const selected = this.value === null ? undefined : children.find((radio) => radio.value === this.value && !radio.disabled);
+        const stateMatchesValue = this.value === null ? checked.length === 0 : Boolean(selected) && checked.length === 1 && checked[0] === selected;
+        if (!stateMatchesValue) {
+            const addedChecked = records
+                .filter((record) => record.type === 'childList')
+                .flatMap((record) => Array.from(record.addedNodes))
+                .filter((node) => node.tagName?.toLowerCase() === 'br-radio' &&
+                node.checked &&
+                !node.disabled)
+                .at(-1);
+            const changedChecked = records
+                .filter((record) => record.type === 'attributes' && record.attributeName === 'checked')
+                .map((record) => record.target)
+                .filter((radio) => radio.checked && !radio.disabled)
+                .at(-1);
+            this.value = (changedChecked ?? addedChecked ?? checked.at(-1))?.value ?? null;
+            return;
+        }
+        this.syncManagedState(children);
+        this.syncFormState();
+    }
+    getValidityMessage() {
+        return (this.customValidationMessage ||
+            this.validatorMessage ||
+            ((this.hasInteracted || this.elementInternals.validity.valueMissing) && this.required && this.value === null
+                ? 'Selecione uma opção.'
+                : ''));
+    }
+    cancelValidation() {
+        this.validationRunId++;
+        this.isValidating = false;
+        this.validatorMessage = null;
+    }
+    getCssClassMap() {
+        const disabled = this.isDisabled();
+        const invalid = !disabled && (this.feedbackState === 'invalid' || this.getValidityMessage() !== '');
+        return {
+            'br-radio-group': true,
+            disabled,
+            horizontal: this.orientation === 'horizontal',
+            vertical: this.orientation === 'vertical',
+            valid: !disabled && this.feedbackState === 'valid' && !invalid,
+            invalid,
+        };
+    }
+    syncFormState() {
+        const disabled = this.isDisabled();
+        const valueMissing = !disabled && this.required && this.value === null;
+        const customError = !disabled && Boolean(this.customValidationMessage || this.validatorMessage);
+        setFormValidity(this.elementInternals, { customError, valueMissing }, this.getValidityMessage(), this.getChildren().find((radio) => radio.checked && !radio.disabled) ??
+            this.getChildren().find((radio) => !radio.disabled));
+        if (disabled || this.value === null)
+            safeSetFormValue(this.elementInternals, null);
+        else
+            safeSetFormValue(this.elementInternals, this.value, this.value);
+    }
+    renderDefaultFeedback(hasError, message) {
+        if (this.hasFeedbackSlot || !hasError)
+            return null;
+        return h("br-message", { state: "danger", message: message });
+    }
+    render() {
+        const feedbackId = `${this.customId}-feedback`;
+        const descriptionId = `${this.customId}-description`;
+        const legendId = `${this.customId}-legend`;
+        const validationMessage = this.getValidityMessage();
+        const hasError = !this.isDisabled() && validationMessage !== '';
+        const isAriaInvalid = !this.isDisabled() && (hasError || this.feedbackState === 'invalid');
+        const hasErrorMessage = hasError || this.hasFeedbackSlot;
+        const hasVisibleLegend = Boolean(this.label || this.hasLabelSlot);
+        return (h(Host, { key: 'ae3ac4cc6cf4a4bff1af2d395d97d5a4fa79c92a', class: this.getCssClassMap(), "aria-busy": this.isValidating ? 'true' : null, "aria-disabled": this.isDisabled() ? 'true' : null, "aria-invalid": isAriaInvalid ? 'true' : null }, h("fieldset", { key: 'b61641320a175a98a0f981f98754ecbab291c779', part: "group", disabled: this.isDisabled(), "aria-label": !hasVisibleLegend ? this.ariaLabel : null, "aria-labelledby": hasVisibleLegend ? legendId : null, "aria-describedby": this.hasDescriptionSlot ? descriptionId : null, "aria-errormessage": hasErrorMessage ? feedbackId : null, "aria-invalid": isAriaInvalid ? 'true' : null }, h("legend", { key: '2fa589ca43588c7f5edca7e7fc8670f9c0eb02aa', id: legendId, part: "legend", hidden: !hasVisibleLegend }, h("slot", { key: '6cd271f83276a81fd679f06ab1f978f9fd2746ee', name: "label", onSlotchange: (event) => (this.hasLabelSlot = hasAssignedSlotContent(event.currentTarget)) }, this.label)), h("div", { key: 'ca4d582ef84b1ae8ff4db643896a0a1fb8ae1b2a', class: "radio-group-options", part: "options" }, h("slot", { key: '57263290203fd43b0dcc6d10ebbc15dc6b027a6a' })), h("div", { key: 'b049ee5c24aafda47bd716e942b08dd8d25f279c', id: descriptionId, class: "radio-group-description", part: "description", hidden: !this.hasDescriptionSlot }, h("slot", { key: '594c48868c942c101fdb402422464c25c5b13030', name: "description", onSlotchange: (event) => (this.hasDescriptionSlot = hasAssignedSlotContent(event.currentTarget)) })), h("div", { key: '7988046b5aa8912e3b0d76ba7e81654f6b29bec0', id: feedbackId, class: "radio-group-feedback", part: "feedback", hidden: !hasError && !this.hasFeedbackSlot }, h("slot", { key: '13bda2bf78bfcceb3012ec20362d8f3499113aa2', name: "feedback", onSlotchange: (event) => (this.hasFeedbackSlot = hasAssignedSlotContent(event.currentTarget)) }), this.renderDefaultFeedback(hasError, validationMessage)), h("div", { key: 'a7839cd4d68536a5f280044c6582e7ae3ce89fd0', part: "validation-loading", hidden: !this.hasValidationLoadingSlot || !this.isValidating }, h("slot", { key: 'f9cd0a4aa045f9c679c34d5551435287ca37bc75', name: "validation-loading" })))));
+    }
+    static get is() { return "br-radio-group"; }
+    static get encapsulation() { return "shadow"; }
+    static get formAssociated() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["radio-group.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["radio-group.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "name": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Nome do campo enviado pelo formul\u00E1rio."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "name"
+            },
+            "value": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "string | null",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Valor atualmente selecionado; `null` representa nenhuma sele\u00E7\u00E3o."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "value",
+                "defaultValue": "null"
+            },
+            "defaultValue": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Valor restaurado por `form.reset()` e usado como sele\u00E7\u00E3o inicial."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "default-value"
+            },
+            "required": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Exige uma op\u00E7\u00E3o habilitada selecionada."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "required",
+                "defaultValue": "false"
+            },
+            "disabled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Desabilita o grupo e seus radios."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "disabled",
+                "defaultValue": "false"
+            },
+            "orientation": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "RadioGroupOrientation",
+                    "resolved": "\"horizontal\" | \"vertical\"",
+                    "references": {
+                        "RadioGroupOrientation": {
+                            "location": "import",
+                            "path": "./radio-group.types",
+                            "id": "src/components/radio-group/radio-group.types.ts::RadioGroupOrientation",
+                            "referenceLocation": "RadioGroupOrientation"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Orienta\u00E7\u00E3o visual das op\u00E7\u00F5es."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "orientation",
+                "defaultValue": "'vertical'"
+            },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto vis\u00EDvel usado como legenda do grupo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "label"
+            },
+            "ariaLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string | null",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Nome acess\u00EDvel usado quando n\u00E3o h\u00E1 uma legenda vis\u00EDvel."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "aria-label",
+                "defaultValue": "null"
+            },
+            "feedbackState": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "'valid' | 'invalid'",
+                    "resolved": "\"invalid\" | \"valid\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Estado visual opcional do feedback. A validade real vem de ElementInternals."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "feedback-state"
+            },
+            "validator": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "RadioGroupValidator",
+                    "resolved": "(value: string) => string | Promise<string>",
+                    "references": {
+                        "RadioGroupValidator": {
+                            "location": "import",
+                            "path": "./radio-group.types",
+                            "id": "src/components/radio-group/radio-group.types.ts::RadioGroupValidator",
+                            "referenceLocation": "RadioGroupValidator"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Regra s\u00EDncrona ou ass\u00EDncrona aplicada ao valor do grupo."
+                },
+                "getter": false,
+                "setter": false
+            },
+            "customId": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Identificador usado nas rela\u00E7\u00F5es acess\u00EDveis internas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "custom-id",
+                "defaultValue": "generateUniqueId()"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "formDisabled": {},
+            "customValidationMessage": {},
+            "validatorMessage": {},
+            "isValidating": {},
+            "hasFeedbackSlot": {},
+            "hasInteracted": {},
+            "hasDescriptionSlot": {},
+            "hasLabelSlot": {},
+            "hasValidationLoadingSlot": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "brRadioGroupValidationChange",
+                "name": "brRadioGroupValidationChange",
+                "bubbles": true,
+                "cancelable": false,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido ao iniciar e concluir uma 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": "Verifica a validade do grupo.",
+                    "tags": []
+                }
+            },
+            "reportValidity": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Verifica a validade e apresenta a mensagem do grupo.",
+                    "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 a mensagem de validade customizada do grupo.",
+                    "tags": []
+                }
+            },
+            "validate": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Executa o validator do grupo.",
+                    "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 o snapshot de validade do grupo.",
+                    "tags": []
+                }
+            },
+            "setFocus": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "HTMLBrRadioElement": {
+                            "location": "global",
+                            "id": "global::HTMLBrRadioElement"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Move o foco para o radio marcado ou para o primeiro radio habilitado.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "value",
+                "methodName": "handleValueChange"
+            }, {
+                "propName": "name",
+                "methodName": "handleNameChange"
+            }, {
+                "propName": "disabled",
+                "methodName": "handleDisabledChange"
+            }, {
+                "propName": "validator",
+                "methodName": "handleValidatorChange"
+            }, {
+                "propName": "defaultValue",
+                "methodName": "handleDefaultValueChange"
+            }, {
+                "propName": "required",
+                "methodName": "handleRequiredChange"
+            }, {
+                "propName": "customValidationMessage",
+                "methodName": "handleCustomValidityChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "input",
+                "method": "handleChildInput",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "change",
+                "method": "handleChildChange",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brInternalRadioChecked",
+                "method": "handleChildChecked",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "keydown",
+                "method": "handleKeyDown",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+    static get attachInternalsMemberName() { return "elementInternals"; }
+}