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

package/dist/types/components/forms/bds-select/bds-select.d.ts

@@ -0,0 +1,98 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { ISelect } from './types/ISelect';
+/**
+ * Component representing a select dropdown, allowing users to choose an option from a list.
+ * It consists of a text field that triggers the dropdown and a list menu that contains the options.
+ * The component supports both single selection and searchable functionality.
+ *
+ * @slot field - The text field element that triggers the select dropdown. It should be a `bds-text-field` component.
+ * @slot list - The list menu element that contains the options for the select dropdown. It should be a `bds-list-menu` component.
+ */
+export declare class BdsSelect implements ISelect {
+    el: HTMLBdsSelectElement;
+    private inheritedAttributes;
+    private hostForm;
+    /** The value of the select component. */
+    value: string;
+    /** Prop to define if its searchable. It allows to write and filter the options */
+    readonly searchable: boolean;
+    /** Name to assign in form */
+    readonly name: string;
+    /** The string representation of the value. */
+    valueString: string;
+    /** state to manage popover visibility */
+    popoverVisible: boolean;
+    /** Emitted when the selection change the value */
+    bdsChange: EventEmitter<string>;
+    /** Emit value Change for vue implementation */
+    valueChange: EventEmitter<string>;
+    /** State for id components for aria controls */
+    private listId;
+    /** Flag to suppress focus-triggered open when focus originated from a mousedown inside the component */
+    private _preventFocusOpen;
+    /** Watch popover visible */
+    watchPopoverVisible(newValue: boolean): void;
+    /** Watch value */
+    watchValue(): void;
+    /** Watch valueString */
+    watchValueString(newValue: string): void;
+    /** Lifecycle method called before the component is loaded */
+    componentWillLoad(): void;
+    /** Lifecycle method called after the component has loaded. */
+    componentDidLoad(): void;
+    /** Lifecycle method called when the component is disconnected from the DOM */
+    disconnectedCallback(): void;
+    /** Get for the list menu element in runtime */
+    private get bdsList();
+    /** Get for the text field element in runtime */
+    private get bdsField();
+    /** Get for the input element inside the text field in runtime */
+    private get bdsInput();
+    /** Get for the popover element in runtime */
+    private get bdsPopover();
+    /** Assigns event listeners to the relevant elements. */
+    private assignListeners;
+    /** Removes event listeners from the relevant elements. */
+    private removeListeners;
+    /** Loads the default properties for the select component. */
+    private loadDefaultProps;
+    /** load default props for textfield */
+    private loadDefaultTextFieldProps;
+    /** load default props to list menu */
+    private loadDefaultListMenuProps;
+    /** set value emitting event */
+    private setValue;
+    /** Listens for changes in the list menu. */
+    private listenListMenu;
+    /** Listen clear input */
+    private listenClearInput;
+    /** Listens for changes in the text field. When is clear and input is empty, resets the child elements. */
+    private listenField;
+    /** Listen blur input to reset on leave */
+    private listenBlurInput;
+    /** Intercepts Tab while the popover is open and moves focus to the selected item, or first available item */
+    private listenKeydown;
+    /** Sets the flag that suppresses focus-open when focus was caused by a mousedown inside the component */
+    private listenMouseDown;
+    /** Opens the popover when the searchable input receives focus from keyboard (Tab), not from click */
+    private listenFocusInput;
+    /** Prevents bds-text-field's own valueChange from bubbling up — bds-select emits its own */
+    private stopFieldValueChange;
+    /** Resets component state when the parent form is reset */
+    private listenFormReset;
+    /** Listens for changes in the popover visibility and updates the state accordingly. */
+    private listenPopOver;
+    /** Resets the value field */
+    private resetValueField;
+    /** Searches for elements in the list menu based on the input text. */
+    private searcherElement;
+    /** Shows the parent label of a given item. */
+    private showParentLabel;
+    /** Resets the children elements of the list menu, making them all visible. */
+    private resetChildren;
+    /** Load value */
+    private loadValue;
+    /** Main Render */
+    render(): any;
+}
+//# sourceMappingURL=bds-select.d.ts.map

package/dist/types/components/forms/bds-select/types/ISelect.d.ts

@@ -0,0 +1,6 @@
+export interface ISelect {
+    value: string;
+    searchable: boolean;
+    name: string;
+}
+//# sourceMappingURL=ISelect.d.ts.map

