@prolibu-suite/cobalt-core 0.1.2 → 0.2.0

package/dist/types/components/co-number-field/co-number-field.d.ts

@@ -1,19 +1,32 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 export declare class CoNumberField {
     label?: string;
+    /** Whether the field is required (renders a required marker on the label). */
+    required: boolean;
     secondaryLabel?: string;
     helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside) */
+    layout: 'vertical' | 'horizontal';
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
-    value: number;
+    value: number | null;
     min?: number;
     max?: number;
     step: number;
     disabled: boolean;
     placeholder: string;
+    size: 's' | 'sm' | 'md' | 'lg';
+    /** Show clear button when the field has a value */
+    clearable: boolean;
     focused: boolean;
     el: HTMLElement;
-    coChange: EventEmitter<number>;
+    coChange: EventEmitter<number | null>;
+    /** Emitted when the clear button is clicked */
+    coClear: EventEmitter<void>;
     private inputEl?;
+    /** True when there is no numeric value (cleared / empty). */
+    private get isEmpty();
+    /** Numeric value to step from, treating an empty field as min (or 0). */
+    private get current();
     private get statusIcon();
     private get canDecrement();
     private get canIncrement();
@@ -22,6 +35,7 @@ export declare class CoNumberField {
     private handleDecrement;
     private handleIncrement;
     private handleInput;
+    private handleClear;
     private handleBlur;
     private handleFocus;
     private handleKeyDown;

package/dist/types/components/co-phone-field/co-phone-field.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Phone input with country code indicator. Composes a country selector
+ * (flag + dial code) alongside a free-form phone number input.
+ *
+ * Value format: free string — the component stores `"{dialCode}{number}"`
+ * concatenated. The host may parse/normalize as needed.
+ *
+ * @event coChange - Emits the full phone string on every change.
+ */
+export declare class CoPhoneField {
+    host: HTMLElement;
+    /** Field label. */
+    label?: string;
+    /** Placeholder for the number input. */
+    placeholder: string;
+    /** Current full value (dialCode + number). */
+    value: string;
+    /** Disable the entire field. */
+    disabled: boolean;
+    /** Required indicator. */
+    required: boolean;
+    /** Validation status. */
+    status: 'default' | 'error' | 'success' | 'warning' | 'info';
+    /** Helper/error text below the field. */
+    helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside) */
+    layout: 'vertical' | 'horizontal';
+    /** Default country ISO2 code (e.g. "CO", "US"). Optional — if not set, starts empty. */
+    defaultCountry: string;
+    /** Emits the full phone string on change. */
+    coChange: EventEmitter<string>;
+    private selectedIso2;
+    private numberPart;
+    private isOpen;
+    private searchQuery;
+    private get selectedEntry();
+    private get filteredCountries();
+    /** Country name with the matched substring wrapped for highlighting. */
+    private renderName;
+    onValueChange(newVal: string): void;
+    onDefaultCountryChange(iso2: string): void;
+    componentWillLoad(): void;
+    private get hasCountry();
+    private get statusIcon();
+    private findDialCodeInValue;
+    private emitValue;
+    private handleCountrySelect;
+    private handleNumberInput;
+    private handleToggleDropdown;
+    private handleSearchInput;
+    private handleOutsideClick;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): any;
+}

package/dist/types/components/co-phone-field/dial-codes.d.ts

@@ -0,0 +1,14 @@
+export interface DialCode {
+    iso2: string;
+    dialCode: string;
+    name: string;
+}
+/**
+ * Dial codes sorted by name. Covers the full ITU-T E.164 assignment.
+ * The iso2 key matches country-flag-icons' 3x2/{ISO2} naming.
+ */
+export declare const DIAL_CODES: DialCode[];
+/** ISO2 code → DialCode entry lookup. */
+export declare const DIAL_CODE_MAP: Record<string, DialCode>;
+/** Convert ISO2 country code to Unicode flag emoji. */
+export declare function iso2ToEmoji(iso2: string): string;

