@guildofgleks/ui 21.11.0 → 21.13.0

package/types/guildofgleks-ui-shared.d.ts

@@ -0,0 +1,2000 @@
+import * as _angular_core from '@angular/core';
+import { Signal, InjectionToken, Type, Provider, DoCheck, TemplateRef, ModelSignal, ElementRef, ApplicationRef } from '@angular/core';
+import { NgControl, ControlValueAccessor } from '@angular/forms';
+import * as _guildofgleks_ui_shared from '@guildofgleks/ui/shared';
+
+interface GogCheckableControlSizeConfig {
+    readonly boxSize: string;
+    readonly labelSize: string;
+    readonly indicatorSize: string;
+}
+declare const GOG_CHECKABLE_CONTROL_PADDING = "var(--gog-control-checkbox-padding, 8px)";
+declare const GOG_CHECKABLE_CONTROL_SIZE_MAP: {
+    readonly xsm: {
+        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 sm: {
+        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 md: {
+        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 lg: {
+        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 slg: {
+        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)";
+    };
+};
+
+type GogSize = 'xsm' | 'sm' | 'md' | 'lg' | 'slg';
+type GogVariant = 'primary' | 'secondary' | 'outline' | 'ghost';
+/**
+ * The `aria-haspopup` values that make sense on a button, matching the ARIA 1.2 enumeration.
+ * `true` is a synonym for `'menu'` in the spec; prefer the specific value, since a screen
+ * reader announces it ("has menu", "has dialog").
+ */
+type GogAriaHasPopup = boolean | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';
+/**
+ * How a surface paints itself, shared by `gog-card` and `gog-panel` so the two agree:
+ * - `'outlined'` — a border, no shadow. The quietest, and right for a grid of many.
+ * - `'elevated'` — the shared surface shadow (`--gog-panel-shadow`), no border.
+ * - `'filled'` — a tinted background, neither border nor shadow.
+ */
+type GogSurfaceVariant = 'outlined' | 'elevated' | 'filled';
+/**
+ * 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;
+/** A `gog-slider`'s value pair when `range` is on. `start` is always kept ≤ `end`. */
+interface GogSliderRange {
+    start: number;
+    end: number;
+}
+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 = GogSeverity;
+/**
+ * What an action or a reading *means*, as opposed to how loudly it is drawn. `'accent'` is the
+ * absence of a claim — the library's own colour, and the default everywhere this appears — and
+ * the four status names are the exception, so nothing has to opt out of a severity it does not
+ * have.
+ *
+ * Deliberately orthogonal to `GogVariant` on `gog-button`: a destructive action can be filled,
+ * outlined or a ghost and is destructive in all three, so `severity` says what it does and
+ * `variant` says only how much room it takes up. Shared rather than re-declared per component —
+ * `gog-progressbar` had this exact union first, under its own name, which is kept as an alias.
+ */
+type GogSeverity = 'accent' | 'success' | 'danger' | 'warning' | 'info';
+/**
+ * How `gog-alert` announces itself, and it is a decision the component cannot make for you.
+ *
+ * - `'assertive'` — interrupts whatever a screen reader is saying. For a message that *just
+ *   happened* and changes what the reader should do: a failed save, a rejected payment.
+ * - `'polite'` — waits for a pause. The right answer for most appearing messages.
+ * - `'off'` — announces nothing. **The right answer for a message that was already on the page
+ *   when it loaded**, which is otherwise an interruption about something nobody asked about yet.
+ *
+ * The choice follows from *why the message appeared*, not from how bad it is — the same red box
+ * earns an interruption on submit and does not on page load. Nothing in `@angular/core` lets a
+ * component tell those apart: `ApplicationRef` exposes no stability member a component can read
+ * synchronously at construction, and `afterNextRender` reports the component's *own* first render
+ * rather than the application's. Measured before being decided; see `docs/alert.md` §1.
+ */
+type GogAlertLive = 'assertive' | 'polite' | 'off';
+/**
+ * - `'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';
+/** Matches the native CSS `resize` value space, applied to `gog-textarea`'s field. */
+type GogTextareaResize = 'vertical' | 'horizontal' | 'both' | 'none';
+/**
+ * The `type`s `gog-inputfield` renders as a single-line text-entry field.
+ *
+ * Deliberately not the whole native list: `checkbox`, `radio`, `range`, `file`, `color`,
+ * `submit`, `hidden` and friends are different controls with different markup and different
+ * accessibility contracts — the library ships `gog-checkbox`, `gog-radio-group`, `gog-slider`
+ * and `gog-button` for those rather than making one component shape-shift.
+ */
+type GogInputType = 'text' | 'password' | 'email' | 'number' | 'search' | 'tel' | 'url' | 'date' | 'time' | 'datetime-local';
+/**
+ * Mirrors the native `inputmode` attribute — the hint that decides which on-screen keyboard a
+ * touch device brings up. Worth setting whenever `type` alone doesn't imply it: a postcode or a
+ * card number is `type="text"` (no browser validation wanted) but `inputmode="numeric"`.
+ */
+type GogInputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+/**
+ * Which corner a toast stack occupies.
+ *
+ * Here rather than beside `ToastService`, where it was declared until 2026-09-12, for two reasons
+ * that turned out to be the same one: `gleks-ui-library.instructions.md` puts public types in this
+ * file, and `shared/config.ts` needs it — so declaring it in a service made `shared` depend on
+ * `services`, which depends on `shared`. A cycle nothing minded while the package is one flat
+ * bundle, and one that a secondary entry point cannot express at all.
+ */
+type ToastPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+
+/**
+ * `'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';
+/**
+ * Shared error-visibility state for the library's form controls. A plain class rather than
+ * a base class or directive so it drops into components that can't share a base class
+ * (`gog-inputfield`, `gog-slider`) as well as ones that already do (`GogDropdownBase`).
+ * Each consumer owns its own instance and wires `check()` into its own `ngDoCheck`.
+ */
+declare class GogErrorState {
+    private readonly errorMessage;
+    private readonly errorDisplay;
+    private readonly ngControl;
+    private readonly controlTouched;
+    private readonly controlInvalid;
+    constructor(errorMessage: Signal<string>, errorDisplay: Signal<GogErrorDisplay>, ngControl: NgControl | null);
+    readonly hasError: Signal<boolean>;
+    readonly visibleError: Signal<string>;
+    /**
+     * `NgControl` exposes validity as plain properties, and has no change notification for
+     * `touched` at all — `statusChanges` fires only on validity transitions, never on
+     * `markAsTouched()` — while its `control` does not exist yet during construction, so
+     * subscribing early would miss it regardless. Mirroring on each check sidesteps both;
+     * re-setting a signal to its current value notifies nothing, so the common case costs two
+     * comparisons.
+     */
+    check(): void;
+}
+
+type GogDropdownDirection = 'auto' | 'up' | 'down';
+interface GogDropdownTriggerRect {
+    top: number;
+    bottom: number;
+    left: number;
+    width: number;
+}
+interface GogDropdownPlacement {
+    direction: 'up' | 'down';
+    top: number;
+    left: number;
+    width: number;
+    maxHeight: number;
+}
+declare function resolveDropdownDirection(direction: GogDropdownDirection, triggerRect: GogDropdownTriggerRect, panelHeight: number, viewportHeight: number, gap?: number, viewportPadding?: number): 'up' | 'down';
+declare function resolveDropdownPlacement(direction: GogDropdownDirection, triggerRect: GogDropdownTriggerRect, panelHeight: number, viewportHeight: number, gap?: number, viewportPadding?: number): GogDropdownPlacement;
+/**
+ * Resolves a CSS length to pixels for the placement math. Only `px`, `%` and `vh` can be
+ * resolved without laying out the DOM — `%` and `vh` are taken relative to the viewport
+ * height, which is exactly what a `position: fixed` panel's height resolves against in CSS.
+ * Any other unit (`rem`, `em`, `auto`, a bare number, …) returns null: the caller falls back
+ * to its own estimate for the up/down decision, while the original string is still written
+ * to the panel's `style.max-height` as-is — only the direction heuristic loses precision.
+ */
+declare function resolveCssLengthPx(value: string, viewportHeight: number): number | null;
+
+/**
+ * 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 {
+    /**
+     * The loading indicator, app-wide.
+     *
+     * `component` is the one config key that carries markup rather than a value, and it is here
+     * because of what it removes: a house spinner otherwise has to be passed into every control
+     * that can show one, and cannot be passed into the ones that render their own. Set it once and
+     * **every** spinner the library draws is yours — `gog-spinner`, `gog-spinner-overlay`, and the
+     * ones inside `gog-button`, `gog-autocomplete` and `gog-table`'s loading states, which have no
+     * input to reach. It is rendered through `NgComponentOutlet` inside the size wrapper, so it
+     * keeps the sizing, the overlay behaviour, the `role="status"` and the accessible name; only
+     * the visual is yours.
+     *
+     * Precedence is the library's usual one, with a wrinkle worth stating: an instance's own
+     * `variant` wins over both keys here, `component` wins over `variant`, and the built-in
+     * `runic` is the fallback. So `<gog-spinner variant="ring">` still gets a ring in an app that
+     * has set a component — an instance asking for something specific is not overridden by a
+     * default.
+     *
+     * Applies to: `gog-spinner`, `gog-spinner-overlay`, and the spinners inside `gog-button`,
+     * `gog-autocomplete` and `gog-table`. Two of those were wrong until 21.10.0 and are worth the
+     * warning: `gog-table` was never listed although it always honoured the key, and
+     * `gog-spinner-overlay` was listed although it did not — it forwards its own `variant` down,
+     * and that input defaulted to `'runic'`, which the spinner inside correctly read as an
+     * instance overruling a default. Neither shows up in a grep for `globalConfig.spinner`,
+     * because neither reads the config: they render a `gog-spinner` that does.
+     */
+    spinner?: {
+        component?: Type<unknown>;
+        variant?: GogSpinnerVariant;
+    };
+    scroll?: {
+        autoHide?: boolean;
+        hideDelay?: number;
+        size?: GogScrollSize;
+        overscrollBehavior?: GogScrollOverscrollBehavior;
+        /**
+         * Whether the overlay thumb/track ever renders. Scrolling itself is unaffected either way
+         * — this is purely the visual affordance. Defaults to `true`.
+         */
+        showTrack?: boolean;
+        /**
+         * Turns a vertical wheel into horizontal scrolling on a `gog-scroll` that has nothing to
+         * scroll vertically. Defaults to `false`; see the component's `horizontalWheel` input for
+         * the conditions it applies under and why it never swallows a gesture at the content's end.
+         */
+        horizontalWheel?: boolean;
+    };
+    button?: {
+        debounce?: number;
+    };
+    /**
+     * Whether the library's own interactive surfaces show a press ripple: `gog-button`,
+     * `[gogButton]`, `gog-button-toggle`, `gog-chip`, `gog-tabs`, `gog-accordion`,
+     * `gog-collapsible`, `gog-menu` and the three dropdowns' options. **Off by default**, so the
+     * effect is additive and nothing changes appearance until an app asks for it.
+     *
+     * This is the one visual default that is *not* expressible as a CSS token, which is why it is
+     * here at all: `--gog-ripple-opacity: 0` would hide the wash but still pay for the DOM node,
+     * the pointer listeners and the animation frames on every press. A real off has to reach the
+     * TypeScript.
+     *
+     * Per-instance: every component listed above takes a `ripple` input that wins over this, so
+     * `[ripple]="false"` opts one control out of an app-wide `true` (and `[ripple]="true"` opts one
+     * in without switching the app over). The `[gogRipple]` directive on your **own** element is
+     * not covered — writing the attribute is already the per-element decision, the same way
+     * `[filter]="true"` on one `gog-select` is; `rippleDisabled` turns that one off.
+     */
+    ripple?: {
+        enabled?: boolean;
+    };
+    tooltip?: {
+        showDelay?: number;
+        hideDelay?: number;
+        position?: GogTooltipPosition;
+    };
+    /**
+     * Applies to `gog-inputfield`, `gog-textarea`, `gog-select`, `gog-multiselect`,
+     * `gog-autocomplete` and `gog-datepicker` — every field that can float a label. All six read
+     * it through the same `GogFloatLabelState`, three of them via `GogDropdownBase`.
+     */
+    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` and `[gogButton]`, `gog-button-toggle-group`,
+     *   `gog-checkbox`, `gog-toggle`, `gog-radio-group`, `gog-inputfield`, `gog-textarea`,
+     *   `gog-select`, `gog-multiselect`, `gog-autocomplete` and `gog-datepicker`. 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-autocomplete`,
+     *   `gog-datepicker`, `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.
+     *
+     * **When you add a reader, add it here — and note that "reader" is not the same as "names
+     * the field".** These lists were wrong for four keys until 2026-09-02, always in the same
+     * direction and for the same reason: `gog-select`, `gog-multiselect` and `gog-autocomplete`
+     * resolve `size`/`errorDisplay`/`clearable`/`floatLabel` inside `GogDropdownBase`, and
+     * `gog-datepicker` composes the same state classes directly, so none of the four contains the
+     * `globalConfig.control?.…` expression that a grep for readers finds. Nor does the resolved
+     * value always reach a template by name — `size` arrives as a computed class (`sizeClass`,
+     * `panelSizeClass`) and `dropdown.direction` is consumed by placement code, so "is the
+     * computed referenced in the component's HTML?" answers *no* for components that genuinely
+     * honour the key. Trace the shared state classes, not just the components.
+     */
+    control?: {
+        size?: GogSize;
+        errorDisplay?: GogErrorDisplay;
+        /**
+         * Whether `gog-inputfield`, `gog-textarea`, `gog-select`, `gog-multiselect`,
+         * `gog-autocomplete` and `gog-datepicker` offer a clear button — every control that
+         * composes `GogClearableState`. 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 per field rather than per component, which is why this is not one sentence:
+     *
+     * - `appendToBody` and `direction` reach `gog-select`, `gog-multiselect`,
+     *   `gog-autocomplete` (all three through `GogDropdownBase`) and `gog-datepicker`, which
+     *   resolves the same pair itself.
+     * - `filter` and `filterPosition` reach `gog-select` and `gog-multiselect` only.
+     *   `gog-autocomplete` inherits both inputs from the same base class and renders no filter
+     *   box for them — its own text field *is* the filter, so a second search box inside the
+     *   panel would be a duplicate. Setting these does nothing to an autocomplete.
+     */
+    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;
+        /**
+         * Whether the option list renders only the rows in view instead of all of them. Reaches
+         * `gog-select`. **Off by default**, and deliberately not switched on above some row count:
+         * a windowed list and a plain one differ under `Ctrl+F`, under a screen reader's "list all
+         * items", and under consumer CSS that targets `:last-child`, so a data-dependent threshold
+         * would make behaviour depend on how much data happened to arrive.
+         *
+         * Worth setting app-wide for an app whose selects are generally fed long lists; a per-field
+         * `virtualize` still wins over it.
+         */
+        virtualize?: boolean;
+    };
+    /**
+     * 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-paginator`, and through it to `gog-table`'s built-in pagination.
+     *
+     * The page-size select is the one piece of paginator chrome an app decides once — either its
+     * tables offer the choice or they don't, and the option list is a house style. Both are still
+     * overridable per instance, for the page whose table genuinely needs `5, 10, 20` while the rest
+     * of the app uses `20, 50, 100`.
+     */
+    paginator?: {
+        /** Whether the rows-per-page select renders at all. **Off by default.** */
+        showPageSizeSelect?: boolean;
+        /** The choices it offers. Defaults to `[10, 20, 30, 40, 50]`. */
+        pageSizeOptions?: number[];
+    };
+    /** 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;
+        /**
+         * Whether focusing the field opens the panel immediately, showing the full option list.
+         * Defaults to `true`.
+         */
+        openOnFocus?: boolean;
+    };
+    /** Applies to `gog-inputfield`. */
+    inputfield?: {
+        /**
+         * Whether a `type="number"` field shows the library's own spin buttons in place of the
+         * browser's native ones. Defaults to `true`.
+         */
+        showSpinButtons?: boolean;
+    };
+    /** Applies to `gog-textarea`. */
+    textarea?: {
+        /**
+         * Which direction(s) the field's own drag handle resizes it in — matches the native CSS
+         * `resize` value space. Defaults to `'vertical'`.
+         */
+        resize?: GogTextareaResize;
+    };
+    toast?: {
+        position?: ToastPosition;
+        /** How long a non-sticky toast stays up, in ms. */
+        duration?: number;
+    };
+    /**
+     * Every fixed, user-visible string the library renders — button text and accessible names for
+     * chrome the consumer never writes markup for.
+     *
+     * These are here rather than as one input per string because they are the definition of a
+     * setting an app states once: a Russian-language app relabels "Clear" once, not on all 340
+     * fields. Where a per-instance input already exists (`clearAriaLabel`, `todayLabel`, …) it
+     * still wins for that one control — the usual instance → config → default order.
+     *
+     * Deliberately excludes anything that is *content* rather than chrome: `gog-checkbox`'s
+     * `ariaLabel`, `gog-button`'s `ariaLabel`, a field's `label` or `placeholder`. Those differ
+     * per instance by definition and have no meaningful app-wide value.
+     */
+    labels?: {
+        /** Clear button on `gog-inputfield` / `gog-textarea`. */
+        clear?: string;
+        /**
+         * Clear button on `gog-select` / `gog-multiselect` / `gog-autocomplete`, which clears a
+         * selection rather than text.
+         */
+        clearSelection?: string;
+        /** Clear button on `gog-datepicker`. */
+        clearDate?: string;
+        /** `gog-multiselect`'s select-all / clear-all buttons — visible text, not just a label. */
+        selectAll?: string;
+        clearAll?: string;
+        /** `gog-inputfield`'s number spin buttons. */
+        increment?: string;
+        decrement?: string;
+        /** `gog-inputfield`'s password reveal toggle, in its two states. */
+        showPassword?: string;
+        hidePassword?: string;
+        /** Close buttons on the two service-driven overlays. */
+        closeDialog?: string;
+        closeToast?: string;
+        /**
+         * `gog-alert`'s dismiss button. Separate from `closeToast` on purpose: a toast closes
+         * something that was going to leave anyway, an alert dismisses a message that would have
+         * stayed, and several languages use different verbs for the two.
+         */
+        closeAlert?: string;
+        /** `gog-paginator`'s `<nav>` accessible name and its two step buttons. */
+        pagination?: string;
+        previousPage?: string;
+        nextPage?: string;
+        /**
+         * `gog-paginator`'s per-page button names ("Go to page 4", "Page 4, current page").
+         *
+         * A function rather than a string, and the only one in this block: these interpolate the
+         * page number, and a template string with a `{0}` placeholder would be a second, weaker
+         * formatting language to learn — one that also can't express languages where the number's
+         * position or the surrounding grammar depends on its value. The default is
+         * `` (page, isCurrent) => isCurrent ? `Page ${page}, current page` : `Go to page ${page}` ``.
+         */
+        page?: (page: number, isCurrent: boolean) => string;
+        /** `gog-datepicker`'s button that opens the calendar panel. */
+        openCalendar?: string;
+        /**
+         * `gog-panel`'s collapse toggle, used **only** when the panel has no `gogPanelHeader` to
+         * borrow a name from. A panel with a heading names its toggle after that heading, which is
+         * both more useful and per-instance by definition.
+         */
+        togglePanel?: string;
+        /** `gog-paginator`'s rows-per-page select. */
+        rowsPerPage?: string;
+        /** `gog-table`: the row-count label, its paginator, and the selection checkboxes. */
+        total?: string;
+        tablePagination?: string;
+        selectRow?: string;
+        selectAllRows?: string;
+        /** `gog-calendar` navigation and shortcuts. */
+        today?: string;
+        thisMonth?: string;
+        previousMonth?: string;
+        nextMonth?: string;
+        previousYear?: string;
+        nextYear?: string;
+        /** `gog-calendar`'s time section. */
+        hours?: string;
+        minutes?: string;
+        seconds?: string;
+    };
+    /**
+     * Applies to `ThemeService`. Every field is off/neutral by default, so an app that configures
+     * nothing keeps the pre-21.3.2 behaviour: adopt whatever `data-theme` is already on `<html>`,
+     * else `'light'`.
+     */
+    theme?: {
+        /**
+         * `localStorage` key the chosen theme is written to and read back from. Unset, nothing is
+         * persisted and the theme resets on every load.
+         */
+        storageKey?: string | null;
+        /** Theme applied when nothing else decides. `'light'` by default. */
+        defaultTheme?: string;
+        /**
+         * Whether to fall back to the OS `prefers-color-scheme` setting — and to keep following it
+         * until the app calls `setTheme`/`toggleTheme`. Off by default: switching this on changes
+         * which theme an existing app opens in.
+         */
+        followSystem?: boolean;
+        /** Theme names `toggleTheme()` alternates between, and `followSystem` maps the OS setting to. */
+        lightTheme?: string;
+        darkTheme?: string;
+    };
+}
+/**
+ * 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 "show a clear button" state for the field-style controls.
+ *
+ * A plain composition class, same reasoning as `GogErrorState` and `GogFloatLabelState`: it has
+ * to serve `gog-inputfield` and `gog-textarea` (no common base class) as well as
+ * `GogDropdownBase`, which is one.
+ *
+ * The two things each control supplies itself are `hasValue` — "there is something to clear"
+ * differs per control (non-empty string / non-null selection / non-empty array) — and the
+ * actual clearing, since only the control knows its own empty value and how to notify forms.
+ */
+declare class GogClearableState {
+    private readonly clearableInput;
+    private readonly hasValue;
+    private readonly isNotEditable;
+    private readonly config;
+    private readonly fallback;
+    /**
+     * @param clearableInput the control's own `clearable` input (`undefined` when unset)
+     * @param hasValue whether there is anything to clear
+     * @param isNotEditable whether the control currently refuses edits — disabled, or (for the
+     *   text controls) read-only. Either way it offers no clear button: the affordance would
+     *   promise a change the control won't accept.
+     * @param config the injected `GOG_CONFIG`
+     * @param fallback the control's own default, read lazily — `GogDropdownBase` constructs this
+     *   in a field initializer, before its subclass has assigned `clearableByDefault`. `false`
+     *   everywhere except `gog-multiselect`, which shipped a clear button before this input
+     *   existed and keeps it.
+     */
+    constructor(clearableInput: Signal<boolean | undefined>, hasValue: Signal<boolean>, isNotEditable: Signal<boolean>, config: GogGlobalConfig, fallback: () => boolean);
+    /** Whether the control is clearable at all — instance input, then config, then the default. */
+    readonly enabled: Signal<boolean>;
+    /**
+     * Whether the clear button should render *right now*. Deliberately value-driven: the control
+     * shows nothing to clear until there is something to clear, so the affordance appears with the
+     * content rather than sitting there permanently as dead chrome.
+     */
+    readonly isVisible: Signal<boolean>;
+}
+
+/** Returns the next id for `prefix`, e.g. `nextGogControlId('gog-input')` → `'gog-input-3'`. */
+declare function nextGogControlId(prefix: string): string;
+
+/**
+ * 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 kind of thing a deprecation is about: an exported symbol, or a CSS custom property. */
+type GogDeprecationKind = 'symbol' | 'token';
+/** One deprecated part of the public API, with the version that removes it. */
+interface GogDeprecation {
+    kind: GogDeprecationKind;
+    /** The deprecated name — an export, an input, or a `--gog-*` custom property. */
+    name: string;
+    /** What to use instead. */
+    replacement: string;
+    /** The version that deprecated it, and the day it was announced. */
+    since: string;
+    sinceDate: string;
+    /** The version that removes it. Until then, the deprecated name still works. */
+    removedIn: string;
+}
+/**
+ * Everything `@guildofgleks/ui` currently deprecates: 28 symbol(s) and 3 token(s).
+ *
+ * Generated from the library's own source — `@deprecated` tags for symbols, and the stylesheets
+ * themselves for tokens — so it cannot drift from what actually still resolves. Meant for tooling
+ * that has to answer "is this still supported, and until when?": a docs site marking an API row,
+ * an editor plugin, a codemod.
+ *
+ * An empty `symbol` half means exactly what it says: nothing in the TypeScript API is deprecated
+ * right now.
+ */
+declare const GOG_DEPRECATIONS: readonly GogDeprecation[];
+
+/**
+ * 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 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. Unset, falls back to
+     * `GOG_CONFIG.labels.clearSelection`, then to `'Clear selection'`.
+     */
+    readonly clearAriaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Instance input → `GOG_CONFIG.labels` → the built-in English default. */
+    protected readonly resolvedClearLabel: Signal<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>;
+    /** Projected `gogDropdownChevron` template, replacing the built-in chevron. */
+    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>;
+    /**
+     * Press ripple on the panel's options. Unset, falls back to `GOG_CONFIG.ripple.enabled`, then
+     * to `false`. The trigger itself never ripples — it is a field, not a button.
+     */
+    readonly ripple: _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.
+     */
+    /**
+     * The gap **between rows**, as a seed for the first frame. Like `optionHeightToken`, the real
+     * value is measured from the rendered list and replaces this.
+     *
+     * **Read the options container's CSS before pointing this at a token, not the token's name.**
+     * Two of the three controls name a token `--gog-<block>-option-gap` and use it for the gap
+     * *inside* a row — between the check mark and the label — with no gap between rows at all.
+     * Seeding from it added 12px per row of panel that does not exist. Only `gog-multiselect`'s
+     * options container declares a `gap`, and only it overrides this.
+     */
+    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.
+     *
+     * Deliberately a bare number rather than `nextGogControlId()` (which the single-element
+     * controls use): each subclass derives *several* ids from this one instance — trigger,
+     * listbox, label, error — so what it needs is the instance number, not one finished id.
+     */
+    protected readonly uid: number;
+    protected readonly elRef: ElementRef<any>;
+    private readonly injector;
+    protected readonly isBrowser: boolean;
+    private readonly document;
+    private readonly appRef;
+    private readonly destroyRef;
+    private readonly ngControl;
+    /** `protected` so subclasses can resolve their own inputs against the same config object. */
+    protected readonly globalConfig: _guildofgleks_ui_shared.GogGlobalConfig;
+    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 rippleEnabled: Signal<boolean>;
+    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;
+    /**
+     * Scrolls `index` into view **without moving focus**, which is what a combobox needs: focus
+     * stays in the text field and the highlight is pointed at with `aria-activedescendant`, so
+     * nothing scrolls the row into view on its own the way focusing it would.
+     */
+    protected revealOption(index: number): void;
+    /** Puts the scroller, the window and the keyboard's idea of "here" back at the top together. */
+    protected resetPanelScroll(): void;
+    /**
+     * Moves the scroller and the window's own idea of where it is, in that order and in the same
+     * turn.
+     *
+     * The signal is written here rather than waiting for the scroller to echo the change back
+     * through `(gogScroll)`: that echo is coalesced into an animation frame, so a keyboard move
+     * that scrolled would compute its new range one frame after it moved focus -- which is one
+     * frame during which the row it is trying to focus has not been rendered.
+     */
+    private setPanelScrollTop;
+    /**
+     * `gog-scroll`'s scrolling element inside the open panel, found in the DOM rather than with a
+     * `viewChild`: an appended panel is attached to `<body>` as its own change-detection root, so a
+     * view query on this component does not reach it.
+     */
+    private panelViewportElement;
+    /** 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;
+    /**
+     * A real row's height, once one has ever been rendered. `null` until then.
+     *
+     * The token this class reads for `optionHeight` calls itself an estimate, and it is a bad one:
+     * measured against a rendered row in all eleven shipped themes it is wrong in every one, from
+     * -0.62px (`terminal`) to +8.38px (`parchment`), and low in ten of them. No static value can be
+     * right -- the same `parchment` row is 48.38px at `--gog-density: 1` and 42.38px at 0.85,
+     * because the height is padding plus leading plus border and a theme or a consumer can move
+     * every term.
+     *
+     * That matters because the estimate is not decorative: `estimatePanelHeight` multiplies it by
+     * the option count and `resolveDropdownDirection` opens the panel up or down on the result. Low
+     * by 7px a row means a five-row panel judged to fit below when it needs 37px more than there is.
+     * Only short lists were ever affected -- above `panelMaxHeightToken` the cap dominates and the
+     * error is masked -- which is why it went unseen.
+     */
+    private measuredOptionHeight;
+    /**
+     * The real gap between two rows, once a list has ever rendered. `null` until then.
+     *
+     * Measured for the same reason the row height is, and it came out of the same audit: the token
+     * `optionGapToken` seeds from is the *inside* of a row in two of the three controls (mark to
+     * label), while their options containers declare no row gap at all. Reading the container is
+     * exact where reading a token is a guess about what the token means.
+     */
+    private measuredOptionGap;
+    private measureFrame;
+    private repositionFrame;
+    /**
+     * Whether this instance windows its list. Resolved the same way every other dropdown setting
+     * is: instance input, then `GOG_CONFIG.dropdown.virtualize`, then off.
+     *
+     * **Off by default and never switched on automatically.** A windowed list and a plain one
+     * differ under `Ctrl+F`, under a screen reader's "list all items", and under any consumer CSS
+     * that targets `:last-child`; flipping that at a row-count threshold would make the component's
+     * behaviour depend on how much data happened to arrive, which works in development and
+     * surprises in production. `GOG_CONFIG.ripple.enabled` is off by default for the same reason.
+     */
+    protected readonly resolvedVirtualize: Signal<boolean>;
+    /**
+     * The subclass's own `virtualize` input, if it offers one.
+     *
+     * A subclass overrides this with its input rather than the base declaring one, so a control
+     * that has not adopted windowing yet does not inherit a public input that does nothing. Read
+     * only from inside a `computed`, which is what lets a subclass field override a base field
+     * that was initialised first.
+     */
+    protected readonly virtualizeRequest: Signal<boolean | undefined>;
+    /**
+     * How far apart two rows start, in px: the row's own height plus whatever gap the list puts
+     * between rows. Seeded from the tokens and replaced by the measurement, exactly as the
+     * placement estimate is -- and for a window it matters more, because the error accumulates
+     * once per row instead of once per panel.
+     */
+    protected readonly rowPitch: _angular_core.WritableSignal<number>;
+    /**
+     * The gap alone, as a signal, because `spacerHeight` needs it from inside a `computed` and the
+     * cached `measuredOptionGap` beside it is a plain field -- a computed reading that would be
+     * correct only by the accident of `rowPitch` changing in the same statement.
+     */
+    private readonly rowGap;
+    /**
+     * The scroller's real geometry, fed from `gog-scroll`'s own `(gogScroll)`.
+     *
+     * The plan called for a `ResizeObserver` on the scroller; it is not needed, because the
+     * scroller already runs one and already coalesces scroll and resize into a single
+     * rAF-batched emission carrying both numbers. A second observer would have measured the same
+     * element one frame later.
+     *
+     * `height` is the viewport's `clientHeight`, never `--gog-*-panel-max-height`: that token is a
+     * cap, and a panel with three options is three rows tall.
+     */
+    protected readonly panelViewport: _angular_core.WritableSignal<{
+        scrollTop: number;
+        height: number;
+    }>;
+    private readonly virtualWindow;
+    /** Index into `visibleOptions()` of the row the keyboard is on, or -1 for none. */
+    protected readonly activeOptionIndex: _angular_core.WritableSignal<number>;
+    /** The slice of `visibleOptions()` actually stamped into the panel. */
+    protected readonly optionWindow: Signal<_guildofgleks_ui_shared.GogVirtualRange>;
+    /**
+     * What the template loops over. Identical to `visibleOptions()` when not windowing, and the
+     * same array instance, so nothing re-renders for the sake of a slice that changed nothing.
+     */
+    protected readonly renderedOptions: Signal<TOption[]>;
+    /**
+     * Filler above and below the rendered rows, in px.
+     *
+     * Spacers rather than absolute positioning: the rows stay flex children of the same container,
+     * so every gap, selector and `:last-child` the component already relies on keeps working. See
+     * `GogVirtualWindow`'s own note for why that trade is worth making for a one-column list.
+     */
+    protected readonly padBefore: Signal<number>;
+    protected readonly padAfter: Signal<number>;
+    /**
+     * A spacer's own height, less the gap the flex column puts either side of it.
+     *
+     * A spacer is a flex child like a row, so a list that declares `gap` gets one *around the
+     * spacer too* -- and the window's padding already accounts for every gap in the rows it stands
+     * in for. Left uncorrected, an open panel is two gaps too tall and every rendered row sits one
+     * gap lower than its index says. It is a constant, not an accumulating error, which is exactly
+     * why it would have survived review: at `gog-multiselect`'s 4px nothing looks wrong, it is just
+     * 4px wrong everywhere.
+     *
+     * `gog-select` and `gog-autocomplete` declare no row gap, so this subtracts nothing there. The
+     * subtraction can never go negative on a spacer that exists: any non-zero padding is at least
+     * one whole row, and a row is taller than the gap beside it.
+     */
+    private spacerHeight;
+    /**
+     * A windowed listbox holds twenty `role="option"` children and has to announce ten thousand.
+     *
+     * Set only while windowing. An unwindowed list has every option in the DOM, and the browser's
+     * own count is then both correct and free -- restating it would be one more thing to keep true.
+     */
+    protected readonly ariaSetSize: Signal<number | null>;
+    /** The real position of a rendered row in the full list, 1-based, or null when not windowing. */
+    protected ariaPosInSet(renderedIndex: number): number | null;
+    /** `(gogScroll)` on the panel's `gog-scroll`. */
+    protected onPanelScroll(metrics: {
+        scrollTop: number;
+        clientHeight: number;
+    }): void;
+    /**
+     * A row that scrolls out of the window is unmounted, and an unmounted element holding focus
+     * drops it on `<body>` -- where an open panel has no keyboard at all: Escape does not close it
+     * and the arrows scroll the page instead of the list.
+     *
+     * So a mouse scroll that would take the focused row away hands focus back to the trigger,
+     * which is a state both Escape and ArrowDown work from. Checked here rather than in an effect
+     * because this runs *before* the re-render, while the row still exists and can still be asked
+     * whether it is the focused one -- after the unmount that question has no answer.
+     *
+     * This is the price of windowing that a plain list does not pay, and the reason it is opt-in.
+     */
+    private releaseFocusLeavingTheWindow;
+    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;
+    /**
+     * Gives the window numbers to work from before anything has rendered.
+     *
+     * Without this the first frame has a viewport height of zero, which `GogVirtualWindow`
+     * deliberately reads as "render everything" -- correct, and exactly the 10 000 rows the window
+     * exists to avoid, stamped once before the scroller reports its real height a frame later. The
+     * seed is the same panel-height estimate placement already uses, so no new arithmetic and no
+     * new token.
+     */
+    private seedWindow;
+    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;
+    /**
+     * Reads one real row after the panel has rendered, and re-places if the token had lied.
+     *
+     * One frame late by construction -- the row has to exist -- so the very first open of an
+     * instance can be placed from the estimate and corrected before the next paint. Every later
+     * open starts from the measurement and is right immediately, which is why this caches rather
+     * than measuring each time.
+     *
+     * Deliberately does **not** fall back to the token when no row is found: an empty list has no
+     * row to measure and no rows to be wrong about, and overwriting a good measurement with the
+     * token because the user filtered everything away would undo the fix.
+     */
+    private scheduleOptionMeasure;
+    /** Jumps from the trigger into the option list on ArrowDown/ArrowUp while open. */
+    protected onTriggerArrowKeydown(event: Event): void;
+    protected onOptionKeydown(event: KeyboardEvent): void;
+    /**
+     * Moves the keyboard's index by one roving-focus key, skipping disabled options and wrapping,
+     * then makes the DOM agree: scroll first if the target is outside the window, focus second.
+     */
+    private moveActiveOption;
+    /**
+     * Puts the keyboard on `index` and the focus with it.
+     *
+     * The wait is conditional on purpose: `scrollOffsetFor` returns null when the row is already
+     * visible, which means it is already rendered and can be focused in this turn. Only a move
+     * that actually changes the window has to wait for the render that stamps the row.
+     */
+    private focusOptionAt;
+    private focusRenderedOption;
+    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;
+    /**
+     * The panel's height, used to choose up/down and to cap `max-height`.
+     *
+     * Estimated on the very first open of an instance and exact from then on. Measuring needs a
+     * rendered row and placement runs before the panel renders, so the first pass uses the row
+     * height token; `measureOptionHeight` then reads a real row and re-places if it disagreed.
+     * Every open after that starts from the measurement.
+     *
+     * A resolvable `dropdownMaxHeight` replaces the row-count arithmetic outright, since it is
+     * exact rather than derived.
+     */
+    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; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "floatLabel": { "alias": "floatLabel"; "required": false; "isSignal": true; }; "floatLabelShowPlaceholder": { "alias": "floatLabelShowPlaceholder"; "required": false; "isSignal": true; }; "ripple": { "alias": "ripple"; "required": false; "isSignal": true; }; }, {}, ["chevronSlot", "optionSlot"], never, true, never>;
+}
+
+/**
+ * Renders a template into `document.body` while keeping it wired to the declaring
+ * component: the view is stamped with that component's style encapsulation and reads
+ * its signals directly.
+ *
+ * That is the whole point of doing it this way rather than with a second, portal-only
+ * component: one `<ng-template>` can serve both the inline and the appended-to-body
+ * dropdown, so the option markup exists once and cannot drift between the two modes,
+ * and selection state needs no manual field-syncing to stay in step.
+ */
+declare class GogDropdownOverlay {
+    private readonly appRef;
+    private readonly document;
+    private hostEl;
+    private viewRef;
+    constructor(appRef: ApplicationRef, document: Document);
+    /** The `<body>` child holding the rendered panel, or null while detached. */
+    get hostElement(): HTMLElement | null;
+    get isAttached(): boolean;
+    attach(template: TemplateRef<unknown>, themeSource?: Element | null): void;
+    detach(): void;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * Icons an app has registered, keyed by the name `gog-icon` will be asked for. Resolves to `{}`
+ * — only the built-ins are available — until a `provideGogIcons(...)` call fills it in.
+ *
+ * Values are raw `<svg>` markup, injected with `bypassSecurityTrustHtml` exactly like the
+ * built-ins. See `provideGogIcons` for what that means for you.
+ */
+declare const GOG_ICONS: InjectionToken<Readonly<Record<string, string>>>;
+/**
+ * Registers icons by name, so `<gog-icon name="cart" />` works for glyphs the library does not
+ * ship. This is the supported way to use your own icon set: the alternative — a `TemplateRef`
+ * per instance through the `template` input — costs a `<ng-template>` at every use site and is
+ * meant for one-offs, not for an icon set.
+ *
+ * ```ts
+ * // app.config.ts
+ * providers: [
+ *   provideGogIcons({
+ *     cart: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor">…</svg>',
+ *     user: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor">…</svg>',
+ *   }),
+ * ]
+ * ```
+ *
+ * **A registered name overrides a built-in of the same name**, which is how you swap the
+ * library's checkmark or chevron for your own without touching every component that renders one.
+ *
+ * **Providing this again further down the injector tree layers onto the parent's set** rather
+ * than replacing it, matching `provideGogConfig`: a lazy feature can register the three icons
+ * only it uses, and the app-wide set stays available inside it.
+ *
+ * ## What to put in the SVG
+ *
+ * Use `stroke="currentColor"` (or `fill="currentColor"`) and a `viewBox`, and leave the sizing
+ * alone — `gog-icon`'s stylesheet drives width, height and stroke width from the
+ * `--gog-icon-*` tokens, so an icon inherits size and colour from wherever it is used, the same
+ * as a built-in.
+ *
+ * ## Security
+ *
+ * The markup is inserted with `DomSanitizer.bypassSecurityTrustHtml`, because Angular's HTML
+ * sanitizer strips SVG and would leave you with nothing. That is safe for what this is for —
+ * static icon markup you wrote or imported at build time — and unsafe for anything derived from
+ * user input or fetched at runtime. **Never build a registered icon string from data you did
+ * not author.** If you need remote icons, fetch them yourself, sanitize them with a real SVG
+ * sanitizer, and register the result.
+ */
+declare function provideGogIcons(icons: Readonly<Record<string, string>>): Provider;
+
+/**
+ * The glyphs the package ships. Kept as a closed union so they still autocomplete and so
+ * `ICON_DEFS` below stays exhaustive — a `Record` over the open `GogIconName` would collapse
+ * into an index signature and stop catching a missing definition.
+ */
+type GogBuiltinIconName = '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' | 'copy' | 'search' | 'plus' | 'minus' | 'trash' | 'pencil' | 'download' | 'upload' | 'refresh' | 'filter' | 'external-link' | 'menu' | 'more-horizontal' | 'more-vertical' | 'arrow-left' | 'arrow-right' | 'user' | 'settings' | 'lock' | 'mail' | 'star' | 'star-filled';
+/**
+ * Any icon `gog-icon` can render: one of the built-ins, or a name registered through
+ * `provideGogIcons(...)`. The `(string & {})` half keeps the built-in names in autocomplete
+ * while letting a registered name through — an open union is the point, since the set of icons
+ * an app uses is the app's business, not the library's.
+ */
+type GogIconName = GogBuiltinIconName | (string & {});
+declare const ICON_DEFS: Record<GogBuiltinIconName, string>;
+
+/**
+ * Which writing direction a portaled overlay has to carry, if any.
+ *
+ * A dropdown panel or tooltip bubble is appended to `<body>`, which takes it out of whatever
+ * subtree it was opened from. `dir` is inherited, so an overlay opened inside an RTL region of
+ * an otherwise-LTR page would render LTR — text aligned the wrong way, the panel's own
+ * `inset-inline-*` resolving against the wrong side. Copying the nearest scoped `dir` onto the
+ * portal host fixes that, exactly as `scopedOverlayTheme` does for `data-theme`.
+ *
+ * **Only when the direction really is scoped.** When the nearest `[dir]` is the document
+ * element — the ordinary case, a whole RTL app — the overlay already inherits it through
+ * `<body>`, and re-stating it is noise on every panel in the app.
+ *
+ * Known limitation, shared with `scopedOverlayTheme`: a direction set through CSS
+ * (`direction: rtl` in a stylesheet) rather than the `dir` attribute is not detected. Reading
+ * `getComputedStyle().direction` would catch it, but that forces layout on every open for a
+ * case the HTML spec itself discourages — `dir` is the attribute browsers, form controls and
+ * assistive tech all key off.
+ */
+declare function scopedOverlayDirection(directionSource: Element | null, documentElement: Element): 'ltr' | 'rtl' | null;
+
+/**
+ * Which `data-theme` an overlay rendered into `<body>` has to carry, if any.
+ *
+ * A panel or tooltip bubble is appended to `<body>`, which puts it outside whatever subtree it
+ * was opened from. `data-theme` can be scoped to any subtree — several themes rendering side by
+ * side is a documented use — so an overlay opened inside one of those has to be told which theme
+ * it belongs to, or it silently picks up the document's instead.
+ *
+ * **But only when the theme really is scoped.** When the nearest themed ancestor is the document
+ * element, copying the attribute is not merely redundant, it is actively wrong: the overlay
+ * already inherits everything from `<html>` through `<body>`, and re-stating `data-theme` on it
+ * makes it match `theme.css`'s derived layer (`:root, [data-theme]`) *locally*. That re-declares
+ * every component token on the overlay itself, resolved against the plain preset palette — which
+ * discards anything set on `<html>` that is not part of that preset. Custom properties written
+ * inline on `:root` are the case that bites: a live theme editor sets them there, the page
+ * follows, and every portal keeps rendering the un-edited theme.
+ *
+ * So: return the theme only for a genuinely scoped ancestor, and let inheritance do the work
+ * otherwise.
+ *
+ * Known limitation, currently unreachable: a *scoped* theme that is itself being edited through
+ * inline custom properties would still lose those on the overlay, since only the attribute is
+ * carried across. Copying resolved values instead would mean reading ~1200 properties on every
+ * open, which is not worth it for a case nothing does yet.
+ */
+declare function scopedOverlayTheme(themeSource: Element | null, documentElement: Element): string | null;
+
+/**
+ * Off, so the ripple is purely additive: adding it to the library changed the appearance of
+ * nothing until an app asks for it. Flipping this default would change how every button in every
+ * consuming app looks, which is a release of its own, not a line in a feature commit.
+ */
+declare const DEFAULT_RIPPLE = false;
+/**
+ * Shared "does this control ripple" state, resolved the usual way — instance input, then
+ * `GOG_CONFIG.ripple.enabled`, then off.
+ *
+ * A plain function rather than a class (`GogClearableState`'s shape) because there is exactly one
+ * derived value and nothing to hold: every component that ripples writes the same two lines, and
+ * this is what keeps the precedence identical across all nine of them instead of nine separate
+ * `??` chains that can drift.
+ *
+ * The component then binds the *negation* onto its own inner element:
+ *
+ * ```html
+ * <button class="gog-btn" gogRipple [rippleDisabled]="!rippleEnabled()">
+ * ```
+ *
+ * `[gogRipple]` is always applied rather than toggled, because a directive cannot be added and
+ * removed by a binding — and it costs nothing while disabled: `GogRippleDirective` attaches no
+ * event listeners at all until `rippleDisabled` goes false.
+ */
+declare function resolveRipple(rippleInput: Signal<boolean | undefined>, config: GogGlobalConfig): Signal<boolean>;
+
+declare const VERTICAL_ARROWS: readonly ["ArrowDown", "ArrowUp"];
+declare const HORIZONTAL_ARROWS: readonly ["ArrowRight", "ArrowLeft"];
+declare const EDGE_KEYS: readonly ["Home", "End"];
+type RovingFocusKey = (typeof VERTICAL_ARROWS)[number] | (typeof HORIZONTAL_ARROWS)[number] | (typeof EDGE_KEYS)[number];
+/**
+ * Whether `key` navigates a roving-tabindex list laid out along `orientation`.
+ *
+ * The orientation filter is the point: a horizontal tablist must leave `ArrowDown` alone so
+ * the page still scrolls, and a vertical listbox must not steal `ArrowRight` from a caret
+ * inside a text field. `Home`/`End` are accepted for both.
+ */
+declare function isRovingFocusKey(key: string, orientation?: GogOrientation): key is RovingFocusKey;
+/**
+ * The index `key` moves to from `currentIndex`, wrapping at both ends.
+ *
+ * `isEnabled` lets a caller keep disabled items in the list — which it must, since they still
+ * occupy a position in the DOM — while navigation steps over them. Without it every index is a
+ * target, which is the behaviour the dropdowns rely on (they pre-filter their own list).
+ * Returns `currentIndex` when nothing else is reachable, so a group of one enabled item cannot
+ * spin.
+ */
+declare function nextRovingFocusIndex(key: RovingFocusKey, currentIndex: number, count: number, isEnabled?: (index: number) => boolean): number;
+/**
+ * Arrow/Home/End navigation across a roving-tabindex-style list of focusable elements.
+ * `event.currentTarget` must be one of `items`. Returns false (and leaves the event
+ * untouched) for any other key, or when `items` doesn't contain the current target,
+ * so callers can safely invoke this unconditionally from a keydown handler.
+ *
+ * Defaults to a vertical list with every item reachable — the shape the option lists and the
+ * accordion were written against — so existing callers need no options object.
+ */
+declare function handleRovingFocusKeydown(event: KeyboardEvent, items: readonly HTMLElement[], options?: {
+    orientation?: GogOrientation;
+    /** Items this returns true for are skipped rather than focused. */
+    isDisabled?: (item: HTMLElement, index: number) => boolean;
+}): boolean;
+
+/** 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-line-height' | '--gog-accordion-chevron-size' | '--gog-accordion-chevron-transition-duration' | '--gog-accordion-content-gap' | '--gog-accordion-disabled-opacity' | '--gog-accordion-focus-ring-color' | '--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-color' | '--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-line-height' | '--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-press-bg' | '--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-alert-accent-color' | '--gog-alert-bg' | '--gog-alert-body-font-size' | '--gog-alert-body-line-height' | '--gog-alert-border-color' | '--gog-alert-border-style' | '--gog-alert-border-width' | '--gog-alert-color' | '--gog-alert-danger-color' | '--gog-alert-edge-width' | '--gog-alert-font-family' | '--gog-alert-gap' | '--gog-alert-heading-color' | '--gog-alert-heading-font-size' | '--gog-alert-heading-font-weight' | '--gog-alert-heading-line-height' | '--gog-alert-icon-font-size' | '--gog-alert-icon-line-height' | '--gog-alert-info-color' | '--gog-alert-main-gap' | '--gog-alert-padding-x' | '--gog-alert-padding-y' | '--gog-alert-radius' | '--gog-alert-success-color' | '--gog-alert-warning-color' | '--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-empty-line-height' | '--gog-autocomplete-error-border-color' | '--gog-autocomplete-error-color' | '--gog-autocomplete-error-font-family' | '--gog-autocomplete-error-font-size' | '--gog-autocomplete-error-line-height' | '--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-line-height' | '--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-press-bg' | '--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-border-style' | '--gog-border-width' | '--gog-button-active-scale' | '--gog-button-bg' | '--gog-button-border' | '--gog-button-border-style' | '--gog-button-border-width' | '--gog-button-color' | '--gog-button-danger-fill' | '--gog-button-danger-fill-hover' | '--gog-button-danger-fill-press' | '--gog-button-danger-ink' | '--gog-button-danger-on-fill' | '--gog-button-danger-wash' | '--gog-button-disabled-opacity' | '--gog-button-focus-ring-color' | '--gog-button-focus-ring-offset' | '--gog-button-focus-ring-width' | '--gog-button-font-family' | '--gog-button-font-weight' | '--gog-button-gap' | '--gog-button-ghost-bg' | '--gog-button-ghost-border' | '--gog-button-ghost-color' | '--gog-button-ghost-hover-bg' | '--gog-button-ghost-hover-color' | '--gog-button-ghost-hover-shadow' | '--gog-button-ghost-press-bg' | '--gog-button-ghost-press-color' | '--gog-button-ghost-shadow' | '--gog-button-ghost-spinner-color' | '--gog-button-ghost-toggled-shadow' | '--gog-button-hover-bg' | '--gog-button-hover-color' | '--gog-button-hover-shadow' | '--gog-button-info-fill' | '--gog-button-info-fill-hover' | '--gog-button-info-fill-press' | '--gog-button-info-ink' | '--gog-button-info-on-fill' | '--gog-button-info-wash' | '--gog-button-letter-spacing' | '--gog-button-lg-font-size' | '--gog-button-lg-padding' | '--gog-button-line-height' | '--gog-button-loading-opacity' | '--gog-button-md-font-size' | '--gog-button-md-padding' | '--gog-button-outline-bg' | '--gog-button-outline-border' | '--gog-button-outline-color' | '--gog-button-outline-hover-bg' | '--gog-button-outline-hover-color' | '--gog-button-outline-hover-shadow' | '--gog-button-outline-press-bg' | '--gog-button-outline-press-color' | '--gog-button-outline-shadow' | '--gog-button-outline-spinner-color' | '--gog-button-outline-toggled-shadow' | '--gog-button-press-bg' | '--gog-button-press-color' | '--gog-button-primary-bg' | '--gog-button-primary-border' | '--gog-button-primary-color' | '--gog-button-primary-hover-bg' | '--gog-button-primary-hover-color' | '--gog-button-primary-hover-shadow' | '--gog-button-primary-press-bg' | '--gog-button-primary-press-color' | '--gog-button-primary-shadow' | '--gog-button-primary-spinner-color' | '--gog-button-primary-toggled-shadow' | '--gog-button-radius' | '--gog-button-secondary-bg' | '--gog-button-secondary-border' | '--gog-button-secondary-color' | '--gog-button-secondary-hover-bg' | '--gog-button-secondary-hover-color' | '--gog-button-secondary-hover-shadow' | '--gog-button-secondary-press-bg' | '--gog-button-secondary-press-color' | '--gog-button-secondary-shadow' | '--gog-button-secondary-spinner-color' | '--gog-button-secondary-toggled-shadow' | '--gog-button-shadow' | '--gog-button-slg-font-size' | '--gog-button-slg-padding' | '--gog-button-sm-font-size' | '--gog-button-sm-padding' | '--gog-button-spinner-color' | '--gog-button-spinner-max-size' | '--gog-button-success-fill' | '--gog-button-success-fill-hover' | '--gog-button-success-fill-press' | '--gog-button-success-ink' | '--gog-button-success-on-fill' | '--gog-button-success-wash' | '--gog-button-text-transform' | '--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-press-bg' | '--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-selected-press-bg' | '--gog-button-toggle-separated-gap' | '--gog-button-toggle-text-transform' | '--gog-button-toggle-transition-duration' | '--gog-button-toggled-ring-width' | '--gog-button-toggled-shadow' | '--gog-button-transition-duration' | '--gog-button-warning-fill' | '--gog-button-warning-fill-hover' | '--gog-button-warning-fill-press' | '--gog-button-warning-ink' | '--gog-button-warning-on-fill' | '--gog-button-warning-wash' | '--gog-button-xsm-font-size' | '--gog-button-xsm-padding' | '--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-footer-gap' | '--gog-calendar-header-gap' | '--gog-calendar-header-margin' | '--gog-calendar-lg-day-size' | '--gog-calendar-lg-font-size' | '--gog-calendar-line-height' | '--gog-calendar-max-width' | '--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-line-height' | '--gog-calendar-weekday-padding' | '--gog-calendar-weekday-text-transform' | '--gog-calendar-xsm-day-size' | '--gog-calendar-xsm-font-size' | '--gog-card-bg' | '--gog-card-border-color' | '--gog-card-border-style' | '--gog-card-border-width' | '--gog-card-color' | '--gog-card-disabled-opacity' | '--gog-card-elevated-bg' | '--gog-card-elevated-border-color' | '--gog-card-elevated-shadow' | '--gog-card-filled-bg' | '--gog-card-filled-border-color' | '--gog-card-filled-shadow' | '--gog-card-focus-ring' | '--gog-card-focus-ring-offset' | '--gog-card-focus-ring-width' | '--gog-card-font-family' | '--gog-card-footer-border-color' | '--gog-card-footer-gap' | '--gog-card-footer-padding-top' | '--gog-card-gap' | '--gog-card-heading-color' | '--gog-card-heading-font-family' | '--gog-card-heading-font-size' | '--gog-card-heading-font-weight' | '--gog-card-heading-line-height' | '--gog-card-hover-border-color' | '--gog-card-hover-shadow' | '--gog-card-lg-gap' | '--gog-card-lg-padding-x' | '--gog-card-lg-padding-y' | '--gog-card-md-gap' | '--gog-card-md-padding-x' | '--gog-card-md-padding-y' | '--gog-card-outlined-bg' | '--gog-card-outlined-border-color' | '--gog-card-outlined-shadow' | '--gog-card-padding-x' | '--gog-card-padding-y' | '--gog-card-radius' | '--gog-card-shadow' | '--gog-card-slg-gap' | '--gog-card-slg-padding-x' | '--gog-card-slg-padding-y' | '--gog-card-sm-gap' | '--gog-card-sm-padding-x' | '--gog-card-sm-padding-y' | '--gog-card-transition-duration' | '--gog-card-xsm-gap' | '--gog-card-xsm-padding-x' | '--gog-card-xsm-padding-y' | '--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-line-height' | '--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-color' | '--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-press-bg' | '--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-selected-ring-width' | '--gog-chip-selected-shadow' | '--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-confirmation-dialog-actions-gap' | '--gog-confirmation-dialog-actions-offset' | '--gog-confirmation-dialog-color' | '--gog-confirmation-dialog-description-color' | '--gog-confirmation-dialog-description-font-size' | '--gog-confirmation-dialog-description-line-height' | '--gog-confirmation-dialog-gap' | '--gog-confirmation-dialog-max-width' | '--gog-confirmation-dialog-min-width' | '--gog-confirmation-dialog-title-font-size' | '--gog-confirmation-dialog-title-line-height' | '--gog-control-border-style' | '--gog-control-border-width' | '--gog-control-boundary-color' | '--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-clear-icon-ratio' | '--gog-control-icon-offset' | '--gog-control-padding-x' | '--gog-control-padding-y' | '--gog-danger-color' | '--gog-danger-shade' | '--gog-danger-text-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-error-line-height' | '--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-line-height' | '--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-panel-width' | '--gog-datepicker-placeholder-color' | '--gog-datepicker-radius' | '--gog-datepicker-text-color' | '--gog-datepicker-toggle-icon-size' | '--gog-datepicker-transition-duration' | '--gog-density' | '--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-line-height' | '--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-dialog-title-font-size' | '--gog-dialog-title-line-height' | '--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-elevated-surface-color' | '--gog-elevation-0' | '--gog-elevation-1' | '--gog-elevation-2' | '--gog-elevation-3' | '--gog-elevation-4' | '--gog-elevation-5' | '--gog-elevation-ambient-alpha' | '--gog-elevation-contact' | '--gog-elevation-contact-blur' | '--gog-elevation-highlight' | '--gog-elevation-highlight-alpha' | '--gog-elevation-highlight-ink' | '--gog-elevation-ink' | '--gog-elevation-key-alpha' | '--gog-elevation-key-blur' | '--gog-elevation-key-x' | '--gog-elevation-key-y' | '--gog-elevation-ring' | '--gog-elevation-ring-width' | '--gog-field-error-line-height' | '--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-icon-glyph' | '--gog-field-icon-glyph-sm' | '--gog-field-icon-glyph-xsm' | '--gog-field-label-line-height' | '--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-line-height' | '--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-font-weight-bold' | '--gog-font-weight-heavy' | '--gog-font-weight-medium' | '--gog-font-weight-semibold' | '--gog-hover-color' | '--gog-icon-fallback-size' | '--gog-icon-size' | '--gog-icon-stroke-width' | '--gog-info-color' | '--gog-info-shade' | '--gog-info-text-color' | '--gog-input-clear-icon-ratio' | '--gog-input-clear-inset' | '--gog-input-clear-line-height' | '--gog-input-clear-radius' | '--gog-input-disabled-opacity' | '--gog-input-error-color' | '--gog-input-error-font-size' | '--gog-input-error-line-height' | '--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-icon-line-height' | '--gog-input-label-color' | '--gog-input-label-font-family' | '--gog-input-label-font-size' | '--gog-input-label-letter-spacing' | '--gog-input-label-line-height' | '--gog-input-label-text-transform' | '--gog-input-padding-x' | '--gog-input-padding-y' | '--gog-input-placeholder-color' | '--gog-input-radius' | '--gog-input-spin-hover-bg' | '--gog-input-spin-width' | '--gog-input-transition-duration' | '--gog-letter-spacing' | '--gog-line-height-loose' | '--gog-line-height-none' | '--gog-line-height-normal' | '--gog-line-height-relaxed' | '--gog-line-height-snug' | '--gog-line-height-tight' | '--gog-menu-available-height' | '--gog-menu-bg' | '--gog-menu-border-color' | '--gog-menu-border-style' | '--gog-menu-border-width' | '--gog-menu-focus-ring' | '--gog-menu-focus-ring-width' | '--gog-menu-font-family' | '--gog-menu-gap' | '--gog-menu-item-color' | '--gog-menu-item-disabled-color' | '--gog-menu-item-disabled-opacity' | '--gog-menu-item-font-size' | '--gog-menu-item-gap' | '--gog-menu-item-hover-bg' | '--gog-menu-item-hover-color' | '--gog-menu-item-icon-size' | '--gog-menu-item-line-height' | '--gog-menu-item-padding' | '--gog-menu-item-press-bg' | '--gog-menu-item-radius' | '--gog-menu-max-height' | '--gog-menu-max-width' | '--gog-menu-min-width' | '--gog-menu-padding' | '--gog-menu-panel-gap' | '--gog-menu-radius' | '--gog-menu-shadow' | '--gog-menu-transition-duration' | '--gog-menu-z' | '--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-border' | '--gog-multiselect-checkbox-checked-bg' | '--gog-multiselect-clear-icon-ratio' | '--gog-multiselect-clear-line-height' | '--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-line-height' | '--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-line-height' | '--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-press-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-overflow-line-height' | '--gog-multiselect-padding-x' | '--gog-multiselect-padding-y' | '--gog-multiselect-panel-bg' | '--gog-multiselect-panel-border' | '--gog-multiselect-panel-gap' | '--gog-multiselect-panel-max-height' | '--gog-multiselect-panel-max-width' | '--gog-multiselect-panel-radius' | '--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-line-height' | '--gog-paginator-ellipsis-min-width' | '--gog-paginator-gap' | '--gog-paginator-page-size-min-width' | '--gog-panel-bg' | '--gog-panel-border-color' | '--gog-panel-border-style' | '--gog-panel-border-width' | '--gog-panel-chevron-size' | '--gog-panel-color' | '--gog-panel-disabled-opacity' | '--gog-panel-elevated-bg' | '--gog-panel-elevated-border-color' | '--gog-panel-filled-bg' | '--gog-panel-filled-border-color' | '--gog-panel-filled-shadow' | '--gog-panel-focus-ring' | '--gog-panel-focus-ring-offset' | '--gog-panel-focus-ring-width' | '--gog-panel-font-family' | '--gog-panel-footer-border-color' | '--gog-panel-footer-gap' | '--gog-panel-footer-padding-top' | '--gog-panel-gap' | '--gog-panel-header-gap' | '--gog-panel-heading-color' | '--gog-panel-heading-font-family' | '--gog-panel-heading-font-size' | '--gog-panel-heading-font-weight' | '--gog-panel-heading-line-height' | '--gog-panel-lg-gap' | '--gog-panel-lg-padding-x' | '--gog-panel-lg-padding-y' | '--gog-panel-md-gap' | '--gog-panel-md-padding-x' | '--gog-panel-md-padding-y' | '--gog-panel-outlined-bg' | '--gog-panel-outlined-border-color' | '--gog-panel-outlined-shadow' | '--gog-panel-padding-x' | '--gog-panel-padding-y' | '--gog-panel-radius' | '--gog-panel-shadow' | '--gog-panel-slg-gap' | '--gog-panel-slg-padding-x' | '--gog-panel-slg-padding-y' | '--gog-panel-sm-gap' | '--gog-panel-sm-padding-x' | '--gog-panel-sm-padding-y' | '--gog-panel-toggle-color' | '--gog-panel-toggle-hover-bg' | '--gog-panel-toggle-radius' | '--gog-panel-toggle-size' | '--gog-panel-transition-duration' | '--gog-panel-xsm-gap' | '--gog-panel-xsm-padding-x' | '--gog-panel-xsm-padding-y' | '--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-edge-backing-color' | '--gog-progressbar-edge-color' | '--gog-progressbar-edge-width' | '--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-line-height' | '--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-error-line-height' | '--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-ripple-color' | '--gog-ripple-easing' | '--gog-ripple-enter-duration' | '--gog-ripple-exit-duration' | '--gog-ripple-opacity' | '--gog-scroll-corner-bg' | '--gog-scroll-fade-duration' | '--gog-scroll-focus-ring' | '--gog-scroll-focus-ring-width' | '--gog-scroll-normal-thumb-hit-padding' | '--gog-scroll-normal-thumb-min-size' | '--gog-scroll-normal-track-width' | '--gog-scroll-thin-thumb-hit-padding' | '--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-line-height' | '--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-error-line-height' | '--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-line-height' | '--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-press-bg' | '--gog-select-option-radius' | '--gog-select-option-selected-color' | '--gog-select-option-transition-duration' | '--gog-select-options-padding' | '--gog-select-panel-bg' | '--gog-select-panel-gap' | '--gog-select-panel-max-height' | '--gog-select-panel-max-width' | '--gog-select-panel-radius' | '--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-error-line-height' | '--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-line-height' | '--gog-slider-label-text-transform' | '--gog-slider-range-color' | '--gog-slider-range-font-size' | '--gog-slider-range-line-height' | '--gog-slider-thumb-bg' | '--gog-slider-thumb-border' | '--gog-slider-thumb-border-width' | '--gog-slider-thumb-glow-color' | '--gog-slider-thumb-glow-size' | '--gog-slider-thumb-radius' | '--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-line-height' | '--gog-slider-value-min-width' | '--gog-slider-vertical-length' | '--gog-space-12' | '--gog-space-16' | '--gog-space-20' | '--gog-space-24' | '--gog-space-28' | '--gog-space-2xl' | '--gog-space-32' | '--gog-space-4' | '--gog-space-40' | '--gog-space-48' | '--gog-space-8' | '--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-success-shade' | '--gog-success-text-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-line-height' | '--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-bg' | '--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-num-line-height' | '--gog-table-numeric-font-family' | '--gog-table-padding-h' | '--gog-table-row-border-width' | '--gog-table-row-press-bg' | '--gog-table-row-transition-duration' | '--gog-table-select-col-width' | '--gog-table-selected-bg' | '--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-line-height' | '--gog-table-td-padding-v' | '--gog-table-text-color' | '--gog-table-th-font-size' | '--gog-table-th-inner-gap' | '--gog-table-th-line-height' | '--gog-table-th-padding-v' | '--gog-table-total-font-size' | '--gog-table-total-letter-spacing' | '--gog-table-total-line-height' | '--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-press-bg' | '--gog-tabs-press-color' | '--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-2xs' | '--gog-text-3xl' | '--gog-text-color' | '--gog-text-lg' | '--gog-text-md' | '--gog-text-slg' | '--gog-text-sm' | '--gog-text-transform' | '--gog-text-xl' | '--gog-text-xs' | '--gog-textarea-clear-icon-ratio' | '--gog-textarea-line-height' | '--gog-textarea-resize-grip-color' | '--gog-textarea-resize-grip-offset' | '--gog-textarea-resize-grip-opacity' | '--gog-textarea-resize-grip-size' | '--gog-textarea-resize-grip-stripe-gap' | '--gog-textarea-resize-grip-stripe-width' | '--gog-textarea-resize-inset-bottom' | '--gog-textarea-resize-inset-right' | '--gog-textarea-scrollbar-width' | '--gog-toast-accent-width' | '--gog-toast-action-font-size' | '--gog-toast-action-line-height' | '--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-line-height' | '--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-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-line-height' | '--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' | '--gog-warning-shade' | '--gog-warning-text-color' | '--gog-z-base';
+/** 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[];
+
+/**
+ * Reading a `--gog-*` token's value from TypeScript, safely.
+ *
+ * **The trap these exist for.** `getComputedStyle(el).getPropertyValue('--x')` returns a custom
+ * property's *specified* value, not a used one. A token declared
+ * `calc(10px * var(--gog-density))` comes back as that whole string, and `Number.parseFloat` on
+ * it returns `NaN` — which every caller in this library turned into its fallback, silently. No
+ * error, no failing test, just a component quietly using the wrong number.
+ *
+ * That is not hypothetical. 21.7.0's density scale (`docs/themes.md` iteration 6) made 178
+ * tokens `calc(<n>px * var(--gog-density))`; none of the three tokens read from TypeScript were
+ * among them, but nothing stopped the next one from being. And a **consumer** can write
+ * `--gog-scroll-thumb-min-size: calc(2rem + 4px)` in their own theme at any time, which no
+ * repo-side check could ever catch.
+ *
+ * So these resolve rather than parse: the fast path still handles a plain `12px`, and anything
+ * else is handed to the browser on a throwaway element, which also gets `rem`, `em`, `%` and
+ * nested `var()` right for free. The probe is appended to the element the token was read from,
+ * so relative units resolve against the same context the real value would.
+ */
+/** Reads a length token in pixels. Returns `fallback` for an empty, unparseable or zero value. */
+declare function resolveLengthToken(el: HTMLElement, token: string, fallback: number): number;
+/**
+ * Reads a unitless numeric token (a `z-index`). Same resolution path as lengths — `z-index`
+ * takes an integer, so the browser computes `calc()` there too.
+ */
+declare function resolveNumberToken(el: HTMLElement, token: string, fallback: number): number;
+
+type GogTooltipSide = 'top' | 'bottom' | 'left' | 'right';
+/** Writing direction of the element a placement is resolved against. */
+type GogWritingDirection = 'ltr' | 'rtl';
+interface GogTooltipTargetRect {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    width: number;
+    height: number;
+}
+interface GogTooltipSize {
+    width: number;
+    height: number;
+}
+interface GogTooltipViewport {
+    width: number;
+    height: number;
+}
+interface GogTooltipPlacement {
+    side: GogTooltipSide;
+    top: number;
+    left: number;
+}
+/**
+ * Picks which side the bubble renders on. `'auto'` tries top, bottom, then the two horizontal
+ * sides — top-first matches the conventional tooltip default — and falls back to whichever
+ * side has the most room if the bubble doesn't fully fit anywhere. An explicit side flips to
+ * its opposite when it has no room but the opposite does, same as `resolveDropdownDirection`
+ * does for up/down; unlike that helper, a request for a specific side is honoured as-is
+ * (no flip) whenever it fits, since the caller asked for that side deliberately.
+ *
+ * **`direction` mirrors the horizontal preference only.** In RTL, `'auto'` prefers the left
+ * side where LTR prefers the right, so a tooltip opens away from the text it belongs to in the
+ * same way in both. An explicit `'left'`/`'right'` is *not* mirrored: those are physical words
+ * in a physical API, and a consumer who wrote `position="right"` meant the right of the screen.
+ * `'start'`/`'end'` would be the logical spelling, and there is deliberately no such value —
+ * `'auto'` already does the right thing for a direction-aware layout.
+ */
+declare function resolveTooltipSide(position: GogTooltipPosition, target: GogTooltipTargetRect, bubble: GogTooltipSize, viewport: GogTooltipViewport, gap?: number, viewportPadding?: number, direction?: GogWritingDirection): GogTooltipSide;
+/**
+ * Resolves the bubble's side and its `position: fixed` top/left, centered on the target's
+ * midpoint along the cross axis and clamped so it never renders past the viewport edge —
+ * the centering can push it there for a target near a corner.
+ */
+declare function resolveTooltipPlacement(position: GogTooltipPosition, target: GogTooltipTargetRect, bubble: GogTooltipSize, viewport: GogTooltipViewport, gap?: number, viewportPadding?: number, direction?: GogWritingDirection): GogTooltipPlacement;
+
+/** The slice of a list that is worth rendering, as indices into the full list. */
+interface GogVirtualRange {
+    /** First index to render, inclusive. */
+    readonly start: number;
+    /** One past the last index to render, so `slice(start, end)` is the window. */
+    readonly end: number;
+}
+/** What `GogVirtualWindow` needs to do its arithmetic. Every input is a signal it reads. */
+interface GogVirtualWindowInputs {
+    /** How many rows the list has in total — not how many are rendered. */
+    readonly count: Signal<number>;
+    /**
+     * One row's height in px, measured rather than assumed.
+     *
+     * The library learned this the expensive way: `--gog-*-option-height` described itself as an
+     * estimate and was wrong in all eleven shipped themes, low by up to 8.38px a row, while a
+     * placement decision depended on it. A window is far less forgiving than a placement — the error
+     * accumulates once per row — so this takes a number that came from `getBoundingClientRect`.
+     */
+    readonly rowHeight: Signal<number>;
+    /** The scroller's visible height in px. Not the panel's max-height, which is a cap. */
+    readonly viewportHeight: Signal<number>;
+    /** How far the scroller is scrolled, in px. */
+    readonly scrollTop: Signal<number>;
+    /**
+     * Rows rendered beyond each edge of the viewport, so a scroll does not expose blank space
+     * before the next frame lands. Defaults to 4.
+     */
+    readonly overscan?: number;
+}
+/**
+ * The arithmetic behind a windowed list, and nothing else.
+ *
+ * **No DOM, no template, no scroll listener.** The component that uses this owns its scroller —
+ * the three dropdowns already own theirs (a `gog-scroll` inside the panel) and `gog-table` owns a
+ * different one — so a primitive that grabbed an element would have to be told which, and would
+ * still not know when that element moved. It reads signals and returns numbers; everything that
+ * touches the page stays in the component.
+ *
+ * That is the same division `GogRippleController` made, for the reason `docs/ripple.md` records:
+ * the engine lives beside the components rather than inside a directive, because the things that
+ * need it cannot all reach a directive through `hostDirectives`.
+ *
+ * ```ts
+ * private readonly window = new GogVirtualWindow({
+ *   count: computed(() => this.visibleOptions().length),
+ *   rowHeight: this.measuredRowHeight,
+ *   viewportHeight: this.panelHeight,
+ *   scrollTop: this.panelScrollTop,
+ * });
+ * // window.range() -> { start, end }
+ * // window.padBefore() / window.padEnd() -> px of filler above and below the rendered slice
+ * ```
+ *
+ * **Why padding rather than absolute positioning.** A spacer above and below the rendered rows
+ * keeps the list in normal flow, so the rows stay `display: flex` children of the same container
+ * and every selector, gap and `:last-child` a component already relies on keeps working. Absolute
+ * positioning each row is the other common shape and it changes what the component's own CSS
+ * means, which is a large price for a list that is one column wide.
+ *
+ * @see docs/virtualization.md — the plan, its measurements, and what still has to be got right in
+ * the components that adopt this (ARIA counts, keyboard reach, panel height, filter resets).
+ */
+declare class GogVirtualWindow {
+    private readonly inputs;
+    private readonly overscan;
+    constructor(inputs: GogVirtualWindowInputs);
+    /**
+     * The total height the list would have if every row were rendered. What the scroller needs to
+     * believe so its thumb is the right size and `scrollTop` spans the whole list.
+     */
+    readonly totalHeight: Signal<number>;
+    /**
+     * The slice worth rendering.
+     *
+     * **Degrades to the whole list rather than to nothing.** A row height of zero is what a caller
+     * has before it has measured anything, and a window computed from it would be `{0, 0}` — an
+     * empty panel that looks like a bug and hides the data. Rendering everything is the pre-window
+     * behaviour, which is slow and correct; that is the right way round for a fallback.
+     */
+    readonly range: Signal<GogVirtualRange>;
+    /** Filler above the rendered slice, in px, so the rows sit where their indices say. */
+    readonly padBefore: Signal<number>;
+    /** Filler below, in px. Derived from the total so rounding cannot leave a gap. */
+    readonly padAfter: Signal<number>;
+    /**
+     * Where the scroller has to be for `index` to be fully visible, or `null` if it already is.
+     *
+     * This is what keyboard navigation needs: arrowing to a row outside the window is a scroll
+     * first and a focus move second, because the element does not exist until the scroll has
+     * re-rendered the slice. Returning `null` rather than the current position lets a caller skip
+     * the scroll entirely, which matters because scrolling when nothing needs to move cancels a
+     * user's own in-progress scroll in some browsers.
+     */
+    scrollOffsetFor(index: number): number | null;
+    /** Guards against the shapes a caller can legitimately be in before it has measured anything. */
+    private safeCount;
+    private safeRowHeight;
+    private safeViewportHeight;
+    private safeScrollTop;
+}
+
+/** What `GogVariableWindow` needs. Every input is a signal it reads. */
+interface GogVariableWindowInputs {
+    /** How many rows the list has in total — not how many are rendered. */
+    readonly count: Signal<number>;
+    /**
+     * The height in px to assume for a row that has never been measured.
+     *
+     * Seeded from the first row the caller measures rather than from a token: `gog-table`'s row
+     * height is padding plus leading plus a border, and `docs/virtualization.md`'s iteration 0
+     * measured the equivalent token wrong in all eleven shipped themes.
+     */
+    readonly estimatedRowHeight: Signal<number>;
+    /** The scroller's visible height in px. Not a `max-height`, which is a cap. */
+    readonly viewportHeight: Signal<number>;
+    /** How far the scroller is scrolled, in px. */
+    readonly scrollTop: Signal<number>;
+    /**
+     * Rows rendered beyond each edge of the viewport, so a scroll does not expose blank space
+     * before the next frame lands. Defaults to 4.
+     */
+    readonly overscan?: number;
+}
+/**
+ * The arithmetic behind a windowed list whose rows are **not** all the same height.
+ *
+ * `GogVirtualWindow` is the one to reach for wherever the rows are uniform — it is exact, it needs
+ * no measurements, and a multiplication beats a binary search. This exists because `gog-table`
+ * cannot use it, for a reason that is a fact about CSS rather than about this library:
+ *
+ * **A table row's height cannot be pinned.** `height` on a `<tr>` or a `<td>` is a *minimum* in
+ * table layout, so a cell whose content wraps makes its row taller and nothing can stop it — one
+ * cell taken from 40 to 600 characters measured 39px → 173.75px, under `table-layout: fixed`, with
+ * the column width unchanged. A single-pitch window cannot describe that list.
+ *
+ * So this holds a height per row: the measured one where a row has ever been rendered, and an
+ * estimate everywhere else. `range()` is then a binary search over the prefix sums rather than a
+ * division.
+ *
+ * **Being an estimate is the whole difficulty**, and it lives in `applyMeasurements`, not here.
+ * See its note: correcting a row *above* the viewport moves everything below it, under the reader,
+ * while they scroll — so the correction has to be reported as a scroll delta and applied in the
+ * same frame.
+ *
+ * @see docs/table-virtualization.md — the survey behind this, and what adopting it has to get right
+ */
+declare class GogVariableWindow {
+    private readonly inputs;
+    private readonly overscan;
+    /**
+     * Measured heights by row index, `undefined` where a row has never been rendered.
+     *
+     * A sparse array rather than a `Map`: the index *is* the key, the reads are sequential, and the
+     * prefix sum walks it start to finish either way.
+     */
+    private readonly measured;
+    constructor(inputs: GogVariableWindowInputs);
+    /**
+     * Running total of row heights: `offsets[i]` is where row `i` starts, and `offsets[count]` is
+     * the list's full height.
+     *
+     * Recomputed whole rather than patched. It is O(n) on a signal that changes only when a
+     * measurement actually differs, and an incremental structure here would be a Fenwick tree
+     * guarding a loop that costs a fraction of the layout it feeds.
+     */
+    private readonly offsets;
+    /** What the scroller has to believe, so its thumb is the right size. */
+    readonly totalHeight: Signal<number>;
+    /**
+     * The slice worth rendering.
+     *
+     * **Degrades to the whole list rather than to nothing**, the same rule `GogVirtualWindow`
+     * follows and for the same reason: a caller that has not measured anything yet has an estimate
+     * of zero, and a window computed from it renders an empty panel that reads as broken. Rendering
+     * everything is the pre-window behaviour — slow, and correct.
+     */
+    readonly range: Signal<GogVirtualRange>;
+    /** Filler above the rendered slice, in px, so the rows sit where their offsets say. */
+    readonly padBefore: Signal<number>;
+    /** Filler below, in px. Derived from the total so rounding cannot leave a gap. */
+    readonly padAfter: Signal<number>;
+    /**
+     * Records what the rendered rows actually measured, and returns **how far the content above the
+     * viewport moved** — which the caller must add to the scroller's `scrollTop`, in the same frame.
+     *
+     * This is the whole difficulty of a variable window, and it is not obvious from the arithmetic.
+     * Every row starts as an estimate. The moment one is measured and disagrees, every row after it
+     * shifts by the difference — including, when the corrected row is *above* the viewport, the rows
+     * the reader is looking at. Scroll up into a region of taller-than-estimated rows and the
+     * content jumps away from the pointer on every frame; the list appears to fight the scroll.
+     *
+     * Adding the delta back to `scrollTop` holds the visible rows still: the content moved down by
+     * `delta`, so the viewport moves down by `delta` too and the same pixels stay under the reader.
+     *
+     * `heights[i]` is keyed by **real row index**, and a `0` or a negative is ignored rather than
+     * stored — an unlaid-out row measures zero, and believing it would collapse the list.
+     */
+    applyMeasurements(heights: ReadonlyMap<number, number>): number;
+    /**
+     * Drops every measurement. For when the rows stop describing the same data — a new page, a new
+     * sort, a filter — after which a cached height belongs to a row that is no longer there.
+     */
+    reset(): void;
+    /** Where the scroller has to be for `index` to be fully visible, or `null` if it already is. */
+    scrollOffsetFor(index: number): number | null;
+    /**
+     * The index of the row containing `position`, by binary search over the offsets.
+     *
+     * Returns the **last** index whose start is `<= position`, clamped to the list. A linear scan
+     * would be fine at a thousand rows and is not at the hundreds of thousands this exists for, and
+     * it runs on every scroll frame.
+     */
+    private indexAt;
+    private safeCount;
+    private safeEstimate;
+    private safeViewportHeight;
+    private safeScrollTop;
+}
+
+export { DEFAULT_RIPPLE, GOG_CHECKABLE_CONTROL_PADDING, GOG_CHECKABLE_CONTROL_SIZE_MAP, GOG_CONFIG, GOG_DEPRECATIONS, GOG_ICONS, GOG_TOKEN_GROUPS, GogClearableState, GogDropdownBase, GogDropdownChevronDirective, GogDropdownOptionDirective, GogDropdownOverlay, GogErrorState, GogFloatLabelState, GogVariableWindow, GogVirtualWindow, ICON_DEFS, addDays, addMonths, addYears, buildMonthGrid, clampDate, copyTimeOnto, daysInMonth, formatDate, getByPath, handleRovingFocusKeydown, isAfterDay, isBeforeDay, isInRange, isRovingFocusKey, isSameDay, isSameMonth, isSameOptionValue, isWithinBounds, localeFirstDayOfWeek, monthNames, nextGogControlId, nextRovingFocusIndex, parseDate, provideGogConfig, provideGogIcons, readOption, resolveConfigured, resolveCssLengthPx, resolveDropdownDirection, resolveDropdownPlacement, resolveLengthToken, resolveNumberToken, resolveRipple, resolveTooltipPlacement, resolveTooltipSide, scopedOverlayDirection, scopedOverlayTheme, startOfDay, weekdayNames, withTime };
+export type { GogAlertLive, GogAriaHasPopup, GogBadgePosition, GogBuiltinIconName, GogButtonToggleAppearance, GogCheckableControlSizeConfig, GogDateRange, GogDateSelectionMode, GogDeprecation, GogDeprecationKind, GogDividerVariant, GogDropdownDirection, GogDropdownFilterPosition, GogDropdownOption, GogDropdownOptionContext, GogDropdownPlacement, GogDropdownTriggerRect, GogErrorDisplay, GogFloatLabelVariant, GogGlobalConfig, GogHourFormat, GogIconName, GogInputMode, GogInputType, GogOptionAccessor, GogOrientation, GogPaginatorRangeMode, GogProgressbarMode, GogProgressbarVariant, GogScrollAxis, GogScrollOverscrollBehavior, GogScrollSize, GogSeverity, GogSize, GogSkeletonAnimation, GogSkeletonShape, GogSliderOrientation, GogSliderRange, GogSpinnerVariant, GogSurfaceVariant, GogTabsAlign, GogTagShape, GogTagVariant, GogTextareaResize, GogTokenGroup, GogTokenLayer, GogTokenName, GogTooltipPlacement, GogTooltipPosition, GogTooltipSide, GogTooltipSize, GogTooltipTargetRect, GogTooltipViewport, GogVariableWindowInputs, GogVariant, GogVirtualRange, GogVirtualWindowInputs, GogWritingDirection, RovingFocusKey, ToastPosition };