package/dist/types/components/forms/bds-slider/bds-slider.d.ts

@@ -0,0 +1,176 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { SliderChangeDetail, SliderRawValue, SliderType, SliderTooltipType, ISlider } from './types';
+import { IFormControl } from "../../../mixins/index";
+declare const BdsSlider_base: abstract new (...args: any[]) => {
+    formDisabledCallback(disabled: boolean): void;
+};
+/**
+ * Slider component for selecting a numeric value or a range of values.
+ *
+ * @summary An accessible, single or multi-handle range slider built on HTML `<input type="range">`.
+ * Supports discrete tick marks, tooltips, disabled state, and N-handle multi-value mode
+ * with automatic collision prevention between handles.
+ *
+ * @property {number}          min      - Minimum selectable value. Defaults to `0`.
+ * @property {number}          max      - Maximum selectable value. Defaults to `100`.
+ * @property {number}          step     - Step size for each increment/decrement. Defaults to `1`.
+ * @property {number[]} value   - Current value(s). A single number for one handle;
+ *                                        an array for multi-handle mode. Defaults to `0`.
+ * @property {boolean}         disabled - Disables interaction with the slider. Defaults to `false`.
+ * @property {boolean}         discrete - Shows tick marks at each step position along the track. Defaults to `false`.
+ * @property {string}          tooltip  - Controls tooltip visibility: `"never"`, or `"focus"`. Defaults to `"focus"`.
+ *
+ * @method getValues - Returns the current value(s) as `number | number[]`.
+ * @method setValues - Programmatically sets the slider value(s).
+ */
+export declare class BdsSlider extends BdsSlider_base implements ISlider, IFormControl<number[]> {
+    private service;
+    private readonly blockClass;
+    el: HTMLBdsSliderElement;
+    internals: ElementInternals;
+    /** Reference to the slider connect element */
+    private connectEl?;
+    /** Reference to the slider track element */
+    private trackEl;
+    /** Active input elements, one per handle */
+    private inputEls;
+    /** Active tooltip elements, one per handle */
+    private tooltipEls;
+    /** Minimum selectable value. Defaults to `0`. */
+    readonly min: number;
+    /** Maximum selectable value. Defaults to `100`. */
+    readonly max: number;
+    /** Slider type that defines the slider behavior. Defaults to `single`. */
+    readonly type: SliderType;
+    /** Label for the slider. Defaults to `""`. */
+    readonly label: string;
+    /**
+     * Step size for each increment/decrement.
+     * Must be a positive number. Defaults to `1`.
+     */
+    readonly step: number;
+    /**
+     * Shows the min and max values of the slider.
+     * Defaults to `false`.
+     */
+    readonly showLimits: boolean;
+    /**
+     * Current value(s) of the slider.
+     * Accepts `number`, `number[]`, or a JSON string for HTML vanilla usage.
+     * - Single handle: `50` or `"50"`
+     * - Multi-handle:  `[10, 50, 80]` or `"[10, 50, 80]"`
+     * - Defaults to `0`.
+     */
+    readonly value: SliderRawValue;
+    /** Disables the slider, preventing all user interaction. Defaults to `false`. */
+    readonly disabled: boolean;
+    /** Name of the form control, submitted as a key in the form data. */
+    readonly name: string;
+    /**
+     * JSON string array of handle values that should be individually disabled.
+     * Each number must match a value present in the `value` prop.
+     * Accepts `number`, `number[]`, or JSON string: `"[5, 30]"`.
+     * Defaults to `"[]"`.
+     */
+    readonly disabledHandlers: SliderRawValue;
+    /**
+     * When `true`, renders discrete tick marks along the track
+     * at every step position between `min` and `max`.
+     * Defaults to `false`.
+     */
+    readonly discrete: boolean;
+    /**
+     * Controls tooltip visibility on each handle.
+     * - `"never"`  — tooltip is hidden.
+     * - `"focus"`  — tooltip appears only when the handle is active/focused.
+     * Defa ults to `"focus"`.
+     */
+    readonly tooltip: SliderTooltipType;
+    /**
+     * Emitted whenever the slider value(s) change due to user interaction.
+     * Payload: `{ value: number }` for single handle, `{ value: number[] }` for multi-handle.
+     */
+    bdsChange: EventEmitter<SliderChangeDetail>;
+    /**
+     * Native-style alias of `bdsChange`. Emitted simultaneously.
+     * Payload: `{ value: number[] }` for multi-handle.
+     */
+    valueChange: EventEmitter<number[]>;
+    /**
+     * Emitted when the user clicks on the slider.
+     * Payload: `{ target: HTMLElement }` and `{ value: number[] }` for multi-handle.
+     */
+    bdsClick: EventEmitter<{
+        target: HTMLElement;
+        value: number[];
+    }>;
+    /** Internal mirror of `disabled`, kept in sync via `@Watch`. */
+    private isDisabled;
+    /** Internal mirror of `discrete`, kept in sync via `@Watch`. */
+    private isDiscrete;
+    /**
+     * Internal mirror of `values` normalized to `number[]`.
+     * All internal logic reads from here; never from `values` directly.
+     * Updated via `parseValues()` whenever `values` prop changes.
+     */
+    private internalValues;
+    onDisabledChange(next: boolean): void;
+    onDisabledHandlersChange(): void;
+    onValueChange(next: SliderRawValue): void;
+    onConfigChange(): void;
+    onRangeChange(): void;
+    formAssociatedCallback(): void;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: unknown, _mode: string): void;
+    private syncFormValue;
+    /**
+     * Returns the current value(s) of the slider.
+     * - Single-handle → `number`
+     * - Multi-handle  → `number[]`
+     */
+    getValues(): Promise<number[]>;
+    /**
+     * Programmatically sets the slider value(s).
+     * @param next - A single `number` or an array of `number[]` matching the number of handles.
+     */
+    setValues(next: SliderRawValue): Promise<void>;
+    private buildAdapter;
+    private syncDOMUpdates;
+    private handleInputEvent;
+    private handleChangeEvent;
+    private onHandleFocus;
+    private onHandleBlur;
+    private onHandleInactive;
+    private handleClick;
+    private syncInputsToValues;
+    private updateProgress;
+    private syncTooltip;
+    private syncTooltips;
+    private resolveValues;
+    private updateValues;
+    private emitChange;
+    private isHandleDisabled;
+    private getPipPositions;
+    /**
+     * Returns the CSS modifier class map for the slider component.
+     *
+     * Includes visual state modifiers such as disabled,
+     * discrete mode, and tooltip behavior.
+     */
+    private get classMap();
+    private getThumbPosition;
+    private getThumbCSSPosition;
+    private renderInput;
+    private renderMinMax;
+    private handleTrackClick;
+    private renderTooltip;
+    private renderPips;
+    private renderLabel;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    componentDidUpdate(): void;
+    disconnectedCallback(): void;
+    render(): any;
+}
+export {};
+//# sourceMappingURL=bds-slider.d.ts.map

