@telesign/boreal-web-components 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/types/components/actions/bds-button/bds-button.d.ts

@@ -15,7 +15,7 @@ import { ComponentState } from "../../../types/index";
  * @attr {string} type - The type of the button, which can be 'button', 'submit', or 'reset'. Default is 'button'.
  * @attr {string} color - The color theme of the button, which can be 'default', 'primary', 'success', or 'error'. Default is 'default'.
  * @attr {string} variant - The visual style of the button, which can be 'default', 'outline', or 'plain'. Default is 'default'.
- * @attr {string} size - The size of the button, which can be 'small', 'medium', or 'large'. Default is 'medium'.
+ * @attr {string} size - The size of the button, which can be 'sm', 'md', or 'lg'. Default is 'md'.
  * @attr {boolean} loading - Indicates whether the button is in a loading state, which can be used to show a loading spinner and disable the button. Default is false.
  * @attr {boolean} disclosure - Indicates if the button should show a chevron down at the end of the content.
  *
@@ -25,14 +25,14 @@ import { ComponentState } from "../../../types/index";
  * @property {string} type - The type of the button, which can be 'button', 'submit', or 'reset'. Default is 'button'.
  * @property {string} color - The color theme of the button, which can be 'default', 'primary', 'success', or 'error'. Default is 'default'.
  * @property {string} variant - The visual style of the button, which can be 'default', 'outline', or 'plain'. Default is 'default'.
- * @property {string} size - The size of the button, which can be 'small', 'medium', or 'large'. Default is 'medium'.
+ * @property {string} size - The size of the button, which can be 'sm', 'md', or 'lg'. Default is 'md'.
  * @property {boolean} loading - Indicates whether the button is in a loading state, which can be used to show a loading spinner and disable the button. Default is false.
  * @property {boolean} disclosure - Indicates if the button should show a chevron down at the end of the content.
  *
  * @default 'button' - Default type value
  * @default 'default' - Default color value
  * @default 'default' - Default variant value
- * @default 'medium' - Default size value
+ * @default 'md' - Default size value
  * @default 'default' - Default status value
  * @default false - Default disabled value
  * @default '' - Default label value
