@guildofgleks/ui 21.2.3 → 21.3.0

package/types/guildofgleks-ui.d.ts

@@ -1,21 +1,95 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, Type, Injector, InjectionToken, OnDestroy, DoCheck, Signal, ModelSignal, ElementRef } from '@angular/core';
+import { TemplateRef, DoCheck, Signal, ModelSignal, ElementRef, InjectionToken, Type, Injector, OnDestroy, Provider } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import * as _angular_platform_browser from '@angular/platform-browser';
 import * as _guildofgleks_ui from '@guildofgleks/ui';
 
 type GogSize = 'xsm' | 'sm' | 'md' | 'lg' | 'slg';
 type GogVariant = 'primary' | 'secondary' | 'outline' | 'ghost';
+/**
+ * Which way a component lays its children out. Shared rather than re-declared per component:
+ * `gog-radio-group`, `gog-slider`, `gog-divider`, `gog-tabs` and `gog-button-toggle-group` all
+ * mean the same thing by it, and `roving-focus.ts` picks its arrow pair from this.
+ */
+type GogOrientation = 'horizontal' | 'vertical';
 type GogSpinnerVariant = 'runic' | 'ring' | 'custom';
 type GogTagVariant = 'success' | 'danger' | 'warning' | 'info';
 type GogTagShape = 'rounded' | 'pill';
 type GogSkeletonShape = 'text' | 'circle' | 'rect';
 type GogSkeletonAnimation = 'pulse' | 'wave' | 'none';
 type GogPaginatorRangeMode = 'window' | 'ellipsis';