package/dist/types/components/co-progress-circle/co-progress-circle.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A circular progress indicator with status colors and optional label.
+ */
+export declare class CoProgressCircle {
+    /** Progress value 0-100 */
+    value: number;
+    /** Status / color variant */
+    status: 'default' | 'success' | 'warning' | 'error';
+    /** Diameter of the circle in px */
+    size: number;
+    /** Stroke width in px */
+    strokeWidth: number;
+    /** Show percentage label inside */
+    showLabel: boolean;
+    render(): any;
+}

package/dist/types/components/co-radio-group/co-radio-group.d.ts

@@ -14,6 +14,8 @@ export declare class CoRadioGroup {
     secondaryLabel?: string;
     /** Helper text displayed below the options */
     helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside) */
+    layout: 'vertical' | 'horizontal';
     /** Validation status */
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
     /** Currently selected value */

package/dist/types/components/co-ref-field/co-ref-field.d.ts

@@ -5,7 +5,11 @@ export interface RefFieldOption {
     description?: string;
     icon?: string;
     color?: string;
+    /** Initials/short text for the avatar bubble (fallback when no image). */
     avatar?: string;
+    /** Image URL for the avatar (e.g. a user's profile picture). Falls back to
+     *  `avatar` initials + `color` if absent or it fails to load. */
+    image?: string;
 }
 export interface RefFieldDisplayItem {
     _id: string;
@@ -13,9 +17,12 @@ export interface RefFieldDisplayItem {
     description?: string;
     color?: string;
     avatar?: string;
+    image?: string;
 }
 export declare class CoRefField {
     label?: string;
+    /** Whether the field is required (renders a required marker on the label). */
+    required: boolean;
     secondaryLabel?: string;
     placeholder: string;
     disabled: boolean;
@@ -24,6 +31,10 @@ export declare class CoRefField {
     status: 'default' | 'error' | 'success' | 'warning';
     helperText?: string;
     iconLeft?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside) */
+    layout: 'vertical' | 'horizontal';
+    /** Size of the trigger. 'sm' reduces height to 32px. */
+    size: 'default' | 'sm';
     /** Selected value: single ID string or JSON array of IDs. */
     value: string;
     /** JSON array of options to display: RefFieldOption[] */
@@ -46,8 +57,15 @@ export declare class CoRefField {
     footerPrimaryLabel: string;
     /** Label for the secondary footer button. */
     footerSecondaryLabel: string;
-    /** Max chips visible in multiple mode before "+N" badge. */
+    /**
+     * Max chips visible in multiple mode before the "+N" badge.
+     * `0` (default) = responsive: the trigger stays single-line and shows as
+     * many chips as actually fit its current width (ResizeObserver-driven);
+     * the badge counts the rest. Set `> 0` to force a fixed cap instead.
+     */
     maxChips: number;
+    /** Panel color theme. 'auto' follows trigger, 'dark' forces dark panel, 'light' forces light. */
+    panelTheme: 'auto' | 'dark' | 'light';
     coChange: EventEmitter<{
         value: string | string[];
         item: RefFieldOption;
@@ -64,9 +82,22 @@ export declare class CoRefField {
     el: HTMLElement;
     isOpen: boolean;
     searchText: string;
+    /** How many trailing chips don't fit the trigger width (responsive mode). */
+    overflowCount: number;
     private searchInputEl?;
     private optionsEl?;
+    private osInstance?;
     private debounceTimer?;
+    private chipsEl?;
+    private observedChipsEl?;
+    private lastChipsKey;
+    private resizeObserver?;
+    /** Selection captured when the panel opens — the dropdown partitions
+     *  selected-first against THIS set so options don't jump while toggling. */
+    private sortSnapshot;
+    /** Display items for the selection captured at open (value order), used to
+     *  prepend selected items the current options page doesn't contain. */
+    private openDisplaySnapshot;
     private get parsedOptions();
     private get parsedSelectedDisplay();
     /**
@@ -77,7 +108,16 @@ export declare class CoRefField {
     private get parsedValue();
     private get hasMore();
     private get remainingCount();
+    componentWillLoad(): void;
+    connectedCallback(): void;
+    componentDidRender(): void;
     disconnectedCallback(): void;
+    /**
+     * Counts how many trailing chips overflow the single-line chips wrapper
+     * (they're kept in the DOM, clipped + visibility:hidden) so the "+N" badge
+     * reflects the REAL available width. Skipped when `maxChips > 0` (fixed cap).
+     */
+    private calcOverflow;
     onOpenChange(isOpen: boolean): void;
     private handlePopoverOpen;
     private handlePopoverClose;
@@ -91,8 +131,21 @@ export declare class CoRefField {
     private handleFooterPrimary;
     private handleFooterSecondary;
     private renderTrigger;
+    /**
+     * Leading visual for a selected value / option. Prefers a real avatar
+     * (image with initials+color fallback, via <co-avatar>), then a color dot.
+     * `size`: 'xxs' (24px) for the selected value, 'xs' (32px) for option rows.
+     */
+    private renderItemAvatar;
     private renderSingleValue;
     private renderMultipleValue;
+    /**
+     * Options in display order: the selection captured at open comes FIRST
+     * (in chip/value order, including selected items the current page doesn't
+     * contain — synthesized from their display item), then the rest in server
+     * order. While searching, only real results render (still selected-first).
+     */
+    private get orderedOptions();
     private renderPanel;
     render(): any;
 }

package/dist/types/components/co-rich-text-editor/co-rich-text-editor.d.ts

@@ -0,0 +1,94 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { Editor, RichTextOutput, RichTextPreset, ToolbarVariant } from '@prolibu-suite/cobalt-rich-text';
+/**
+ * Rich text editor backed by Tiptap v3.
+ *
+ * Uses `shadow: false, scoped: false` (the co-data-table pattern) because
+ * ProseMirror builds its editable DOM imperatively — Stencil's scoped CSS would
+ * never reach it. All styles live in light DOM via BEM + `--co-*` tokens.
+ *
+ * @part wrapper - Outer container
+ * @part toolbar - Formatting toolbar
+ * @part content - Editable ProseMirror surface
+ * @part label - Field label
+ * @part helper - Helper text row
+ */
+export declare class CoRichTextEditor {
+    el: HTMLElement;
+    /** ProseMirror document as a JSON string. `null`/empty = empty editor. */
+    value: string | null;
+    /** Preset controlling allowed nodes/marks, toolbar and sanitization. */
+    preset: RichTextPreset;
+    placeholder: string;
+    label?: string;
+    secondaryLabel?: string;
+    helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside) */
+    layout: 'vertical' | 'horizontal';
+    status: 'default' | 'error' | 'success' | 'warning' | 'info';
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    maxLength?: number;
+    showCharacterCount: boolean;
+    autofocus: boolean;
+    /** Toolbar layout. `auto` uses the preset default. */
+    toolbar: ToolbarVariant;
+    /** Feature overrides (JSON string for HTML attr, or object via JS property). */
+    features?: string | object;
+    /**
+     * Extra Tiptap extensions appended to the preset (JS property only).
+     * Registered at editor creation — required for new schema nodes (images,
+     * tables, embeds, …) that `getEditorInstance()` cannot add afterwards.
+     */
+    customExtensions?: object[];
+    /** Host image upload handler (JS property): `(file) => Promise<url>`. */
+    imageUpload?: (file: File) => Promise<string>;
+    /** Emitted on every keystroke. */
+    coInput: EventEmitter<RichTextOutput>;
+    /** Emitted on blur (committed value). */
+    coChange: EventEmitter<RichTextOutput>;
+    coFocus: EventEmitter<void>;
+    coBlur: EventEmitter<void>;
+    coClear: EventEmitter<void>;
+    /** Emitted once the editor is mounted and ready. */
+    coReady: EventEmitter<void>;
+    ready: boolean;
+    hasFocus: boolean;
+    charCount: number;
+    private editor?;
+    private contentEl?;
+    private toolbarEl?;
+    /** Last value we emitted — guards the value Watch against feedback loops. */
+    private lastEmitted;
+    /** True while applying an external value (suppresses emit). */
+    private applyingExternal;
+    private rt?;
+    /** Set by disconnectedCallback — aborts editor creation if the element was
+     *  removed while the lazy import was still in flight (ProseMirror leak). */
+    private destroyed;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    componentDidRender(): void;
+    onValueChange(next: string | null): void;
+    onEditableChange(): void;
+    getJSON(): Promise<object | null>;
+    getHtml(): Promise<string>;
+    getText(): Promise<string>;
+    clear(): Promise<void>;
+    focusEditor(): Promise<void>;
+    setContent(content: string | object): Promise<void>;
+    getEditorInstance(): Promise<Editor | null>;
+    private get parsedFeatures();
+    private parseValue;
+    private sanitizeHtml;
+    private buildOutput;
+    private handleUpdate;
+    private handleFocus;
+    private handleBlur;
+    private refreshCharCount;
+    private syncToolbar;
+    private get resolvedToolbar();
+    private get helperIcon();
+    render(): any;
+}

package/dist/types/components/co-rich-text-toolbar/co-rich-text-toolbar.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { Editor, ToolbarItem } from '@prolibu-suite/cobalt-rich-text';
+/**
+ * Formatting toolbar for co-rich-text-editor. Receives the Tiptap editor
+ * instance via the `editor` JS property, runs commands, and reflects active
+ * state. Can also be placed standalone and wired to any editor instance.
+ *
+ * @part toolbar - The toolbar container
+ * @part button - A toolbar button
+ */
+export declare class CoRichTextToolbar {
+    /** Editor instance (set as a property by the host editor). */
+    editor?: Editor;
+    /** Toolbar layout variant. */
+    variant: 'none' | 'compact' | 'basic' | 'full';
+    disabled: boolean;
+    /** Emitted whenever a toolbar action runs (observability for hosts). */
+    coAction: EventEmitter<{
+        action: string;
+        payload?: unknown;
+    }>;
+    items: ToolbarItem[];
+    /** Bumped on every editor transaction to refresh active state. */
+    tick: number;
+    private onTransaction;
+    componentWillLoad(): Promise<void>;
+    onVariantChange(v: string): Promise<void>;
+    onEditorChange(next?: Editor, prev?: Editor): void;
+    disconnectedCallback(): void;
+    private isActive;
+    private run;
+    /** Accept only fetchable URL schemes from the prompt (no javascript: etc.). */
+    private static safeUrl;
+    private toggleLink;
+    private insertImage;
+    /** Hide buttons whose node/mark isn't in the editor's schema — e.g. the
+     *  image button on the `full` toolbar with a preset that has no image node
+     *  (clicking it would call an unregistered command and throw). */
+    private supportedBySchema;
+    private canRun;
+    render(): any;
+}

package/dist/types/components/co-rich-text-viewer/co-rich-text-viewer.d.ts

@@ -0,0 +1,32 @@
+import type { RichTextPreset } from '@prolibu-suite/cobalt-rich-text';
+/**
+ * Read-only renderer for rich-text content. For `format="html"` it only runs
+ * the package's canonical sanitizer (the `/sanitizer` subpath has no Tiptap
+ * import → tiny). `format="json"` lazily pulls the serializer to turn a
+ * ProseMirror document into sanitized HTML.
+ *
+ * @part content - The rendered content container
+ * @part empty - The empty-state element
+ */
+export declare class CoRichTextViewer {
+    /** HTML string (default) or ProseMirror JSON string. */
+    value: string | null;
+    /** Input format. `html` is the lightweight path. */
+    format: 'html' | 'json';
+    /** Sanitization profile to apply. */
+    preset: RichTextPreset;
+    /** Feature overrides used when the content was authored with them (JSON
+     *  string for HTML attr, or object via JS property) — keeps the whitelist
+     *  in lock-step with the editor that produced the content. */
+    features?: string | object;
+    /** Text shown when there is no content. */
+    emptyText?: string;
+    /** Reduced padding. */
+    compact: boolean;
+    html: string;
+    componentWillLoad(): Promise<void>;
+    watchInputs(): Promise<void>;
+    private get parsedFeatures();
+    private compute;
+    render(): any;
+}

package/dist/types/components/co-select/co-select.d.ts

@@ -3,41 +3,71 @@ export interface SelectOption {
     label: string;
     value: string;
     icon?: string;
+    /** Image URL shown before the label (e.g. a country flag). Takes precedence over `icon`. */
+    image?: string;
     disabled?: boolean;
 }
 export declare class CoSelect {
     label?: string;
+    /** Whether the field is required (renders a required marker on the label). */
+    required: boolean;
     secondaryLabel?: string;
     placeholder: string;
     disabled: boolean;
     iconLeft?: string;
     clearable: boolean;
     helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside) */
+    layout: 'vertical' | 'horizontal';
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
     options: SelectOption[] | string[] | string;
     value: string | string[];
     multiple: boolean;
+    size: 's' | 'sm' | 'md' | 'lg';
+    /** Show a search box inside the dropdown to filter options client-side. */
+    searchable: boolean;
+    searchPlaceholder: string;
+    emptyText: string;
     isOpen: boolean;
     scrollTop: number;
+    searchText: string;
+    private sortSnapshot;
     el: HTMLElement;
     private optionsContainerEl?;
+    private osInstance?;
+    private searchInputEl?;
     private static readonly ITEM_HEIGHT;
     private static readonly VIEWPORT_ITEMS;
     private static readonly OVERSCAN;
     coChange: EventEmitter<string | string[]>;
     coClear: EventEmitter<void>;
+    private lastOptionsRaw;
+    private lastParsedOptions;
+    private lastRankInput?;
+    private lastRankSearch;
+    private lastRanked;
     private get parsedOptions();
+    /** Options after the in-dropdown search filter (client-side, by label), with
+     *  the selected ones pinned first in multiple mode (frozen at open time). */
+    private get filteredOptions();
     private get selectedValues();
     private get hasValue();
+    /** The selected option in single mode (used to show its flag/image in the trigger). */
+    private get selectedOption();
     private get displayText();
     private get statusIcon();
     onOpenChange(open: boolean): void;
+    private handleSearchInput;
     private handleTriggerClick;
     private handlePopoverOpen;
     private handlePopoverClose;
     private handleClear;
     private handleOptionClick;
-    private handleOptionsScroll;
+    private syncOverlayScrollbars;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    /** Option label with the matched substring wrapped for highlighting. */
+    private renderLabel;
     private getVirtualSlice;
     render(): any;
 }

package/dist/types/components/co-switch/co-switch.d.ts

@@ -6,6 +6,8 @@ export declare class CoSwitch {
     disabled: boolean;
     /** Label text displayed beside the switch */
     label?: string;
+    /** Whether the field is required (renders a required marker on the label). */
+    required: boolean;
     /** Secondary label displayed on the right side */
     secondaryLabel?: string;
     /** Helper text displayed below */

package/dist/types/components/co-tags-field/co-tags-field.d.ts

@@ -0,0 +1,82 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Free-text tags input — type a value and press Enter/Tab (or comma) to add it
+ * as a chip. Backspace on an empty input removes the last chip; double-click a
+ * chip to edit it inline. Unlike `co-combobox` (which selects from a fixed list
+ * of options), this field has no option list: every chip is arbitrary text the
+ * user typed. It is the renderer for schema fields whose Mongoose type is an
+ * array of primitives (e.g. `type: [String]`).
+ *
+ * The committed `value` is a JSON array of strings (or an actual `string[]` when
+ * set programmatically). `coChange` emits the array on every add/edit/remove/clear.
+ *
+ * Visually mirrors `co-date-field`/`co-input` so it sits flush with the rest of
+ * the form controls.
+ *
+ * @part wrapper - Root container
+ * @part label - The field label
+ * @part field - The bordered chip+input row
+ * @part input - The native text input
+ * @part clear - The clear-all button
+ * @part helper - The helper/error text row
+ */
+export declare class CoTagsField {
+    el: HTMLElement;
+    /** Committed value as a JSON array of strings (or an actual `string[]`). */
+    value: string[] | string;
+    label?: string;
+    placeholder: string;
+    name?: string;
+    required: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    clearable: boolean;
+    /** Maximum number of tags allowed (no cap when undefined). */
+    maxTags?: number;
+    /** Allow the same value to be added more than once. */
+    allowDuplicates: boolean;
+    /** External invalid flag (e.g. from a form controller). */
+    invalid: boolean;
+    /** Message shown when invalid. */
+    errorMessage?: string;
+    /** Helper text shown when valid. */
+    helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside) */
+    layout: 'vertical' | 'horizontal';
+    /** Emitted with the full array on every add/edit/remove/clear. */
+    coChange: EventEmitter<string[]>;
+    /** Emitted on every keystroke of the inline input with the raw text. */
+    coInput: EventEmitter<string>;
+    /** Emitted when the clear-all button is clicked. */
+    coClear: EventEmitter<void>;
+    coFocus: EventEmitter<void>;
+    coBlur: EventEmitter<void>;
+    /** Raw text in the inline input. */
+    draft: string;
+    /** Index of the chip being edited inline, or null. */
+    editingIndex: number | null;
+    /** Draft text while editing a chip. */
+    editingDraft: string;
+    hasFocus: boolean;
+    private inputEl?;
+    private editEl?;
+    onEditingIndexChange(next: number | null): void;
+    private get tags();
+    private get hasValue();
+    private get isInvalid();
+    private get atCapacity();
+    private commit;
+    private addTag;
+    private removeTag;
+    private startEdit;
+    private saveEdit;
+    private cancelEdit;
+    private handleClearAll;
+    private handleInput;
+    private handleKeyDown;
+    private handleFocus;
+    private handleBlur;
+    private handleEditKeyDown;
+    private handleFieldClick;
+    render(): any;
+}

package/dist/types/components/co-textarea/co-textarea.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Multiline text input field with label, helper text, character counter,
+ * and clear functionality. Mirrors `co-input` styling but renders a native
+ * `<textarea>` for multiline content (bios, descriptions, notes).
+ *
+ * @part wrapper - Root container
+ * @part label - The field label
+ * @part field - The bordered textarea wrapper
+ * @part input - The native textarea element
+ * @part helper - The helper/error text row
+ * @part counter - The character counter element
+ */
+export declare class CoTextarea {
+    el: HTMLElement;
+    /** Current value */
+    value: string;
+    /** Label text displayed above the textarea */
+    label?: string;
+    /** Secondary label displayed on the right side */
+    secondaryLabel?: string;
+    /** Placeholder text */
+    placeholder: string;
+    /** Input name attribute */
+    name?: string;
+    /** Whether the field is required */
+    required: boolean;
+    /** Disabled state */
+    disabled: boolean;
+    /** Read-only state */
+    readonly: boolean;
+    /** Number of visible text rows */
+    rows: number;
+    /** Maximum character length. When set, a counter is displayed. */
+    maxLength?: number;
+    /** Validation status */
+    status: 'default' | 'error' | 'success' | 'warning';
+    /** Helper text displayed below the textarea */
+    helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside) */
+    layout: 'vertical' | 'horizontal';
+    /** Show clear button when textarea has value */
+    clearable: boolean;
+    /** Resize behavior of the textarea */
+    resize: 'vertical' | 'none' | 'both';
+    /** Emitted on every keystroke with the current text */
+    coInput: EventEmitter<string>;
+    /** Emitted with the committed text on blur */
+    coChange: EventEmitter<string>;
+    /** Emitted on focus */
+    coFocus: EventEmitter<void>;
+    /** Emitted on blur */
+    coBlur: EventEmitter<void>;
+    /** Emitted when clear button is clicked */
+    coClear: EventEmitter<void>;
+    hasFocus: boolean;
+    private textareaEl?;
+    private handleInput;
+    private handleFocus;
+    private handleBlur;
+    private handleClear;
+    private get hasValue();
+    private get charCount();
+    render(): any;
+}

package/dist/types/components/co-toggle-button-group/co-toggle-button-group.d.ts

@@ -6,6 +6,8 @@ export declare class CoToggleButtonGroup {
     size: 'l' | 'm' | 's' | 'xs';
     disabled: boolean;
     direction: 'row' | 'column';
+    /** Stretch the group to fill its container; each button shares the width equally. */
+    fullWidth: boolean;
     el: HTMLElement;
     coChange: EventEmitter<string | string[]>;
     private get selectedValues();