@@ -41,6 +41,7 @@ import { ComponentState } from "../../../types/index";
  * @default false - Default disclosure value
  */
 export declare class BdsButton implements IButton {
+    private readonly _keyboard;
     /** State to manage states */
     currentState: ComponentState;
     /** The accessible name for the button, used for screen readers. It should be provided by the user for accessibility purposes. */
@@ -55,7 +56,7 @@ export declare class BdsButton implements IButton {
     readonly color: IButton['color'];
     /** variant is a string attribute. The visual style of the button, which can be 'default', 'outline', or 'plain'. Default is 'default'.*/
     readonly variant: IButton['variant'];
-    /** size is a string attribute. The size of the button, which can be 'small', 'medium', or 'large'. Default is 'medium'. */
+    /** size is a string attribute. The size of the button, which can be 'sm', 'md', or 'lg'. Default is 'md'. */
     readonly size: IButton['size'];
     /** loading is a boolean attribute. Indicates whether the button is in a loading state, which can be used to show a loading spinner and disable the button. Default is false. */
     readonly loading: IButton['loading'];
@@ -74,6 +75,8 @@ export declare class BdsButton implements IButton {
     componentWillLoad(): void;
     /** After component rendered */
     componentDidLoad(): void;
+    /** Bind keyboard events through KeyboardController. */
+    private setupKeyboard;
     /** Event for listen keydown from button, make navigation easier */
     private handleKeyDown;
     /** reset status on keyup */
@@ -84,6 +87,7 @@ export declare class BdsButton implements IButton {
     private handleClick;
     /** Decide which form action to perform based on button type */
     private processFormClick;
+    disconnectedCallback(): void;
     private get getClassMap();
     render(): any;
 }

package/dist/types/components/actions/bds-button/types/enum.d.ts

@@ -4,9 +4,9 @@ export declare const BUTTON_VARIANTS: {
     readonly PLAIN: "plain";
 };
 export declare const BUTTON_SIZES: {
-    readonly SMALL: "small";
-    readonly MEDIUM: "medium";
-    readonly LARGE: "large";
+    readonly SMALL: "sm";
+    readonly MEDIUM: "md";
+    readonly LARGE: "lg";
 };
 export declare const BUTTON_TYPES: {
     readonly BUTTON: "button";

package/dist/types/components/actions/bds-button-group/bds-button-group.d.ts

@@ -0,0 +1,40 @@
+import { IButtonGroup } from './types/IButtonGroup';
+/**
+ * Button group component for grouping related buttons together in a unified visual unit.
+ * @slot - The content of the button group, typically multiple `<bds-button>` elements.
+ *
+ */
+export declare class BdsButtonGroup implements IButtonGroup {
+    private inheritedAttributes;
+    private readonly logger;
+    private readonly _keyboard;
+    /** Controls the size applied to all child `<bds-button>` elements. Accepted values: `'sm'`, `'md'`, `'lg'`. Default is `'md'`. */
+    readonly size: IButtonGroup['size'];
+    /** Controls the layout direction of the grouped buttons. Accepted values: `'horizontal'`, `'vertical'`. Default is `'horizontal'`. */
+    readonly orientation: IButtonGroup['orientation'];
+    /** Provides an accessible label for the button group. */
+    readonly label: IButtonGroup['label'];
+    /** Controls the color applied to all child `<bds-button>` elements. Accepted values: see `CoreColors`. Default is `default`. */
+    readonly color: IButtonGroup['color'];
+    /** Controls the variant applied to all child `<bds-button>` elements. Accepted values: `'default'`, `'outline'`, `'plain'`. Default is `'default'`. */
+    readonly variant: IButtonGroup['variant'];
+    /** Reference to the host element. */
+    el: HTMLBdsButtonGroupElement;
+    /** Validates `size`, `orientation`, `color`, and `variant` prop values on change, falling back to defaults if invalid. */
+    validateProps(): void;
+    /** Propagates `size`, `color` and `variant` to all child `<bds-button>` elements via `setAttribute`. */
+    propagatePropsToButtons(): void;
+    /** Validates props before the first render. */
+    componentWillLoad(): void;
+    /** Warns when non-`<bds-button>` elements are placed in the default slot. */
+    private validateSlotContent;
+    /** Propagates initial props to child buttons after the component is mounted. */
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    private get _role();
+    private _setupKeyboard;
+    /** Builds the CSS class map applied to the host element based `orientation`. */
+    private get classMapButtonGroup();
+    render(): any;
+}
+//# sourceMappingURL=bds-button-group.d.ts.map

package/dist/types/components/actions/bds-button-group/types/IButtonGroup.d.ts

@@ -0,0 +1,11 @@
+import { Orientation } from "../../../../types/orientation";
+import { CoreColors } from "../../../../types/coreColors";
+import { ButtonVariant, ButtonSizes } from '../../bds-button/types/types';
+export interface IButtonGroup {
+    size: ButtonSizes;
+    orientation: Orientation;
+    label?: string;
+    color: CoreColors;
+    variant: ButtonVariant;
+}
+//# sourceMappingURL=IButtonGroup.d.ts.map

package/dist/types/components/actions/bds-list-menu/bds-list-menu/bds-list-menu.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from '../../../../stencil-public-runtime';
+import { IListMenu, ListMenuChangeDetail } from './types/IListMenu';
 /**
  * Container component that manages a list of menu items.
  * It handles selection logic (single/multiple) and maintains the data state.
@@ -6,33 +7,35 @@ import { EventEmitter } from '../../../../stencil-public-runtime';
  * @summary A list menu component that can contain multiple menu items and manage their selection state.
  * @slot - Default slot for bds-list-menu-item elements.
  *
- * @attr {boolean} multiple - If true, allows multiple items to be selected. Default is false (single selection).
- * @attr {string} menuRole - Defines the ARIA role of the menu. Can be 'menu' or 'listbox'. Default is 'menu'.
- *
- * @property {boolean} multiple - If true, allows multiple items to be selected. Default is false (single selection).
- * @property {string} menuRole - Defines the ARIA role of the menu. Can be 'menu' or 'listbox'. Default is 'menu'.
- *
- * @event bdsChange - Emitted when the selection changes, providing the current selected value(s).
+ * @fires bdsChange - Emitted when the selection changes, providing the current selected value(s).
+ * @fires bdsSelect - Emmited when item is selected in menu-role="menu" is clicked
  * @method getSelectedValues - Returns the currently selected value(s). If multiple is true, returns an array of strings; otherwise, returns a single string or undefined.
  * @method setSelectedValues - Sets the selected value(s). Accepts a string for single selection or an array of strings for multiple selection.
- *
- * @default false - By default, the menu does not allow multiple selections (single selection mode).
- * @default 'menu' - The default ARIA role for the menu is 'menu'.
- *
  */
 export declare class BdsListMenu {
+    private inheritedAttributes;
     /** The host element */
     el: HTMLBdsListMenuElement;
-    /** If true, allows multiple items to be selected. Default is false (single selection). */
-    readonly multiple: boolean;
+    /** The selection mode of the menu. Can be 'SINGLE' or 'MULTIPLE'. Default is 'SINGLE'. */
+    readonly selectionMode: IListMenu['selectionMode'];
     /** Defines the ARIA role of the menu. Can be 'menu' or 'listbox'. Default is 'menu'. */
-    readonly menuRole: 'menu' | 'listbox';
+    readonly menuRole: IListMenu['menuRole'];
+    /** Determines if the menu items have selectall/deselectall controls */
+    readonly selectControls: IListMenu['selectControls'];
+    /** is empty state item */
+    readonly empty: IListMenu['empty'];
+    /** Prop to show in all items a checkbox */
+    readonly checkable: IListMenu['checkable'];
+    /** Prop to show empty text */
+    readonly emptyText: IListMenu['emptyText'];
     /** State to manage selected values */
     selectedValues: string[];
     /** Emitted when the selection changes, providing the current selected value(s). */
     readonly bdsChange: EventEmitter<string | string[]>;
     /** Emitted when the selection changes, providing the current selected value(s). */
-    readonly bdsClicked: EventEmitter<HTMLElement>;
+    readonly bdsSelect: EventEmitter<ListMenuChangeDetail>;
+    /** Verify props to be valid */
+    checkProps(): void;
     /**
      * Retrieves the currently selected value(s) programmatically.
      * @method getSelectedValues
@@ -46,6 +49,8 @@ export declare class BdsListMenu {
      * @param {string | string[]} values - The value or values to be marked as selected.
      */
     setSelectedValues(values: string | string[]): Promise<void>;
+    /** Retrieves all child menu items. */
+    getAllItems(): Promise<HTMLBdsListMenuItemElement[]>;
     /** Handles the click event on a menu item, updating the selection state accordingly. */
     handleItemClick(event: CustomEvent): void;
     /** Initializes the selected values based on the child menu items that have the 'selected' attribute set. */
@@ -54,6 +59,10 @@ export declare class BdsListMenu {
     get childItems(): HTMLBdsListMenuItemElement[];
     /** First clickable element  */
     get firstEnabledItem(): HTMLBdsListMenuItemElement;
+    /** Checks if the menu is in multiple selection mode */
+    get isMultiple(): boolean;
+    /** Send default props to items */
+    private setDefaultProps;
     /** Updates the active state of the menu items based on the current selection. */
     private updateActiveState;
     /** Handles selection logic for multiple selection mode. */
@@ -62,8 +71,16 @@ export declare class BdsListMenu {
     private handleSingleSelection;
     /** Updates the state of child menu items based on the current selection. */
     private updateChildrenState;
+    /** activate item based on interaction */
+    private setActiveItem;
     /** Initializes the selected values based on the child menu items that have the 'selected' attribute set. */
     private initialSelectedValues;
+    /** Handles the toggle of select/deselect all controls, updating the selection state accordingly. */
+    private handleToggleSelect;
+    /** Renders the select/deselect all controls if applicable based on the props. */
+    private renderSelectControls;
+    /** Renders the empty state message if the 'empty' prop is true. */
+    private renderEmptyState;
     /** Renders the component with a slot for menu items. */
     render(): any;
 }

package/dist/types/components/actions/bds-list-menu/bds-list-menu/types/IListMenu.d.ts

@@ -0,0 +1,17 @@
+import { MenuRole } from "../../../../../types/index";
+import { ListMenuSelectionMode } from './types';
+export interface IListMenu {
+    menuRole: MenuRole;
+    selectionMode: ListMenuSelectionMode;
+    selectControls: boolean;
+    empty: boolean;
+    checkable: boolean;
+    emptyText: string;
+}
+export interface ListMenuChangeDetail {
+    value: string | string[] | undefined;
+    element: HTMLElement;
+    index: string | number;
+    checked: boolean | undefined;
+}
+//# sourceMappingURL=IListMenu.d.ts.map

package/dist/types/components/actions/bds-list-menu/bds-list-menu/types/enum.d.ts

@@ -0,0 +1,5 @@
+export declare const LIST_MENU_SELECTION_MODE: {
+    readonly SINGLE: "single";
+    readonly MULTIPLE: "multiple";
+};
+//# sourceMappingURL=enum.d.ts.map

package/dist/types/components/actions/bds-list-menu/bds-list-menu/types/types.d.ts

@@ -0,0 +1,3 @@
+import { LIST_MENU_SELECTION_MODE } from './enum';
+export type ListMenuSelectionMode = (typeof LIST_MENU_SELECTION_MODE)[keyof typeof LIST_MENU_SELECTION_MODE];
+//# sourceMappingURL=types.d.ts.map

package/dist/types/components/actions/bds-list-menu/bds-list-menu-item/bds-list-menu-item.d.ts

@@ -6,6 +6,7 @@ declare const BdsListMenuItem_base: abstract new (...args: any[]) => {
     disabled: boolean;
     selected: boolean;
     activeItem: boolean;
+    readonly parent: HTMLElement | null;
     readonly parentRole: import("@/types").MenuRole | null;
     readonly menuItemRole: import("@/types").MenuItemRole;
     readonly ariaSelected: string | null;
@@ -80,6 +81,8 @@ export declare class BdsListMenuItem extends BdsListMenuItem_base implements ILi
     readonly selected: IListMenuItem['selected'];
     /** Value associated with the menu item */
     readonly value: IListMenuItem['value'];
+    /** Checkable state item, if is activated should be visible a checkbox */
+    readonly checkable: IListMenuItem['checkable'];
     /** Active state item */
     readonly activeItem: IListMenuItem['activeItem'];
     /** Link behavior props */
@@ -90,11 +93,16 @@ export declare class BdsListMenuItem extends BdsListMenuItem_base implements ILi
     readonly download: IListMenuItem['download'];
     /** State to manage click and keyboard interaction states */
     currentState: ComponentState;
+    /** State to manage checked box */
+    boxChecked: boolean;
     /** Event handler for activation */
-    readonly bdsSelect: EventEmitter<IListMenuItemEvent>;
+    readonly bdsSelectItem: EventEmitter<IListMenuItemEvent>;
     checkPropsVariant(): void;
+    handleSelectedChange(newValue: boolean): void;
     /** Lifecycle method called before the component is loaded */
     componentWillLoad(): void;
+    /** Improve aria resolve for checkable items */
+    get menuItemRoleExtended(): import("@/types").MenuItemRole | "checkbox" | "menuitemcheckbox";
     /** Event to notify when the menu item is clicked */
     private handleClick;
     /** Event to handle keydown navigation and trigger click */
@@ -107,6 +115,7 @@ export declare class BdsListMenuItem extends BdsListMenuItem_base implements ILi
     private get classMap();
     /** Return the render for the label variant of the list menu item */
     private renderTypeLabel;
+    private renderCheckbox;
     /** Return the render for the button variant of the list menu item */
     private renderTypeButton;
     /** Main render */

package/dist/types/components/actions/bds-list-menu/bds-list-menu-item/types/IListMenuItem.d.ts

@@ -4,9 +4,11 @@ export interface IListMenuItem extends IMenuBehavior, IWithLinks {
     variant: ListMenuItemVariants;
     name: string;
     value: string;
+    checkable: boolean;
 }
 export interface IListMenuItemEvent {
     value: string;
     selected: boolean;
+    element: HTMLBdsListMenuItemElement;
 }
 //# sourceMappingURL=IListMenuItem.d.ts.map

package/dist/types/components/actions/bds-toggle/types/IToggle.d.ts

@@ -1,6 +1,6 @@
 import { ComponentInterface } from '../../../../stencil-public-runtime';
 import { TogglePlacementType } from './types';
-import { IFormProps } from "../../../../types/IFormProps";
+import { IFormProps } from "../../../../types/index";
 export interface IToggle extends ComponentInterface, IFormProps {
     name: string;
     disabled: boolean;

package/dist/types/components/forms/bds-checkbox/{bds-checkbox.d.ts → bds-checkbox/bds-checkbox.d.ts}

@@ -1,6 +1,6 @@
-import { EventEmitter } from '../../../stencil-public-runtime';
-import type { ICheckbox, CheckboxChangeDetail } from './types/ICheckbox';
-import { type IFormControl } from "../../../mixins/form-associated.mixin";
+import { EventEmitter } from '../../../../stencil-public-runtime';
+import { type IFormControl } from "../../../../mixins/form-associated.mixin";
+import { CheckboxChangeDetail, ICheckbox } from '../types/ICheckbox';
 declare const BdsCheckbox_base: abstract new (...args: any[]) => {
     formDisabledCallback(disabled: boolean): void;
 };
@@ -22,15 +22,21 @@ declare const BdsCheckbox_base: abstract new (...args: any[]) => {
  */
 export declare class BdsCheckbox extends BdsCheckbox_base implements ICheckbox, IFormControl<boolean> {
     private inheritedAttributes;
+    private readonly _keyboard;
+    private readonly _id;
     /** Internal mirror of the `disabled` prop, kept in sync via `@Watch` and `formDisabledCallback`. */
-    private isDisabled;
+    isDisabled: boolean;
+    /** Set to true when native form validation fires the `invalid` event; cleared on reset or when value becomes valid. */
+    isInvalid: boolean;
     el: HTMLBdsCheckboxElement;
     internals: ElementInternals;
     /** Name of the form control, submitted as a key in the form data. */
     readonly name: string;
-    /** Disables the control. */
+    /** Tooltip text for the checkbox. */
+    readonly info: string;
+    /** Disables the checkbox. */
     readonly disabled: boolean;
-    /** Marks the control as required for form submission. */
+    /** Marks the checkbox as required for form submission. */
     readonly required: boolean;
     /** Whether the checkbox is selected. */
     checked: boolean;
@@ -42,23 +48,32 @@ export declare class BdsCheckbox extends BdsCheckbox_base implements ICheckbox,
     readonly value: string;
     /** Label displayed next to the checkbox. If not provided, the default slot is used. */
     readonly label: string;
+    private formCheckbox;
     /** Emitted when the checked state changes (for 2-way binding / v-model). */
     valueChange: EventEmitter<boolean>;
     /** Emitted when the user toggles the checkbox. */
     bdsChange: EventEmitter<CheckboxChangeDetail>;
     componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
     onCheckedChange(): void;
     onDisabledChange(next: boolean): void;
     formAssociatedCallback(): void;
     formResetCallback(): void;
-    formStateRestoreCallback(state: unknown, _mode: string): void;
+    formStateRestoreCallback(state: string): void;
     formDisabledCallback(disabled: boolean): void;
-    private syncFormValue;
+    /** Reports the group's validity state to the user, showing native validation UI if invalid. */
+    checkValidity(): Promise<boolean>;
+    /** Reports the group's validity state to the user, showing native validation UI if invalid. */
+    reportValidity(): Promise<boolean>;
+    handleInvalid(event: Event): void;
     private toggle;
     private handleClick;
-    private handleKeyDown;
+    private get isError();
     private getAriaChecked;
+    private get hideFromScreenReaders();
     private renderCheckIcon;
+    private getClasses;
     render(): any;
 }
 export {};

package/dist/types/components/forms/bds-checkbox/bds-checkbox-button/bds-checkbox-button.d.ts

@@ -0,0 +1,68 @@
+import { EventEmitter } from '../../../../stencil-public-runtime';
+import type { CheckboxButtonChangeDetail, ICheckboxButton } from './types/ICheckboxButton';
+import { type IFormControl } from "../../../../mixins/index";
+declare const BdsCheckboxButton_base: abstract new (...args: any[]) => {
+    formDisabledCallback(disabled: boolean): void;
+};
+/**
+ * Button-shaped checkbox option that toggles independently on each interaction.
+ * Renders as a pill-button with the same visual language as `bds-radio-button`, but uses
+ * `role="checkbox"` and multi-select semantics — toggling one button has no effect on others.
+ *
+ * Can be used standalone (with `name` and optional `required`) or inside a `bds-checkbox-group`,
+ * which is the recommended approach for coordinated form state and group-level validation.
+ *
+ * @slot - Label content rendered when no `label` prop is provided.
+ * @slot icon - Optional icon displayed to the left of the label.
+ */
+export declare class BdsCheckboxButton extends BdsCheckboxButton_base implements ICheckboxButton, IFormControl<boolean> {
+    isDisabled: boolean;
+    isInvalid: boolean;
+    el: HTMLBdsCheckboxButtonElement;
+    internals: ElementInternals;
+    /** Name of the form control, submitted as a key in the form data. */
+    readonly name: string;
+    /** Disables the button, preventing interaction. Propagated by `bds-checkbox-group` when the group is disabled. */
+    readonly disabled: boolean;
+    /** Marks this button as required for form submission. Has no effect when used inside `bds-checkbox-group`. */
+    readonly required: boolean;
+    /** Toggle state of this button. Flips on every interaction when not disabled. */
+    checked: boolean;
+    /** Shows error styling on the button. */
+    readonly error: boolean;
+    /** Value associated with this button; submitted with form data when checked. */
+    readonly value: string;
+    /** Label text displayed inside the button. Falls back to the default slot when empty. */
+    readonly label: string;
+    /** Tooltip text shown on an info icon next to the label. */
+    readonly info: string;
+    private formCheckbox;
+    /** Emitted when the checked state changes. Used for `v-model` two-way binding in Vue. Payload: `boolean`. */
+    valueChange: EventEmitter<boolean>;
+    /**
+     * Emitted on every toggle — both when the button becomes checked and when it becomes unchecked.
+     * Payload: `{ checked: boolean, value: string }`.
+     */
+    bdsChange: EventEmitter<CheckboxButtonChangeDetail>;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    onCheckedChange(): void;
+    onDisabledChange(next: boolean): void;
+    formAssociatedCallback(): void;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: string): void;
+    formDisabledCallback(disabled: boolean): void;
+    handleInvalid(event: Event): void;
+    /** Returns whether this button satisfies its validation constraints. */
+    checkValidity(): Promise<boolean>;
+    /** Reports validity to the user, showing native validation UI if invalid. */
+    reportValidity(): Promise<boolean>;
+    private toggle;
+    private handleClick;
+    private handleKeyDown;
+    private get isError();
+    private get classMap();
+    render(): any;
+}
+export {};
+//# sourceMappingURL=bds-checkbox-button.d.ts.map

package/dist/types/components/forms/bds-checkbox/bds-checkbox-button/types/ICheckboxButton.d.ts

@@ -0,0 +1,15 @@
+export interface CheckboxButtonChangeDetail {
+    checked: boolean;
+    value: string;
+}
+export interface ICheckboxButton {
+    name: string;
+    value: string;
+    label: string;
+    info: string;
+    checked: boolean;
+    disabled: boolean;
+    error: boolean;
+    required: boolean;
+}
+//# sourceMappingURL=ICheckboxButton.d.ts.map

package/dist/types/components/forms/bds-checkbox/bds-checkbox-card/bds-checkbox-card.d.ts

@@ -0,0 +1,63 @@
+import { IFormControl } from "../../../../mixins/index";
+import { ICheckboxCard } from './types/ICheckboxCard';
+declare const BdsCheckboxCard_base: abstract new (...args: any[]) => {
+    formDisabledCallback(disabled: boolean): void;
+};
+/**
+ * @summary Checkbox card component is a selectable card-based checkbox option.
+ *
+ * @slot - Label content when no `label` prop is provided.
+ * @slot icon - Optional icon rendered to the left of the label.
+ * @slot description - Optional descriptive text rendered below the label.
+ */
+export declare class BdsCheckboxCard extends BdsCheckboxCard_base implements ICheckboxCard, IFormControl<boolean> {
+    private checkboxElement;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    private isIndeterminate;
+    el: HTMLBdsCheckboxCardElement;
+    internals: ElementInternals;
+    /** Name of the form control, submitted as a key in the form data. */
+    readonly name: ICheckboxCard['name'];
+    /** Disables the control. */
+    readonly disabled: ICheckboxCard['disabled'];
+    /** Marks the control as required for form submission. */
+    readonly required: ICheckboxCard['required'];
+    /** Value submitted with the form when this checkbox is selected. */
+    readonly value: ICheckboxCard['value'];
+    /** Label text displayed next to the checkbox indicator. Falls back to the default slot when empty. */
+    readonly label: ICheckboxCard['label'];
+    /** Whether this checkbox card is selected. */
+    checked: ICheckboxCard['checked'];
+    /** Whether the checkbox card shows an indeterminate visual state. */
+    readonly indeterminate: ICheckboxCard['indeterminate'];
+    /** Whether the checkbox card is in an error state. */
+    readonly error: ICheckboxCard['error'];
+    private formCheckbox;
+    /** Emitted when the checked state changes. Useful for 2-way binding / v-model. */
+    valueChange: ICheckboxCard['valueChange'];
+    /** Emitted when the user toggles this checkbox card. */
+    bdsChange: ICheckboxCard['bdsChange'];
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    onDisabledChange(next: boolean): void;
+    onIndeterminateChange(next: boolean): void;
+    onCheckedChange(next: boolean): void;
+    /** Reports the group's validity state to the user, showing native validation UI if invalid. */
+    checkValidity(): Promise<boolean>;
+    /** Reports the group's validity state to the user, showing native validation UI if invalid. */
+    reportValidity(): Promise<boolean>;
+    handleInvalid(_event: Event): void;
+    private toggle;
+    private handleClick;
+    private handleKeyDown;
+    private get hostClasses();
+    formAssociatedCallback(): void;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: string): void;
+    formDisabledCallback(disabled: boolean): void;
+    private get isError();
+    render(): any;
+}
+export {};
+//# sourceMappingURL=bds-checkbox-card.d.ts.map

package/dist/types/components/forms/bds-checkbox/bds-checkbox-card/types/ICheckboxCard.d.ts

@@ -0,0 +1,9 @@
+import { ComponentInterface } from '../../../../../stencil-public-runtime';
+import { ICheckbox } from '../../types/ICheckbox';
+export interface ICheckboxCard extends ComponentInterface, ICheckbox {
+    name: string;
+    disabled: boolean;
+    required: boolean;
+    indeterminate: boolean;
+}
+//# sourceMappingURL=ICheckboxCard.d.ts.map

package/dist/types/components/forms/bds-checkbox/bds-checkbox-group/bds-checkbox-group.d.ts

@@ -0,0 +1,86 @@
+import { EventEmitter } from '../../../../stencil-public-runtime';
+import type { ICheckboxGroup, CheckboxGroupChangeDetail, CheckboxGroupType } from './types';
+import { type IFormControl } from "../../../../mixins/index";
+import { type Orientation } from "../../../../types/index";
+declare const BdsCheckboxGroup_base: abstract new (...args: any[]) => {
+    formDisabledCallback(disabled: boolean): void;
+};
+/**
+ * Checkbox group component that orchestrates multi-selection across a set of `bds-checkbox`, `bds-checkbox-button`, `bds-checkbox-card` children.
+ *
+ * @slot - Default slot for `bds-checkbox`, `bds-checkbox-button`, `bds-checkbox-card` child elements.
+ */
+export declare class BdsCheckboxGroup extends BdsCheckboxGroup_base implements ICheckboxGroup, IFormControl<string[]> {
+    private readonly _id;
+    internals: ElementInternals;
+    el: HTMLBdsCheckboxGroupElement;
+    /** Internal mirror of the `disabled` prop, kept in sync via `@Watch` and `formDisabledCallback`. */
+    private isDisabled;
+    /** Set to true when native form validation fires the `invalid` event; cleared on reset or when value becomes valid. */
+    private isInvalid;
+    /** Disables all child checkboxes and prevents selection. Also mirrored to isDisabled @State for form-level disable support. */
+    readonly disabled: boolean;
+    /** Shows error styling on the group helper text. Propagated to all child checkboxes. */
+    readonly error: boolean;
+    /** Error message rendered below the checkbox options when error is true. Replaces helperText. */
+    readonly errorMessage: string;
+    /** Helper text rendered below the checkbox options. Shown in default state; replaced by errorMessage in error state. */
+    readonly helperText: string;
+    /** Tooltip text shown on the group label info icon. */
+    readonly info: string;
+    /** Group label rendered above the checkbox options. */
+    readonly label: string;
+    /** Name of the form control; submitted as the field key in FormData. */
+    readonly name: string;
+    /** Layout direction of the checkbox options. */
+    readonly orientation: Orientation;
+    /** Marks the group as required for form submission. Triggers validity error when no checkboxes are selected. */
+    readonly required: boolean;
+    /** Identifies this group variant. 'checkbox' renders bds-checkbox children; 'checkboxbutton' renders bds-checkbox-button segmented control; 'checkboxcard' renders bds-checkbox-card element. */
+    readonly type: CheckboxGroupType;
+    /** Currently selected checkbox values. Synced to children on change. */
+    value: string[];
+    /** Hides the divider between checkbox buttons when type is 'checkboxbutton'. */
+    readonly joined = false;
+    onJoinedChange(): void;
+    checkPropValues(): void;
+    onDisabledChange(next: boolean): void;
+    onErrorChange(val: boolean): void;
+    onValuesChange(vals: string[]): void;
+    /** Emitted when any checkbox is toggled. Payload includes the complete updated values array. */
+    bdsChange: EventEmitter<CheckboxGroupChangeDetail>;
+    /** Emitted when any checkbox is toggled. Used for v-model two-way binding in Vue. */
+    valueChange: EventEmitter<string[]>;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    formAssociatedCallback(): void;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: unknown, _mode: string): void;
+    formDisabledCallback(disabled: boolean): void;
+    handleCheckboxChange(event: CustomEvent<{
+        checked: boolean;
+        value: string;
+    }>): void;
+    handleInvalid(event: Event): void;
+    handleValueChange(event: Event): void;
+    /** Returns whether the group's current value satisfies the browser's built-in constraint validation. */
+    checkValidity(): Promise<boolean>;
+    /** Reports the group's validity state to the user, showing native validation UI if invalid. */
+    reportValidity(): Promise<boolean>;
+    private handleKeyDown;
+    private insertDividers;
+    private navigateTo;
+    private updateCheckboxSelection;
+    private syncCheckboxStates;
+    private get checkboxElements();
+    private propagatePropertyToCheckboxes;
+    private updateFormValue;
+    private syncFormValue;
+    private updateFormValidity;
+    private updateLayoutCount;
+    private get isError();
+    private get classMap();
+    render(): any;
+}
+export {};
+//# sourceMappingURL=bds-checkbox-group.d.ts.map