+type GogSliderOrientation = GogOrientation;
+type GogScrollAxis = 'vertical' | 'horizontal' | 'both';
+type GogScrollSize = 'normal' | 'thin';
+/**
+ * Mirrors the CSS `overscroll-behavior` value space directly:
+ * - `'auto'` — scrolling past this instance's edge chains to the next scrollable ancestor
+ *   (a page, a dialog body, another gog-scroll), the same as an un-customized native
+ *   `overflow: auto` div. The default — matches what most embedded content expects.
+ * - `'contain'` — scrolling stops dead at this instance's edge; nothing behind it moves.
+ *   Suited to overlay-style panels (a dropdown, a modal) where scrolling past the end
+ *   shouldn't also scroll whatever is behind them.
+ * - `'none'` — like `'contain'`, and additionally suppresses the platform's own overscroll
+ *   affordances (rubber-banding, pull-to-refresh) for this instance.
+ */
+type GogScrollOverscrollBehavior = 'auto' | 'contain' | 'none';
+/**
+ * Which side of the trigger the tooltip bubble renders on. `'auto'` (the default) picks
+ * whichever of the four sides has room for the bubble, preferring top, then bottom, then
+ * right, then left — see `resolveTooltipPlacement` in `tooltip-position.ts`. An explicit
+ * side still flips to its opposite if the requested side has no room but the opposite does.
+ */
+type GogTooltipPosition = 'auto' | 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Where a field's label sits once it "floats" out of its resting position (overlapping the
+ * field like a placeholder) on focus or once the field has content. `'none'` (the default)
+ * keeps today's static label-above-the-field layout — nothing floats.
+ * - `'in'` — floats up but stays fully inside the field's border.
+ * - `'on'` — floats up until vertically centered on the top border line.
+ * - `'over'` — floats all the way above the field, outside the border.
+ */
+type GogFloatLabelVariant = 'none' | 'in' | 'on' | 'over';
+/**
+ * Which end of a dropdown panel the search box sticks to. Matches `gog-multiselect`'s
+ * `controlsPosition` vocabulary — the same idea applied to its select-all row.
+ */
+type GogDropdownFilterPosition = 'top' | 'bottom';
+/** How `gog-divider` paints its rule. */
+type GogDividerVariant = 'solid' | 'dashed' | 'dotted';
+/**
+ * Which corner of its host a `gogBadge` sits on. Named by block/inline edge rather than
+ * left/right so it follows the writing direction in an RTL layout.
+ */
+type GogBadgePosition = 'top-end' | 'top-start' | 'bottom-end' | 'bottom-start';
+/**
+ * - `'determinate'` — the bar reflects `value`.
+ * - `'indeterminate'` — work of unknown length; the bar animates and reports no value to
+ *   assistive tech, which is what marks it indeterminate.
+ * - `'buffer'` — `value` plus a second, lighter `buffer` level ahead of it (streaming/preload).
+ */
+type GogProgressbarMode = 'determinate' | 'indeterminate' | 'buffer';
+/**
+ * `gog-progressbar`'s colour. Wider than `GogTagVariant` by one: progress is usually just
+ * "the app is working", which is the accent colour rather than any of the four status hues —
+ * so `'accent'` is the default and the status names are the exception.
+ */
+type GogProgressbarVariant = 'accent' | 'success' | 'danger' | 'warning' | 'info';
+/**
+ * - `'joined'` — one segmented control, buttons sharing borders (Material's look).
+ * - `'separated'` — discrete buttons with a gap between them.
+ */
+type GogButtonToggleAppearance = 'joined' | 'separated';
+/** How the tab headers distribute along the tablist. `'stretch'` makes them share the width. */
+type GogTabsAlign = 'start' | 'center' | 'end' | 'stretch';
+/** Whether `gog-datepicker` picks one day or a start/end pair. */
+type GogDateSelectionMode = 'single' | 'range';
+/** Clock convention for `gog-datepicker`'s time section. */
+type GogHourFormat = '12' | '24';
 
 declare class ButtonComponent {
     variant: _angular_core.InputSignal<GogVariant>;
-    size: _angular_core.InputSignal<GogSize>;
+    /** Unset, falls back to `GOG_CONFIG.control.size`, then to `'md'`. */
+    size: _angular_core.InputSignal<GogSize | undefined>;
     disabled: _angular_core.InputSignal<boolean>;
     fullWidth: _angular_core.InputSignal<boolean>;
     type: _angular_core.InputSignal<"button" | "submit" | "reset">;
@@ -25,8 +99,9 @@ declare class ButtonComponent {
      * guard, not a delay before the first click fires: the first click in a
      * window is emitted immediately (leading edge), and any further clicks
      * within `debounce` ms are silently dropped until the window elapses.
+     * Unset, falls back to `GOG_CONFIG.button.debounce`, then to `300`.
      */
-    debounce: _angular_core.InputSignal<number>;
+    debounce: _angular_core.InputSignal<number | undefined>;
     /**
      * Accessible name for the button, forwarded to the native <button>.
      * Setting `aria-label` directly on <gog-button> in a template does NOT
@@ -41,7 +116,16 @@ declare class ButtonComponent {
     /** Logically blocked from activating (disabled OR loading), used to guard click handling. */
     protected isDisabled: _angular_core.Signal<boolean>;
     private static readonly SPINNER_SIZE_BY_BUTTON_SIZE;
+    private readonly globalConfig;
+    /** Instance input → `GOG_CONFIG` → the component's own default. See `resolveConfigured`. */
+    protected readonly resolvedSize: _angular_core.Signal<GogSize>;
     protected spinnerSize: _angular_core.Signal<GogSize>;
+    protected readonly resolvedDebounce: _angular_core.Signal<number>;
+    /**
+     * The single size modifier, replacing one `[class.gog-btn--<size>]` binding per size.
+     * Always emitted — `gog-btn` has a rule for every size, `md` included.
+     */
+    protected readonly sizeClass: _angular_core.Signal<string>;
     private readonly destroyRef;
     private readonly click$;
     constructor();
@@ -89,6 +173,12 @@ declare class GogAccordionChevronDirective {
 declare class AccordionComponent {
     private static nextUid;
     readonly items: _angular_core.InputSignal<GogAccordionItem[]>;
+    /**
+     * The single size modifier, replacing one `[class.gog-accordion--<size>]` binding per size.
+     * Empty for `'lg'`: that is this component's default size, and its tokens are what every
+     * `--gog-accordion-*` chain bottoms out at, so it has no modifier rule of its own.
+     */
+    protected readonly sizeClass: _angular_core.Signal<string>;
     readonly size: _angular_core.InputSignal<GogSize>;
     readonly expandFirst: _angular_core.InputSignal<boolean>;
     readonly multi: _angular_core.InputSignal<boolean>;
@@ -108,7 +198,7 @@ declare class AccordionComponent {
      * Left unset by default since not every accordion instance represents document structure
      * (e.g. one nested inside a card).
      */
-    readonly headingLevel: _angular_core.InputSignal<4 | 3 | 2 | 5 | 6 | undefined>;
+    readonly headingLevel: _angular_core.InputSignal<2 | 3 | 4 | 5 | 6 | undefined>;
     /**
      * Two-way bindable set of currently open item ids. Exposed as a model so consumers
      * can drive the accordion externally (e.g. `[(openIds)]="mySet"`) instead of only
@@ -144,22 +234,1564 @@ declare class AccordionComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionComponent, "gog-accordion", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "expandFirst": { "alias": "expandFirst"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "skeletonCount": { "alias": "skeletonCount"; "required": false; "isSignal": true; }; "showChevron": { "alias": "showChevron"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "openIds": { "alias": "openIds"; "required": false; "isSignal": true; }; }, { "openIds": "openIdsChange"; "gogToggle": "gogToggle"; }, ["headerTpl", "chevronTpl", "contentTpl"], never, true, never>;
 }
 
-declare class CheckboxComponent implements ControlValueAccessor {
+/**
+ * Headless expand/collapse primitive — a trigger toggles a content region open and
+ * closed, in place (no portal/overlay, unlike `gog-select`/`gog-multiselect`). Unopinionated
+ * about markup: project any element as the trigger via `gogCollapsibleTrigger` and any
+ * element as the content via `gogCollapsibleContent`; this component only holds the shared
+ * `open` state and generates the id pair linking them for ARIA.
+ */
+declare class CollapsibleComponent {
+    private static nextUid;
+    /** Two-way bindable open state: `[(open)]="signal"`. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Closes the panel once focus leaves both the trigger and the content — e.g. Tabbing past
+     * the last focusable element inside, or a click landing somewhere else on the page. Off by
+     * default: plenty of consumers (an FAQ list, a settings section someone reads top to bottom)
+     * want the panel to stay open regardless of where focus goes next, so this is opt-in rather
+     * than baked in.
+     */
+    readonly collapseOnFocusOut: _angular_core.InputSignal<boolean>;
+    private readonly elementRef;
+    private readonly uid;
+    readonly contentId: _angular_core.Signal<string>;
+    toggle(): void;
+    protected onFocusOut(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollapsibleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CollapsibleComponent, "gog-collapsible", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "collapseOnFocusOut": { "alias": "collapseOnFocusOut"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Marks the element that toggles a `gog-collapsible`. Works on any clickable element
+ * (`<button>`, `<a>`, ...) — this only wires the click handler and the ARIA attributes
+ * pointing at the matching `gogCollapsibleContent`; it owns no markup of its own.
+ */
+declare class GogCollapsibleTriggerDirective {
+    protected readonly collapsible: CollapsibleComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogCollapsibleTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogCollapsibleTriggerDirective, "[gogCollapsibleTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks the element that a `gog-collapsible` shows and hides. Applies the open/closed
+ * CSS state and the ARIA wiring (`id`, `aria-hidden`, `inert`) to whatever element this is
+ * placed on — that element owns its own content and layout.
+ */
+declare class GogCollapsibleContentDirective {
+    protected readonly collapsible: CollapsibleComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogCollapsibleContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogCollapsibleContentDirective, "[gogCollapsibleContent]", never, {}, {}, never, never, true, never>;
+}
+
+type GogDropdownDirection = 'auto' | 'up' | 'down';
+interface GogDropdownPlacement {
+    direction: 'up' | 'down';
+    top: number;
+    left: number;
+    width: number;
+    maxHeight: number;
+}
+
+/**
+ * `'manual'` (default): the field shows `errorMessage` for as long as it is non-empty — the
+ * consumer decides when to clear it, e.g.
+ * `errorMessage="control.invalid && control.touched ? 'Required' : ''"`.
+ *
+ * `'auto'`: shown once the attached form control has been touched and is invalid — the
+ * consumer only supplies the message text, not the timing. Requires a
+ * `[formControl]` / `formControlName` on the element; without one this falls back to
+ * `'manual'`, since there is no control state to key off.
+ */
+type GogErrorDisplay = 'auto' | 'manual';
+
+/**
+ * How a collection-driven component reads one field off a consumer's own object.
+ *
+ * A `string` is a property name, or a dot-path into a nested one (`'profile.city'`). A function
+ * is anything else. This is what lets `gog-select` / `gog-multiselect` take a consumer's real
+ * DTO instead of forcing everything through a `{ id, name }` shape first.
+ */
+type GogOptionAccessor<TOption, TResult> = string | ((option: TOption) => TResult);
+/** Resolves `field` against `source`, following dot-paths (e.g. `"address.city"`). */
+declare function getByPath(source: unknown, field: string): unknown;
+/** Applies an accessor — a property path or a function — to one option. */
+declare function readOption<TOption, TResult>(option: TOption, accessor: GogOptionAccessor<TOption, TResult>): TResult;
+/**
+ * Whether two resolved option values refer to the same option.
+ *
+ * Primitives are compared as strings, so a `formControl` holding `'1'` still matches an option
+ * whose value is the number `1` — the library behaved this way before option values could be
+ * anything, and forms routinely stringify. Objects are compared by identity instead: coercing
+ * them would make every plain object equal to every other (`"[object Object]"`).
+ */
+declare function isSameOptionValue(a: unknown, b: unknown): boolean;
+
+/**
+ * Custom markup for the trigger's chevron, on `gog-select` and `gog-multiselect`:
+ *
+ * ```html
+ * <gog-select [options]="opts">
+ *   <ng-template gogDropdownChevron><gog-icon name="sort" /></ng-template>
+ * </gog-select>
+ * ```
+ */
+declare class GogDropdownChevronDirective {
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogDropdownChevronDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogDropdownChevronDirective, "[gogDropdownChevron]", never, {}, {}, never, never, true, never>;
+}
+/** Context handed to a `gogDropdownOption` template. */
+interface GogDropdownOptionContext<TOption> {
+    /** The consumer's own option object, untouched. */
+    $implicit: TOption;
+    selected: boolean;
+    disabled: boolean;
+    /** The resolved label, so a custom row can decorate it rather than re-derive it. */
+    label: string;
+}
+/**
+ * Custom markup for one option row, on `gog-select` and `gog-multiselect`:
+ *
+ * ```html
+ * <gog-select [options]="users" optionLabel="fullName" optionValue="id" [(value)]="userId">
+ *   <ng-template gogDropdownOption let-user let-selected="selected">
+ *     <img [src]="user.avatar" alt="" /> {{ user.fullName }}
+ *   </ng-template>
+ * </gog-select>
+ * ```
+ */
+declare class GogDropdownOptionDirective<TOption = unknown> {
+    readonly templateRef: TemplateRef<GogDropdownOptionContext<TOption>>;
+    static ngTemplateContextGuard<TOption>(_dir: GogDropdownOptionDirective<TOption>, ctx: unknown): ctx is GogDropdownOptionContext<TOption>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogDropdownOptionDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogDropdownOptionDirective<any>, "[gogDropdownOption]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The shape the listbox controls assume when their accessor inputs are left at their defaults.
+ *
+ * It is no longer required: `optionLabel` / `optionValue` / `optionDisabled` accept any property
+ * path or function, so a consumer can pass their own DTO straight through. This interface just
+ * describes what the *default* accessors (`'name'` / `'id'` / `'disabled'`) expect to find.
+ */
+interface GogDropdownOption {
+    id: string | number;
+    name: string;
+    disabled?: boolean;
+}
+/**
+ * Shared behaviour for the listbox-style controls: open/close, placement, the
+ * append-to-body overlay, click-outside, keyboard navigation and `ControlValueAccessor`
+ * plumbing. Subclasses supply only what actually differs — the value type, the panel
+ * markup, and the BEM class names used to find the trigger and the options.
+ *
+ * Exported because it appears in the public type signatures of the components that
+ * extend it; it is not meant to be used or subclassed by consumers.
+ */
+declare abstract class GogDropdownBase<TValue, TOption = GogDropdownOption> implements ControlValueAccessor, DoCheck {
+    private static nextUid;
     readonly label: _angular_core.InputSignal<string>;
     readonly ariaLabel: _angular_core.InputSignal<string>;
-    readonly size: _angular_core.InputSignal<GogSize>;
-    readonly indeterminate: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<TOption[]>;
+    /**
+     * How to read an option's visible text — a property path (`'name'`, `'profile.title'`) or a
+     * function. Defaults to `'name'`, matching `GogDropdownOption`.
+     */
+    readonly optionLabel: _angular_core.InputSignal<GogOptionAccessor<TOption, string>>;
+    /**
+     * How to read the value this control emits for an option. A property path or a function, or
+     * `null` to emit **the option object itself** — which is what lets a consumer keep their own
+     * DTO end to end instead of mapping ids back to objects on every change.
+     *
+     * Defaults to `'id'`, matching `GogDropdownOption`, so existing code is unaffected.
+     */
+    readonly optionValue: _angular_core.InputSignal<GogOptionAccessor<TOption, unknown> | null>;
+    /** How to read whether an option is disabled. Defaults to `'disabled'`. */
+    readonly optionDisabled: _angular_core.InputSignal<GogOptionAccessor<TOption, boolean>>;
+    /**
+     * Whether to offer a clear button once something is selected. Unset, falls back to
+     * `GOG_CONFIG.control.clearable`, then to the control's own default.
+     */
+    readonly clearable: _angular_core.InputSignal<boolean | undefined>;
+    /** Accessible name for the clear button. */
+    readonly clearAriaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Smallest width the trigger may shrink to, as any CSS length. Only meaningful with
+     * `[fullWidth]="false"`, where the trigger otherwise sizes to whatever is currently selected
+     * and can collapse to almost nothing on a short option. Left unset it falls back to the
+     * `--gog-{select,multiselect}-min-width` token.
+     */
+    readonly minWidth: _angular_core.InputSignal<string | null>;
+    /**
+     * Whether the panel shows a search box that narrows the option list. Unset, falls back to
+     * `GOG_CONFIG.dropdown.filter`, then to `false`.
+     */
+    readonly filter: _angular_core.InputSignal<boolean | undefined>;
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    /**
+     * Which end of the panel the search box sticks to. Named to match `gog-multiselect`'s
+     * `controlsPosition`, which is the same idea for its select-all row. Unset, falls back to
+     * `GOG_CONFIG.dropdown.filterPosition`, then to `'top'`.
+     */
+    readonly filterPosition: _angular_core.InputSignal<GogDropdownFilterPosition | undefined>;
+    /** Shown in place of the list when the query matches nothing. */
+    readonly filterEmptyMessage: _angular_core.InputSignal<string>;
+    /**
+     * How an option is matched against the query. Left null, the resolved `optionLabel` is
+     * matched case-insensitively as a substring — pass a function to search other fields, match
+     * on a prefix, or plug in your own fuzzy matcher.
+     */
+    readonly filterMatch: _angular_core.InputSignal<((option: TOption, query: string) => boolean) | null>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
+    /**
+     * See `GogErrorDisplay`. Unset, falls back to `GOG_CONFIG.control.errorDisplay`, then to
+     * `'manual'` — matching every other control in the library.
+     */
+    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.control.size`, then to `'md'`. */
+    readonly size: _angular_core.InputSignal<GogSize | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.dropdown.direction`, then to `'auto'`. */
+    readonly dropdownDirection: _angular_core.InputSignal<GogDropdownDirection | undefined>;
+    /**
+     * Explicit stacking order for the panel. Left unset the panel falls back to the
+     * stylesheet's `--gog-dropdown-z`, so the default lives in CSS where a consumer can
+     * retheme it, rather than being baked into the component.
+     */
+    readonly dropdownZIndex: _angular_core.InputSignal<number | null>;
+    /**
+     * Fixed panel width as any CSS length (`'320px'`, `'40ch'`, `'100%'`, …), applied only
+     * when `appendToBody` is set. Left unset the panel matches the trigger's width, same as
+     * the inline panel already does via CSS.
+     */
+    readonly dropdownWidth: _angular_core.InputSignal<string | null>;
+    /**
+     * Fixed panel max-height as any CSS length, applied only when `appendToBody` is set.
+     * `px`, `%` and `vh` also feed the up/down placement math (see `resolveCssLengthPx`); any
+     * other unit still renders correctly but is invisible to that heuristic, so the panel may
+     * pick the "wrong" side close to a viewport edge. Left unset the panel keeps the existing
+     * viewport-derived, auto-flipping height.
+     */
+    readonly dropdownMaxHeight: _angular_core.InputSignal<string | null>;
+    /** Unset, falls back to `GOG_CONFIG.dropdown.appendToBody`, then to `false`. */
+    readonly appendToBody: _angular_core.InputSignal<boolean | undefined>;
     readonly disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project an `<ng-template gogDropdownChevron>` into
+     * the control instead. Removed in 21.5.0.
+     */
+    readonly chevronTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Projected `gogDropdownChevron` template; wins over the deprecated `chevronTemplate`. */
+    protected readonly chevronSlot: Signal<GogDropdownChevronDirective | undefined>;
+    /**
+     * Full width of the container by default, matching every other field-style control.
+     * Set to `false` to shrink the trigger to fit its selected label instead.
+     */
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    /** Unset, falls back to `GOG_CONFIG.floatLabel.variant`, then to `'none'` (off). */
+    readonly floatLabel: _angular_core.InputSignal<GogFloatLabelVariant | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.floatLabel.showPlaceholder`, then to `false`. */
+    readonly floatLabelShowPlaceholder: _angular_core.InputSignal<boolean | undefined>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** Projected `gogDropdownOption` template, if the consumer supplied one. */
+    protected readonly optionSlot: Signal<GogDropdownOptionDirective<any> | undefined>;
+    /** An option's visible text, via `optionLabel`. */
+    protected labelOf(option: TOption): string;
+    /**
+     * The value this control emits for an option, via `optionValue` — or the option object
+     * itself when `optionValue` is `null`.
+     */
+    protected valueOf(option: TOption): unknown;
+    /** Whether an option is disabled, via `optionDisabled`. Anything falsy counts as enabled. */
+    protected isOptionDisabled(option: TOption): boolean;
+    /** Context for a projected `gogDropdownOption` row. */
+    protected optionContext(option: TOption, selected: boolean): GogDropdownOptionContext<TOption>;
+    /** Shared by both controls to match a resolved option value against the current value. */
+    protected sameValue(a: unknown, b: unknown): boolean;
+    /** The `<ng-template>` holding the panel markup, rendered inline or into `<body>`. */
+    protected abstract readonly panelTemplate: Signal<TemplateRef<unknown> | undefined>;
+    /** Declared by the subclass so each control keeps its own value type. */
+    protected abstract readonly value: ModelSignal<TValue>;
+    /** Value applied when a form writes `null` / the control is reset. */
+    protected abstract readonly emptyValue: TValue;
+    /** BEM class of one option button, used to collect keyboard-navigable elements. */
+    protected abstract readonly optionClass: string;
+    /** BEM class of the focusable trigger. */
+    protected abstract readonly triggerClass: string;
+    /**
+     * BEM block that carries the size modifier — `.gog-select` vs `.gog-ms-wrapper`. Separate
+     * from `triggerClass` because in `gog-multiselect` the two are different elements.
+     */
+    protected abstract readonly sizeBlockClass: string;
+    /** BEM block of the panel, which repeats the size modifier when appended to `<body>`. */
+    protected abstract readonly panelBlockClass: string;
+    /** Whether the control currently has a selection — drives the float-label "filled" state. */
+    protected abstract readonly hasFloatValue: Signal<boolean>;
+    /**
+     * Spacing tokens feeding the height estimate. Overridable so each control keeps the
+     * `--gog-<block>-*` names it already exposes to consumers for theming.
+     */
+    protected readonly optionGapToken: string;
+    protected readonly optionsPaddingToken: string;
+    /** Keep in sync with the real `max-height` on the subclass's `__dropdown` block. */
+    protected readonly panelMaxHeightToken: string;
+    /** Estimated row height fed into the placement math; not a real layout property. */
+    protected readonly optionHeightToken: string;
+    /** Unique per-instance suffix, so several dropdowns on a page can't collide on DOM ids. */
+    protected readonly uid: number;
+    protected readonly elRef: ElementRef<any>;
+    protected readonly isBrowser: boolean;
+    private readonly document;
+    private readonly appRef;
+    private readonly destroyRef;
+    private readonly ngControl;
+    private readonly globalConfig;
+    private readonly overlay;
+    /** Set from `(focus)`/`(blur)` on the trigger — see `onFocusIn`/`onFocusOut`. */
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    /** Instance input → `GOG_CONFIG` → the component's own default. See `resolveConfigured`. */
+    protected readonly resolvedSize: Signal<GogSize>;
+    protected readonly resolvedErrorDisplay: Signal<GogErrorDisplay>;
+    protected readonly resolvedAppendToBody: Signal<boolean>;
+    protected readonly resolvedDropdownDirection: Signal<GogDropdownDirection>;
+    /**
+     * The single size modifier for the wrapper, replacing one `[class.<block>--<size>]` binding
+     * per size. Empty for `'md'`: that is the default size and has no modifier rule of its own —
+     * every `--gog-<block>-size-*` chain bottoms out at the `md` tokens.
+     */
+    protected readonly sizeClass: Signal<string>;
+    /**
+     * Same modifier repeated on the panel, but only when it is appended to `<body>` — outside
+     * the component's subtree the panel no longer inherits the wrapper's size tokens, so it has
+     * to carry them itself. See the `--portal` blocks in the component stylesheets.
+     */
+    protected readonly panelSizeClass: Signal<string>;
+    private readonly cvaDisabled;
+    private readonly errorState;
+    protected readonly isDisabled: Signal<boolean>;
+    protected readonly dropdownDirectionState: _angular_core.WritableSignal<"up" | "down">;
+    protected readonly panelPlacement: _angular_core.WritableSignal<GogDropdownPlacement | null>;
+    /**
+     * Stacking order to write onto the panel, or null to leave it to the stylesheet.
+     *
+     * Only needed when appending to `<body>`: an inline panel inherits `--gog-dropdown-z` from
+     * its surroundings — which is how a dropdown inside a dialog ends up above the dialog —
+     * but an appended one sits outside that subtree and inherits nothing, so the value has
+     * to be resolved from the trigger and written out explicitly.
+     */
+    protected readonly panelZIndex: _angular_core.WritableSignal<number | null>;
+    /**
+     * Explicit panel width, or null to let it size to its own content.
+     *
+     * The panel used to be pinned to the trigger's width, which broke a trigger narrower than its
+     * options: with `[fullWidth]="false"` the trigger shrinks to the *current* selection, so
+     * picking a short option cut the longer ones off in the list. It now sizes to its content with
+     * the trigger width as a floor — see `resolvedPanelMinWidth`.
+     */
+    protected readonly resolvedPanelWidth: Signal<string | null>;
+    /** The trigger's width, used as the panel's minimum so it never renders narrower than it. */
+    protected readonly resolvedPanelMinWidth: Signal<string | null>;
+    /** `dropdownMaxHeight`, or the viewport-derived max-height from `panelPlacement`. */
+    protected readonly resolvedPanelMaxHeight: Signal<string | null>;
+    protected readonly hasError: Signal<boolean>;
+    protected readonly visibleError: Signal<string>;
+    /**
+     * Each control supplies its own default: `gog-multiselect` shipped a clear button before
+     * `clearable` existed, so it keeps one; `gog-select` opts in.
+     */
+    protected abstract readonly clearableByDefault: boolean;
+    private readonly clearableState;
+    /** Whether to render the clear button right now — see `GogClearableState`. */
+    protected readonly showClear: Signal<boolean>;
+    protected readonly resolvedFilter: Signal<boolean>;
+    protected readonly resolvedFilterPosition: Signal<GogDropdownFilterPosition>;
+    /** Current search text. Cleared whenever the panel closes, so reopening starts fresh. */
+    protected readonly filterQuery: _angular_core.WritableSignal<string>;
+    /**
+     * The options actually rendered. Everything downstream — the loops, the keyboard navigation
+     * target list, the panel height estimate, and multiselect's select-all — reads this rather
+     * than `options()`, so filtering stays consistent instead of only hiding rows visually.
+     */
+    protected readonly visibleOptions: Signal<TOption[]>;
+    protected onFilterInput(event: Event): void;
+    /** Resets the control to its empty value and notifies any attached form. */
+    protected clearValue(event: Event): void;
+    /**
+     * `hasFloatValue` is wrapped in a `computed` rather than passed straight through: these
+     * field initializers run before the *subclass's* do, so `this.hasFloatValue` is still
+     * undefined right here. The arrow defers the read until the signal is first evaluated, by
+     * which time the subclass has assigned it.
+     */
+    private readonly floatLabelState;
+    protected readonly resolvedFloatLabel: Signal<GogFloatLabelVariant>;
+    protected readonly isFloatLabelActive: Signal<boolean>;
+    protected readonly isFloatLabelFloated: Signal<boolean>;
+    protected readonly effectivePlaceholder: Signal<string>;
+    /** Measured once per open rather than per scroll tick — see `refreshPanelMetrics`. */
+    private optionGap;
+    private optionsPadding;
+    private maxPanelHeight;
+    private optionHeight;
+    private repositionFrame;
+    private onChangeFn;
+    private onTouchedFn;
+    constructor();
+    /**
+     * Binds the click-outside and reposition listeners only for as long as the panel is
+     * open. Bound permanently — as host listeners were — every dropdown on the page runs a
+     * handler on every document click and every scroll frame, whether or not it is showing
+     * anything.
+     */
+    private bindWhileOpen;
+    ngDoCheck(): void;
+    writeValue(val: TValue | null): void;
+    registerOnChange(fn: (val: TValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Bound to `(focus)` on the trigger — only drives the float-label floated state. */
+    protected onFocusIn(): void;
+    /** Bound to `(blur)` on the trigger — only drives the float-label floated state. */
+    protected onFocusOut(): void;
+    protected toggle(): void;
+    protected open(): void;
+    protected close(): void;
+    /** Writes a new selection out to both the model and the attached form control. */
+    protected commitValue(next: TValue): void;
+    protected markTouched(): void;
+    private closeIfClickedOutside;
+    /**
+     * Coalesces bursts of scroll/resize events into one reposition per frame. Placement
+     * reads layout, so running it per event is what makes a scroll janky.
+     */
+    private scheduleReposition;
+    /** Jumps from the trigger into the option list on ArrowDown/ArrowUp while open. */
+    protected onTriggerArrowKeydown(event: Event): void;
+    protected onOptionKeydown(event: KeyboardEvent): void;
+    protected focusTrigger(): void;
+    /** Extra chrome stacked above the options (e.g. a select-all row), in px. */
+    protected extraPanelHeight(): number;
+    private enabledOptionElements;
+    private attachOverlay;
+    /**
+     * Reads the spacing tokens that feed the height estimate. Done once per open instead of
+     * on every scroll tick, because `getComputedStyle` forces a style recalculation and the
+     * tokens cannot change while the panel is on screen.
+     */
+    private refreshPanelMetrics;
+    /**
+     * Rough height, used only to choose up/down and to cap `max-height` before the panel
+     * has been laid out. Deliberately an estimate: measuring would require rendering the
+     * panel first, which is what we are trying to position. A resolvable `dropdownMaxHeight`
+     * replaces the row-count guess outright, since it is exact rather than estimated.
+     */
+    private estimatePanelHeight;
+    /**
+     * The trigger's own rect, not the whole component's — a label above it or an error
+     * message below it sit in normal document flow and are not part of what the panel needs
+     * to clear. This also keeps `appendToBody` placement consistent with the inline panel,
+     * which is already positioned purely relative to the trigger via CSS.
+     */
+    private triggerRect;
+    /** The stacking order the panel would have had if it were still inside the subtree. */
+    private resolvePanelZIndex;
+    private updatePlacement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogDropdownBase<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogDropdownBase<any, any>, never, never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "filterPosition": { "alias": "filterPosition"; "required": false; "isSignal": true; }; "filterEmptyMessage": { "alias": "filterEmptyMessage"; "required": false; "isSignal": true; }; "filterMatch": { "alias": "filterMatch"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dropdownDirection": { "alias": "dropdownDirection"; "required": false; "isSignal": true; }; "dropdownZIndex": { "alias": "dropdownZIndex"; "required": false; "isSignal": true; }; "dropdownWidth": { "alias": "dropdownWidth"; "required": false; "isSignal": true; }; "dropdownMaxHeight": { "alias": "dropdownMaxHeight"; "required": false; "isSignal": true; }; "appendToBody": { "alias": "appendToBody"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "chevronTemplate": { "alias": "chevronTemplate"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "floatLabel": { "alias": "floatLabel"; "required": false; "isSignal": true; }; "floatLabelShowPlaceholder": { "alias": "floatLabelShowPlaceholder"; "required": false; "isSignal": true; }; }, {}, ["chevronSlot", "optionSlot"], never, true, never>;
+}
+
+/**
+ * A text field that suggests options as you type.
+ *
+ * ```html
+ * <gog-autocomplete
+ *   [options]="users"
+ *   optionLabel="profile.fullName"
+ *   [optionValue]="null"
+ *   [(value)]="user"
+ *   (gogSearch)="load($event)"
+ *   [loading]="loading()"
+ * />
+ * ```
+ *
+ * Shares `GogDropdownBase` with `gog-select` — placement, the append-to-body overlay, the
+ * option accessors, float label, error state and `ControlValueAccessor` all come from there.
+ * What makes it a separate control rather than a mode of `gog-select` is the trigger: here it
+ * is a real `<input>`, which changes the ARIA contract completely. The input keeps DOM focus
+ * the whole time and the highlighted option is pointed at with `aria-activedescendant`, where
+ * a listbox moves focus onto the option itself.
+ */
+declare class AutocompleteComponent<TOption = GogDropdownOption, TValue = string | number | null> extends GogDropdownBase<TValue, TOption> {
+    readonly inputId: _angular_core.InputSignal<string>;
+    /**
+     * Two-way bindable selected value: `[(value)]="signal"`. Carries whatever `optionValue`
+     * resolves to — an id by default, or the option object itself when `optionValue` is `null`.
+     */
+    readonly value: _angular_core.ModelSignal<TValue>;
+    /**
+     * Whether to narrow `options` in the browser as the user types.
+     *
+     * Leave it on for a list you already hold. Turn it **off** when `gogSearch` fetches an
+     * already-filtered list from a server: filtering that answer a second time against the same
+     * query is the classic double-filtering bug, and it silently drops rows whose match the
+     * server found in a field this component cannot see.
+     */
+    readonly filterLocal: _angular_core.InputSignal<boolean>;
+    /** How many characters before the panel opens at all. */
+    readonly minLength: _angular_core.InputSignal<number | undefined>;
+    /** Milliseconds of quiet before `gogSearch` fires. `0` emits on every keystroke. */
+    readonly searchDebounce: _angular_core.InputSignal<number | undefined>;
+    /** Shows a spinner in the trailing slot — for a server-backed source that is still loading. */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    /** Shown in place of the list when nothing matches. */
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    /**
+     * Whether free text that matches no option is discarded when the field loses focus.
+     *
+     * On (the default) the field always ends up reflecting a real selection: editing is treated
+     * as transient, so the current `value` survives keystrokes and Escape or blur snaps the text
+     * back to it.
+     *
+     * Off, what the user typed is itself meaningful — a create-as-you-type flow. The text is left
+     * alone on blur and `value` is dropped as soon as it stops matching, so the two never
+     * disagree. Read the typed text from `gogSearch` rather than from `value`.
+     */
+    readonly forceSelection: _angular_core.InputSignal<boolean>;
+    /** The current query, debounced. Wire a server-side lookup to this. */
+    readonly gogSearch: _angular_core.OutputEmitterRef<string>;
+    protected readonly panelTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    /** A cleared autocomplete is `null`, whatever `TValue` the consumer bound. */
+    protected readonly emptyValue: TValue;
+    protected readonly optionClass = "gog-autocomplete__option";
+    protected readonly triggerClass = "gog-autocomplete__control";
+    protected readonly sizeBlockClass = "gog-autocomplete";
+    protected readonly panelBlockClass = "gog-autocomplete__dropdown";
+    /** Opt-in, matching `gog-select` and `gog-inputfield`. */
+    protected readonly clearableByDefault = false;
+    protected readonly optionGapToken = "--gog-autocomplete-option-gap";
+    protected readonly panelMaxHeightToken = "--gog-autocomplete-panel-max-height";
+    protected readonly optionHeightToken = "--gog-autocomplete-option-height";
+    private readonly config;
+    private readonly ownDestroyRef;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly listboxId: _angular_core.Signal<string>;
+    protected readonly labelId: _angular_core.Signal<string>;
+    protected readonly errorId: _angular_core.Signal<string | null>;
+    protected optionId(index: number): string;
+    protected readonly resolvedMinLength: _angular_core.Signal<number>;
+    private readonly resolvedDebounce;
+    /** What is actually in the `<input>`. Not the same thing as the committed `value`. */
+    protected readonly query: _angular_core.WritableSignal<string>;
+    /**
+     * Which option the arrows have highlighted. `-1` means none — Enter then does nothing rather
+     * than committing whichever row happened to be first, which is what stops a fast typist from
+     * selecting something they never looked at.
+     */
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly selectedOption: _angular_core.Signal<NonNullable<TOption> | null>;
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    protected readonly hasFloatValue: _angular_core.Signal<boolean>;
+    /**
+     * Local filtering, replacing the base's panel-filter behaviour: here the query comes from the
+     * trigger, not from a search box inside the panel. Overriding this rather than duplicating a
+     * second filtered list keeps the keyboard targets, the empty state and the panel height
+     * estimate all reading the same set.
+     */
+    protected readonly visibleOptions: _angular_core.Signal<TOption[]>;
+    protected readonly activeOptionId: _angular_core.Signal<string | null>;
+    private searchTimer;
+    constructor();
+    protected isSelected(option: TOption): boolean;
+    protected onInput(event: Event): void;
+    /**
+     * The input owns its arrow keys; the base's option-focusing handlers are deliberately not
+     * wired up here. Moving DOM focus into the list would take the caret out of the field, which
+     * is exactly what a combobox must not do.
+     */
+    protected onInputKeydown(event: KeyboardEvent): void;
+    protected onOptionClick(option: TOption, event: MouseEvent): void;
+    /**
+     * Keeps the caret in the field while an option is clicked. Without it the input blurs first,
+     * `forceSelection` wipes the text, and the click lands on a list that has already closed.
+     */
+    protected onOptionMousedown(event: MouseEvent): void;
+    protected onInputFocus(): void;
+    protected onInputBlur(): void;
+    protected close(): void;
+    /** Clearing has to empty the *text* as well; the base only knows about the value. */
+    protected clearValue(event: Event): void;
+    private pick;
+    /** Snaps the field back to whatever `value` holds — the empty string when nothing is picked. */
+    private restoreSelectedText;
+    private moveActive;
+    private setActive;
+    private scrollActiveIntoView;
+    private scheduleSearch;
+    private cancelPendingSearch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteComponent<any, any>, "gog-autocomplete", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "filterLocal": { "alias": "filterLocal"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "searchDebounce": { "alias": "searchDebounce"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "forceSelection": { "alias": "forceSelection"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "gogSearch": "gogSearch"; }, never, never, true, never>;
+}
+
+/**
+ * A count or status dot pinned to the corner of another element.
+ *
+ * ```html
+ * <gog-button gogBadge="12" badgeAriaLabel="12 непрочитанных">Входящие</gog-button>
+ * <gog-icon name="info" gogBadge badgeDot />
+ * ```
+ *
+ * A **directive, not a component**, because a badge decorates something that already exists —
+ * a button, an icon, an avatar. As a component it would have to wrap its host, which changes
+ * that host's layout, and it would duplicate `gog-tag` for the sake of one different radius.
+ *
+ * It renders **nothing at all** when the value is `0`, `null` or empty and `badgeDot` is off:
+ * a badge reading "0" is the defining bug of this component class, so it is not reachable.
+ */
+declare class GogBadgeDirective {
+    /** The badge content. Numbers above `badgeMax` render as `N+`. */
+    readonly gogBadge: _angular_core.InputSignal<string | number | null>;
+    readonly badgePosition: _angular_core.InputSignal<GogBadgePosition>;
+    /** Reuses the library's semantic colour set — the same four names `gog-tag` takes. */
+    readonly badgeVariant: _angular_core.InputSignal<GogTagVariant>;
+    /** Renders a bare dot with no text: "something changed here", with no count to give. */
+    readonly badgeDot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly badgeMax: _angular_core.InputSignal<number>;
+    /** Keeps the badge out of the DOM without removing the directive. */
+    readonly badgeHidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * What assistive tech should hear instead of the bare number.
+     *
+     * Left empty, the badge text is announced inline with the host's own label, which reads as
+     * "Входящие 12" — acceptable, and what Material does. Set this and the visible badge becomes
+     * `aria-hidden` while this wording is announced in its place, so the host reads as
+     * "Входящие, 12 непрочитанных" instead.
+     */
+    readonly badgeAriaLabel: _angular_core.InputSignal<string>;
+    private readonly hostRef;
+    private readonly renderer;
+    private readonly isBrowser;
+    private badgeEl;
+    private descriptionEl;
+    /** `0` and `''` count as "nothing to show" — see the class comment. */
+    private readonly hasContent;
+    protected readonly visible: _angular_core.Signal<boolean>;
+    protected readonly text: _angular_core.Signal<string>;
+    private readonly classNames;
+    constructor();
+    private render;
+    private removeDescription;
+    private teardown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogBadgeDirective, "[gogBadge]", never, { "gogBadge": { "alias": "gogBadge"; "required": false; "isSignal": true; }; "badgePosition": { "alias": "badgePosition"; "required": false; "isSignal": true; }; "badgeVariant": { "alias": "badgeVariant"; "required": false; "isSignal": true; }; "badgeDot": { "alias": "badgeDot"; "required": false; "isSignal": true; }; "badgeMax": { "alias": "badgeMax"; "required": false; "isSignal": true; }; "badgeHidden": { "alias": "badgeHidden"; "required": false; "isSignal": true; }; "badgeAriaLabel": { "alias": "badgeAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type GogIconName = 'check' | 'close' | 'chevron-up' | 'chevron-down' | 'chevron-left' | 'chevron-right' | 'calendar' | 'clock' | 'sort' | 'sort-up' | 'sort-down' | 'success' | 'error' | 'warning' | 'info' | 'checkbox' | 'checkbox-checked' | 'eye' | 'eye-off';
+declare const ICON_DEFS: Record<GogIconName, string>;
+
+declare class IconComponent {
+    private readonly sanitizer;
+    readonly name: _angular_core.InputSignal<GogIconName>;
+    readonly template: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly ariaHidden: _angular_core.InputSignal<boolean>;
+    protected readonly ariaLabel: _angular_core.Signal<string | null>;
+    protected readonly iconSvg: _angular_core.Signal<_angular_platform_browser.SafeHtml>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "gog-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "ariaHidden": { "alias": "ariaHidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Context handed to a `gogButtonToggleOption` template. */
+interface GogButtonToggleOptionContext<TOption> {
+    /** The consumer's own option object, untouched. */
+    $implicit: TOption;
+    selected: boolean;
+    disabled: boolean;
+    /** The resolved label, so custom markup can decorate it rather than re-derive it. */
+    label: string;
+}
+/**
+ * Custom markup for one button in the group:
+ *
+ * ```html
+ * <gog-button-toggle-group [options]="views">
+ *   <ng-template gogButtonToggleOption let-view let-selected="selected">
+ *     <gog-icon [name]="view.icon" /> {{ view.title }}
+ *   </ng-template>
+ * </gog-button-toggle-group>
+ * ```
+ */
+declare class GogButtonToggleOptionDirective<TOption = unknown> {
+    readonly templateRef: TemplateRef<GogButtonToggleOptionContext<TOption>>;
+    static ngTemplateContextGuard<TOption>(_dir: GogButtonToggleOptionDirective<TOption>, ctx: unknown): ctx is GogButtonToggleOptionContext<TOption>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogButtonToggleOptionDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogButtonToggleOptionDirective<any>, "[gogButtonToggleOption]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A row of buttons where one — or, with `multiple`, several — can be picked.
+ *
+ * ```html
+ * <gog-button-toggle-group [options]="alignments" [(value)]="align" />
+ * <gog-button-toggle-group [options]="tools" [multiple]="true" [(value)]="active" />
+ * ```
+ *
+ * Takes the consumer's own objects through `optionLabel` / `optionValue` / `optionDisabled`
+ * accessors — the same ones `gog-select` uses — rather than a fixed `{ id, label }` shape.
+ *
+ * **Single and multiple are different widgets to assistive tech, not a cosmetic switch.**
+ * Single mode is a radio group: `role="radiogroup"` / `role="radio"` with `aria-checked`, and
+ * the arrow keys move *and* select, because that is what a radio group does. Multiple mode is
+ * a toolbar of independent toggles: `role="group"` with `aria-pressed`, arrows only move and
+ * Space toggles. Getting this backwards is the usual defect in this component.
+ */
+declare class ButtonToggleGroupComponent<TOption = unknown, TValue = unknown> implements ControlValueAccessor {
+    readonly options: _angular_core.InputSignal<TOption[]>;
+    readonly optionLabel: _angular_core.InputSignal<GogOptionAccessor<TOption, string>>;
+    /**
+     * How an option turns into the emitted value. `null` emits the **option object itself**,
+     * exactly as `gog-select` does, so a consumer's DTO survives the round trip.
+     */
+    readonly optionValue: _angular_core.InputSignal<GogOptionAccessor<TOption, unknown> | null>;
+    readonly optionDisabled: _angular_core.InputSignal<GogOptionAccessor<TOption, boolean>>;
+    /** Optional leading icon per option. Unset means no icons anywhere in the group. */
+    readonly optionIcon: _angular_core.InputSignal<GogOptionAccessor<TOption, GogIconName | null> | null>;
+    /** Whether more than one option can be active at a time. */
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly appearance: _angular_core.InputSignal<GogButtonToggleAppearance>;
+    readonly orientation: _angular_core.InputSignal<GogOrientation>;
+    /** Unset, falls back to `GOG_CONFIG.control.size`, then to `'md'`. */
+    readonly size: _angular_core.InputSignal<GogSize | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Two-way bindable selection: `[(value)]="signal"`. A single value in single mode, an array
+     * in `multiple` mode. Also drivable through `formControl` / `formControlName`.
+     */
+    readonly value: _angular_core.ModelSignal<TValue | TValue[] | null>;
+    protected readonly optionSlot: _angular_core.Signal<GogButtonToggleOptionDirective<any> | undefined>;
+    private readonly buttonRefs;
+    private readonly ngControl;
+    private readonly cvaDisabled;
+    private readonly globalConfig;
+    /** Instance input → `GOG_CONFIG` → the component's own default. See `resolveConfigured`. */
+    protected readonly resolvedSize: _angular_core.Signal<GogSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /** The current selection as an array, whatever mode the group is in. */
+    private readonly selectedValues;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /**
+     * A roving tabindex: the group is one tab stop and the arrows move within it. The *selected*
+     * option is the one that keeps `tabindex="0"` so Tab returns to where the user left off;
+     * with nothing selected, the first enabled option takes it, since a group nobody can Tab
+     * into is unreachable by keyboard.
+     */
+    protected readonly tabStopIndex: _angular_core.Signal<number>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(val: TValue | TValue[] | null): void;
+    registerOnChange(fn: (val: TValue | TValue[] | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected labelOf(option: TOption): string;
+    protected iconOf(option: TOption): GogIconName | null;
+    protected valueOf(option: TOption): unknown;
+    protected isOptionDisabled(option: TOption): boolean;
+    protected isSelected(option: TOption): boolean;
+    protected optionContext(option: TOption): GogButtonToggleOptionContext<TOption>;
+    protected onOptionClick(option: TOption): void;
+    /**
+     * Arrow keys. In single mode moving also selects — that is the radio-group contract, and it
+     * is why `role="radio"` is only used there. In multiple mode the arrows are pure navigation
+     * and Space/Enter (handled natively by the `<button>`) does the toggling.
+     */
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onBlur(): void;
+    private commit;
+    private setValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonToggleGroupComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonToggleGroupComponent<any, any>, "gog-button-toggle-group", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "optionIcon": { "alias": "optionIcon"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["optionSlot"], never, true, never>;
+}
+
+/**
+ * Marks a tab's content as **lazy**: it is built the first time the tab is shown, and kept
+ * alive afterwards.
+ *
+ * ```html
+ * <gog-tab label="Отчёт">
+ *   <ng-template gogTabContent><app-expensive-report /></ng-template>
+ * </gog-tab>
+ * ```
+ *
+ * Without it, content written directly inside `<gog-tab>` renders immediately and is merely
+ * hidden while inactive — which is what you want for cheap content, because it preserves
+ * scroll position, un-submitted input and any state the DOM is holding. Which behaviour you
+ * get is decided by whether this template is present; there is no `lazy` input to keep in sync.
+ */
+declare class GogTabContentDirective {
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogTabContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogTabContentDirective, "[gogTabContent]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * One tab inside a `<gog-tabs>`. Declares its own header text and holds its own content.
+ *
+ * ```html
+ * <gog-tabs>
+ *   <gog-tab label="Профиль"><app-profile /></gog-tab>
+ *   <gog-tab label="Настройки" iconName="info" [disabled]="!canEdit">…</gog-tab>
+ * </gog-tabs>
+ * ```
+ */
+declare class TabComponent {
+    private static nextUid;
+    private readonly uid;
+    /** Header text. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Optional leading icon in the header. */
+    readonly iconName: _angular_core.InputSignal<GogIconName | null>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly panelId: string;
+    readonly headerId: string;
+    private readonly tabsState;
+    /** Identity comparison against the group's current tab — no index bookkeeping either side. */
+    readonly active: _angular_core.Signal<boolean>;
+    protected readonly lazySlot: _angular_core.Signal<GogTabContentDirective | undefined>;
+    /**
+     * Latches on first activation and never resets, so a lazy tab pays its build cost once and
+     * then behaves like an eager one — revisiting it does not rebuild the subtree or lose what
+     * the user typed into it.
+     */
+    private readonly everActivated;
+    protected readonly shouldRenderLazy: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabComponent, "gog-tab", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["lazySlot"], ["*"], true, never>;
+}
+
+/**
+ * What a `gog-tab` needs from the `gog-tabs` it sits in: which tab is currently showing.
+ *
+ * A token rather than injecting the component directly, purely to keep the import graph
+ * acyclic — `tabs.component.ts` has to import `TabComponent` for its `contentChildren`, so the
+ * tab cannot import the group back. Both sides depend on this file, which depends on neither.
+ */
+interface GogTabsState {
+    /** The active tab instance, compared by identity. `null` when the group has no tabs. */
+    readonly activeTab: Signal<unknown | null>;
+}
+declare const GOG_TABS_STATE: InjectionToken<GogTabsState>;
+
+/** Context handed to a `gogTabHeader` template. */
+interface GogTabHeaderContext {
+    /** The `gog-tab` this header belongs to. */
+    $implicit: TabComponent;
+    active: boolean;
+    disabled: boolean;
+    index: number;
+}
+/**
+ * Custom markup for a tab's header button:
+ *
+ * ```html
+ * <gog-tabs>
+ *   <ng-template gogTabHeader let-tab let-active="active">
+ *     {{ tab.label() }} <gog-tag *ngIf="active">•</gog-tag>
+ *   </ng-template>
+ *   <gog-tab label="Входящие">…</gog-tab>
+ * </gog-tabs>
+ * ```
+ */
+declare class GogTabHeaderDirective {
+    readonly templateRef: TemplateRef<GogTabHeaderContext>;
+    static ngTemplateContextGuard(_dir: GogTabHeaderDirective, ctx: unknown): ctx is GogTabHeaderContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogTabHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogTabHeaderDirective, "[gogTabHeader]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A tablist over projected `<gog-tab>` children.
+ *
+ * ```html
+ * <gog-tabs [(activeIndex)]="index" align="start">
+ *   <gog-tab label="Профиль"><app-profile /></gog-tab>
+ *   <gog-tab label="Настройки"><app-settings /></gog-tab>
+ * </gog-tabs>
+ * ```
+ *
+ * The header row is built from each tab's own `label` / `iconName` / `disabled`, so a tab is
+ * declared in exactly one place. Overflowing headers scroll inside a `<gog-scroll>` rather than
+ * a native `overflow-x`, per the library's styling contract — a native scrollbar is the one
+ * piece of chrome no `--gog-*` token can reach.
+ */
+declare class TabsComponent implements GogTabsState {
+    readonly tabs: _angular_core.Signal<readonly TabComponent[]>;
+    /** Two-way bindable index of the visible tab: `[(activeIndex)]="signal"`. */
+    readonly activeIndex: _angular_core.ModelSignal<number>;
+    readonly align: _angular_core.InputSignal<GogTabsAlign>;
+    readonly orientation: _angular_core.InputSignal<GogOrientation>;
+    readonly size: _angular_core.InputSignal<GogSize>;
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Emits the newly active index whenever it changes, including via keyboard. */
+    readonly gogTabChange: _angular_core.OutputEmitterRef<number>;
+    protected readonly headerSlot: _angular_core.Signal<GogTabHeaderDirective | undefined>;
+    private readonly headerRefs;
+    /**
+     * The index actually shown. Clamped, and never a disabled tab: `activeIndex` is a plain
+     * number a consumer can set to anything, and silently showing nothing would be worse than
+     * falling back to the nearest usable tab.
+     */
+    protected readonly resolvedIndex: _angular_core.Signal<number>;
+    /** Read by each `gog-tab` through `GOG_TABS_STATE`; see `tabs-state.ts`. */
+    readonly activeTab: _angular_core.Signal<TabComponent | null>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected selectIndex(index: number): void;
+    protected headerContext(tab: TabComponent, index: number): GogTabHeaderContext;
+    /**
+     * Arrows move focus and activate in one step — the "automatic activation" variant of the
+     * ARIA tabs pattern, which suits panels that are already in the DOM. Home/End jump to the
+     * first/last enabled tab.
+     */
+    protected onHeaderKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "gog-tabs", never, { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; "gogTabChange": "gogTabChange"; }, ["tabs", "headerSlot"], ["*"], true, never>;
+}
+
+/**
+ * Custom markup for the checkbox's tick:
+ *
+ * ```html
+ * <ng-template gogCheckboxIcon><my-icon /></ng-template>
+ * ```
+ */
+declare class GogCheckboxIconDirective {
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogCheckboxIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogCheckboxIconDirective, "[gogCheckboxIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class CheckboxComponent implements ControlValueAccessor {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Unset, falls back to `GOG_CONFIG.control.size`, then to `'md'`. */
+    readonly size: _angular_core.InputSignal<GogSize | undefined>;
+    readonly indeterminate: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project an `<ng-template gogCheckboxIcon>` into the component instead. Removed in 21.5.0.
+     */
+    readonly checkIconTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Projected `gogCheckboxIcon` template; wins over the deprecated `checkIconTemplate` input. */
+    protected readonly checkIconSlot: _angular_core.Signal<GogCheckboxIconDirective | undefined>;
+    /**
+     * Two-way bindable checked state: `[(checked)]="signal"`.
+     * This is the same state Angular Forms drives via `writeValue`/`registerOnChange`
+     * when the component is used with `formControlName`/`[formControl]`.
+     * Don't wire both a form directive AND `[(checked)]` to the same instance —
+     * pick one, otherwise you end up with two competing sources of truth.
+     */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    private readonly globalConfig;
+    /** Instance input → `GOG_CONFIG` → the component's own default. See `resolveConfigured`. */
+    protected readonly resolvedSize: _angular_core.Signal<GogSize>;
+    protected readonly controlSize: _angular_core.Signal<{
+        readonly boxSize: "var(--gog-control-checkbox-box-size-xsm, 12px)";
+        readonly labelSize: "var(--gog-control-checkbox-label-size-xsm, 0.6875rem)";
+        readonly indicatorSize: "var(--gog-control-checkbox-icon-size-xsm, 10px)";
+    } | {
+        readonly boxSize: "var(--gog-control-checkbox-box-size-sm, 18px)";
+        readonly labelSize: "var(--gog-control-checkbox-label-size-sm, 0.8125rem)";
+        readonly indicatorSize: "var(--gog-control-checkbox-icon-size-sm, 12px)";
+    } | {
+        readonly boxSize: "var(--gog-control-checkbox-box-size-md, 24px)";
+        readonly labelSize: "var(--gog-control-checkbox-label-size-md, 0.9375rem)";
+        readonly indicatorSize: "var(--gog-control-checkbox-icon-size-md, 14px)";
+    } | {
+        readonly boxSize: "var(--gog-control-checkbox-box-size-lg, 32px)";
+        readonly labelSize: "var(--gog-control-checkbox-label-size-lg, 1.0625rem)";
+        readonly indicatorSize: "var(--gog-control-checkbox-icon-size-lg, 18px)";
+    } | {
+        readonly boxSize: "var(--gog-control-checkbox-box-size-slg, 40px)";
+        readonly labelSize: "var(--gog-control-checkbox-label-size-slg, 1.1875rem)";
+        readonly indicatorSize: "var(--gog-control-checkbox-icon-size-slg, 22px)";
+    }>;
+    protected readonly boxSize: _angular_core.Signal<"var(--gog-control-checkbox-box-size-xsm, 12px)" | "var(--gog-control-checkbox-box-size-sm, 18px)" | "var(--gog-control-checkbox-box-size-md, 24px)" | "var(--gog-control-checkbox-box-size-lg, 32px)" | "var(--gog-control-checkbox-box-size-slg, 40px)">;
+    protected readonly checkboxPadding = "var(--gog-control-checkbox-padding, 6px)";
+    protected readonly labelSize: _angular_core.Signal<"var(--gog-control-checkbox-label-size-xsm, 0.6875rem)" | "var(--gog-control-checkbox-label-size-sm, 0.8125rem)" | "var(--gog-control-checkbox-label-size-md, 0.9375rem)" | "var(--gog-control-checkbox-label-size-lg, 1.0625rem)" | "var(--gog-control-checkbox-label-size-slg, 1.1875rem)">;
+    protected readonly iconSize: _angular_core.Signal<"var(--gog-control-checkbox-icon-size-xsm, 10px)" | "var(--gog-control-checkbox-icon-size-sm, 12px)" | "var(--gog-control-checkbox-icon-size-md, 14px)" | "var(--gog-control-checkbox-icon-size-lg, 18px)" | "var(--gog-control-checkbox-icon-size-slg, 22px)">;
+    private readonly ngControl;
+    private readonly cvaDisabled;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    writeValue(val: boolean): void;
+    registerOnChange(fn: (val: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInputChange(event: Event): void;
+    onBlur(): void;
+    private onCheckedChange;
+    private onTouched;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "gog-checkbox", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "checkIconTemplate": { "alias": "checkIconTemplate"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, ["checkIconSlot"], never, true, never>;
+}
+
+/**
+ * Every date calculation `gog-datepicker` and `gog-calendar` do, as pure functions.
+ *
+ * Kept out of the components so the arithmetic is testable without a fixture, and so a range
+ * calculation is written once rather than once per selection mode.
+ *
+ * **Everything here works in local time.** Nothing round-trips through `toISOString()` or
+ * compares `Date` objects directly: an ISO round trip converts to UTC, which moves the date
+ * across midnight for anyone east or west of Greenwich, and two `Date`s for "the same day"
+ * are almost never equal because they carry different times. Comparisons go through
+ * `startOfDay` and `isSameDay` instead. This is the single most common defect in a datepicker.
+ */
+/** A start/end pair. `end` is null while a range is half-picked. */
+interface GogDateRange {
+    start: Date | null;
+    end: Date | null;
+}
+/** Midnight local time on the same calendar day. */
+declare function startOfDay(date: Date): Date;
+/** Whether two dates fall on the same calendar day, ignoring the time of day. */
+declare function isSameDay(a: Date | null, b: Date | null): boolean;
+/** Whether two dates fall in the same calendar month. */
+declare function isSameMonth(a: Date | null, b: Date | null): boolean;
+declare function addDays(date: Date, days: number): Date;
+/** Days in a given month. `month` is 0-based, as `Date` uses it. */
+declare function daysInMonth(year: number, month: number): number;
+/**
+ * Adds whole months, **clamping the day** to the target month's length: 31 January plus one
+ * month is 28 February, not 3 March. `Date.setMonth` does the latter, which is why this is
+ * not a one-liner.
+ */
+declare function addMonths(date: Date, months: number): Date;
+declare function addYears(date: Date, years: number): Date;
+/** Day-granularity comparison: `a` is strictly before `b`'s day. */
+declare function isBeforeDay(a: Date, b: Date): boolean;
+/** Day-granularity comparison: `a` is strictly after `b`'s day. */
+declare function isAfterDay(a: Date, b: Date): boolean;
+/** Whether `date`'s day falls within `[min, max]`, either bound optional. */
+declare function isWithinBounds(date: Date, min: Date | null, max: Date | null): boolean;
+/** Whether `date`'s day falls inside a range, inclusive of both ends. */
+declare function isInRange(date: Date, start: Date | null, end: Date | null): boolean;
+/** Pulls `date` inside `[min, max]`, keeping its time of day. */
+declare function clampDate(date: Date, min: Date | null, max: Date | null): Date;
+/** A new date on `day`'s calendar day carrying `time`'s clock. */
+declare function copyTimeOnto(day: Date, time: Date): Date;
+/** A new date on the same day with the clock replaced. */
+declare function withTime(date: Date, hours: number, minutes: number, seconds?: number): Date;
+/**
+ * The six-week grid a month is drawn on, always 6×7 so the calendar's height never changes as
+ * you page through months — a grid that grows and shrinks pushes the rest of the page around
+ * and moves the button you were about to click.
+ *
+ * `firstDayOfWeek` is 0 (Sunday) to 6 (Saturday). Leading and trailing cells come from the
+ * neighbouring months, as every calendar does.
+ */
+declare function buildMonthGrid(year: number, month: number, firstDayOfWeek: number): Date[][];
+/** Weekday names in `locale`, rotated so `firstDayOfWeek` comes first. */
+declare function weekdayNames(locale: string, firstDayOfWeek: number, style?: 'short' | 'narrow' | 'long'): string[];
+/** Month names in `locale`. */
+declare function monthNames(locale: string, style?: 'long' | 'short'): string[];
+/**
+ * The first day of the week for a locale, from `Intl.Locale.prototype.getWeekInfo` where the
+ * engine has it, falling back to Monday.
+ *
+ * `getWeekInfo` reports 1–7 with 1 = Monday and 7 = Sunday; `Date.getDay()` uses 0 = Sunday.
+ * Converting between the two is exactly the kind of off-by-one that silently shifts a whole
+ * calendar by a day, which is why it happens here once.
+ */
+declare function localeFirstDayOfWeek(locale: string): number;
+/**
+ * Formats a date against a token pattern.
+ *
+ * Supported tokens: `yyyy`, `MM`, `dd`, `HH` (24h), `hh` (12h), `mm`, `ss`, `a` (AM/PM).
+ * Anything else is copied through literally.
+ *
+ * Deliberately **not** `Intl.DateTimeFormat`: this pattern is also what `parseDate` reads, and
+ * a formatter whose output cannot be parsed back is how a typed date silently becomes a
+ * different one. `Intl` is still used for month and weekday *names*, which are never parsed.
+ */
+declare function formatDate(date: Date, pattern: string): string;
+/**
+ * Reads a date back out of text written in `pattern`. Returns `null` when the text doesn't
+ * match, or matches but isn't a real date (`31.02.2026`).
+ *
+ * The out-of-range check matters: `new Date(2026, 1, 31)` happily rolls over to 3 March, so a
+ * typo would be accepted as a different date rather than rejected.
+ */
+declare function parseDate(text: string, pattern: string): Date | null;
+
+/** What `gog-calendar` and `gog-datepicker` carry, depending on `selectionMode`. */
+type GogDatepickerValue = Date | GogDateRange | null;
+/** One rendered day cell. Precomputed so the template stays free of logic. */
+interface GogCalendarDay {
+    date: Date;
+    label: string;
+    outside: boolean;
+    today: boolean;
+    disabled: boolean;
+    selected: boolean;
+    rangeStart: boolean;
+    rangeEnd: boolean;
+    inRange: boolean;
+}
+/**
+ * The month grid behind `gog-datepicker`, usable on its own for an always-visible calendar.
+ *
+ * ```html
+ * <gog-calendar [(value)]="date" [min]="today" />
+ * <gog-calendar selectionMode="range" [(value)]="range" [numberOfMonths]="2" />
+ * ```
+ *
+ * Split out from the field deliberately: `gog-datepicker` is three widgets (a date, a range
+ * and a time) behind one selector, and keeping the grid separate is what stops either half
+ * from becoming unreadable. It is also exactly what `inline` mode renders.
+ */
+declare class CalendarComponent {
+    /** Two-way bindable selection: a `Date` in `'single'` mode, a `GogDateRange` in `'range'`. */
+    readonly value: _angular_core.ModelSignal<GogDatepickerValue>;
+    readonly selectionMode: _angular_core.InputSignal<GogDateSelectionMode>;
+    readonly min: _angular_core.InputSignal<Date | null>;
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /**
+     * Extra exclusions, as a predicate rather than a list: an array cannot express "weekends"
+     * or "public holidays" without the consumer materialising every date in range first.
+     */
+    readonly disabledDates: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /** BCP-47 tag driving the month and weekday names. */
+    readonly locale: _angular_core.InputSignal<string>;
+    /** 0 = Sunday … 6 = Saturday. Unset, it comes from the locale. */
+    readonly firstDayOfWeek: _angular_core.InputSignal<number | null>;
+    /** Which month to open on when there is no selection yet. */
+    readonly defaultMonth: _angular_core.InputSignal<Date | null>;
+    /** How many months to show side by side. Two is what makes a range picker usable. */
+    readonly numberOfMonths: _angular_core.InputSignal<number>;
+    readonly showTime: _angular_core.InputSignal<boolean>;
+    readonly hourFormat: _angular_core.InputSignal<GogHourFormat>;
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    readonly showSeconds: _angular_core.InputSignal<boolean>;
+    /**
+     * The "Today" button, which **selects** today's date — the view follows, because the
+     * selection is what the calendar opens on.
+     *
+     * Kept separate from `showThisMonthButton` on purpose: one button that both selected and
+     * navigated read as "jump to today" to anyone who pressed it after paging away, and there is
+     * no wording that makes a single control unambiguous about which of the two it does.
+     */
+    readonly showTodayButton: _angular_core.InputSignal<boolean>;
+    /**
+     * The "This month" button, which only moves the *view* back to the current month and leaves
+     * the selection alone. Off by default — it is for browsing far from today without committing
+     * to anything, which is the rarer of the two needs.
+     */
+    readonly showThisMonthButton: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<GogSize>;
+    readonly todayLabel: _angular_core.InputSignal<string>;
+    readonly thisMonthLabel: _angular_core.InputSignal<string>;
+    readonly previousMonthLabel: _angular_core.InputSignal<string>;
+    readonly nextMonthLabel: _angular_core.InputSignal<string>;
+    readonly previousYearLabel: _angular_core.InputSignal<string>;
+    readonly nextYearLabel: _angular_core.InputSignal<string>;
+    /** Emitted when a selection is *complete* — a day in single mode, both ends of a range. */
+    readonly gogDateSelect: _angular_core.OutputEmitterRef<GogDatepickerValue>;
+    private readonly elRef;
+    /** First of the leftmost visible month. */
+    private readonly viewMonth;
+    /** The cell the keyboard is on, and the only one carrying `tabindex="0"`. */
+    protected readonly focusedDate: _angular_core.WritableSignal<Date>;
+    /** Drives the range preview while the second end is still being chosen. */
+    protected readonly hoverDate: _angular_core.WritableSignal<Date | null>;
+    /** Whether a focus move should also pull the DOM focus over — only after a keypress. */
+    private pendingFocus;
+    protected readonly resolvedFirstDayOfWeek: _angular_core.Signal<number>;
+    protected readonly weekdays: _angular_core.Signal<string[]>;
+    private readonly months;
+    private readonly range;
+    private readonly singleDate;
+    /** Start/end as currently *displayed*, including the end the pointer is hovering over. */
+    private readonly previewRange;
+    /** One entry per visible month; each is a 6×7 grid. */
+    protected readonly monthViews: _angular_core.Signal<{
+        label: string;
+        weeks: GogCalendarDay[][];
+    }[]>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /**
+     * Whether today can actually be picked — `min`, `max` or `disabledDates` may rule it out, and
+     * a "Today" button that silently does nothing is worse than one that is visibly unavailable.
+     * The signal reads inside `isDayDisabled` are what make this follow those inputs.
+     */
+    protected readonly isTodaySelectable: _angular_core.Signal<boolean>;
+    protected readonly timeSource: _angular_core.Signal<Date | null>;
+    protected readonly hours: _angular_core.Signal<number>;
+    protected readonly minutes: _angular_core.Signal<number>;
+    protected readonly seconds: _angular_core.Signal<number>;
+    protected readonly isPm: _angular_core.Signal<boolean>;
+    protected readonly maxHour: _angular_core.Signal<12 | 23>;
+    protected readonly minHour: _angular_core.Signal<0 | 1>;
+    constructor();
+    /** Steps the view by whole months or years. */
+    protected shiftView(months: number): void;
+    protected shiftViewYears(years: number): void;
+    protected onDayClick(day: GogCalendarDay): void;
+    protected onDayHover(day: GogCalendarDay): void;
+    protected onGridLeave(): void;
+    /**
+     * Selects today. The view needs no separate nudge: the selection is the anchor the calendar
+     * opens on, so moving it there moves the month too.
+     */
+    protected selectToday(): void;
+    /** Moves the view back to the current month, leaving the selection untouched. */
+    protected goToThisMonth(): void;
+    /**
+     * The ARIA grid pattern's keyboard contract: arrows by day, PageUp/PageDown by month,
+     * Shift + those by year, Home/End to the ends of the week. Movement is clamped into
+     * `[min, max]` so the caret cannot wander into a region nothing can be picked from.
+     */
+    protected onGridKeydown(event: KeyboardEvent): void;
+    protected onHourInput(event: Event): void;
+    protected onMinuteInput(event: Event): void;
+    protected onSecondInput(event: Event): void;
+    protected toggleMeridiem(): void;
+    private selectionAnchor;
+    private isDayDisabled;
+    private buildWeeks;
+    private select;
+    private commit;
+    private applyTime;
+    /**
+     * Moves the DOM focus onto the newly focused cell, but only after a key or button press —
+     * never in response to the selection changing, which would steal focus from whatever the
+     * consumer is doing elsewhere on the page.
+     */
+    private applyPendingFocus;
+    protected isFocusedDay(date: Date): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarComponent, "gog-calendar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "disabledDates": { "alias": "disabledDates"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "defaultMonth": { "alias": "defaultMonth"; "required": false; "isSignal": true; }; "numberOfMonths": { "alias": "numberOfMonths"; "required": false; "isSignal": true; }; "showTime": { "alias": "showTime"; "required": false; "isSignal": true; }; "hourFormat": { "alias": "hourFormat"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; "isSignal": true; }; "showThisMonthButton": { "alias": "showThisMonthButton"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "todayLabel": { "alias": "todayLabel"; "required": false; "isSignal": true; }; "thisMonthLabel": { "alias": "thisMonthLabel"; "required": false; "isSignal": true; }; "previousMonthLabel": { "alias": "previousMonthLabel"; "required": false; "isSignal": true; }; "nextMonthLabel": { "alias": "nextMonthLabel"; "required": false; "isSignal": true; }; "previousYearLabel": { "alias": "previousYearLabel"; "required": false; "isSignal": true; }; "nextYearLabel": { "alias": "nextYearLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "gogDateSelect": "gogDateSelect"; }, never, never, true, never>;
+}
+
+/**
+ * A date field with a calendar panel.
+ *
+ * ```html
+ * <gog-datepicker [(value)]="date" label="Дата рождения" [max]="today" />
+ * <gog-datepicker selectionMode="range" [(value)]="range" [numberOfMonths]="2" />
+ * <gog-datepicker [showTime]="true" hourFormat="24" [(value)]="when" />
+ * ```
+ *
+ * Native `Date`, no date library and no adapter abstraction: this package has zero runtime
+ * dependencies, and pulling one in for a single component would be the largest dependency
+ * decision it has ever made. `Intl` covers month and weekday names; the display/parse format is
+ * a token pattern (`dd.MM.yyyy`) so what is written can always be read back — see
+ * `date-utils.ts`, which also explains why nothing here goes near `toISOString()`.
+ *
+ * The calendar itself is `gog-calendar`, exported separately and usable on its own. `inline`
+ * mode is literally that component rendered without this field.
+ */
+declare class DatepickerComponent implements ControlValueAccessor, DoCheck {
+    private static nextUid;
+    protected readonly uid: number;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly selectionMode: _angular_core.InputSignal<GogDateSelectionMode>;
+    readonly min: _angular_core.InputSignal<Date | null>;
+    readonly max: _angular_core.InputSignal<Date | null>;
+    readonly disabledDates: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    readonly defaultMonth: _angular_core.InputSignal<Date | null>;
+    readonly numberOfMonths: _angular_core.InputSignal<number>;
+    readonly showTime: _angular_core.InputSignal<boolean>;
+    readonly hourFormat: _angular_core.InputSignal<GogHourFormat>;
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    readonly showSeconds: _angular_core.InputSignal<boolean>;
+    /** The "Today" button in the panel's footer, which **selects** today's date. */
+    readonly showTodayButton: _angular_core.InputSignal<boolean>;
+    /**
+     * A second footer button that only moves the *view* back to the current month, leaving the
+     * selection alone. Off by default; see `gog-calendar` for why the two are separate controls.
+     */
+    readonly showThisMonthButton: _angular_core.InputSignal<boolean>;
+    readonly todayLabel: _angular_core.InputSignal<string>;
+    readonly thisMonthLabel: _angular_core.InputSignal<string>;
+    /**
+     * Display and parse pattern (`dd.MM.yyyy`, `yyyy-MM-dd`, …). Left unset it is derived from
+     * `showTime`, so switching the time section on does not also require restating the format.
+     */
+    readonly format: _angular_core.InputSignal<string | null>;
+    /** Unset, falls back to `GOG_CONFIG.datepicker.locale`, then to `'en-US'`. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.datepicker.firstDayOfWeek`, then to the locale's own. */
+    readonly firstDayOfWeek: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Whether the date can be typed as well as picked. Typed text is parsed against `format`;
+     * text that isn't a real date leaves the value untouched and is reverted on blur, rather
+     * than silently resetting the field.
+     */
+    readonly allowTextInput: _angular_core.InputSignal<boolean>;
+    /** Renders the calendar directly, with no field and no panel. */
+    readonly inline: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean | undefined>;
+    readonly clearAriaLabel: _angular_core.InputSignal<string>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
+    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay | undefined>;
+    readonly size: _angular_core.InputSignal<GogSize | undefined>;
+    readonly floatLabel: _angular_core.InputSignal<GogFloatLabelVariant | undefined>;
+    readonly floatLabelShowPlaceholder: _angular_core.InputSignal<boolean | undefined>;
+    readonly appendToBody: _angular_core.InputSignal<boolean | undefined>;
+    readonly dropdownDirection: _angular_core.InputSignal<GogDropdownDirection | undefined>;
+    readonly dropdownZIndex: _angular_core.InputSignal<number | null>;
+    readonly openCalendarLabel: _angular_core.InputSignal<string>;
+    /** Two-way bindable value: a `Date` in `'single'` mode, a `GogDateRange` in `'range'`. */
+    readonly value: _angular_core.ModelSignal<GogDatepickerValue>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    private readonly elRef;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly destroyRef;
+    private readonly ngControl;
+    private readonly globalConfig;
+    private readonly overlay;
+    protected readonly panelTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    private readonly cvaDisabled;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly panelPlacement: _angular_core.WritableSignal<GogDropdownPlacement | null>;
+    protected readonly directionState: _angular_core.WritableSignal<"up" | "down">;
+    /** What is in the `<input>`; diverges from `value` only while the user is typing. */
+    protected readonly text: _angular_core.WritableSignal<string>;
+    /**
+     * Whether the user is part-way through typing a date.
+     *
+     * Deliberately **not** the same thing as "the field has focus": picking a date from the
+     * calendar hands focus back to the field, and keying the guard on focus meant the text was
+     * then refused — you would pick a date and watch the field stay empty.
+     */
+    private readonly isEditing;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly resolvedSize: _angular_core.Signal<GogSize>;
+    protected readonly resolvedErrorDisplay: _angular_core.Signal<GogErrorDisplay>;
+    protected readonly resolvedAppendToBody: _angular_core.Signal<boolean>;
+    protected readonly resolvedDirection: _angular_core.Signal<GogDropdownDirection>;
+    protected readonly resolvedLocale: _angular_core.Signal<string>;
+    protected readonly resolvedFirstDayOfWeek: _angular_core.Signal<number | null>;
+    /** Derived from `showTime` so turning the clock on doesn't also require a new format. */
+    protected readonly resolvedFormat: _angular_core.Signal<string>;
+    private readonly errorState;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly visibleError: _angular_core.Signal<string>;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    private readonly clearableState;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    private readonly floatLabelState;
+    protected readonly resolvedFloatLabel: _angular_core.Signal<GogFloatLabelVariant>;
+    protected readonly isFloatLabelActive: _angular_core.Signal<boolean>;
+    protected readonly isFloatLabelFloated: _angular_core.Signal<boolean>;
+    protected readonly effectivePlaceholder: _angular_core.Signal<string>;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly panelId: _angular_core.Signal<string>;
+    protected readonly labelId: _angular_core.Signal<string>;
+    protected readonly errorId: _angular_core.Signal<string | null>;
+    protected readonly sizeClass: _angular_core.Signal<string>;
+    /** How `value` reads in the field. A half-picked range shows only its start. */
+    protected readonly displayText: _angular_core.Signal<string>;
+    private onChangeFn;
+    private onTouchedFn;
+    private repositionFrame;
+    constructor();
+    ngDoCheck(): void;
+    writeValue(val: GogDatepickerValue): void;
+    registerOnChange(fn: (val: GogDatepickerValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected toggle(): void;
+    protected open(): void;
+    protected close(): void;
+    /** A completed selection closes the panel; a half-picked range leaves it open. */
+    protected onCalendarSelect(next: GogDatepickerValue): void;
+    /** Every calendar change, including the half-picked ones, has to reach the form. */
+    protected onCalendarValue(next: GogDatepickerValue): void;
+    protected onTextInput(event: Event): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected clearValue(event: Event): void;
+    protected focusTrigger(): void;
+    private commit;
+    /**
+     * Binds click-outside and reposition listeners only while the panel is open — bound
+     * permanently, every datepicker on the page would run a handler on every document click and
+     * every scroll frame whether or not it is showing anything.
+     */
+    private bindWhileOpen;
+    private closeIfClickedOutside;
+    private scheduleReposition;
+    private updatePlacement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatepickerComponent, "gog-datepicker", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "disabledDates": { "alias": "disabledDates"; "required": false; "isSignal": true; }; "defaultMonth": { "alias": "defaultMonth"; "required": false; "isSignal": true; }; "numberOfMonths": { "alias": "numberOfMonths"; "required": false; "isSignal": true; }; "showTime": { "alias": "showTime"; "required": false; "isSignal": true; }; "hourFormat": { "alias": "hourFormat"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; "isSignal": true; }; "showThisMonthButton": { "alias": "showThisMonthButton"; "required": false; "isSignal": true; }; "todayLabel": { "alias": "todayLabel"; "required": false; "isSignal": true; }; "thisMonthLabel": { "alias": "thisMonthLabel"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "allowTextInput": { "alias": "allowTextInput"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "floatLabel": { "alias": "floatLabel"; "required": false; "isSignal": true; }; "floatLabelShowPlaceholder": { "alias": "floatLabelShowPlaceholder"; "required": false; "isSignal": true; }; "appendToBody": { "alias": "appendToBody"; "required": false; "isSignal": true; }; "dropdownDirection": { "alias": "dropdownDirection"; "required": false; "isSignal": true; }; "dropdownZIndex": { "alias": "dropdownZIndex"; "required": false; "isSignal": true; }; "openCalendarLabel": { "alias": "openCalendarLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * A rule separating two regions, optionally with a label running through it.
+ *
+ * ```html
+ * <gog-divider />
+ * <gog-divider orientation="vertical" />
+ * <gog-divider>ИЛИ</gog-divider>
+ * ```
+ *
+ * The label is projected content rather than a `label` input: it is markup, so a consumer can
+ * put an icon or a `<gog-tag>` in it without the component growing an input per case. There is
+ * no `hasLabel` input either — the stylesheet keys off whether anything was actually projected,
+ * so the two forms above are the whole API.
+ */
+declare class DividerComponent {
+    readonly orientation: _angular_core.InputSignal<GogOrientation>;
+    readonly variant: _angular_core.InputSignal<GogDividerVariant>;
+    /**
+     * Indents the rule from the leading edge so it lines up with the *text* of a list whose rows
+     * start with an icon or avatar, instead of cutting across the whole row.
+     */
+    readonly inset: _angular_core.InputSignal<boolean>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DividerComponent, "gog-divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A horizontal progress indicator.
+ *
+ * ```html
+ * <gog-progressbar [value]="42" />
+ * <gog-progressbar mode="indeterminate" ariaLabel="Загрузка" />
+ * <gog-progressbar mode="buffer" [value]="42" [buffer]="70" />
+ * ```
+ *
+ * `value` and `buffer` are percentages and are clamped to 0–100 rather than trusted: a bar
+ * driven straight from `loaded / total` overshoots on the last chunk often enough that
+ * clamping here is worth more than letting the caller find out from a broken layout.
+ */
+declare class ProgressbarComponent {
+    protected readonly MIN = 0;
+    protected readonly MAX = 100;
+    /** Percentage complete, 0–100. Ignored in `'indeterminate'` mode. */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Secondary level shown behind `value` in `'buffer'` mode — preloaded but not yet played. */
+    readonly buffer: _angular_core.InputSignal<number>;
+    readonly mode: _angular_core.InputSignal<GogProgressbarMode>;
+    readonly variant: _angular_core.InputSignal<GogProgressbarVariant>;
+    readonly size: _angular_core.InputSignal<GogSize>;
+    /** Renders the percentage next to the bar. Off by default — most bars sit under a label. */
+    readonly showValue: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly isIndeterminate: _angular_core.Signal<boolean>;
+    protected readonly clampedValue: _angular_core.Signal<number>;
+    protected readonly clampedBuffer: _angular_core.Signal<number>;
+    protected readonly displayValue: _angular_core.Signal<string>;
+    /** The fill is driven to 100% in indeterminate mode; the animation moves it, not the width. */
+    protected readonly fillPercent: _angular_core.Signal<number>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressbarComponent, "gog-progressbar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "buffer": { "alias": "buffer"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * An on/off switch.
+ *
+ * ```html
+ * <gog-toggle label="Уведомления" [(checked)]="on" />
+ * <gog-toggle formControlName="darkMode" onLabel="ВКЛ" offLabel="ВЫКЛ" />
+ * ```
+ *
+ * Next to `gog-checkbox` rather than a variant of it, because the two answer different
+ * questions. A checkbox is "is this one of the things you selected"; a switch is "is this
+ * setting on", takes effect immediately, and announces as **"switch, on"** rather than
+ * "checkbox, checked". That announcement comes from `role="switch"` on a native
+ * `<input type="checkbox">`, so keyboard, forms and assistive tech all still come from the
+ * platform — only the painting differs.
+ */
+declare class ToggleComponent implements ControlValueAccessor {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Unset, falls back to `GOG_CONFIG.control.size`, then to `'md'`. */
+    readonly size: _angular_core.InputSignal<GogSize | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    /** Which side of the switch the label sits on. */
+    readonly labelPosition: _angular_core.InputSignal<"start" | "end">;
+    /**
+     * Text rendered *inside* the track — the one thing a checkbox genuinely cannot do, and what
+     * makes a switch readable at a glance in a dense settings list. Both must be short; the
+     * track sizes to the wider of the two.
+     */
+    readonly onLabel: _angular_core.InputSignal<string>;
+    readonly offLabel: _angular_core.InputSignal<string>;
+    /**
+     * Two-way bindable on/off state: `[(checked)]="signal"`.
+     * This is the same state Angular Forms drives via `writeValue`/`registerOnChange`
+     * when the component is used with `formControlName`/`[formControl]`.
+     * Don't wire both a form directive AND `[(checked)]` to the same instance —
+     * pick one, otherwise you end up with two competing sources of truth.
+     */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    private readonly ngControl;
+    private readonly cvaDisabled;
+    private readonly globalConfig;
+    /** Instance input → `GOG_CONFIG` → the component's own default. See `resolveConfigured`. */
+    protected readonly resolvedSize: _angular_core.Signal<GogSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly hasTrackLabels: _angular_core.Signal<boolean>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    constructor();
+    writeValue(val: boolean): void;
+    registerOnChange(fn: (val: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onInputChange(event: Event): void;
+    protected onBlur(): void;
+    private onCheckedChange;
+    private onTouched;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleComponent, "gog-toggle", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "onLabel": { "alias": "onLabel"; "required": false; "isSignal": true; }; "offLabel": { "alias": "offLabel"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
+}
+
+/** A single choice in a `gog-radio-group`. */
+interface GogRadioOption {
+    id: string | number;
+    label: string;
+    disabled?: boolean;
+}
+declare class RadioGroupComponent implements ControlValueAccessor {
+    private static nextUid;
+    protected readonly uid: string;
+    readonly options: _angular_core.InputSignal<GogRadioOption[]>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Shared `name` for the underlying native radios. Auto-generated per instance if unset. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Unset, falls back to `GOG_CONFIG.control.size`, then to `'md'`. */
+    readonly size: _angular_core.InputSignal<GogSize | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly orientation: _angular_core.InputSignal<GogOrientation>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
+    /** See `GogErrorDisplay`. Defaults to `'manual'`, matching every other control in the library. */
+    /** Unset, falls back to `GOG_CONFIG.control.errorDisplay`, then to `'manual'`. */
+    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay | undefined>;
     readonly fullWidth: _angular_core.InputSignal<boolean>;
-    readonly checkIconTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    /**
-     * Two-way bindable checked state: `[(checked)]="signal"`.
-     * This is the same state Angular Forms drives via `writeValue`/`registerOnChange`
-     * when the component is used with `formControlName`/`[formControl]`/`ngModel`.
-     * Don't wire both a form directive AND `[(checked)]` to the same instance —
-     * pick one, otherwise you end up with two competing sources of truth.
-     */
-    readonly checked: _angular_core.ModelSignal<boolean>;
+    /** Two-way bindable selected option id: `[(value)]="signal"`. */
+    readonly value: _angular_core.ModelSignal<string | number | null>;
+    private readonly ngControl;
+    private readonly cvaDisabled;
+    private readonly globalConfig;
+    /** Instance input → `GOG_CONFIG` → the component's own default. See `resolveConfigured`. */
+    protected readonly resolvedSize: _angular_core.Signal<GogSize>;
+    private readonly resolvedErrorDisplay;
+    private readonly errorState;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly controlSize: _angular_core.Signal<{
         readonly boxSize: "var(--gog-control-checkbox-box-size-xsm, 12px)";
         readonly labelSize: "var(--gog-control-checkbox-label-size-xsm, 0.6875rem)";
@@ -182,21 +1814,26 @@ declare class CheckboxComponent implements ControlValueAccessor {
         readonly indicatorSize: "var(--gog-control-checkbox-icon-size-slg, 22px)";
     }>;
     protected readonly boxSize: _angular_core.Signal<"var(--gog-control-checkbox-box-size-xsm, 12px)" | "var(--gog-control-checkbox-box-size-sm, 18px)" | "var(--gog-control-checkbox-box-size-md, 24px)" | "var(--gog-control-checkbox-box-size-lg, 32px)" | "var(--gog-control-checkbox-box-size-slg, 40px)">;
-    protected readonly checkboxPadding = "var(--gog-control-checkbox-padding, 6px)";
     protected readonly labelSize: _angular_core.Signal<"var(--gog-control-checkbox-label-size-xsm, 0.6875rem)" | "var(--gog-control-checkbox-label-size-sm, 0.8125rem)" | "var(--gog-control-checkbox-label-size-md, 0.9375rem)" | "var(--gog-control-checkbox-label-size-lg, 1.0625rem)" | "var(--gog-control-checkbox-label-size-slg, 1.1875rem)">;
-    protected readonly iconSize: _angular_core.Signal<"var(--gog-control-checkbox-icon-size-xsm, 10px)" | "var(--gog-control-checkbox-icon-size-sm, 12px)" | "var(--gog-control-checkbox-icon-size-md, 14px)" | "var(--gog-control-checkbox-icon-size-lg, 18px)" | "var(--gog-control-checkbox-icon-size-slg, 22px)">;
-    private readonly cvaDisabled;
-    protected readonly isDisabled: _angular_core.Signal<boolean>;
-    writeValue(val: boolean): void;
-    registerOnChange(fn: (val: boolean) => void): void;
+    protected readonly radioPadding = "var(--gog-control-checkbox-padding, 6px)";
+    protected readonly groupName: _angular_core.Signal<string>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly visibleError: _angular_core.Signal<string>;
+    protected readonly errorId: _angular_core.Signal<string | null>;
+    protected readonly labelId: _angular_core.Signal<string | null>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(val: string | number | null): void;
+    registerOnChange(fn: (val: string | number | null) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
-    onInputChange(event: Event): void;
-    onBlur(): void;
-    private onCheckedChange;
-    private onTouched;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "gog-checkbox", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "checkIconTemplate": { "alias": "checkIconTemplate"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
+    protected isOptionDisabled(option: GogRadioOption): boolean;
+    protected isSelected(option: GogRadioOption): boolean;
+    protected onOptionChange(event: Event, option: GogRadioOption): void;
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent, "gog-radio-group", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
 interface ConfirmDialogData {
@@ -216,21 +1853,6 @@ declare class ConfirmationDialogComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmationDialogComponent, "gog-confirmation-dialog", never, {}, {}, never, never, true, never>;
 }
 
-type GogIconName = 'check' | 'close' | 'chevron-up' | 'chevron-down' | 'sort' | 'sort-up' | 'sort-down' | 'success' | 'error' | 'warning' | 'info' | 'checkbox' | 'checkbox-checked' | 'eye' | 'eye-off';
-declare const ICON_DEFS: Record<GogIconName, string>;
-
-declare class IconComponent {
-    private readonly sanitizer;
-    readonly name: _angular_core.InputSignal<GogIconName>;
-    readonly template: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    readonly title: _angular_core.InputSignal<string>;
-    readonly ariaHidden: _angular_core.InputSignal<boolean>;
-    protected readonly ariaLabel: _angular_core.Signal<string | null>;
-    protected readonly iconSvg: _angular_core.Signal<_angular_platform_browser.SafeHtml>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "gog-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "ariaHidden": { "alias": "ariaHidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
 interface DialogConfig {
     title?: string;
     component: Type<unknown>;
@@ -345,6 +1967,11 @@ interface ToastConfig {
 }
 declare class ToastService {
     readonly toasts: _angular_core.WritableSignal<Toast[]>;
+    /**
+     * Read once at construction rather than per `show()` call: this is a root-provided singleton,
+     * so the config it resolves against cannot change over its lifetime anyway.
+     */
+    private readonly globalConfig;
     private generateId;
     show(config: ToastConfig): string;
     dismiss(id: string): void;
@@ -414,30 +2041,62 @@ declare class ToastContainerComponent {
 }
 
 /**
- * `'manual'` (default): the field shows `errorMessage` for as long as it is non-empty — the
- * consumer decides when to clear it, e.g.
- * `errorMessage="control.invalid && control.touched ? 'Required' : ''"`.
+ * Arbitrary markup in the field's leading slot — an icon, a button, a prefix label:
  *
- * `'auto'`: shown once the attached form control has been touched and is invalid — the
- * consumer only supplies the message text, not the timing. Requires a
- * `[formControl]` / `formControlName` / `ngModel` on the element; without one this falls
- * back to `'manual'`, since there is no control state to key off.
+ * ```html
+ * <gog-inputfield label="Amount">
+ *   <span gogInputAddonStart>€</span>
+ * </gog-inputfield>
+ *
+ * <gog-inputfield label="Search">
+ *   <button gogInputAddonStart type="button" aria-label="Search" (click)="run()">
+ *     <gog-icon name="check" />
+ *   </button>
+ * </gog-inputfield>
+ * ```
+ *
+ * Unlike the deprecated `iconStartTemplate` / `iconStartFn` / `iconStartLabel` trio this
+ * replaces, the projected element is a normal DOM element: it carries its own `aria-label`,
+ * its own click handler, and its own disabled state, so the component needs no input per
+ * capability. `iconStart` — a bare icon name — stays, since that really is the common case.
  */
-type GogErrorDisplay = 'auto' | 'manual';
-
+declare class GogInputAddonStartDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogInputAddonStartDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogInputAddonStartDirective, "[gogInputAddonStart]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Arbitrary markup in the field's trailing slot — see `GogInputAddonStartDirective`.
+ *
+ * On `type="password"` the built-in show/hide toggle owns this slot and a projected end addon
+ * is ignored, so the reveal control can never be accidentally replaced by a decorative one.
+ */
+declare class GogInputAddonEndDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogInputAddonEndDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogInputAddonEndDirective, "[gogInputAddonEnd]", never, {}, {}, never, never, true, never>;
+}
 declare class InputfieldComponent implements ControlValueAccessor, DoCheck {
     readonly label: _angular_core.InputSignal<string>;
     readonly placeholder: _angular_core.InputSignal<string>;
-    readonly type: _angular_core.InputSignal<"text" | "password" | "email">;
+    readonly type: _angular_core.InputSignal<"number" | "text" | "password" | "email" | "date">;
     /** Defaults to 'current-password' for password fields, 'off' otherwise */
     readonly autocomplete: _angular_core.InputSignal<string>;
+    /** Only applied when `type="number"`. */
+    readonly min: _angular_core.InputSignal<number | null>;
+    /** Only applied when `type="number"`. */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Only applied when `type="number"`. */
+    readonly step: _angular_core.InputSignal<number | null>;
     readonly errorMessage: _angular_core.InputSignal<string>;
-    /** See `GogErrorDisplay`. Defaults to `'manual'`, matching every other control in the library. */
-    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay>;
+    /**
+     * See `GogErrorDisplay`. Unset, falls back to `GOG_CONFIG.control.errorDisplay`, then to
+     * `'manual'` — matching every other control in the library.
+     */
+    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay | undefined>;
     readonly name: _angular_core.InputSignal<string>;
     readonly inputId: _angular_core.InputSignal<string>;
     readonly disabled: _angular_core.InputSignal<boolean>;
-    readonly size: _angular_core.InputSignal<GogSize>;
+    /** Unset, falls back to `GOG_CONFIG.control.size`, then to `'md'`. */
+    readonly size: _angular_core.InputSignal<GogSize | undefined>;
     /**
      * Full width of the container by default, matching every other field-style control.
      * Set to `false` to shrink the field to fit its content instead.
@@ -447,284 +2106,281 @@ declare class InputfieldComponent implements ControlValueAccessor, DoCheck {
     readonly iconStart: _angular_core.InputSignal<"" | GogIconName>;
     /** Default icon name for the trailing icon. */
     readonly iconEnd: _angular_core.InputSignal<"" | GogIconName>;
-    /** Custom leading icon template. */
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project a `<span gogInputAddonStart>` element instead. Removed in 21.5.0.
+     */
     readonly iconStartTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    /** Custom trailing icon template. */
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project a `<span gogInputAddonEnd>` element instead. Removed in 21.5.0.
+     */
     readonly iconEndTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    /** When provided, the start icon becomes a clickable button invoking this fn */
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project a `<button gogInputAddonStart>` element instead. Removed in 21.5.0. A projected button carries its own
+     * `(click)` handler, so no input is needed for it.
+     */
     readonly iconStartFn: _angular_core.InputSignal<(() => void) | null>;
-    /** When provided, the end icon becomes a clickable button invoking this fn */
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project a `<button gogInputAddonEnd>` element instead. Removed in 21.5.0. A projected button carries its own
+     * `(click)` handler, so no input is needed for it.
+     */
     readonly iconEndFn: _angular_core.InputSignal<(() => void) | null>;
-    /** aria-label for the start icon button (required when iconStartFn is set) */
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project a `<button gogInputAddonStart>` element instead. Removed in 21.5.0. Put `aria-label` on that button.
+     */
     readonly iconStartLabel: _angular_core.InputSignal<string>;
-    /** aria-label for the end icon button (required when iconEndFn is set) */
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project a `<button gogInputAddonEnd>` element instead. Removed in 21.5.0. Put `aria-label` on that button.
+     */
     readonly iconEndLabel: _angular_core.InputSignal<string>;
     /** aria-label for the reveal-password button, shown when `type` is `'password'` */
     readonly showPasswordLabel: _angular_core.InputSignal<string>;
     /** aria-label for the hide-password button, shown once the password is revealed */
     readonly hidePasswordLabel: _angular_core.InputSignal<string>;
-    /** Two-way bindable value: `[(value)]="signal"` or `[value]` / `(valueChange)`. */
+    /**
+     * Whether to offer a clear button once the field has text. Unset, falls back to
+     * `GOG_CONFIG.control.clearable`, then to `false`.
+     */
+    readonly clearable: _angular_core.InputSignal<boolean | undefined>;
+    /** Accessible name for the clear button. */
+    readonly clearAriaLabel: _angular_core.InputSignal<string>;
+    /** Unset, falls back to `GOG_CONFIG.floatLabel.variant`, then to `'none'` (off). */
+    readonly floatLabel: _angular_core.InputSignal<GogFloatLabelVariant | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.floatLabel.showPlaceholder`, then to `false`. */
+    readonly floatLabelShowPlaceholder: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Two-way bindable value: `[(value)]="signal"` or `[value]` / `(valueChange)`.
+     * Always a string, including for `type="number"` — that field's `formControl`/
+     * `formControlName` value is a `number` (or `null` when empty); the string here is only
+     * the raw text shown in the native input.
+     */
     readonly value: _angular_core.ModelSignal<string>;
     private readonly ngControl;
+    private readonly globalConfig;
     private readonly cvaDisabled;
+    /** Instance input → `GOG_CONFIG` → the component's own default. See `resolveConfigured`. */
+    protected readonly resolvedSize: _angular_core.Signal<GogSize>;
+    private readonly resolvedErrorDisplay;
     private readonly errorState;
     private readonly passwordVisible;
+    /** Set from `(focus)`/`(blur)` on the `<input>` — see `onFocus`/`onBlur`. */
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    /**
+     * The single size modifier, replacing one `[class.gog-input-wrapper--<size>]` binding per size.
+     * Empty for `'md'`: that is this component's default size and has no modifier rule of its own — every `gog-input-wrapper--*` chain bottoms out at it.
+     */
+    protected readonly sizeClass: _angular_core.Signal<string>;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly isPasswordField: _angular_core.Signal<boolean>;
-    protected readonly effectiveType: _angular_core.Signal<"text" | "password" | "email">;
+    protected readonly isNumberField: _angular_core.Signal<boolean>;
+    protected readonly effectiveType: _angular_core.Signal<"number" | "text" | "password" | "email" | "date">;
     protected readonly effectiveAutocomplete: _angular_core.Signal<string>;
     protected readonly hasError: _angular_core.Signal<boolean>;
     protected readonly visibleError: _angular_core.Signal<string>;
-    protected readonly hasIconStart: _angular_core.Signal<boolean>;
-    protected readonly hasIconStartAction: _angular_core.Signal<boolean>;
-    /** For password fields the trailing icon is always the built-in show/hide toggle. */
-    protected readonly effectiveIconEnd: _angular_core.Signal<"" | GogIconName>;
-    protected readonly effectiveIconEndLabel: _angular_core.Signal<string>;
-    protected readonly hasIconEnd: _angular_core.Signal<boolean>;
-    protected readonly hasIconEndAction: _angular_core.Signal<boolean>;
-    private _onChange;
-    private _onTouched;
-    constructor();
-    ngDoCheck(): void;
-    writeValue(val: string): void;
-    registerOnChange(fn: (val: string) => void): void;
-    registerOnTouched(fn: () => void): void;
-    setDisabledState(isDisabled: boolean): void;
-    protected onIconStartClick(): void;
-    protected onIconEndClick(): void;
-    onInput(event: Event): void;
-    onBlur(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputfieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputfieldComponent, "gog-inputfield", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "iconStart": { "alias": "iconStart"; "required": false; "isSignal": true; }; "iconEnd": { "alias": "iconEnd"; "required": false; "isSignal": true; }; "iconStartTemplate": { "alias": "iconStartTemplate"; "required": false; "isSignal": true; }; "iconEndTemplate": { "alias": "iconEndTemplate"; "required": false; "isSignal": true; }; "iconStartFn": { "alias": "iconStartFn"; "required": false; "isSignal": true; }; "iconEndFn": { "alias": "iconEndFn"; "required": false; "isSignal": true; }; "iconStartLabel": { "alias": "iconStartLabel"; "required": false; "isSignal": true; }; "iconEndLabel": { "alias": "iconEndLabel"; "required": false; "isSignal": true; }; "showPasswordLabel": { "alias": "showPasswordLabel"; "required": false; "isSignal": true; }; "hidePasswordLabel": { "alias": "hidePasswordLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
-}
-
-declare class ChipComponent {
-    readonly size: _angular_core.InputSignal<GogSize>;
-    readonly shape: _angular_core.InputSignal<GogTagShape>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    readonly clickable: _angular_core.InputSignal<boolean>;
-    readonly removable: _angular_core.InputSignal<boolean>;
-    readonly fullWidth: _angular_core.InputSignal<boolean>;
-    readonly ariaLabel: _angular_core.InputSignal<string>;
-    readonly removeAriaLabel: _angular_core.InputSignal<string>;
-    readonly avatarUrl: _angular_core.InputSignal<string | null>;
-    readonly avatarAlt: _angular_core.InputSignal<string>;
-    readonly iconName: _angular_core.InputSignal<GogIconName | null>;
-    readonly gogClick: _angular_core.OutputEmitterRef<MouseEvent | KeyboardEvent>;
-    readonly gogRemove: _angular_core.OutputEmitterRef<void>;
-    protected readonly hostClasses: _angular_core.Signal<string>;
-    protected readonly isInteractive: _angular_core.Signal<boolean>;
-    protected onChipClick(event: MouseEvent): void;
-    protected onKeydown(event: KeyboardEvent): void;
-    protected onRemoveClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipComponent, "gog-chip", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "removeAriaLabel": { "alias": "removeAriaLabel"; "required": false; "isSignal": true; }; "avatarUrl": { "alias": "avatarUrl"; "required": false; "isSignal": true; }; "avatarAlt": { "alias": "avatarAlt"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; }, { "gogClick": "gogClick"; "gogRemove": "gogRemove"; }, never, ["*"], true, never>;
-}
-
-declare class TagComponent {
-    readonly variant: _angular_core.InputSignal<GogTagVariant>;
-    readonly size: _angular_core.InputSignal<GogSize>;
-    readonly shape: _angular_core.InputSignal<GogTagShape>;
-    readonly iconName: _angular_core.InputSignal<GogIconName | null>;
-    readonly iconTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    readonly fullWidth: _angular_core.InputSignal<boolean>;
-    protected readonly hasIcon: _angular_core.Signal<boolean>;
-    protected readonly hostClasses: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "gog-tag", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "iconTemplate": { "alias": "iconTemplate"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
-}
-
-type GogDropdownDirection = 'auto' | 'up' | 'down';
-interface GogDropdownPlacement {
-    direction: 'up' | 'down';
-    top: number;
-    left: number;
-    width: number;
-    maxHeight: number;
-}
-
-/** A single choice in any of the listbox-style controls (`gog-select`, `gog-multiselect`). */
-interface GogDropdownOption {
-    id: string | number;
-    name: string;
-    disabled?: boolean;
-}
-/**
- * Shared behaviour for the listbox-style controls: open/close, placement, the
- * append-to-body overlay, click-outside, keyboard navigation and `ControlValueAccessor`
- * plumbing. Subclasses supply only what actually differs — the value type, the panel
- * markup, and the BEM class names used to find the trigger and the options.
- *
- * Exported because it appears in the public type signatures of the components that
- * extend it; it is not meant to be used or subclassed by consumers.
- */
-declare abstract class GogDropdownBase<TValue> implements ControlValueAccessor, DoCheck {
-    private static nextUid;
-    readonly label: _angular_core.InputSignal<string>;
-    readonly ariaLabel: _angular_core.InputSignal<string>;
-    readonly placeholder: _angular_core.InputSignal<string>;
-    readonly options: _angular_core.InputSignal<GogDropdownOption[]>;
-    readonly errorMessage: _angular_core.InputSignal<string>;
-    /** See `GogErrorDisplay`. Defaults to `'manual'`, matching every other control in the library. */
-    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay>;
-    readonly size: _angular_core.InputSignal<GogSize>;
-    readonly dropdownDirection: _angular_core.InputSignal<GogDropdownDirection>;
-    /**
-     * Explicit stacking order for the panel. Left unset the panel falls back to the
-     * stylesheet's `--gog-dropdown-z`, so the default lives in CSS where a consumer can
-     * retheme it, rather than being baked into the component.
-     */
-    readonly dropdownZIndex: _angular_core.InputSignal<number | null>;
-    /**
-     * Fixed panel width as any CSS length (`'320px'`, `'40ch'`, `'100%'`, …), applied only
-     * when `appendToBody` is set. Left unset the panel matches the trigger's width, same as
-     * the inline panel already does via CSS.
-     */
-    readonly dropdownWidth: _angular_core.InputSignal<string | null>;
-    /**
-     * Fixed panel max-height as any CSS length, applied only when `appendToBody` is set.
-     * `px`, `%` and `vh` also feed the up/down placement math (see `resolveCssLengthPx`); any
-     * other unit still renders correctly but is invisible to that heuristic, so the panel may
-     * pick the "wrong" side close to a viewport edge. Left unset the panel keeps the existing
-     * viewport-derived, auto-flipping height.
-     */
-    readonly dropdownMaxHeight: _angular_core.InputSignal<string | null>;
-    readonly appendToBody: _angular_core.InputSignal<boolean>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    readonly chevronTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    /**
-     * Full width of the container by default, matching every other field-style control.
-     * Set to `false` to shrink the trigger to fit its selected label instead.
-     */
-    readonly fullWidth: _angular_core.InputSignal<boolean>;
-    readonly isOpen: _angular_core.WritableSignal<boolean>;
-    /** The `<ng-template>` holding the panel markup, rendered inline or into `<body>`. */
-    protected abstract readonly panelTemplate: Signal<TemplateRef<unknown> | undefined>;
-    /** Declared by the subclass so each control keeps its own value type. */
-    protected abstract readonly value: ModelSignal<TValue>;
-    /** Value applied when a form writes `null` / the control is reset. */
-    protected abstract readonly emptyValue: TValue;
-    /** BEM class of one option button, used to collect keyboard-navigable elements. */
-    protected abstract readonly optionClass: string;
-    /** BEM class of the focusable trigger. */
-    protected abstract readonly triggerClass: string;
-    /**
-     * Spacing tokens feeding the height estimate. Overridable so each control keeps the
-     * `--gog-<block>-*` names it already exposes to consumers for theming.
-     */
-    protected readonly optionGapToken: string;
-    protected readonly optionsPaddingToken: string;
-    /** Keep in sync with the real `max-height` on the subclass's `__dropdown` block. */
-    protected readonly panelMaxHeightToken: string;
-    /** Estimated row height fed into the placement math; not a real layout property. */
-    protected readonly optionHeightToken: string;
-    /** Unique per-instance suffix, so several dropdowns on a page can't collide on DOM ids. */
-    protected readonly uid: number;
-    protected readonly elRef: ElementRef<any>;
-    protected readonly isBrowser: boolean;
-    private readonly document;
-    private readonly appRef;
-    private readonly destroyRef;
-    private readonly ngControl;
-    private readonly overlay;
-    private readonly cvaDisabled;
-    private readonly errorState;
-    protected readonly isDisabled: Signal<boolean>;
-    protected readonly dropdownDirectionState: _angular_core.WritableSignal<"up" | "down">;
-    protected readonly panelPlacement: _angular_core.WritableSignal<GogDropdownPlacement | null>;
-    /**
-     * Stacking order to write onto the panel, or null to leave it to the stylesheet.
-     *
-     * Only needed when appending to `<body>`: an inline panel inherits `--gog-dropdown-z` from
-     * its surroundings — which is how a dropdown inside a dialog ends up above the dialog —
-     * but an appended one sits outside that subtree and inherits nothing, so the value has
-     * to be resolved from the trigger and written out explicitly.
-     */
-    protected readonly panelZIndex: _angular_core.WritableSignal<number | null>;
-    /** `dropdownWidth`, or the trigger-derived width from `panelPlacement`, as a CSS value. */
-    protected readonly resolvedPanelWidth: Signal<string | null>;
-    /** `dropdownMaxHeight`, or the viewport-derived max-height from `panelPlacement`. */
-    protected readonly resolvedPanelMaxHeight: Signal<string | null>;
-    protected readonly hasError: Signal<boolean>;
-    protected readonly visibleError: Signal<string>;
-    /** Measured once per open rather than per scroll tick — see `refreshPanelMetrics`. */
-    private optionGap;
-    private optionsPadding;
-    private maxPanelHeight;
-    private optionHeight;
-    private repositionFrame;
-    private onChangeFn;
-    private onTouchedFn;
-    constructor();
+    private readonly floatLabelState;
+    private readonly clearableState;
+    /** Whether to render the clear button right now — see `GogClearableState`. */
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    protected readonly resolvedFloatLabel: _angular_core.Signal<GogFloatLabelVariant>;
+    protected readonly isFloatLabelActive: _angular_core.Signal<boolean>;
+    protected readonly isFloatLabelFloated: _angular_core.Signal<boolean>;
+    protected readonly effectivePlaceholder: _angular_core.Signal<string>;
+    /** Projected `gogInputAddonStart` element, if any. */
+    protected readonly addonStart: _angular_core.Signal<GogInputAddonStartDirective | undefined>;
+    /** Projected `gogInputAddonEnd` element, if any. */
+    protected readonly addonEnd: _angular_core.Signal<GogInputAddonEndDirective | undefined>;
     /**
-     * Binds the click-outside and reposition listeners only for as long as the panel is
-     * open. Bound permanently — as host listeners were — every dropdown on the page runs a
-     * handler on every document click and every scroll frame, whether or not it is showing
-     * anything.
+     * Drives the wrapper's `--icon-start` class, which widens the field's leading gutter. Counts
+     * a projected addon as well as the legacy icon inputs, or the addon would overlap the text.
      */
-    private bindWhileOpen;
+    protected readonly hasIconStart: _angular_core.Signal<boolean>;
+    protected readonly hasIconStartAction: _angular_core.Signal<boolean>;
+    /** For password fields the trailing icon is always the built-in show/hide toggle. */
+    protected readonly effectiveIconEnd: _angular_core.Signal<"" | GogIconName>;
+    protected readonly effectiveIconEndLabel: _angular_core.Signal<string>;
+    protected readonly hasIconEnd: _angular_core.Signal<boolean>;
+    protected readonly hasIconEndAction: _angular_core.Signal<boolean>;
+    /** `number` for a `type="number"` field (`null` when empty), `string` otherwise. */
+    private _onChange;
+    private _onTouched;
+    constructor();
     ngDoCheck(): void;
-    writeValue(val: TValue | null): void;
-    registerOnChange(fn: (val: TValue) => void): void;
+    writeValue(val: string | number | null): void;
+    registerOnChange(fn: (val: string | number | null) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
-    protected toggle(): void;
-    protected open(): void;
-    protected close(): void;
-    /** Writes a new selection out to both the model and the attached form control. */
-    protected commitValue(next: TValue): void;
-    protected markTouched(): void;
-    private closeIfClickedOutside;
+    protected onIconStartClick(): void;
+    protected onIconEndClick(): void;
+    onInput(event: Event): void;
+    /** Clears the field and notifies any attached form, then returns focus to the input. */
+    protected clearValue(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputfieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputfieldComponent, "gog-inputfield", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "iconStart": { "alias": "iconStart"; "required": false; "isSignal": true; }; "iconEnd": { "alias": "iconEnd"; "required": false; "isSignal": true; }; "iconStartTemplate": { "alias": "iconStartTemplate"; "required": false; "isSignal": true; }; "iconEndTemplate": { "alias": "iconEndTemplate"; "required": false; "isSignal": true; }; "iconStartFn": { "alias": "iconStartFn"; "required": false; "isSignal": true; }; "iconEndFn": { "alias": "iconEndFn"; "required": false; "isSignal": true; }; "iconStartLabel": { "alias": "iconStartLabel"; "required": false; "isSignal": true; }; "iconEndLabel": { "alias": "iconEndLabel"; "required": false; "isSignal": true; }; "showPasswordLabel": { "alias": "showPasswordLabel"; "required": false; "isSignal": true; }; "hidePasswordLabel": { "alias": "hidePasswordLabel"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; "floatLabel": { "alias": "floatLabel"; "required": false; "isSignal": true; }; "floatLabelShowPlaceholder": { "alias": "floatLabelShowPlaceholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["addonStart", "addonEnd"], ["[gogInputAddonStart]", "[gogInputAddonEnd]"], true, never>;
+}
+
+declare class TextareaComponent implements ControlValueAccessor, DoCheck {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
     /**
-     * Coalesces bursts of scroll/resize events into one reposition per frame. Placement
-     * reads layout, so running it per event is what makes a scroll janky.
+     * See `GogErrorDisplay`. Unset, falls back to `GOG_CONFIG.control.errorDisplay`, then to
+     * `'manual'` — matching every other control in the library.
      */
-    private scheduleReposition;
-    /** Jumps from the trigger into the option list on ArrowDown/ArrowUp while open. */
-    protected onTriggerArrowKeydown(event: Event): void;
-    protected onOptionKeydown(event: KeyboardEvent): void;
-    protected focusTrigger(): void;
-    /** Extra chrome stacked above the options (e.g. a select-all row), in px. */
-    protected extraPanelHeight(): number;
-    private enabledOptionElements;
-    private attachOverlay;
+    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay | undefined>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Unset, falls back to `GOG_CONFIG.control.size`, then to `'md'`. */
+    readonly size: _angular_core.InputSignal<GogSize | undefined>;
+    /** Native `rows` attribute, controlling the field's initial height. */
+    readonly rows: _angular_core.InputSignal<number>;
     /**
-     * Reads the spacing tokens that feed the height estimate. Done once per open instead of
-     * on every scroll tick, because `getComputedStyle` forces a style recalculation and the
-     * tokens cannot change while the panel is on screen.
+     * Full width of the container by default, matching every other field-style control.
+     * Set to `false` to shrink the field to fit its content instead.
      */
-    private refreshPanelMetrics;
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
     /**
-     * Rough height, used only to choose up/down and to cap `max-height` before the panel
-     * has been laid out. Deliberately an estimate: measuring would require rendering the
-     * panel first, which is what we are trying to position. A resolvable `dropdownMaxHeight`
-     * replaces the row-count guess outright, since it is exact rather than estimated.
+     * Whether to offer a clear button once the field has text. Unset, falls back to
+     * `GOG_CONFIG.control.clearable`, then to `false`.
      */
-    private estimatePanelHeight;
+    readonly clearable: _angular_core.InputSignal<boolean | undefined>;
+    /** Accessible name for the clear button. */
+    readonly clearAriaLabel: _angular_core.InputSignal<string>;
+    /** Unset, falls back to `GOG_CONFIG.floatLabel.variant`, then to `'none'` (off). */
+    readonly floatLabel: _angular_core.InputSignal<GogFloatLabelVariant | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.floatLabel.showPlaceholder`, then to `false`. */
+    readonly floatLabelShowPlaceholder: _angular_core.InputSignal<boolean | undefined>;
+    /** Two-way bindable value: `[(value)]="signal"` or `[value]` / `(valueChange)`. */
+    readonly value: _angular_core.ModelSignal<string>;
+    private readonly ngControl;
+    private readonly globalConfig;
+    private readonly cvaDisabled;
+    /** Instance input → `GOG_CONFIG` → the component's own default. See `resolveConfigured`. */
+    protected readonly resolvedSize: _angular_core.Signal<GogSize>;
+    private readonly resolvedErrorDisplay;
+    private readonly errorState;
+    /** Set from `(focus)`/`(blur)` on the `<textarea>` — see `onFocus`/`onBlur`. */
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    private readonly fieldRef;
     /**
-     * The trigger's own rect, not the whole component's — a label above it or an error
-     * message below it sit in normal document flow and are not part of what the panel needs
-     * to clear. This also keeps `appendToBody` placement consistent with the inline panel,
-     * which is already positioned purely relative to the trigger via CSS.
+     * Width of the textarea's own scrollbar, published so the clear button can clear it.
+     *
+     * It has to be measured: the width is platform- and settings-dependent (0 on overlay
+     * scrollbars, ~15-19px on classic ones), and it only exists once the content overflows. The
+     * pure-CSS alternative, `scrollbar-gutter: stable`, reserves the gutter even when the field
+     * isn't scrolling, which shifts the resting layout of every textarea.
      */
-    private triggerRect;
-    /** The stacking order the panel would have had if it were still inside the subtree. */
-    private resolvePanelZIndex;
-    private updatePlacement;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogDropdownBase<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogDropdownBase<any>, never, never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dropdownDirection": { "alias": "dropdownDirection"; "required": false; "isSignal": true; }; "dropdownZIndex": { "alias": "dropdownZIndex"; "required": false; "isSignal": true; }; "dropdownWidth": { "alias": "dropdownWidth"; "required": false; "isSignal": true; }; "dropdownMaxHeight": { "alias": "dropdownMaxHeight"; "required": false; "isSignal": true; }; "appendToBody": { "alias": "appendToBody"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "chevronTemplate": { "alias": "chevronTemplate"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    protected readonly scrollbarWidth: _angular_core.WritableSignal<number>;
+    /**
+     * The single size modifier, replacing one `[class.gog-input-wrapper--<size>]` binding per size.
+     * Empty for `'md'`: that is this component's default size and has no modifier rule of its own — every `gog-input-wrapper--*` chain bottoms out at it.
+     */
+    protected readonly sizeClass: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly visibleError: _angular_core.Signal<string>;
+    private readonly floatLabelState;
+    private readonly clearableState;
+    /** Whether to render the clear button right now — see `GogClearableState`. */
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    protected readonly resolvedFloatLabel: _angular_core.Signal<GogFloatLabelVariant>;
+    protected readonly isFloatLabelActive: _angular_core.Signal<boolean>;
+    protected readonly isFloatLabelFloated: _angular_core.Signal<boolean>;
+    protected readonly effectivePlaceholder: _angular_core.Signal<string>;
+    private _onChange;
+    private _onTouched;
+    constructor();
+    ngDoCheck(): void;
+    writeValue(val: string): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    /** Clears the field and notifies any attached form, then returns focus to the input. */
+    protected clearValue(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "gog-textarea", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; "floatLabel": { "alias": "floatLabel"; "required": false; "isSignal": true; }; "floatLabelShowPlaceholder": { "alias": "floatLabelShowPlaceholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare class ChipComponent {
+    readonly size: _angular_core.InputSignal<GogSize>;
+    readonly shape: _angular_core.InputSignal<GogTagShape>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clickable: _angular_core.InputSignal<boolean>;
+    readonly removable: _angular_core.InputSignal<boolean>;
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly removeAriaLabel: _angular_core.InputSignal<string>;
+    readonly avatarUrl: _angular_core.InputSignal<string | null>;
+    readonly avatarAlt: _angular_core.InputSignal<string>;
+    readonly iconName: _angular_core.InputSignal<GogIconName | null>;
+    readonly gogClick: _angular_core.OutputEmitterRef<MouseEvent | KeyboardEvent>;
+    readonly gogRemove: _angular_core.OutputEmitterRef<void>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected readonly isInteractive: _angular_core.Signal<boolean>;
+    protected onChipClick(event: MouseEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onRemoveClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipComponent, "gog-chip", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "removeAriaLabel": { "alias": "removeAriaLabel"; "required": false; "isSignal": true; }; "avatarUrl": { "alias": "avatarUrl"; "required": false; "isSignal": true; }; "avatarAlt": { "alias": "avatarAlt"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; }, { "gogClick": "gogClick"; "gogRemove": "gogRemove"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Custom markup for the tag's leading icon:
+ *
+ * ```html
+ * <ng-template gogTagIcon><my-icon /></ng-template>
+ * ```
+ */
+declare class GogTagIconDirective {
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogTagIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogTagIconDirective, "[gogTagIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class TagComponent {
+    readonly variant: _angular_core.InputSignal<GogTagVariant>;
+    readonly size: _angular_core.InputSignal<GogSize>;
+    readonly shape: _angular_core.InputSignal<GogTagShape>;
+    readonly iconName: _angular_core.InputSignal<GogIconName | null>;
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project an `<ng-template gogTagIcon>` into the component instead. Removed in 21.5.0.
+     */
+    readonly iconTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Projected `gogTagIcon` template; wins over the deprecated `iconTemplate` input. */
+    protected readonly iconSlot: _angular_core.Signal<GogTagIconDirective | undefined>;
+    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    protected readonly hasIcon: _angular_core.Signal<boolean>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "gog-tag", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "iconTemplate": { "alias": "iconTemplate"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, ["iconSlot"], ["*"], true, never>;
 }
 
-/** @deprecated Prefer `GogDropdownOption`; kept as an alias so existing imports keep working. */
+/**
+ * @deprecated since 21.2.2 (2026-07-30) — use `GogDropdownOption` instead. Removed in 21.4.0.
+ */
 type GogSelectOption = GogDropdownOption;
-declare class SelectComponent extends GogDropdownBase<string | number | null> {
+declare class SelectComponent<TOption = GogDropdownOption, TValue = string | number | null> extends GogDropdownBase<TValue, TOption> {
     readonly inputId: _angular_core.InputSignal<string>;
-    /** Two-way bindable selected value: `[(value)]="signal"`. */
-    readonly value: _angular_core.ModelSignal<string | number | null>;
+    /**
+     * Two-way bindable selected value: `[(value)]="signal"`.
+     *
+     * Carries whatever `optionValue` resolves to — an id by default, or the option object itself
+     * when `optionValue` is `null`. `TValue` is inferred from the signal you bind, so a
+     * `WritableSignal<string | null>` keeps typing exactly as before.
+     */
+    readonly value: _angular_core.ModelSignal<TValue>;
     protected readonly panelTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
-    protected readonly emptyValue: null;
+    /** A cleared select is `null`, whatever `TValue` the consumer bound. */
+    protected readonly emptyValue: TValue;
     protected readonly optionClass = "gog-select__option";
     protected readonly triggerClass = "gog-select__control";
+    /** Opt-in: a select had no clear affordance before 21.3.0. */
+    protected readonly clearableByDefault = false;
+    protected readonly sizeBlockClass = "gog-select";
+    protected readonly panelBlockClass = "gog-select__dropdown";
     protected readonly optionGapToken = "--gog-select-option-gap";
     protected readonly panelMaxHeightToken = "--gog-select-panel-max-height";
     protected readonly optionHeightToken = "--gog-select-option-height";
@@ -732,40 +2388,96 @@ declare class SelectComponent extends GogDropdownBase<string | number | null> {
     protected readonly listboxId: _angular_core.Signal<string>;
     protected readonly labelId: _angular_core.Signal<string>;
     protected readonly errorId: _angular_core.Signal<string | null>;
-    protected readonly selectedOption: _angular_core.Signal<GogDropdownOption | null>;
-    protected isSelected(id: string | number): boolean;
-    protected selectOption(option: GogDropdownOption, event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "gog-select", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    protected readonly selectedOption: _angular_core.Signal<NonNullable<TOption> | null>;
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    protected readonly hasFloatValue: _angular_core.Signal<boolean>;
+    protected isSelected(option: TOption): boolean;
+    protected selectOption(option: TOption, event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent<any, any>, "gog-select", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
-/** @deprecated Prefer `GogDropdownOption`; kept as an alias so existing imports keep working. */
+/**
+ * @deprecated since 21.2.2 (2026-07-30) — use `GogDropdownOption` instead. Removed in 21.4.0.
+ */
 type GogMultiselectOption = GogDropdownOption;
-declare class MultiselectComponent extends GogDropdownBase<(string | number)[]> {
+/**
+ * Custom markup for the multiselect's clear button:
+ *
+ * ```html
+ * <ng-template gogMultiselectClearIcon><my-icon /></ng-template>
+ * ```
+ */
+declare class GogMultiselectClearIconDirective {
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogMultiselectClearIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogMultiselectClearIconDirective, "[gogMultiselectClearIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class MultiselectComponent<TOption = GogDropdownOption, TValue = string | number> extends GogDropdownBase<TValue[], TOption> {
     readonly showControls: _angular_core.InputSignal<boolean>;
     /** Where the "select all"/"clear" row sits relative to the option list. Sticky either way. */
     readonly controlsPosition: _angular_core.InputSignal<"top" | "bottom">;
+    /**
+     * @deprecated since 21.3.0 (2026-08-07) — project an `<ng-template gogMultiselectClearIcon>` into the component instead. Removed in 21.5.0.
+     */
     readonly clearIconTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    /** Two-way bindable selected ids: `[(value)]="signal"`. */
-    readonly value: _angular_core.ModelSignal<(string | number)[]>;
+    /** Projected `gogMultiselectClearIcon` template; wins over the deprecated `clearIconTemplate` input. */
+    protected readonly clearIconSlot: _angular_core.Signal<GogMultiselectClearIconDirective | undefined>;
+    /**
+     * Two-way bindable selection: `[(value)]="signal"`.
+     *
+     * Each entry is whatever `optionValue` resolves to — an id by default, or the option objects
+     * themselves when `optionValue` is `null`.
+     */
+    readonly value: _angular_core.ModelSignal<TValue[]>;
     protected readonly panelTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
-    protected readonly emptyValue: (string | number)[];
+    protected readonly emptyValue: TValue[];
     protected readonly optionClass = "gog-ms__option";
     protected readonly triggerClass = "gog-ms";
+    /**
+     * On by default: this control shipped a clear button before `clearable` existed, so the
+     * default preserves it. Set `[clearable]="false"` to drop it.
+     */
+    protected readonly clearableByDefault = true;
+    protected readonly sizeBlockClass = "gog-ms-wrapper";
+    protected readonly panelBlockClass = "gog-ms__dropdown";
     protected readonly optionGapToken = "--gog-ms-option-gap";
     protected readonly optionsPaddingToken = "--gog-ms-options-padding";
     protected readonly panelMaxHeightToken = "--gog-ms-panel-max-height";
     protected readonly optionHeightToken = "--gog-ms-option-height";
     protected readonly listboxId: _angular_core.Signal<string>;
     protected readonly labelId: _angular_core.Signal<string>;
+    /** Labels of the current selection, driven off the selected *options* so it works whatever
+     * `optionValue` resolves to. */
+    readonly selectedLabels: _angular_core.Signal<string[]>;
+    /** Comma-joined selection — the full text, before any overflow trimming. */
     readonly selectedNames: _angular_core.Signal<string>;
-    protected isSelected(id: string | number): boolean;
-    protected toggleOption(option: GogDropdownOption, event: MouseEvent): void;
+    private readonly valueRef;
+    private readonly resizeDestroyRef;
+    /** Width available to the summary text, tracked so the split recomputes as the field resizes. */
+    private readonly valueWidth;
+    private readonly valueFont;
+    /**
+     * Splits the selection into what fits on one line and a `+N` remainder.
+     *
+     * Measured with `canvas.measureText` rather than by rendering candidates and reading back
+     * layout: the greedy fit is O(n) over the labels and costs no reflow, where a DOM-based probe
+     * would thrash layout on every keystroke-sized change.
+     */
+    protected readonly summary: _angular_core.Signal<{
+        text: string;
+        hidden: number;
+    }>;
+    protected readonly hasFloatValue: _angular_core.Signal<boolean>;
+    protected isSelected(option: TOption): boolean;
+    protected toggleOption(option: TOption, event: MouseEvent): void;
+    /** Acts on the *visible* options, so "select all" under an active filter means what it says. */
     protected selectAll(event: MouseEvent): void;
     protected clearAll(event: Event): void;
+    constructor();
     protected extraPanelHeight(): number;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiselectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiselectComponent, "gog-multiselect", never, { "showControls": { "alias": "showControls"; "required": false; "isSignal": true; }; "controlsPosition": { "alias": "controlsPosition"; "required": false; "isSignal": true; }; "clearIconTemplate": { "alias": "clearIconTemplate"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiselectComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiselectComponent<any, any>, "gog-multiselect", never, { "showControls": { "alias": "showControls"; "required": false; "isSignal": true; }; "controlsPosition": { "alias": "controlsPosition"; "required": false; "isSignal": true; }; "clearIconTemplate": { "alias": "clearIconTemplate"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["clearIconSlot"], never, true, never>;
 }
 
 declare class SliderComponent implements ControlValueAccessor, DoCheck {
@@ -779,7 +2491,8 @@ declare class SliderComponent implements ControlValueAccessor, DoCheck {
     readonly showThumb: _angular_core.InputSignal<boolean>;
     readonly errorMessage: _angular_core.InputSignal<string>;
     /** See `GogErrorDisplay`. Defaults to `'manual'`, matching every other control in the library. */
-    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay>;
+    /** Unset, falls back to `GOG_CONFIG.control.errorDisplay`, then to `'manual'`. */
+    readonly errorDisplay: _angular_core.InputSignal<GogErrorDisplay | undefined>;
     readonly ariaLabel: _angular_core.InputSignal<string>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     /**
@@ -787,18 +2500,34 @@ declare class SliderComponent implements ControlValueAccessor, DoCheck {
      * `--gog-slider-auto-width` instead — a slider's track has no content of its own to
      * shrink-wrap to, so unlike the other field controls this needs an explicit fallback
      * width rather than `fit-content`.
+     *
+     * Ignored when `orientation` is `'vertical'`: a vertical slider's own width is its
+     * thickness, not its length, so it always sizes to fit its content. Its length instead
+     * comes from `--gog-slider-vertical-length` (default `160px`), same idea as
+     * `--gog-slider-auto-width` for the horizontal auto-width case.
      */
     readonly fullWidth: _angular_core.InputSignal<boolean>;
+    /**
+     * `'horizontal'` (default) or `'vertical'`. The developer picks per instance — there is
+     * no global default for this, since it's a layout decision tied to where the slider sits,
+     * not a house style. Backed by a native `<input type="range">` rotated via `writing-mode`,
+     * so dragging, touch and keyboard (Up/Down as well as Left/Right) all keep working exactly
+     * as they do horizontally.
+     */
+    readonly orientation: _angular_core.InputSignal<_guildofgleks_ui.GogOrientation>;
     /** Two-way bindable value: `[(value)]="signal"`. */
     readonly value: _angular_core.ModelSignal<number>;
     private readonly ngControl;
     private readonly cvaDisabled;
+    private readonly globalConfig;
+    private readonly resolvedErrorDisplay;
     private readonly errorState;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly clampedValue: _angular_core.Signal<number>;
     protected readonly fillPercent: _angular_core.Signal<number>;
     protected readonly thumbPos: _angular_core.Signal<string>;
     protected readonly fillScale: _angular_core.Signal<number>;
+    protected readonly isVertical: _angular_core.Signal<boolean>;
     protected readonly hasError: _angular_core.Signal<boolean>;
     protected readonly visibleError: _angular_core.Signal<string>;
     protected readonly errorId: _angular_core.Signal<string | null>;
@@ -813,7 +2542,7 @@ declare class SliderComponent implements ControlValueAccessor, DoCheck {
     onInput(event: Event): void;
     onBlur(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SliderComponent, "gog-slider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "showThumb": { "alias": "showThumb"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SliderComponent, "gog-slider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "showThumb": { "alias": "showThumb"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "errorDisplay": { "alias": "errorDisplay"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
 declare class SkeletonComponent {
@@ -876,6 +2605,136 @@ declare class PaginatorComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginatorComponent, "gog-paginator", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": false; "isSignal": true; }; "rangeMode": { "alias": "rangeMode"; "required": false; "isSignal": true; }; "visiblePages": { "alias": "visiblePages"; "required": false; "isSignal": true; }; "showFirstPage": { "alias": "showFirstPage"; "required": false; "isSignal": true; }; "showLastPage": { "alias": "showLastPage"; "required": false; "isSignal": true; }; "siblingCount": { "alias": "siblingCount"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
 }
 
+/** Snapshot of the viewport's native scroll geometry, emitted on every scroll/resize. */
+interface GogScrollMetrics {
+    scrollTop: number;
+    scrollLeft: number;
+    scrollHeight: number;
+    scrollWidth: number;
+    clientHeight: number;
+    clientWidth: number;
+}
+type GogScrollDirection = 'vertical' | 'horizontal';
+/**
+ * Drop-in replacement for a native `overflow: auto` region: the content still scrolls
+ * natively (wheel, touch, keyboard, focus-into-view all keep working unmodified), only the
+ * browser's own scrollbar chrome is hidden and replaced with a themeable, draggable
+ * overlay thumb built from plain pointer events + `ResizeObserver` — no CDK involved, to
+ * stay consistent with the rest of this library's hand-rolled overlay/positioning code.
+ */
+declare class ScrollComponent {
+    /** Which axes get an overlay thumb. Native scrolling on the other axis is unaffected. */
+    readonly axis: _angular_core.InputSignal<GogScrollAxis>;
+    /** Unset, falls back to `GOG_CONFIG.scroll.size`, then to `'normal'`. */
+    readonly size: _angular_core.InputSignal<GogScrollSize | undefined>;
+    /**
+     * Fades the thumb out after `hideDelay` ms of inactivity; false keeps it always visible.
+     * Unset, falls back to `GOG_CONFIG.scroll.autoHide`, then to `true`.
+     */
+    readonly autoHide: _angular_core.InputSignal<boolean | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.scroll.hideDelay`, then to `800`. */
+    readonly hideDelay: _angular_core.InputSignal<number | undefined>;
+    /** Pixel distance from an edge that still counts as "reached" for gogReachStart/End. */
+    readonly reachThreshold: _angular_core.InputSignal<number>;
+    /**
+     * Renders the viewport as its own tab stop (`tabindex="0"`, `role="region"`) per the
+     * WAI-ARIA scrollable-region pattern. Turn off when nesting inside a component that
+     * already owns focus/keyboard handling (a listbox panel, a dialog body) so this doesn't
+     * add a redundant stop — the descendants' own focus still auto-scrolls into view either way.
+     */
+    readonly focusable: _angular_core.InputSignal<boolean>;
+    /** Accessible name for the viewport when `focusable` is true and there is no visible label. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * What happens when a scroll gesture reaches this instance's edge. Unset, falls back to
+     * `GOG_CONFIG.scroll.overscrollBehavior`, then to `'auto'`. See `GogScrollOverscrollBehavior`
+     * for what each value does.
+     */
+    readonly overscrollBehavior: _angular_core.InputSignal<GogScrollOverscrollBehavior | undefined>;
+    readonly gogScroll: _angular_core.OutputEmitterRef<GogScrollMetrics>;
+    readonly gogReachStart: _angular_core.OutputEmitterRef<GogScrollDirection>;
+    readonly gogReachEnd: _angular_core.OutputEmitterRef<GogScrollDirection>;
+    protected readonly viewportRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    protected readonly contentRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    protected readonly showTrackV: _angular_core.WritableSignal<boolean>;
+    protected readonly showTrackH: _angular_core.WritableSignal<boolean>;
+    /**
+     * Flips true once the first real measurement has run. Before that (SSR, or the client
+     * frame before hydration/afterNextRender fires), an allowed axis defaults to `auto` — the
+     * same safe, always-clips behavior this component had before viewportOverflowY/X existed —
+     * rather than guessing `visible` from a `showTrackV`/`H` that just hasn't been measured yet.
+     */
+    private readonly measured;
+    /**
+     * `overflow-y`/`overflow-x` on the viewport, driven by measured overflow rather than a
+     * static `axis`-only class. Any axis that isn't *currently, actually* scrolling — because
+     * it's disabled by `axis`, or because it's allowed but the content doesn't overflow it —
+     * gets `visible`, never `hidden`/`auto`. A non-`visible` overflow value makes the viewport
+     * a "scroll container" per spec regardless of whether it has anything to scroll, which
+     * becomes the containing block for `position: sticky` descendants (e.g. gog-table's sticky
+     * header) and a scroll-chaining boundary for wheel input. Left non-visible on a disabled or
+     * unneeded axis, an instance nested inside another scroller — axis="horizontal" wrapping a
+     * table that fits, itself inside a taller outer gog-scroll — would silently swallow the
+     * outer axis's wheel scroll and break its sticky headers, even though this instance itself
+     * never visibly scrolls that axis. `visible` whenever the axis is inert avoids both.
+     */
+    protected readonly viewportOverflowY: _angular_core.Signal<"auto" | "visible">;
+    protected readonly viewportOverflowX: _angular_core.Signal<"auto" | "visible">;
+    /** App/subtree-wide fallbacks for the inputs above that don't set their own value. */
+    private readonly globalConfig;
+    protected readonly resolvedSize: _angular_core.Signal<GogScrollSize>;
+    protected readonly resolvedAutoHide: _angular_core.Signal<boolean>;
+    protected readonly resolvedHideDelay: _angular_core.Signal<number>;
+    protected readonly resolvedOverscrollBehavior: _angular_core.Signal<GogScrollOverscrollBehavior>;
+    /**
+     * Only applies `resolvedOverscrollBehavior` on an axis that's actually acting as a scroll
+     * container — on an axis that's `visible` (see viewportOverflowY/X above) there is no
+     * scroll boundary on it to contain in the first place.
+     */
+    protected readonly viewportOverscrollY: _angular_core.Signal<GogScrollOverscrollBehavior>;
+    protected readonly viewportOverscrollX: _angular_core.Signal<GogScrollOverscrollBehavior>;
+    protected readonly thumbSizeV: _angular_core.WritableSignal<number>;
+    protected readonly thumbPosV: _angular_core.WritableSignal<number>;
+    protected readonly thumbSizeH: _angular_core.WritableSignal<number>;
+    protected readonly thumbPosH: _angular_core.WritableSignal<number>;
+    protected readonly interacting: _angular_core.WritableSignal<boolean>;
+    protected readonly dragAxis: _angular_core.WritableSignal<GogScrollDirection | null>;
+    private readonly isBrowser;
+    private readonly destroyRef;
+    private resizeObserver;
+    private updateFrame;
+    private hideTimer;
+    /** Read once per token change instead of per drag/scroll tick — see refreshTokens(). */
+    private thumbMinSizePx;
+    private dragStartPointer;
+    private dragStartScroll;
+    private dragTrackLength;
+    private dragThumbSizePct;
+    private readonly reachState;
+    constructor();
+    /** Scrolls the viewport exactly like `Element.scrollTo` — this simply forwards to it. */
+    scrollTo(options: ScrollToOptions): void;
+    scrollToTop(behavior?: ScrollBehavior): void;
+    scrollToBottom(behavior?: ScrollBehavior): void;
+    scrollToLeft(behavior?: ScrollBehavior): void;
+    scrollToRight(behavior?: ScrollBehavior): void;
+    protected onScroll(): void;
+    protected onActivity(): void;
+    protected onTrackPointerDown(event: PointerEvent, axis: GogScrollDirection): void;
+    protected onThumbPointerDown(event: PointerEvent, axis: GogScrollDirection): void;
+    protected onThumbPointerMove(event: PointerEvent, axis: GogScrollDirection): void;
+    protected onThumbPointerUp(event: PointerEvent): void;
+    private restartHideTimer;
+    /** Reads the tokens that feed thumb-size math. Cheap, but still only once per change. */
+    private refreshTokens;
+    /** Coalesces scroll/resize bursts into one measurement per frame. */
+    private scheduleMeasure;
+    private measure;
+    private checkReach;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollComponent, "gog-scroll", never, { "axis": { "alias": "axis"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; "reachThreshold": { "alias": "reachThreshold"; "required": false; "isSignal": true; }; "focusable": { "alias": "focusable"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "overscrollBehavior": { "alias": "overscrollBehavior"; "required": false; "isSignal": true; }; }, { "gogScroll": "gogScroll"; "gogReachStart": "gogReachStart"; "gogReachEnd": "gogReachEnd"; }, never, ["*"], true, never>;
+}
+
 declare class SpinnerOverlayComponent {
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly size: _angular_core.InputSignal<GogSize>;
@@ -887,7 +2746,53 @@ declare class SpinnerOverlayComponent {
 
 /** Default comparator: locale-aware for strings via `Intl.Collator`, `<`/`>` otherwise. */
 declare function defaultCompare(a: unknown, b: unknown): number;
-declare class Column {
+/** Context handed to a `gogColumnBody` template. */
+interface GogColumnBodyContext<T> {
+    /** The row object. */
+    $implicit: T;
+    /** Alias for `$implicit`, for templates that prefer naming it. */
+    row: T;
+    /** Index within the currently rendered page, not the whole data set. */
+    index: number;
+    /** The already-resolved cell value for this column's `field`. */
+    value: unknown;
+}
+/** Context handed to a `gogColumnHeader` template. */
+interface GogColumnHeaderContext {
+    /** The column's own `header` text, so a custom header can decorate rather than replace it. */
+    $implicit: string;
+    field: string;
+}
+/**
+ * Custom cell markup for one column:
+ *
+ * ```html
+ * <gog-column field="status" header="Status">
+ *   <ng-template gogColumnBody let-row let-value="value">
+ *     <gog-tag [variant]="row.ok ? 'success' : 'danger'">{{ value }}</gog-tag>
+ *   </ng-template>
+ * </gog-column>
+ * ```
+ */
+declare class GogColumnBodyDirective<T = unknown> {
+    readonly templateRef: TemplateRef<GogColumnBodyContext<T>>;
+    static ngTemplateContextGuard<T>(_dir: GogColumnBodyDirective<T>, ctx: unknown): ctx is GogColumnBodyContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogColumnBodyDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogColumnBodyDirective<any>, "[gogColumnBody]", never, {}, {}, never, never, true, never>;
+}
+/** Custom header markup for one column — see `GogColumnBodyDirective` for the shape. */
+declare class GogColumnHeaderDirective {
+    readonly templateRef: TemplateRef<GogColumnHeaderContext>;
+    static ngTemplateContextGuard(_dir: GogColumnHeaderDirective, ctx: unknown): ctx is GogColumnHeaderContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogColumnHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogColumnHeaderDirective, "[gogColumnHeader]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * One column of `gog-table`. Cell and header markup are projected as `gogColumnBody` /
+ * `gogColumnHeader` templates inside the column itself, so the column owning them is
+ * structural rather than looked up by a matching string.
+ */
+declare class GogColumn {
     /** Field name, or a dot-path into a nested property (e.g. `"address.city"`). */
     readonly field: _angular_core.InputSignal<string>;
     readonly header: _angular_core.InputSignal<string>;
@@ -900,9 +2805,20 @@ declare class Column {
     readonly maxWidth: _angular_core.InputSignal<string>;
     /** Custom sort comparator for this column. Defaults to `defaultCompare`. */
     readonly comparator: _angular_core.InputSignal<((a: unknown, b: unknown) => number) | null>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Column, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Column, "column", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "comparator": { "alias": "comparator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    readonly bodyTemplate: _angular_core.Signal<GogColumnBodyDirective<any> | undefined>;
+    readonly headerTemplate: _angular_core.Signal<GogColumnHeaderDirective | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogColumn, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogColumn, "gog-column, column", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "comparator": { "alias": "comparator"; "required": false; "isSignal": true; }; }, {}, ["bodyTemplate", "headerTemplate"], never, true, never>;
 }
+/**
+ * @deprecated since 21.3.0 (2026-08-07) — use `GogColumn` instead. Removed in 21.5.0.
+ * The same class under its old, unprefixed name.
+ */
+declare const Column: typeof GogColumn;
+/**
+ * @deprecated since 21.3.0 (2026-08-07) — use `GogColumn` instead. Removed in 21.5.0.
+ */
+type Column = GogColumn;
 
 interface GogTableBodyContext<T> {
     $implicit: T;
@@ -912,11 +2828,29 @@ interface GogTableHeaderContext {
     $implicit: never;
 }
 /**
- * Marks a <ng-template> inside <gog-table> with a field name and optional type.
+ * Marks a `<ng-template>` inside `<gog-table>` with a field name and optional type:
+ *
+ * ```html
+ * <ng-template template="status" type="body" let-row>…</ng-template>
+ * ```
+ *
+ * @deprecated since 21.3.0 (2026-08-07) — declare the template inside its own column with
+ * `gogColumnBody` / `gogColumnHeader` instead. Removed in 21.5.0.
+ *
+ * The field name here is a string the compiler cannot check, so a typo silently renders the
+ * default cell rather than failing; the column-scoped directives bind structurally and carry a
+ * typed context. Migration:
  *
- * Usage:
- *   <ng-template template="status" type="body" let-row>...</ng-template>
- *   <ng-template template="status" type="header">...</ng-template>
+ * ```html
+ * <!-- before -->
+ * <gog-column field="status" />
+ * <ng-template template="status" type="body" let-row>…</ng-template>
+ *
+ * <!-- after -->
+ * <gog-column field="status">
+ *   <ng-template gogColumnBody let-row>…</ng-template>
+ * </gog-column>
+ * ```
  */
 declare class TemplateDirective {
     readonly template: _angular_core.InputSignal<string>;
@@ -933,6 +2867,11 @@ interface SortState {
     direction: SortDirection;
 }
 declare class TableComponent<T extends object> {
+    /**
+     * The single size modifier, replacing one `[class.gog-table--<size>]` binding per size.
+     * Empty for `'lg'`: that is this component's default size and has no modifier rule of its own — every `gog-table--*` chain bottoms out at it.
+     */
+    protected readonly sizeClass: _angular_core.Signal<string>;
     readonly value: _angular_core.InputSignal<T[]>;
     /**
      * Full width of the container by default. Set to `false` to shrink the table to fit
@@ -945,7 +2884,7 @@ declare class TableComponent<T extends object> {
     readonly showTotal: _angular_core.InputSignal<boolean>;
     readonly emptyPlaceholder: _angular_core.InputSignal<string>;
     /** Alignment of pagination controls */
-    readonly paginatorPosition: _angular_core.InputSignal<"center" | "left" | "right">;
+    readonly paginatorPosition: _angular_core.InputSignal<"left" | "right" | "center">;
     /** Alignment of total count label (only when showTotal=true) */
     readonly totalPosition: _angular_core.InputSignal<"left" | "right" | "opposite">;
     /** Show loading spinner instead of rows */
@@ -956,7 +2895,7 @@ declare class TableComponent<T extends object> {
     readonly stickyHeader: _angular_core.InputSignal<boolean>;
     /** Row density: lg (default) / md (compact) / sm (dense) */
     readonly size: _angular_core.InputSignal<GogSize>;
-    readonly columns: _angular_core.Signal<readonly Column[]>;
+    readonly columns: _angular_core.Signal<readonly GogColumn[]>;
     readonly templates: _angular_core.Signal<readonly TemplateDirective[]>;
     readonly sortState: _angular_core.WritableSignal<SortState>;
     readonly sortedData: _angular_core.Signal<T[]>;
@@ -972,19 +2911,27 @@ declare class TableComponent<T extends object> {
     readonly visibleRows: _angular_core.Signal<T[]>;
     readonly hasPagination: _angular_core.Signal<boolean>;
     readonly emptyColspan: _angular_core.Signal<number>;
-    getBodyTemplate(field: string): TemplateRef<unknown> | null;
-    getHeaderTemplate(field: string): TemplateRef<unknown> | null;
-    toggleSort(col: Column): void;
+    /**
+     * A `gogColumnBody` template declared inside the column wins; the string-keyed
+     * `<ng-template template="field" type="body">` is the deprecated fallback.
+     */
+    getBodyTemplate(col: GogColumn): TemplateRef<unknown> | null;
+    getHeaderTemplate(col: GogColumn): TemplateRef<unknown> | null;
+    /** Context for a `gogColumnBody` template — see `GogColumnBodyContext`. */
+    bodyContext(row: T, col: GogColumn, index: number): GogColumnBodyContext<T>;
+    /** Context for a `gogColumnHeader` template — see `GogColumnHeaderContext`. */
+    headerContext(col: GogColumn): GogColumnHeaderContext;
+    toggleSort(col: GogColumn): void;
     getSortDirection(field: string): SortDirection;
     getAriaSort(field: string): 'ascending' | 'descending' | null;
-    handleSortClick(col: Column): void;
+    handleSortClick(col: GogColumn): void;
     getCellValue(row: T, field: string): unknown;
     formatCellValue(row: T, field: string): string;
     globalRowIndex(localIndex: number): number;
     /** CSS grid-area for the total label: left slot or right slot */
     readonly totalGridArea: _angular_core.Signal<"left" | "right">;
     /** CSS grid-area for the pagination block */
-    readonly paginatorGridArea: _angular_core.Signal<"center" | "left" | "right">;
+    readonly paginatorGridArea: _angular_core.Signal<"left" | "right" | "center">;
     private readonly bodyTemplateMap;
     private readonly headerTemplateMap;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent<any>, never>;
@@ -1005,6 +2952,87 @@ declare class SpinnerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "gog-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+/**
+ * Adds a hover/focus tooltip to any element — a `gog-*` component's host tag or a plain
+ * native one — without that element needing to know anything about it:
+ * `<button gogTooltip="Save changes">` or `<gog-chip [gogTooltip]="hint">` both just work,
+ * since this only ever reads the host `ElementRef` and never assumes what created it.
+ *
+ * The bubble itself is a separate component (`GogTooltipBubbleComponent`) created on demand
+ * and moved into `document.body` via `GogTooltipOverlay` — see that file for why a portal is
+ * necessary here (clipping/position ancestors) and why it isn't built on `GogDropdownOverlay`.
+ */
+declare class GogTooltipDirective {
+    /** The hint text, or a `TemplateRef` for richer content. Empty/null shows nothing. */
+    readonly gogTooltip: _angular_core.InputSignal<string | TemplateRef<unknown> | null>;
+    /** Unset, falls back to `GOG_CONFIG.tooltip.position`, then to `'auto'`. */
+    readonly gogTooltipPosition: _angular_core.InputSignal<GogTooltipPosition | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.tooltip.showDelay`, then to `300` (ms). */
+    readonly gogTooltipShowDelay: _angular_core.InputSignal<number | undefined>;
+    /** Unset, falls back to `GOG_CONFIG.tooltip.hideDelay`, then to `100` (ms). */
+    readonly gogTooltipHideDelay: _angular_core.InputSignal<number | undefined>;
+    readonly gogTooltipDisabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Extra class(es) applied to the bubble itself, for restyling one specific tooltip
+     * instance. The bubble is appended to `document.body`, so a `--gog-tooltip-*` override
+     * scoped to an ancestor (anything short of `:root`) never reaches it — a class targeting
+     * the bubble directly, e.g. `.my-tooltip { --gog-tooltip-bg: gold; }`, is what does.
+     */
+    readonly gogTooltipClass: _angular_core.InputSignal<string>;
+    private readonly elRef;
+    private readonly viewContainerRef;
+    private readonly document;
+    private readonly destroyRef;
+    private readonly globalConfig;
+    private readonly isBrowser;
+    private readonly uid;
+    private readonly overlay;
+    private readonly isVisible;
+    protected readonly describedById: _angular_core.Signal<string | null>;
+    private readonly resolvedPosition;
+    private readonly resolvedShowDelay;
+    private readonly resolvedHideDelay;
+    private activeRef;
+    private showTimer;
+    private hideTimer;
+    private repositionFrame;
+    private readonly onReflow;
+    /**
+     * Bound to the bubble itself (see `show()`) so moving the pointer off the trigger and
+     * onto the bubble — to read more of it, or to scroll one tall enough to need it — cancels
+     * the pending hide instead of racing it; leaving the bubble then re-queues the same hide
+     * delay leaving the trigger would. WCAG 2.1 SC 1.4.13 "hoverable" requires exactly this:
+     * hover-triggered content has to stay visible while the pointer is over the content, not
+     * just the trigger.
+     */
+    private readonly onBubbleMouseEnter;
+    private readonly onBubbleMouseLeave;
+    constructor();
+    protected onPointerEnter(): void;
+    protected onPointerLeave(): void;
+    protected onFocusIn(): void;
+    protected onFocusOut(): void;
+    protected onEscape(): void;
+    private queueShow;
+    private queueHide;
+    private cancelTimers;
+    private show;
+    private hide;
+    private scheduleReposition;
+    private applyPlacement;
+    /**
+     * A tooltip appended to `document.body` loses whatever `--gog-tooltip-z` an ancestor
+     * (e.g. a `gog-dialog` panel, which raises it so nested overlays stack above the dialog)
+     * declared, since `body` isn't part of that subtree anymore — same problem
+     * `GogDropdownBase.resolvePanelZIndex` solves for dropdown panels, resolved here from the
+     * trigger while it's still in its real position in the tree, before the bubble moves out.
+     */
+    private resolveZIndex;
+    private cleanup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GogTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GogTooltipDirective, "[gogTooltip]", never, { "gogTooltip": { "alias": "gogTooltip"; "required": false; "isSignal": true; }; "gogTooltipPosition": { "alias": "gogTooltipPosition"; "required": false; "isSignal": true; }; "gogTooltipShowDelay": { "alias": "gogTooltipShowDelay"; "required": false; "isSignal": true; }; "gogTooltipHideDelay": { "alias": "gogTooltipHideDelay"; "required": false; "isSignal": true; }; "gogTooltipDisabled": { "alias": "gogTooltipDisabled"; "required": false; "isSignal": true; }; "gogTooltipClass": { "alias": "gogTooltipClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare class ThemeService {
     private readonly document;
     private readonly root;
@@ -1018,5 +3046,235 @@ declare class ThemeService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
 }
 
-export { AccordionComponent, ButtonComponent, CheckboxComponent, ChipComponent, Column, ConfirmationDialogComponent, DIALOG_DATA, DIALOG_REF, DialogComponent, DialogService, GogAccordionChevronDirective, GogAccordionContentDirective, GogAccordionHeaderDirective, GogDropdownBase, ICON_DEFS, IconComponent, InputfieldComponent, MultiselectComponent, PaginatorComponent, SelectComponent, SkeletonComponent, SliderComponent, SpinnerComponent, SpinnerOverlayComponent, TableComponent, TagComponent, TemplateDirective, ThemeService, ToastComponent, ToastContainerComponent, ToastService, defaultCompare };
-export type { ConfirmDialogData, DialogConfig, DialogHandle, DialogRef, GogAccordionChevronContext, GogAccordionHeaderContext, GogAccordionItem, GogAccordionToggleEvent, GogDropdownDirection, GogDropdownOption, GogIconName, GogMultiselectOption, GogPaginatorRangeMode, GogSelectOption, GogSize, GogSkeletonAnimation, GogSkeletonShape, GogSpinnerVariant, GogTableBodyContext, GogTableHeaderContext, GogTagShape, GogTagVariant, GogVariant, OpenDialog, SortDirection, Toast, ToastAction, ToastConfig, ToastPosition, ToastType };
+/**
+ * App-wide defaults for the handful of component inputs where that actually makes sense —
+ * timing/behavior knobs a whole app typically wants to set once (a house style for how long
+ * scrollbars stay visible, how aggressively buttons debounce clicks), not visual ones.
+ * Visual defaults (colors, radii, animation *durations expressed in CSS*) already have a
+ * global mechanism: the `--gog-*` custom properties in `styles/theme.css`. This is only for
+ * inputs that can't be a CSS token because a component reads them in TypeScript (a
+ * `setTimeout` delay, an RxJS `timer` duration) — see `styling.instructions.md` and
+ * `gleks-ui-library.instructions.md`'s "Global configuration" section for the line between
+ * the two and for how to add a new field here when a component needs one.
+ *
+ * Every field is optional at every level: set only the ones you want to change from the
+ * component's own built-in default. An instance's own input, when set, always wins over
+ * this — this only fills in what the instance didn't specify itself.
+ */
+interface GogGlobalConfig {
+    scroll?: {
+        autoHide?: boolean;
+        hideDelay?: number;
+        size?: GogScrollSize;
+        overscrollBehavior?: GogScrollOverscrollBehavior;
+    };
+    button?: {
+        debounce?: number;
+    };
+    tooltip?: {
+        showDelay?: number;
+        hideDelay?: number;
+        position?: GogTooltipPosition;
+    };
+    /** Applies to `gog-inputfield`, `gog-select`, `gog-multiselect` and `gog-textarea`. */
+    floatLabel?: {
+        variant?: GogFloatLabelVariant;
+        /**
+         * Whether the field's own `placeholder` reappears once its label has floated out of
+         * the way. Defaults to `false` — the placeholder stays hidden the whole time a float
+         * label is active, since the resting label already occupies that space.
+         */
+        showPlaceholder?: boolean;
+    };
+    /**
+     * Defaults for the interactive form controls — the two settings an app otherwise repeats on
+     * literally every one of them: a compact app writes `size="sm"` everywhere, and a
+     * Reactive-Forms app writes `errorDisplay="auto"` on every field.
+     *
+     * - `size` applies to `gog-button`, `gog-inputfield`, `gog-textarea`, `gog-select`,
+     *   `gog-multiselect`, `gog-checkbox` and `gog-radio-group`. Deliberately **not** to
+     *   `gog-table`, `gog-accordion` or `gog-paginator` (whose `size` means row/layout density
+     *   and whose defaults differ), nor to `gog-spinner`, `gog-skeleton`, `gog-tag` or
+     *   `gog-chip` (sized to fit whatever they sit next to, not to a form's density).
+     * - `errorDisplay` applies to every control that renders a validation message:
+     *   `gog-inputfield`, `gog-textarea`, `gog-select`, `gog-multiselect`, `gog-radio-group`
+     *   and `gog-slider`.
+     *
+     * A component's own built-in default still applies when this is unset, so setting `size`
+     * here does not flatten the different defaults those excluded components have.
+     */
+    control?: {
+        size?: GogSize;
+        errorDisplay?: GogErrorDisplay;
+        /**
+         * Whether `gog-inputfield`, `gog-textarea`, `gog-select` and `gog-multiselect` offer a
+         * clear button. The button only ever appears once the control actually has something to
+         * clear, so switching this on app-wide adds no permanent chrome.
+         *
+         * Component defaults are `false`, except `gog-multiselect`, which had a clear button
+         * before this input existed and keeps it.
+         */
+        clearable?: boolean;
+    };
+    /** Applies to `gog-select` and `gog-multiselect`. */
+    dropdown?: {
+        /**
+         * Whether the panel is rendered into `<body>` instead of inline. Worth setting app-wide
+         * for a layout whose dropdowns generally live inside scrollable or overflow-clipped
+         * containers, which is the case this exists for.
+         */
+        appendToBody?: boolean;
+        direction?: GogDropdownDirection;
+        /** Whether the panel shows a search box. Off by default. */
+        filter?: boolean;
+        /** Which end of the panel the search box sticks to. `'top'` by default. */
+        filterPosition?: GogDropdownFilterPosition;
+    };
+    /**
+     * Applies to `gog-datepicker` and `gog-calendar`. Every field here is something an app sets
+     * once rather than per field — a locale and a date format repeated on every date input is
+     * exactly the boilerplate this config exists to remove.
+     */
+    datepicker?: {
+        /** BCP-47 tag driving month and weekday names. */
+        locale?: string;
+        /** 0 = Sunday … 6 = Saturday. Unset, it comes from the locale. */
+        firstDayOfWeek?: number;
+        /** Display and parse pattern (`dd.MM.yyyy`, `yyyy-MM-dd`, …). */
+        format?: string;
+    };
+    /** Applies to `gog-autocomplete`. */
+    autocomplete?: {
+        /**
+         * Milliseconds to wait after the last keystroke before `gogSearch` fires. A whole app
+         * usually wants one answer here, tuned to its backend rather than to each field.
+         */
+        searchDebounce?: number;
+        /** How many characters before the panel opens at all. */
+        minLength?: number;
+    };
+    toast?: {
+        position?: ToastPosition;
+        /** How long a non-sticky toast stays up, in ms. */
+        duration?: number;
+    };
+}
+/**
+ * Resolves to `{}` — every field falls through to its component's own hardcoded default —
+ * until a `provideGogConfig(...)` call overrides it somewhere in the injector tree.
+ */
+declare const GOG_CONFIG: InjectionToken<GogGlobalConfig>;
+/**
+ * Sets app-wide (or subtree-wide, if placed in a route's or component's own `providers`
+ * instead of the bootstrap config) defaults for every `@guildofgleks/ui` component that
+ * reads `GOG_CONFIG` — one call instead of a separate injection token per setting:
+ *
+ * ```ts
+ * // app.config.ts
+ * providers: [
+ *   provideGogConfig({
+ *     scroll: { hideDelay: 1000 },
+ *     button: { debounce: 500 },
+ *   }),
+ * ]
+ * ```
+ *
+ * **Providing this again further down the injector tree layers onto the parent's config
+ * rather than replacing it.** A route that only cares about tooltips can say so, and the
+ * app-wide `button.debounce` stays in effect inside it:
+ *
+ * ```ts
+ * // a route's providers — button.debounce from app.config.ts still applies here
+ * provideGogConfig({ tooltip: { showDelay: 0 } })
+ * ```
+ *
+ * Merging is one level deep, per component key: the nearest provider wins field by field, so
+ * `{ tooltip: { showDelay: 0 } }` overrides only `showDelay` and leaves a parent's
+ * `tooltip.position` alone. To drop an inherited value rather than change it, set it back to
+ * the component's own default explicitly — there is no "unset" marker.
+ */
+declare function provideGogConfig(config: GogGlobalConfig): Provider;
+/**
+ * The library's precedence rule for a configurable input, in one place: an instance's own
+ * input wins, then the app-wide `GOG_CONFIG` value, then the component's built-in default.
+ *
+ * Every configurable input resolves through this rather than repeating the `??` chain, so the
+ * order can't drift between components — a component that accidentally checked the config
+ * first would silently ignore the input on that one control only, which is close to invisible
+ * in review. Kept a plain function (no `inject`) so it works anywhere: inside a `computed`, in
+ * a composition class like `GogFloatLabelState`, and in unit tests without an injector.
+ *
+ * ```ts
+ * private readonly globalConfig = inject(GOG_CONFIG);
+ * protected readonly resolvedDebounce = computed(() =>
+ *   resolveConfigured(this.debounce(), this.globalConfig.button?.debounce, DEFAULT_DEBOUNCE),
+ * );
+ * ```
+ */
+declare function resolveConfigured<T>(instanceValue: T | undefined, configuredValue: T | undefined, fallback: T): T;
+
+/**
+ * Shared float-label state for the library's field-style controls.
+ *
+ * A plain class rather than a base class or directive, for the same reason as `GogErrorState`:
+ * it has to serve `gog-inputfield` and `gog-textarea`, which share no base class, as well as
+ * `GogDropdownBase`, which is one. Each consumer owns an instance and exposes whichever
+ * members its template needs.
+ *
+ * The one thing each control must supply itself is `hasValue` — "this field has content" means
+ * something different everywhere (a non-empty string, a non-null selection, a non-empty
+ * selection array), which is exactly why this is composed in rather than implemented as a
+ * directive sitting outside the component.
+ */
+declare class GogFloatLabelState {
+    private readonly variantInput;
+    private readonly showPlaceholderInput;
+    private readonly placeholder;
+    private readonly isFocused;
+    private readonly hasValue;
+    private readonly config;
+    /**
+     * @param variantInput the control's own `floatLabel` input (`undefined` when unset)
+     * @param showPlaceholderInput the control's own `floatLabelShowPlaceholder` input
+     * @param placeholder the control's `placeholder` input
+     * @param isFocused whether the control currently has focus
+     * @param hasValue whether the control has a value — see the class note
+     * @param config the injected `GOG_CONFIG`
+     */
+    constructor(variantInput: Signal<GogFloatLabelVariant | undefined>, showPlaceholderInput: Signal<boolean | undefined>, placeholder: Signal<string>, isFocused: Signal<boolean>, hasValue: Signal<boolean>, config: GogGlobalConfig);
+    /** The resolved variant: instance input, else `GOG_CONFIG.floatLabel.variant`, else `'none'`. */
+    readonly variant: Signal<GogFloatLabelVariant>;
+    readonly showPlaceholder: Signal<boolean>;
+    /** Whether a float label is in effect at all — `false` keeps the static label-above layout. */
+    readonly isActive: Signal<boolean>;
+    /** Whether the label is at its floated target rather than resting like a placeholder. */
+    readonly isFloated: Signal<boolean>;
+    /**
+     * The placeholder the control should actually render. While a float label is active the
+     * resting label already occupies that space, so the placeholder stays hidden unless the
+     * consumer opted into `floatLabelShowPlaceholder` — and even then only once the label has
+     * floated out of the way.
+     */
+    readonly effectivePlaceholder: Signal<string>;
+}
+
+/** Every `--gog-*` custom property the library declares or documents as an override point. */
+type GogTokenName = '--gog-accent-bright' | '--gog-accent-color' | '--gog-accent-dim' | '--gog-accent-pale' | '--gog-accent-text-color' | '--gog-accordion-accent-color' | '--gog-accordion-body-bg' | '--gog-accordion-body-color' | '--gog-accordion-body-font-family' | '--gog-accordion-body-font-size' | '--gog-accordion-body-lift' | '--gog-accordion-body-line-height' | '--gog-accordion-body-padding-bottom' | '--gog-accordion-body-padding-top' | '--gog-accordion-body-radius' | '--gog-accordion-body-transition-duration' | '--gog-accordion-border-color' | '--gog-accordion-border-style' | '--gog-accordion-border-width' | '--gog-accordion-chevron-font-size' | '--gog-accordion-chevron-size' | '--gog-accordion-chevron-transition-duration' | '--gog-accordion-content-gap' | '--gog-accordion-disabled-opacity' | '--gog-accordion-focus-ring-width' | '--gog-accordion-font-family' | '--gog-accordion-font-size' | '--gog-accordion-header-bg' | '--gog-accordion-header-gap' | '--gog-accordion-header-text-transform' | '--gog-accordion-hover-bg' | '--gog-accordion-hover-ring' | '--gog-accordion-letter-spacing' | '--gog-accordion-lg-body-font-size' | '--gog-accordion-lg-body-line-height' | '--gog-accordion-lg-body-padding-bottom' | '--gog-accordion-lg-body-padding-top' | '--gog-accordion-lg-chevron-font-size' | '--gog-accordion-lg-chevron-size' | '--gog-accordion-lg-content-gap' | '--gog-accordion-lg-font-size' | '--gog-accordion-lg-letter-spacing' | '--gog-accordion-lg-padding-x' | '--gog-accordion-lg-padding-y' | '--gog-accordion-md-body-font-size' | '--gog-accordion-md-body-line-height' | '--gog-accordion-md-body-padding-bottom' | '--gog-accordion-md-body-padding-top' | '--gog-accordion-md-chevron-font-size' | '--gog-accordion-md-chevron-size' | '--gog-accordion-md-content-gap' | '--gog-accordion-md-font-size' | '--gog-accordion-md-letter-spacing' | '--gog-accordion-md-padding-x' | '--gog-accordion-md-padding-y' | '--gog-accordion-padding-x' | '--gog-accordion-padding-y' | '--gog-accordion-radius' | '--gog-accordion-slg-body-font-size' | '--gog-accordion-slg-body-line-height' | '--gog-accordion-slg-body-padding-bottom' | '--gog-accordion-slg-body-padding-top' | '--gog-accordion-slg-chevron-font-size' | '--gog-accordion-slg-chevron-size' | '--gog-accordion-slg-content-gap' | '--gog-accordion-slg-font-size' | '--gog-accordion-slg-letter-spacing' | '--gog-accordion-slg-padding-x' | '--gog-accordion-slg-padding-y' | '--gog-accordion-sm-body-font-size' | '--gog-accordion-sm-body-line-height' | '--gog-accordion-sm-body-padding-bottom' | '--gog-accordion-sm-body-padding-top' | '--gog-accordion-sm-chevron-font-size' | '--gog-accordion-sm-chevron-size' | '--gog-accordion-sm-content-gap' | '--gog-accordion-sm-font-size' | '--gog-accordion-sm-letter-spacing' | '--gog-accordion-sm-padding-x' | '--gog-accordion-sm-padding-y' | '--gog-accordion-text-color' | '--gog-accordion-transition-duration' | '--gog-accordion-xsm-body-font-size' | '--gog-accordion-xsm-body-line-height' | '--gog-accordion-xsm-body-padding-bottom' | '--gog-accordion-xsm-body-padding-top' | '--gog-accordion-xsm-chevron-font-size' | '--gog-accordion-xsm-chevron-size' | '--gog-accordion-xsm-content-gap' | '--gog-accordion-xsm-font-size' | '--gog-accordion-xsm-letter-spacing' | '--gog-accordion-xsm-padding-x' | '--gog-accordion-xsm-padding-y' | '--gog-autocomplete-actions-gap' | '--gog-autocomplete-actions-inset' | '--gog-autocomplete-actions-reserve' | '--gog-autocomplete-bg' | '--gog-autocomplete-border-color' | '--gog-autocomplete-border-style' | '--gog-autocomplete-border-width' | '--gog-autocomplete-clear-color' | '--gog-autocomplete-clear-hover-color' | '--gog-autocomplete-clear-icon-ratio' | '--gog-autocomplete-color' | '--gog-autocomplete-disabled-opacity' | '--gog-autocomplete-empty-color' | '--gog-autocomplete-empty-font-size' | '--gog-autocomplete-error-border-color' | '--gog-autocomplete-error-color' | '--gog-autocomplete-error-font-family' | '--gog-autocomplete-error-font-size' | '--gog-autocomplete-field-bg' | '--gog-autocomplete-float-label-in-top' | '--gog-autocomplete-float-label-on-bg' | '--gog-autocomplete-float-label-over-gap' | '--gog-autocomplete-float-label-over-reserve' | '--gog-autocomplete-float-label-reserve' | '--gog-autocomplete-focus-ring-color' | '--gog-autocomplete-focus-ring-offset' | '--gog-autocomplete-focus-ring-width' | '--gog-autocomplete-font-family' | '--gog-autocomplete-font-size' | '--gog-autocomplete-gap' | '--gog-autocomplete-hover-border-color' | '--gog-autocomplete-label-color' | '--gog-autocomplete-label-font-family' | '--gog-autocomplete-label-font-size' | '--gog-autocomplete-label-font-weight' | '--gog-autocomplete-label-letter-spacing' | '--gog-autocomplete-label-text-transform' | '--gog-autocomplete-line-height' | '--gog-autocomplete-min-width' | '--gog-autocomplete-option-color' | '--gog-autocomplete-option-gap' | '--gog-autocomplete-option-height' | '--gog-autocomplete-option-hover-bg' | '--gog-autocomplete-option-hover-color' | '--gog-autocomplete-option-padding' | '--gog-autocomplete-option-radius' | '--gog-autocomplete-option-selected-bg' | '--gog-autocomplete-option-selected-color' | '--gog-autocomplete-options-padding' | '--gog-autocomplete-padding-x' | '--gog-autocomplete-padding-y' | '--gog-autocomplete-panel-bg' | '--gog-autocomplete-panel-border-color' | '--gog-autocomplete-panel-border-style' | '--gog-autocomplete-panel-border-width' | '--gog-autocomplete-panel-gap' | '--gog-autocomplete-panel-max-height' | '--gog-autocomplete-panel-max-width' | '--gog-autocomplete-panel-radius' | '--gog-autocomplete-panel-shadow' | '--gog-autocomplete-placeholder-color' | '--gog-autocomplete-radius' | '--gog-autocomplete-spinner-size' | '--gog-autocomplete-text-color' | '--gog-autocomplete-transition-duration' | '--gog-background-color' | '--gog-badge-bg' | '--gog-badge-border-color' | '--gog-badge-border-style' | '--gog-badge-border-width' | '--gog-badge-color' | '--gog-badge-danger-bg' | '--gog-badge-danger-color' | '--gog-badge-dot-size' | '--gog-badge-font-family' | '--gog-badge-font-size' | '--gog-badge-font-weight' | '--gog-badge-info-bg' | '--gog-badge-info-color' | '--gog-badge-line-height' | '--gog-badge-offset' | '--gog-badge-padding-inline' | '--gog-badge-radius' | '--gog-badge-size' | '--gog-badge-success-bg' | '--gog-badge-success-color' | '--gog-badge-warning-bg' | '--gog-badge-warning-color' | '--gog-badge-z' | '--gog-border-color' | '--gog-btn-active-scale' | '--gog-btn-bg' | '--gog-btn-border' | '--gog-btn-border-style' | '--gog-btn-border-width' | '--gog-btn-color' | '--gog-btn-disabled-opacity' | '--gog-btn-focus-ring-offset' | '--gog-btn-focus-ring-width' | '--gog-btn-font-family' | '--gog-btn-font-weight' | '--gog-btn-gap' | '--gog-btn-ghost-bg' | '--gog-btn-ghost-border' | '--gog-btn-ghost-color' | '--gog-btn-ghost-hover-bg' | '--gog-btn-ghost-hover-color' | '--gog-btn-ghost-hover-shadow' | '--gog-btn-ghost-shadow' | '--gog-btn-ghost-spinner-color' | '--gog-btn-hover-bg' | '--gog-btn-hover-color' | '--gog-btn-hover-shadow' | '--gog-btn-letter-spacing' | '--gog-btn-lg-font-size' | '--gog-btn-lg-padding' | '--gog-btn-line-height' | '--gog-btn-loading-opacity' | '--gog-btn-md-font-size' | '--gog-btn-md-padding' | '--gog-btn-outline-bg' | '--gog-btn-outline-border' | '--gog-btn-outline-color' | '--gog-btn-outline-hover-bg' | '--gog-btn-outline-hover-color' | '--gog-btn-outline-hover-shadow' | '--gog-btn-outline-shadow' | '--gog-btn-outline-spinner-color' | '--gog-btn-primary-bg' | '--gog-btn-primary-border' | '--gog-btn-primary-color' | '--gog-btn-primary-hover-bg' | '--gog-btn-primary-hover-color' | '--gog-btn-primary-hover-shadow' | '--gog-btn-primary-shadow' | '--gog-btn-primary-spinner-color' | '--gog-btn-radius' | '--gog-btn-secondary-bg' | '--gog-btn-secondary-border' | '--gog-btn-secondary-color' | '--gog-btn-secondary-hover-bg' | '--gog-btn-secondary-hover-color' | '--gog-btn-secondary-hover-shadow' | '--gog-btn-secondary-shadow' | '--gog-btn-secondary-spinner-color' | '--gog-btn-shadow' | '--gog-btn-slg-font-size' | '--gog-btn-slg-padding' | '--gog-btn-sm-font-size' | '--gog-btn-sm-padding' | '--gog-btn-spinner-color' | '--gog-btn-spinner-max-size' | '--gog-btn-text-transform' | '--gog-btn-transition-duration' | '--gog-btn-xsm-font-size' | '--gog-btn-xsm-padding' | '--gog-button-toggle-bg' | '--gog-button-toggle-border-color' | '--gog-button-toggle-border-style' | '--gog-button-toggle-border-width' | '--gog-button-toggle-color' | '--gog-button-toggle-disabled-opacity' | '--gog-button-toggle-focus-ring-color' | '--gog-button-toggle-focus-ring-offset' | '--gog-button-toggle-focus-ring-width' | '--gog-button-toggle-font-family' | '--gog-button-toggle-font-size' | '--gog-button-toggle-font-weight' | '--gog-button-toggle-gap' | '--gog-button-toggle-hover-bg' | '--gog-button-toggle-hover-color' | '--gog-button-toggle-icon-size' | '--gog-button-toggle-letter-spacing' | '--gog-button-toggle-line-height' | '--gog-button-toggle-padding' | '--gog-button-toggle-radius' | '--gog-button-toggle-rest-bg' | '--gog-button-toggle-rest-color' | '--gog-button-toggle-selected-bg' | '--gog-button-toggle-selected-border-color' | '--gog-button-toggle-selected-color' | '--gog-button-toggle-separated-gap' | '--gog-button-toggle-text-transform' | '--gog-button-toggle-transition-duration' | '--gog-calendar-action-padding' | '--gog-calendar-color' | '--gog-calendar-day-bg' | '--gog-calendar-day-border-style' | '--gog-calendar-day-border-width' | '--gog-calendar-day-color' | '--gog-calendar-day-hover-bg' | '--gog-calendar-day-outside-color' | '--gog-calendar-day-radius' | '--gog-calendar-day-rest-bg' | '--gog-calendar-day-rest-color' | '--gog-calendar-day-size' | '--gog-calendar-disabled-opacity' | '--gog-calendar-divider-color' | '--gog-calendar-divider-style' | '--gog-calendar-divider-width' | '--gog-calendar-focus-ring-color' | '--gog-calendar-focus-ring-offset' | '--gog-calendar-focus-ring-width' | '--gog-calendar-font-family' | '--gog-calendar-header-gap' | '--gog-calendar-header-margin' | '--gog-calendar-lg-day-size' | '--gog-calendar-lg-font-size' | '--gog-calendar-md-day-size' | '--gog-calendar-md-font-size' | '--gog-calendar-months-gap' | '--gog-calendar-nav-bg' | '--gog-calendar-nav-color' | '--gog-calendar-nav-hover-bg' | '--gog-calendar-nav-hover-color' | '--gog-calendar-nav-icon-overlap' | '--gog-calendar-nav-icon-size' | '--gog-calendar-nav-radius' | '--gog-calendar-nav-size' | '--gog-calendar-padding' | '--gog-calendar-range-bg' | '--gog-calendar-range-color' | '--gog-calendar-selected-bg' | '--gog-calendar-selected-color' | '--gog-calendar-selected-font-weight' | '--gog-calendar-slg-day-size' | '--gog-calendar-slg-font-size' | '--gog-calendar-sm-day-size' | '--gog-calendar-sm-font-size' | '--gog-calendar-time-gap' | '--gog-calendar-time-input-bg' | '--gog-calendar-time-input-padding' | '--gog-calendar-time-input-width' | '--gog-calendar-time-margin' | '--gog-calendar-title-color' | '--gog-calendar-title-font-weight' | '--gog-calendar-today-border-color' | '--gog-calendar-today-font-weight' | '--gog-calendar-transition-duration' | '--gog-calendar-weekday-color' | '--gog-calendar-weekday-font-size' | '--gog-calendar-weekday-font-weight' | '--gog-calendar-weekday-padding' | '--gog-calendar-weekday-text-transform' | '--gog-calendar-xsm-day-size' | '--gog-calendar-xsm-font-size' | '--gog-checkbox-bg' | '--gog-checkbox-border-color' | '--gog-checkbox-border-style' | '--gog-checkbox-border-width' | '--gog-checkbox-box-size' | '--gog-checkbox-checked-bg' | '--gog-checkbox-checked-border' | '--gog-checkbox-dash-height' | '--gog-checkbox-dash-radius' | '--gog-checkbox-dash-width-ratio' | '--gog-checkbox-disabled-opacity' | '--gog-checkbox-focus-ring' | '--gog-checkbox-focus-ring-offset' | '--gog-checkbox-focus-ring-width' | '--gog-checkbox-font-family' | '--gog-checkbox-gap' | '--gog-checkbox-icon-color' | '--gog-checkbox-icon-size' | '--gog-checkbox-label-color' | '--gog-checkbox-label-line-height' | '--gog-checkbox-label-size' | '--gog-checkbox-padding' | '--gog-checkbox-radius' | '--gog-checkbox-transition-duration' | '--gog-chip-avatar-inset-ratio' | '--gog-chip-avatar-size' | '--gog-chip-bg' | '--gog-chip-border' | '--gog-chip-border-style' | '--gog-chip-border-width' | '--gog-chip-color' | '--gog-chip-disabled-opacity' | '--gog-chip-focus-ring-offset' | '--gog-chip-focus-ring-width' | '--gog-chip-font-family' | '--gog-chip-font-size' | '--gog-chip-font-weight' | '--gog-chip-gap' | '--gog-chip-hover-bg' | '--gog-chip-icon-size' | '--gog-chip-lg-avatar-size' | '--gog-chip-lg-font-size' | '--gog-chip-lg-gap' | '--gog-chip-lg-icon-size' | '--gog-chip-lg-padding-block' | '--gog-chip-lg-padding-inline' | '--gog-chip-lg-remove-size' | '--gog-chip-line-height' | '--gog-chip-md-avatar-size' | '--gog-chip-md-font-size' | '--gog-chip-md-gap' | '--gog-chip-md-icon-size' | '--gog-chip-md-padding-block' | '--gog-chip-md-padding-inline' | '--gog-chip-md-remove-size' | '--gog-chip-padding-block' | '--gog-chip-padding-inline' | '--gog-chip-pill-radius' | '--gog-chip-radius' | '--gog-chip-remove-color' | '--gog-chip-remove-hover-color' | '--gog-chip-remove-inset-ratio' | '--gog-chip-remove-scale' | '--gog-chip-remove-size' | '--gog-chip-slg-avatar-size' | '--gog-chip-slg-font-size' | '--gog-chip-slg-gap' | '--gog-chip-slg-icon-size' | '--gog-chip-slg-padding-block' | '--gog-chip-slg-padding-inline' | '--gog-chip-slg-remove-size' | '--gog-chip-sm-avatar-size' | '--gog-chip-sm-font-size' | '--gog-chip-sm-gap' | '--gog-chip-sm-icon-size' | '--gog-chip-sm-padding-block' | '--gog-chip-sm-padding-inline' | '--gog-chip-sm-remove-size' | '--gog-chip-xsm-avatar-size' | '--gog-chip-xsm-font-size' | '--gog-chip-xsm-gap' | '--gog-chip-xsm-icon-size' | '--gog-chip-xsm-padding-block' | '--gog-chip-xsm-padding-inline' | '--gog-chip-xsm-remove-size' | '--gog-collapsible-disabled-opacity' | '--gog-collapsible-max-height' | '--gog-collapsible-transition-duration' | '--gog-confirm-actions-gap' | '--gog-confirm-actions-offset' | '--gog-confirm-color' | '--gog-confirm-description-color' | '--gog-confirm-gap' | '--gog-confirm-max-width' | '--gog-confirm-min-width' | '--gog-control-border-style' | '--gog-control-border-width' | '--gog-control-checkbox-box-size-lg' | '--gog-control-checkbox-box-size-md' | '--gog-control-checkbox-box-size-slg' | '--gog-control-checkbox-box-size-sm' | '--gog-control-checkbox-box-size-xsm' | '--gog-control-checkbox-icon-size-lg' | '--gog-control-checkbox-icon-size-md' | '--gog-control-checkbox-icon-size-slg' | '--gog-control-checkbox-icon-size-sm' | '--gog-control-checkbox-icon-size-xsm' | '--gog-control-checkbox-label-size-lg' | '--gog-control-checkbox-label-size-md' | '--gog-control-checkbox-label-size-slg' | '--gog-control-checkbox-label-size-sm' | '--gog-control-checkbox-label-size-xsm' | '--gog-control-checkbox-padding' | '--gog-control-icon-offset' | '--gog-control-padding-x' | '--gog-control-padding-y' | '--gog-danger-color' | '--gog-datepicker-actions-gap' | '--gog-datepicker-actions-inset' | '--gog-datepicker-actions-reserve' | '--gog-datepicker-bg' | '--gog-datepicker-border-color' | '--gog-datepicker-border-style' | '--gog-datepicker-border-width' | '--gog-datepicker-clear-color' | '--gog-datepicker-clear-icon-ratio' | '--gog-datepicker-color' | '--gog-datepicker-disabled-opacity' | '--gog-datepicker-error-border-color' | '--gog-datepicker-error-color' | '--gog-datepicker-error-font-family' | '--gog-datepicker-error-font-size' | '--gog-datepicker-field-bg' | '--gog-datepicker-float-label-in-top' | '--gog-datepicker-float-label-on-bg' | '--gog-datepicker-float-label-over-gap' | '--gog-datepicker-float-label-over-reserve' | '--gog-datepicker-float-label-reserve' | '--gog-datepicker-focus-ring-color' | '--gog-datepicker-focus-ring-offset' | '--gog-datepicker-focus-ring-width' | '--gog-datepicker-font-family' | '--gog-datepicker-font-size' | '--gog-datepicker-gap' | '--gog-datepicker-hover-border-color' | '--gog-datepicker-icon-color' | '--gog-datepicker-icon-hover-color' | '--gog-datepicker-label-color' | '--gog-datepicker-label-font-family' | '--gog-datepicker-label-font-size' | '--gog-datepicker-label-letter-spacing' | '--gog-datepicker-label-text-transform' | '--gog-datepicker-line-height' | '--gog-datepicker-min-width' | '--gog-datepicker-padding-x' | '--gog-datepicker-padding-y' | '--gog-datepicker-panel-bg' | '--gog-datepicker-panel-border-color' | '--gog-datepicker-panel-border-style' | '--gog-datepicker-panel-border-width' | '--gog-datepicker-panel-gap' | '--gog-datepicker-panel-radius' | '--gog-datepicker-panel-shadow' | '--gog-datepicker-placeholder-color' | '--gog-datepicker-radius' | '--gog-datepicker-text-color' | '--gog-datepicker-toggle-icon-size' | '--gog-datepicker-transition-duration' | '--gog-dialog-backdrop-bg' | '--gog-dialog-backdrop-blur' | '--gog-dialog-backdrop-fade-duration' | '--gog-dialog-backdrop-padding' | '--gog-dialog-bg' | '--gog-dialog-body-max-height' | '--gog-dialog-body-padding' | '--gog-dialog-border' | '--gog-dialog-border-style' | '--gog-dialog-border-width' | '--gog-dialog-close-color' | '--gog-dialog-close-focus-ring' | '--gog-dialog-close-focus-ring-offset' | '--gog-dialog-close-focus-ring-width' | '--gog-dialog-close-font-size' | '--gog-dialog-close-hover-bg' | '--gog-dialog-close-hover-border' | '--gog-dialog-close-hover-color' | '--gog-dialog-close-size' | '--gog-dialog-color' | '--gog-dialog-enter-distance' | '--gog-dialog-enter-duration' | '--gog-dialog-font-family' | '--gog-dialog-header-border-color' | '--gog-dialog-header-gap' | '--gog-dialog-header-padding' | '--gog-dialog-max-height' | '--gog-dialog-min-width' | '--gog-dialog-offset-x' | '--gog-dialog-offset-y' | '--gog-dialog-radius' | '--gog-dialog-shadow' | '--gog-disabled-opacity' | '--gog-divider-block-spacing' | '--gog-divider-color' | '--gog-divider-dashed-style' | '--gog-divider-dotted-style' | '--gog-divider-inline-spacing' | '--gog-divider-inset-size' | '--gog-divider-label-color' | '--gog-divider-label-font-family' | '--gog-divider-label-font-size' | '--gog-divider-label-font-weight' | '--gog-divider-label-gap' | '--gog-divider-label-line-height' | '--gog-divider-line-color' | '--gog-divider-line-thickness' | '--gog-divider-solid-style' | '--gog-divider-spacing' | '--gog-divider-thickness' | '--gog-divider-vertical-length' | '--gog-dropdown-z' | '--gog-duration-base' | '--gog-duration-fast' | '--gog-duration-slow' | '--gog-easing' | '--gog-field-float-label-in-top' | '--gog-field-float-label-over-gap' | '--gog-field-float-label-over-reserve' | '--gog-field-float-label-reserve' | '--gog-field-lg-font-size' | '--gog-field-lg-icon-inset' | '--gog-field-lg-icon-offset' | '--gog-field-lg-padding-x' | '--gog-field-lg-padding-y' | '--gog-field-md-font-size' | '--gog-field-md-icon-inset' | '--gog-field-md-icon-offset' | '--gog-field-md-padding-x' | '--gog-field-md-padding-y' | '--gog-field-slg-font-size' | '--gog-field-slg-icon-inset' | '--gog-field-slg-icon-offset' | '--gog-field-slg-padding-x' | '--gog-field-slg-padding-y' | '--gog-field-sm-font-size' | '--gog-field-sm-icon-inset' | '--gog-field-sm-icon-offset' | '--gog-field-sm-padding-x' | '--gog-field-sm-padding-y' | '--gog-field-xsm-font-size' | '--gog-field-xsm-icon-inset' | '--gog-field-xsm-icon-offset' | '--gog-field-xsm-padding-x' | '--gog-field-xsm-padding-y' | '--gog-focus-ring-offset' | '--gog-focus-ring-width' | '--gog-font-body' | '--gog-font-heading' | '--gog-font-mono' | '--gog-hover-color' | '--gog-icon-fallback-size' | '--gog-icon-size' | '--gog-icon-stroke-width' | '--gog-info-color' | '--gog-input-clear-icon-ratio' | '--gog-input-clear-inset' | '--gog-input-clear-radius' | '--gog-input-disabled-opacity' | '--gog-input-error-color' | '--gog-input-error-font-size' | '--gog-input-error-offset' | '--gog-input-field-bg' | '--gog-input-field-border' | '--gog-input-field-border-style' | '--gog-input-field-border-width' | '--gog-input-field-color' | '--gog-input-float-label-in-top' | '--gog-input-float-label-on-bg' | '--gog-input-float-label-over-gap' | '--gog-input-float-label-over-reserve' | '--gog-input-float-label-reserve' | '--gog-input-focus-border' | '--gog-input-focus-glow' | '--gog-input-focus-ring' | '--gog-input-focus-ring-offset' | '--gog-input-focus-ring-width' | '--gog-input-font' | '--gog-input-font-family' | '--gog-input-gap' | '--gog-input-icon-action-radius' | '--gog-input-icon-color' | '--gog-input-icon-focus-ring-width' | '--gog-input-icon-hover-color' | '--gog-input-label-color' | '--gog-input-label-font-family' | '--gog-input-label-font-size' | '--gog-input-label-letter-spacing' | '--gog-input-label-text-transform' | '--gog-input-padding-x' | '--gog-input-padding-y' | '--gog-input-placeholder-color' | '--gog-input-radius' | '--gog-input-transition-duration' | '--gog-ms-actions-gap' | '--gog-ms-actions-inset' | '--gog-ms-arrow-icon-ratio' | '--gog-ms-arrow-transition-duration' | '--gog-ms-border-color' | '--gog-ms-checkbox-bg' | '--gog-ms-checkbox-border' | '--gog-ms-checkbox-checked-bg' | '--gog-ms-checkbox-checked-color' | '--gog-ms-clear-icon-ratio' | '--gog-ms-clear-radius' | '--gog-ms-controls-gap' | '--gog-ms-controls-padding' | '--gog-ms-disabled-opacity' | '--gog-ms-error-color' | '--gog-ms-error-font-size' | '--gog-ms-error-offset' | '--gog-ms-field-bg' | '--gog-ms-field-border' | '--gog-ms-field-border-style' | '--gog-ms-field-border-width' | '--gog-ms-field-color' | '--gog-ms-filter-border-color' | '--gog-ms-filter-border-style' | '--gog-ms-filter-border-width' | '--gog-ms-filter-empty-color' | '--gog-ms-filter-empty-padding' | '--gog-ms-filter-input-bg' | '--gog-ms-filter-input-border' | '--gog-ms-filter-input-color' | '--gog-ms-filter-input-padding-x' | '--gog-ms-filter-input-padding-y' | '--gog-ms-filter-input-radius' | '--gog-ms-filter-padding' | '--gog-ms-float-label-in-top' | '--gog-ms-float-label-over-gap' | '--gog-ms-float-label-over-reserve' | '--gog-ms-float-label-reserve' | '--gog-ms-focus-border' | '--gog-ms-focus-glow' | '--gog-ms-focus-ring' | '--gog-ms-focus-ring-offset' | '--gog-ms-focus-ring-width' | '--gog-ms-font-family' | '--gog-ms-gap' | '--gog-ms-label-color' | '--gog-ms-label-font-family' | '--gog-ms-label-font-size' | '--gog-ms-label-letter-spacing' | '--gog-ms-label-text-transform' | '--gog-ms-mark-icon-ratio' | '--gog-ms-mark-size-ratio' | '--gog-ms-min-width' | '--gog-ms-option-color' | '--gog-ms-option-disabled-opacity' | '--gog-ms-option-gap' | '--gog-ms-option-gap-inline' | '--gog-ms-option-height' | '--gog-ms-option-hover-bg' | '--gog-ms-option-radius' | '--gog-ms-option-transition-duration' | '--gog-ms-options-padding' | '--gog-ms-overflow-color' | '--gog-ms-overflow-font-size' | '--gog-ms-overflow-gap' | '--gog-ms-panel-bg' | '--gog-ms-panel-border' | '--gog-ms-panel-max-height' | '--gog-ms-panel-max-width' | '--gog-ms-panel-offset' | '--gog-ms-panel-shadow' | '--gog-ms-placeholder-color' | '--gog-ms-radius' | '--gog-ms-transition-duration' | '--gog-ms-value-color' | '--gog-multiselect-actions-gap' | '--gog-multiselect-actions-inset' | '--gog-multiselect-arrow-icon-ratio' | '--gog-multiselect-arrow-transition-duration' | '--gog-multiselect-border-color' | '--gog-multiselect-checkbox-bg' | '--gog-multiselect-checkbox-border' | '--gog-multiselect-checkbox-checked-bg' | '--gog-multiselect-checkbox-checked-color' | '--gog-multiselect-clear-icon-ratio' | '--gog-multiselect-clear-radius' | '--gog-multiselect-controls-gap' | '--gog-multiselect-controls-padding' | '--gog-multiselect-disabled-opacity' | '--gog-multiselect-error-color' | '--gog-multiselect-error-font-size' | '--gog-multiselect-error-offset' | '--gog-multiselect-field-bg' | '--gog-multiselect-field-border' | '--gog-multiselect-field-border-style' | '--gog-multiselect-field-border-width' | '--gog-multiselect-field-color' | '--gog-multiselect-filter-border-color' | '--gog-multiselect-filter-border-style' | '--gog-multiselect-filter-border-width' | '--gog-multiselect-filter-empty-color' | '--gog-multiselect-filter-empty-padding' | '--gog-multiselect-filter-input-bg' | '--gog-multiselect-filter-input-border' | '--gog-multiselect-filter-input-color' | '--gog-multiselect-filter-input-padding-x' | '--gog-multiselect-filter-input-padding-y' | '--gog-multiselect-filter-input-radius' | '--gog-multiselect-filter-padding' | '--gog-multiselect-float-label-in-top' | '--gog-multiselect-float-label-on-bg' | '--gog-multiselect-float-label-over-gap' | '--gog-multiselect-float-label-over-reserve' | '--gog-multiselect-float-label-reserve' | '--gog-multiselect-focus-border' | '--gog-multiselect-focus-glow' | '--gog-multiselect-focus-ring' | '--gog-multiselect-focus-ring-offset' | '--gog-multiselect-focus-ring-width' | '--gog-multiselect-font-family' | '--gog-multiselect-font-size' | '--gog-multiselect-gap' | '--gog-multiselect-label-color' | '--gog-multiselect-label-font-family' | '--gog-multiselect-label-font-size' | '--gog-multiselect-label-letter-spacing' | '--gog-multiselect-label-text-transform' | '--gog-multiselect-mark-icon-ratio' | '--gog-multiselect-mark-size-ratio' | '--gog-multiselect-min-width' | '--gog-multiselect-option-color' | '--gog-multiselect-option-disabled-opacity' | '--gog-multiselect-option-gap' | '--gog-multiselect-option-gap-inline' | '--gog-multiselect-option-height' | '--gog-multiselect-option-hover-bg' | '--gog-multiselect-option-radius' | '--gog-multiselect-option-transition-duration' | '--gog-multiselect-options-padding' | '--gog-multiselect-overflow-color' | '--gog-multiselect-overflow-font-size' | '--gog-multiselect-overflow-gap' | '--gog-multiselect-padding-x' | '--gog-multiselect-padding-y' | '--gog-multiselect-panel-bg' | '--gog-multiselect-panel-border' | '--gog-multiselect-panel-max-height' | '--gog-multiselect-panel-max-width' | '--gog-multiselect-panel-offset' | '--gog-multiselect-panel-shadow' | '--gog-multiselect-placeholder-color' | '--gog-multiselect-radius' | '--gog-multiselect-transition-duration' | '--gog-multiselect-value-color' | '--gog-muted-text-color' | '--gog-paginator-ellipsis-color' | '--gog-paginator-ellipsis-font-family' | '--gog-paginator-ellipsis-font-size' | '--gog-paginator-ellipsis-min-width' | '--gog-paginator-gap' | '--gog-panel-border-style' | '--gog-panel-border-width' | '--gog-panel-radius' | '--gog-panel-shadow' | '--gog-primary-color' | '--gog-progressbar-accent-bg' | '--gog-progressbar-accent-buffer-bg' | '--gog-progressbar-buffer-bg' | '--gog-progressbar-danger-bg' | '--gog-progressbar-danger-buffer-bg' | '--gog-progressbar-fill-bg' | '--gog-progressbar-height' | '--gog-progressbar-indeterminate-duration' | '--gog-progressbar-indeterminate-easing' | '--gog-progressbar-info-bg' | '--gog-progressbar-info-buffer-bg' | '--gog-progressbar-lg-height' | '--gog-progressbar-md-height' | '--gog-progressbar-radius' | '--gog-progressbar-slg-height' | '--gog-progressbar-sm-height' | '--gog-progressbar-stripe-color' | '--gog-progressbar-stripe-size' | '--gog-progressbar-success-bg' | '--gog-progressbar-success-buffer-bg' | '--gog-progressbar-track-base-bg' | '--gog-progressbar-track-bg' | '--gog-progressbar-transition-duration' | '--gog-progressbar-value-color' | '--gog-progressbar-value-font-family' | '--gog-progressbar-value-font-size' | '--gog-progressbar-value-gap' | '--gog-progressbar-value-min-width' | '--gog-progressbar-warning-bg' | '--gog-progressbar-warning-buffer-bg' | '--gog-progressbar-xsm-height' | '--gog-radio-bg' | '--gog-radio-border-color' | '--gog-radio-border-style' | '--gog-radio-border-width' | '--gog-radio-box-size' | '--gog-radio-checked-bg' | '--gog-radio-checked-border' | '--gog-radio-disabled-opacity' | '--gog-radio-dot-color' | '--gog-radio-dot-size-ratio' | '--gog-radio-error-color' | '--gog-radio-error-font-size' | '--gog-radio-focus-ring' | '--gog-radio-focus-ring-offset' | '--gog-radio-focus-ring-width' | '--gog-radio-font-family' | '--gog-radio-gap' | '--gog-radio-group-gap' | '--gog-radio-group-label-color' | '--gog-radio-group-label-size' | '--gog-radio-group-option-gap' | '--gog-radio-group-option-gap-horizontal' | '--gog-radio-label-color' | '--gog-radio-label-line-height' | '--gog-radio-label-size' | '--gog-radio-padding' | '--gog-radio-transition-duration' | '--gog-radius' | '--gog-scroll-corner-bg' | '--gog-scroll-fade-duration' | '--gog-scroll-focus-ring' | '--gog-scroll-focus-ring-width' | '--gog-scroll-normal-thumb-min-size' | '--gog-scroll-normal-track-width' | '--gog-scroll-thin-thumb-min-size' | '--gog-scroll-thin-track-width' | '--gog-scroll-thumb-active-bg' | '--gog-scroll-thumb-bg' | '--gog-scroll-thumb-hover-bg' | '--gog-scroll-thumb-inset' | '--gog-scroll-thumb-radius' | '--gog-scroll-track-bg' | '--gog-scroll-track-radius' | '--gog-secondary-color' | '--gog-select-chevron-color' | '--gog-select-chevron-icon-ratio' | '--gog-select-chevron-inset' | '--gog-select-clear-color' | '--gog-select-clear-gap' | '--gog-select-clear-hover-color' | '--gog-select-clear-icon-ratio' | '--gog-select-clear-radius' | '--gog-select-control-font' | '--gog-select-control-gap' | '--gog-select-control-padding-x' | '--gog-select-control-padding-y' | '--gog-select-disabled-opacity' | '--gog-select-error-color' | '--gog-select-error-font-size' | '--gog-select-field-bg' | '--gog-select-field-border' | '--gog-select-field-border-style' | '--gog-select-field-border-width' | '--gog-select-field-color' | '--gog-select-filter-border-color' | '--gog-select-filter-border-style' | '--gog-select-filter-border-width' | '--gog-select-filter-empty-color' | '--gog-select-filter-empty-padding' | '--gog-select-filter-input-bg' | '--gog-select-filter-input-border' | '--gog-select-filter-input-color' | '--gog-select-filter-input-padding-x' | '--gog-select-filter-input-padding-y' | '--gog-select-filter-input-radius' | '--gog-select-filter-padding' | '--gog-select-float-label-in-top' | '--gog-select-float-label-on-bg' | '--gog-select-float-label-over-gap' | '--gog-select-float-label-over-reserve' | '--gog-select-float-label-reserve' | '--gog-select-focus-border' | '--gog-select-focus-glow' | '--gog-select-focus-ring' | '--gog-select-focus-ring-offset' | '--gog-select-focus-ring-width' | '--gog-select-font-family' | '--gog-select-gap' | '--gog-select-label-color' | '--gog-select-label-font-family' | '--gog-select-label-font-size' | '--gog-select-label-letter-spacing' | '--gog-select-label-text-transform' | '--gog-select-mark-icon-ratio' | '--gog-select-mark-size-ratio' | '--gog-select-min-width' | '--gog-select-option-color' | '--gog-select-option-disabled-opacity' | '--gog-select-option-gap' | '--gog-select-option-height' | '--gog-select-option-hover-bg' | '--gog-select-option-selected-color' | '--gog-select-option-transition-duration' | '--gog-select-panel-bg' | '--gog-select-panel-max-height' | '--gog-select-panel-max-width' | '--gog-select-panel-offset' | '--gog-select-panel-shadow' | '--gog-select-placeholder-color' | '--gog-select-radius' | '--gog-select-transition-duration' | '--gog-skeleton-base' | '--gog-skeleton-circle-size-lg' | '--gog-skeleton-circle-size-md' | '--gog-skeleton-circle-size-slg' | '--gog-skeleton-circle-size-sm' | '--gog-skeleton-circle-size-xsm' | '--gog-skeleton-line-gap' | '--gog-skeleton-line-height-lg' | '--gog-skeleton-line-height-md' | '--gog-skeleton-line-height-slg' | '--gog-skeleton-line-height-sm' | '--gog-skeleton-line-height-xsm' | '--gog-skeleton-line-radius' | '--gog-skeleton-pulse-duration' | '--gog-skeleton-pulse-min-opacity' | '--gog-skeleton-radius' | '--gog-skeleton-rect-height-lg' | '--gog-skeleton-rect-height-md' | '--gog-skeleton-rect-height-slg' | '--gog-skeleton-rect-height-sm' | '--gog-skeleton-rect-height-xsm' | '--gog-skeleton-shine' | '--gog-skeleton-short-line-width' | '--gog-skeleton-square-radius' | '--gog-skeleton-wave-duration' | '--gog-slider-auto-width' | '--gog-slider-disabled-opacity' | '--gog-slider-error-color' | '--gog-slider-error-font-family' | '--gog-slider-error-font-size' | '--gog-slider-fill-bg' | '--gog-slider-focus-ring' | '--gog-slider-focus-ring-width' | '--gog-slider-gap' | '--gog-slider-label-color' | '--gog-slider-label-font-family' | '--gog-slider-label-font-size' | '--gog-slider-label-letter-spacing' | '--gog-slider-label-text-transform' | '--gog-slider-range-color' | '--gog-slider-range-font-size' | '--gog-slider-thumb-bg' | '--gog-slider-thumb-border' | '--gog-slider-thumb-border-width' | '--gog-slider-thumb-glow-size' | '--gog-slider-thumb-radius' | '--gog-slider-thumb-shadow' | '--gog-slider-thumb-size' | '--gog-slider-track-area-height' | '--gog-slider-track-bg' | '--gog-slider-track-border-color' | '--gog-slider-track-border-style' | '--gog-slider-track-border-width' | '--gog-slider-track-height' | '--gog-slider-track-radius' | '--gog-slider-value-color' | '--gog-slider-value-font-family' | '--gog-slider-value-font-size' | '--gog-slider-value-min-width' | '--gog-slider-vertical-length' | '--gog-space-2xl' | '--gog-space-lg' | '--gog-space-md' | '--gog-space-sm' | '--gog-space-xs' | '--gog-spinner-arc-inner-color' | '--gog-spinner-arc-inner-dash' | '--gog-spinner-arc-inner-glow' | '--gog-spinner-arc-inner-opacity' | '--gog-spinner-arc-inner-pulse-opacity' | '--gog-spinner-arc-inner-stroke-compact' | '--gog-spinner-arc-outer-color' | '--gog-spinner-arc-outer-dash' | '--gog-spinner-arc-outer-glow' | '--gog-spinner-arc-outer-pulse-opacity' | '--gog-spinner-diamond-color' | '--gog-spinner-diamond-glow' | '--gog-spinner-diamond-opacity' | '--gog-spinner-glow-color' | '--gog-spinner-overlay-bg' | '--gog-spinner-overlay-blur' | '--gog-spinner-overlay-fade-duration' | '--gog-spinner-overlay-z' | '--gog-spinner-pulse-duration' | '--gog-spinner-ring-duration' | '--gog-spinner-ring-glow' | '--gog-spinner-ring-padding' | '--gog-spinner-rune-color' | '--gog-spinner-rune-font-family' | '--gog-spinner-rune-glow' | '--gog-spinner-rune-pulse-opacity' | '--gog-spinner-rune-size' | '--gog-spinner-size-lg' | '--gog-spinner-size-md' | '--gog-spinner-size-slg' | '--gog-spinner-size-sm' | '--gog-spinner-size-xsm' | '--gog-spinner-spin-duration' | '--gog-spinner-spin-slow-duration' | '--gog-spinner-ticks-duration' | '--gog-spinner-track-color' | '--gog-spinner-track-opacity' | '--gog-success-color' | '--gog-surface-color' | '--gog-table-accent-bright' | '--gog-table-accent-color' | '--gog-table-border-color' | '--gog-table-border-style' | '--gog-table-border-width' | '--gog-table-empty-font-size' | '--gog-table-empty-padding' | '--gog-table-focus-ring' | '--gog-table-focus-ring-width' | '--gog-table-font-family' | '--gog-table-footer-gap' | '--gog-table-footer-min-height' | '--gog-table-gap' | '--gog-table-header-font-family' | '--gog-table-header-letter-spacing' | '--gog-table-header-text-transform' | '--gog-table-hover-bg' | '--gog-table-lg-padding-v' | '--gog-table-lg-td-font-size' | '--gog-table-lg-th-font-size' | '--gog-table-loading-opacity' | '--gog-table-loading-padding' | '--gog-table-md-padding-v' | '--gog-table-md-td-font-size' | '--gog-table-md-th-font-size' | '--gog-table-muted-color' | '--gog-table-num-col-width' | '--gog-table-num-font-size' | '--gog-table-numeric-font-family' | '--gog-table-padding-h' | '--gog-table-row-border-width' | '--gog-table-row-transition-duration' | '--gog-table-slg-padding-v' | '--gog-table-slg-td-font-size' | '--gog-table-slg-th-font-size' | '--gog-table-sm-padding-v' | '--gog-table-sm-td-font-size' | '--gog-table-sm-th-font-size' | '--gog-table-sort-icon-opacity' | '--gog-table-sort-icon-size' | '--gog-table-sort-icon-width' | '--gog-table-surface' | '--gog-table-td-font-size' | '--gog-table-td-padding-v' | '--gog-table-text-color' | '--gog-table-th-font-size' | '--gog-table-th-inner-gap' | '--gog-table-th-padding-v' | '--gog-table-total-font-size' | '--gog-table-total-letter-spacing' | '--gog-table-total-text-transform' | '--gog-table-xsm-padding-v' | '--gog-table-xsm-td-font-size' | '--gog-table-xsm-th-font-size' | '--gog-tabs-active-color' | '--gog-tabs-disabled-opacity' | '--gog-tabs-focus-ring-color' | '--gog-tabs-focus-ring-offset' | '--gog-tabs-focus-ring-width' | '--gog-tabs-font-family' | '--gog-tabs-font-weight' | '--gog-tabs-gap' | '--gog-tabs-header-border-color' | '--gog-tabs-header-border-style' | '--gog-tabs-header-border-width' | '--gog-tabs-hover-color' | '--gog-tabs-icon-size' | '--gog-tabs-indicator-color' | '--gog-tabs-indicator-radius' | '--gog-tabs-indicator-thickness' | '--gog-tabs-letter-spacing' | '--gog-tabs-lg-font-size' | '--gog-tabs-lg-padding' | '--gog-tabs-line-height' | '--gog-tabs-md-font-size' | '--gog-tabs-md-padding' | '--gog-tabs-panel-color' | '--gog-tabs-panel-padding' | '--gog-tabs-rest-bg' | '--gog-tabs-rest-color' | '--gog-tabs-slg-font-size' | '--gog-tabs-slg-padding' | '--gog-tabs-sm-font-size' | '--gog-tabs-sm-padding' | '--gog-tabs-tab-bg' | '--gog-tabs-tab-color' | '--gog-tabs-tab-font-size' | '--gog-tabs-tab-gap' | '--gog-tabs-tab-padding' | '--gog-tabs-text-transform' | '--gog-tabs-transition-duration' | '--gog-tabs-xsm-font-size' | '--gog-tabs-xsm-padding' | '--gog-tag-accent' | '--gog-tag-bg' | '--gog-tag-bg-base' | '--gog-tag-bg-mix' | '--gog-tag-border' | '--gog-tag-border-style' | '--gog-tag-border-width' | '--gog-tag-color' | '--gog-tag-color-base' | '--gog-tag-color-mix' | '--gog-tag-danger-color' | '--gog-tag-default-color' | '--gog-tag-font-family' | '--gog-tag-font-size' | '--gog-tag-font-weight' | '--gog-tag-gap' | '--gog-tag-icon-size' | '--gog-tag-info-color' | '--gog-tag-inner-border-width' | '--gog-tag-lg-font-size' | '--gog-tag-lg-gap' | '--gog-tag-lg-icon-size' | '--gog-tag-lg-padding-block' | '--gog-tag-lg-padding-inline' | '--gog-tag-line-height' | '--gog-tag-md-font-size' | '--gog-tag-md-gap' | '--gog-tag-md-icon-size' | '--gog-tag-md-padding-block' | '--gog-tag-md-padding-inline' | '--gog-tag-padding-block' | '--gog-tag-padding-inline' | '--gog-tag-pill-radius' | '--gog-tag-radius' | '--gog-tag-slg-font-size' | '--gog-tag-slg-gap' | '--gog-tag-slg-icon-size' | '--gog-tag-slg-padding-block' | '--gog-tag-slg-padding-inline' | '--gog-tag-sm-font-size' | '--gog-tag-sm-gap' | '--gog-tag-sm-icon-size' | '--gog-tag-sm-padding-block' | '--gog-tag-sm-padding-inline' | '--gog-tag-success-color' | '--gog-tag-warning-color' | '--gog-tag-xsm-font-size' | '--gog-tag-xsm-gap' | '--gog-tag-xsm-icon-size' | '--gog-tag-xsm-padding-block' | '--gog-tag-xsm-padding-inline' | '--gog-text-2xl' | '--gog-text-3xl' | '--gog-text-color' | '--gog-text-lg' | '--gog-text-md' | '--gog-text-sm' | '--gog-text-xl' | '--gog-text-xs' | '--gog-textarea-clear-icon-ratio' | '--gog-textarea-scrollbar-width' | '--gog-toast-accent-width' | '--gog-toast-action-font-size' | '--gog-toast-action-padding' | '--gog-toast-actions-gap' | '--gog-toast-base-z' | '--gog-toast-bg' | '--gog-toast-border' | '--gog-toast-close-font-size' | '--gog-toast-close-padding' | '--gog-toast-color' | '--gog-toast-content-gap' | '--gog-toast-enter-distance' | '--gog-toast-error-color' | '--gog-toast-font-family' | '--gog-toast-gap' | '--gog-toast-icon-color' | '--gog-toast-icon-line-height' | '--gog-toast-icon-size' | '--gog-toast-info-color' | '--gog-toast-main-gap' | '--gog-toast-max-width' | '--gog-toast-message-font-size' | '--gog-toast-message-line-height' | '--gog-toast-min-width' | '--gog-toast-padding' | '--gog-toast-progress-height' | '--gog-toast-progress-opacity' | '--gog-toast-radius' | '--gog-toast-shadow' | '--gog-toast-stack-expanded-gap' | '--gog-toast-stack-max-depth' | '--gog-toast-stack-min-opacity' | '--gog-toast-stack-opacity-step' | '--gog-toast-stack-padding' | '--gog-toast-stack-peek' | '--gog-toast-stack-scale-step' | '--gog-toast-success-color' | '--gog-toast-transition-duration' | '--gog-toast-warning-color' | '--gog-toast-z-index' | '--gog-toggle-border-color' | '--gog-toggle-border-style' | '--gog-toggle-border-width' | '--gog-toggle-disabled-opacity' | '--gog-toggle-focus-ring-color' | '--gog-toggle-focus-ring-offset' | '--gog-toggle-focus-ring-width' | '--gog-toggle-font-family' | '--gog-toggle-gap' | '--gog-toggle-label-color' | '--gog-toggle-label-line-height' | '--gog-toggle-lg-label-size' | '--gog-toggle-lg-state-font-size' | '--gog-toggle-lg-thumb-size' | '--gog-toggle-lg-track-height' | '--gog-toggle-lg-track-width' | '--gog-toggle-md-label-size' | '--gog-toggle-md-state-font-size' | '--gog-toggle-md-thumb-size' | '--gog-toggle-md-track-height' | '--gog-toggle-md-track-width' | '--gog-toggle-on-border-color' | '--gog-toggle-padding' | '--gog-toggle-radius' | '--gog-toggle-slg-label-size' | '--gog-toggle-slg-state-font-size' | '--gog-toggle-slg-thumb-size' | '--gog-toggle-slg-track-height' | '--gog-toggle-slg-track-width' | '--gog-toggle-sm-label-size' | '--gog-toggle-sm-state-font-size' | '--gog-toggle-sm-thumb-size' | '--gog-toggle-sm-track-height' | '--gog-toggle-sm-track-width' | '--gog-toggle-state-color' | '--gog-toggle-state-font-weight' | '--gog-toggle-state-letter-spacing' | '--gog-toggle-state-offset' | '--gog-toggle-state-padding-inline' | '--gog-toggle-state-thumb-gap' | '--gog-toggle-thumb-bg' | '--gog-toggle-thumb-inset' | '--gog-toggle-thumb-off-bg' | '--gog-toggle-thumb-on-bg' | '--gog-toggle-thumb-shadow' | '--gog-toggle-track-bg' | '--gog-toggle-track-off-bg' | '--gog-toggle-track-on-bg' | '--gog-toggle-transition-duration' | '--gog-toggle-xsm-label-size' | '--gog-toggle-xsm-state-font-size' | '--gog-toggle-xsm-thumb-size' | '--gog-toggle-xsm-track-height' | '--gog-toggle-xsm-track-width' | '--gog-tooltip-arrow-size' | '--gog-tooltip-bg' | '--gog-tooltip-border-color' | '--gog-tooltip-border-style' | '--gog-tooltip-border-width' | '--gog-tooltip-color' | '--gog-tooltip-font-family' | '--gog-tooltip-font-size' | '--gog-tooltip-gap' | '--gog-tooltip-line-height' | '--gog-tooltip-max-height' | '--gog-tooltip-max-width' | '--gog-tooltip-padding' | '--gog-tooltip-radius' | '--gog-tooltip-shadow' | '--gog-tooltip-transition-duration' | '--gog-tooltip-z' | '--gog-warning-color';
+/** Which of the three layers a token belongs to — see the README's theming section. */
+type GogTokenLayer = 'foundation' | 'component' | 'instance';
+interface GogTokenGroup {
+    /** The `── Section ──` heading the token sits under in theme.css. */
+    readonly section: string;
+    readonly layer: GogTokenLayer;
+    readonly tokens: readonly GogTokenName[];
+}
+/**
+ * The token catalogue, grouped as theme.css groups it. Exported so a theme editor or docs page
+ * can enumerate the real tokens instead of keeping a hand-copied list that drifts.
+ */
+declare const GOG_TOKEN_GROUPS: readonly GogTokenGroup[];
+
+type GogTooltipSide = 'top' | 'bottom' | 'left' | 'right';
+
+export { AccordionComponent, AutocompleteComponent, ButtonComponent, ButtonToggleGroupComponent, CalendarComponent, CheckboxComponent, ChipComponent, CollapsibleComponent, Column, ConfirmationDialogComponent, DIALOG_DATA, DIALOG_REF, DatepickerComponent, DialogComponent, DialogService, DividerComponent, GOG_CONFIG, GOG_TABS_STATE, GOG_TOKEN_GROUPS, GogAccordionChevronDirective, GogAccordionContentDirective, GogAccordionHeaderDirective, GogBadgeDirective, GogButtonToggleOptionDirective, GogCheckboxIconDirective, GogCollapsibleContentDirective, GogCollapsibleTriggerDirective, GogColumn, GogColumnBodyDirective, GogColumnHeaderDirective, GogDropdownBase, GogDropdownChevronDirective, GogDropdownOptionDirective, GogFloatLabelState, GogInputAddonEndDirective, GogInputAddonStartDirective, GogMultiselectClearIconDirective, GogTabContentDirective, GogTabHeaderDirective, GogTagIconDirective, GogTooltipDirective, ICON_DEFS, IconComponent, InputfieldComponent, MultiselectComponent, PaginatorComponent, ProgressbarComponent, RadioGroupComponent, ScrollComponent, SelectComponent, SkeletonComponent, SliderComponent, SpinnerComponent, SpinnerOverlayComponent, TabComponent, TableComponent, TabsComponent, TagComponent, TemplateDirective, TextareaComponent, ThemeService, ToastComponent, ToastContainerComponent, ToastService, ToggleComponent, addDays, addMonths, addYears, buildMonthGrid, clampDate, copyTimeOnto, daysInMonth, defaultCompare, formatDate, getByPath, isAfterDay, isBeforeDay, isInRange, isSameDay, isSameMonth, isSameOptionValue, isWithinBounds, localeFirstDayOfWeek, monthNames, parseDate, provideGogConfig, readOption, resolveConfigured, startOfDay, weekdayNames, withTime };
+export type { ConfirmDialogData, DialogConfig, DialogHandle, DialogRef, GogAccordionChevronContext, GogAccordionHeaderContext, GogAccordionItem, GogAccordionToggleEvent, GogBadgePosition, GogButtonToggleAppearance, GogButtonToggleOptionContext, GogCalendarDay, GogColumnBodyContext, GogColumnHeaderContext, GogDateRange, GogDateSelectionMode, GogDatepickerValue, GogDividerVariant, GogDropdownDirection, GogDropdownFilterPosition, GogDropdownOption, GogDropdownOptionContext, GogFloatLabelVariant, GogGlobalConfig, GogHourFormat, GogIconName, GogMultiselectOption, GogOptionAccessor, GogOrientation, GogPaginatorRangeMode, GogProgressbarMode, GogProgressbarVariant, GogRadioOption, GogScrollAxis, GogScrollMetrics, GogScrollOverscrollBehavior, GogScrollSize, GogSelectOption, GogSize, GogSkeletonAnimation, GogSkeletonShape, GogSliderOrientation, GogSpinnerVariant, GogTabHeaderContext, GogTableBodyContext, GogTableHeaderContext, GogTabsAlign, GogTabsState, GogTagShape, GogTagVariant, GogTokenGroup, GogTokenLayer, GogTokenName, GogTooltipPosition, GogTooltipSide, GogVariant, OpenDialog, SortDirection, Toast, ToastAction, ToastConfig, ToastPosition, ToastType };