package/dist/types/components/forms/bds-slider/helpers/SliderDOMController.d.ts

@@ -0,0 +1,38 @@
+export declare class SliderDOMController {
+    /**
+     * Adds the necessary classes to show the tooltip when a handle is focused or active.
+     * This is used in both focus and active states to ensure the tooltip remains visible.
+     * @param inputEl - The input element to add the states to.
+     * @param blockClass - The block class of the slider.
+     */
+    static addTooltipsStates(inputEl: HTMLDivElement, blockClass: string): void;
+    /**
+     * Removes the necessary classes to hide the tooltip when a handle is blurred or inactive.
+     * @param inputEl - The input element to remove the states from.
+     * @param blockClass - The block class of the slider.
+     */
+    static removeTooltipsStates(inputEl: HTMLDivElement, blockClass: string): void;
+    /**
+     * Syncs the tooltips with the given values and inputs.
+     * @param values - The values to sync the tooltips with.
+     * @param inputsEl - The inputs to sync the tooltips with.
+     */
+    static syncTooltips(values: number[], inputsEl: HTMLInputElement[]): void;
+    /**
+     * Moves the connect element to the given percentage position.
+     * @param connectEl - The connect element to move.
+     * @param segment - The percentage position to move the connect element to.
+     */
+    static moveConnect(connectEl: HTMLDivElement, segment: {
+        left: number;
+        width: number;
+    }): void;
+    /**
+     * Returns the CSS position of the thumb in pixels based on the track and percent.
+     * @param percent - The percentage of the track that the thumb should be positioned at.
+     * @returns The position of the thumb in pixels.
+     */
+    static getThumbCSSPosition(percent: number): string;
+    static updateInputValue(inputEl: HTMLInputElement, value: number): void;
+}
+//# sourceMappingURL=SliderDOMController.d.ts.map

package/dist/types/components/forms/bds-slider/helpers/SliderService.d.ts

@@ -0,0 +1,44 @@
+import type { ISliderOptions } from '../types/ISliderOptions';
+export declare class SliderService {
+    private readonly options;
+    constructor(options: ISliderOptions);
+    /**
+     * Clamps a value between min and max.
+     */
+    clamp(value: number): number;
+    /**
+     * Rounds a value to the nearest step.
+     */
+    snapToStep(value: number): number;
+    /**
+     * Applies collision prevention for range mode.
+     * Ensures handles never overlap — always at least 1 step apart.
+     */
+    applyCollision(values: number[], changedIndex: number): number[];
+    /**
+     * Calculates the percentage position of a value along the track.
+     */
+    toPercent(value: number): number;
+    /**
+     * Returns connect segments for the track.
+     * single: [left=0, width=percent of value]
+     * range:  [left=percent of min, width=percent of (max - min)]
+     */
+    getConnectSegment(values: number[]): {
+        left: number;
+        width: number;
+    };
+    /**
+     * Returns pip positions as percentages, excluding min and max.
+     */
+    getPipPositions(): number[];
+    /**
+     * Returns the CSS position of the thumb in pixels based on the track and percent.
+     * @param value - The value of the slider at the given clientX position.
+     * @param trackWidth - The width of the track element.
+     * @param thumbSize - The size of the thumb element.
+     * @returns The position of the thumb in pixels.
+     */
+    getThumbCSSPosition(value: number, trackWidth: number, thumbSize: number): number;
+}
+//# sourceMappingURL=SliderService.d.ts.map

package/dist/types/components/forms/bds-slider/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './parseValues';
+export * from './SliderService';
+export * from './SliderDOMController';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/forms/bds-slider/helpers/parseValues.d.ts

@@ -0,0 +1,18 @@
+import { SliderRawValue, SliderType } from '../types';
+/**
+ * Parses any valid `values` input into a clean `number[]`.
+ * This is the single source of truth for value normalization.
+ *
+ * Handles:
+ * - `number[]` → `[10, 50, 80]` (passthrough, filtered for NaN)
+ * - `"[10, 50, 80]"` → `[10, 50, 80]`
+ * - anything malformed → `[this.min]` as safe fallback
+ */
+export declare function parseValues(raw: string | number[], fallback?: number[]): number[];
+/**
+ * Serialize the value for the form: a single number → "10", multiple → "10,20,30"
+ * FormData does not support arrays natively, so we use CSV.
+ */
+export declare function serializeFormValue(values: number[]): string;
+export declare function resolveValues(raw: SliderRawValue, min: number, max: number, type: SliderType): number[];
+//# sourceMappingURL=parseValues.d.ts.map

package/dist/types/components/forms/bds-slider/types/ChangeDetail.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Detailed information about a slider change event.
+ * This includes the new value of the slider.
+ * @property {number[]} value - The new value of the slider.
+ */
+export interface SliderChangeDetail {
+    value: number[];
+}
+//# sourceMappingURL=ChangeDetail.d.ts.map

package/dist/types/components/forms/bds-slider/types/ISlider.d.ts

@@ -0,0 +1,17 @@
+import { IFormProps } from "../../../../types/index";
+import { SliderRawValue, SliderTooltipType, SliderType } from './types';
+export interface ISlider extends IFormProps {
+    min: number;
+    max: number;
+    step: number;
+    value: SliderRawValue;
+    disabledHandlers: SliderRawValue;
+    discrete: boolean;
+    label: string;
+    disabled: boolean;
+    showLimits: boolean;
+    name: string;
+    tooltip: SliderTooltipType;
+    type: SliderType;
+}
+//# sourceMappingURL=ISlider.d.ts.map

package/dist/types/components/forms/bds-slider/types/ISliderOptions.d.ts

@@ -0,0 +1,31 @@
+import { SliderTooltipType, SliderType } from './types';
+/**
+ * Options for the slider component.
+ * @property {number} min - Minimum selectable value.
+ * @property {number} max - Maximum selectable value.
+ * @property {number} step - Step size for each increment/decrement.
+ * @property {number[]} value - Current value(s) of the slider.
+ * @property {number[]} disabledHandlers - JSON string array of handle values that should be individually disabled.
+ * @property {boolean} discrete - Shows tick marks at each step position along the track.
+ * @property {boolean} disabled - Disables the slider, preventing all user interaction.
+ * @property {string} name - Name of the form control, submitted as a key in the form data.
+ */
+export interface ISliderOptions {
+    min: number;
+    max: number;
+    step: number;
+    value: number[];
+    disabledHandlers: number[];
+    discrete: boolean;
+    type: SliderType;
+    disabled: boolean;
+    name: string;
+}
+/**
+ * Options for the slider component with tooltip visibility.
+ * @property {SliderTooltipType} tooltip - Controls tooltip visibility.
+ */
+export interface ISliderTooltipOptions extends ISliderOptions {
+    tooltip: SliderTooltipType;
+}
+//# sourceMappingURL=ISliderOptions.d.ts.map

package/dist/types/components/forms/bds-slider/types/enum.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Available tooltip types for the slider component.
+ * Used to control the visibility of the tooltip.
+ */
+export declare const SLIDER_TOOLTIP: {
+    readonly NEVER: "never";
+    readonly FOCUS: "focus";
+};
+/**
+ * Available slider types for the slider component.
+ * Used to control the behavior of the slider.
+ */
+export declare const SLIDER_TYPE: {
+    readonly SINGLE: "single";
+    readonly RANGE: "range";
+};
+//# sourceMappingURL=enum.d.ts.map

package/dist/types/components/forms/bds-slider/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './ChangeDetail';
+export * from './enum';
+export * from './types';
+export * from './ISlider';
+export * from './ISliderOptions';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/forms/bds-slider/types/types.d.ts

@@ -0,0 +1,5 @@
+import { SLIDER_TOOLTIP, SLIDER_TYPE } from './enum';
+export type SliderTooltipType = (typeof SLIDER_TOOLTIP)[keyof typeof SLIDER_TOOLTIP];
+export type SliderRawValue = string | number[];
+export type SliderType = (typeof SLIDER_TYPE)[keyof typeof SLIDER_TYPE];
+//# sourceMappingURL=types.d.ts.map

package/dist/types/components/forms/bds-text-field/bds-text-field.d.ts

@@ -109,6 +109,10 @@ export declare class BdsTextField extends BdsTextField_base implements ITextFiel
     readonly counter: boolean;
     /** Sets a custom width via the `--bds-text-field-width` CSS custom property. */
     readonly customWidth: string;
+    /** Set mode readonly to use in selects */
+    readonly selectable: boolean;
+    /** Icon rendered on the right side of the input, on the actions containers. (e.g., 'bds-icon-settings') */
+    readonly iconRight: string;
     /** Tracks focus state to drive the `bds-text-field--focused` CSS modifier. */
     private focused;
     /** Controls whether the password input renders as plain text. */

package/dist/types/components/navigation/bds-breadcrumb/bds-breadcrumb.d.ts

@@ -0,0 +1,57 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { BdsClickBreadcrumbEvent, BdsClickCollapsedEvent, IBreadcrumb } from './types/IBreadcrumb';
+import { BdsClickCollapseEvent, BdsClickItemEvent } from "../../../components";
+/**
+ * @summary Breadcrumb navigation container component. Provides a structured navigation trail and
+ * handles overflow using a collapse mechanism when the number of items exceeds `maxItems`.
+ *
+ * @slot - The content of the bds-breadcrumb group. It's meant for multiple `<bds-breadcrumb-item>` elements.
+ */
+export declare class BdsBreadcrumb implements IBreadcrumb {
+    private inheritedAttributes;
+    el: HTMLBdsBreadcrumbElement;
+    /**
+     * Separator rendered between breadcrumb items.
+     * @default "/"
+     */
+    readonly separator: string;
+    /**
+     * Maximum number of breadcrumb items visible before collapsing.
+     * If set to 0 or undefined, no collapsing is applied.
+     * @default 0
+     */
+    readonly maxItems: number;
+    /**
+     * Number of items visible at the start before collapse occurs.
+     * @default 1
+     */
+    readonly itemsBeforeCollapse: number;
+    /**
+     * Number of items visible at the end after collapse occurs.
+     * @default 1
+     */
+    readonly itemsAfterCollapse: number;
+    /**
+     * Emitted when the collapse indicator ("...") is clicked.
+     * Returns a reference to the clicked element and the list of collapsed breadcrumb items.
+     */
+    bdsClickCollapsed: EventEmitter<BdsClickCollapsedEvent>;
+    /**
+     * Emitted when a breadcrumb item is clicked.
+     */
+    bdsClickBreadcrumb: EventEmitter<BdsClickBreadcrumbEvent>;
+    componentWillLoad(): void;
+    onSeparatorChange(): void;
+    onMaxItemsChange(): void;
+    onCollapsedClick(ev: CustomEvent<BdsClickCollapseEvent>): void;
+    onBreadcrumbClick(ev: CustomEvent<BdsClickItemEvent>): void;
+    private applyCustomSeparator;
+    private handleSlotChange;
+    private updateBreadcrumbCollapse;
+    private shouldCollapse;
+    private getBreadcrumbItems;
+    private showAllItems;
+    private applyVisibility;
+    render(): any;
+}
+//# sourceMappingURL=bds-breadcrumb.d.ts.map

package/dist/types/components/navigation/bds-breadcrumb/types/IBreadcrumb.d.ts

@@ -0,0 +1,17 @@
+export interface IBreadcrumb {
+    separator: string;
+    maxItems: number;
+    itemsBeforeCollapse: number;
+    itemsAfterCollapse: number;
+}
+export type BdsClickCollapsedEvent = {
+    element: HTMLElement;
+    collapsedBreadcrumbs: HTMLBdsBreadcrumbItemElement[];
+};
+export type BdsClickBreadcrumbEvent = {
+    element: HTMLElement;
+    index?: number;
+    href?: string;
+    router?: boolean;
+};
+//# sourceMappingURL=IBreadcrumb.d.ts.map

package/dist/types/components/navigation/bds-breadcrumb-item/bds-breadcrumb-item.d.ts

@@ -0,0 +1,83 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import type { BdsClickCollapseEvent, BdsClickItemEvent, IBreadcrumbItem } from './types/IBreadcrumbItem';
+/**
+ * @summary Breadcrumb navigation item component that represents a single step within a breadcrumb navigation trail.
+ *
+ * @slot - The text content of the breadcrumb item, can include simple text or text with icons.
+ */
+export declare class BdsBreadcrumbItem implements IBreadcrumbItem {
+    private collapsedRef;
+    el: HTMLBdsBreadcrumbItemElement;
+    /**
+     * Marks this breadcrumb item as the current page.
+     *
+     * When true, the item is non-interactive and has aria-current="page".
+     *
+     * @default false
+     */
+    readonly active: boolean;
+    /**
+     * Enables router-based navigation instead of native link navigation.
+     *
+     * @default false
+     */
+    readonly router: boolean;
+    /**
+     * Internal prop controlled by the parent breadcrumb.
+     * Indicates that this item is part of a collapsed range.
+     *
+     * @default false
+     */
+    readonly collapsed: boolean;
+    /**
+     * Internal prop controlled by the parent breadcrumb.
+     * Renders the collapse indicator ("...") for hidden items.
+     *
+     * @default false
+     */
+    readonly showCollapse: boolean;
+    /**
+     * URL for the breadcrumb link.
+     *
+     * @default ''
+     */
+    readonly href: string;
+    /**
+     * Specifies where to open the linked document.
+     *
+     * @default '_self'
+     */
+    readonly target: '_blank' | '_parent' | '_self' | '_top';
+    /**
+     * Enables download behavior for the link.
+     *
+     * @default false
+     */
+    readonly downloadable: boolean;
+    /**
+     * Suggested filename for the downloaded file.
+     *
+     * @default 'filename'
+     */
+    readonly filename: string;
+    /**
+     * Relationship between the current document and the linked resource.
+     *
+     * @default ''
+     */
+    readonly rel: string;
+    /**
+     * Emitted when a breadcrumb item is clicked.
+     */
+    bdsClick: EventEmitter<BdsClickItemEvent>;
+    /**
+     * Emitted when the collapse indicator ("...") is activated.
+     */
+    bdsClickCollapse: EventEmitter<BdsClickCollapseEvent>;
+    private handleClick;
+    private get breadcrumbItem();
+    private handleCollapseClick;
+    private get cssClasses();
+    render(): any;
+}
+//# sourceMappingURL=bds-breadcrumb-item.d.ts.map