@slotted/angular 0.0.0-stage → 0.1.0-beta.1

package/types/slotted-angular-select.d.ts

@@ -0,0 +1,507 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, SelectMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, TemplateRef } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor, Validator, ValidationErrors } from '@angular/forms';
+import { SlField } from '@slotted/angular/field';
+import * as _slotted_core_highlight from '@slotted/core/highlight';
+
+type SelectSize = 'sm' | 'md' | 'lg';
+type SelectVariant = 'outline' | 'subtle' | 'plain';
+type SelectSide = 'bottom' | 'top' | 'inline-start' | 'inline-end' | 'left' | 'right';
+type SelectAlign = 'start' | 'center' | 'end';
+type SelectWidth = 'anchor' | 'content';
+type SelectMount = 'active' | 'lazy' | 'eager';
+type SelectStrategy = 'absolute' | 'fixed';
+type SelectOptionValue = string;
+type SelectSelection = SelectOptionValue | readonly SelectOptionValue[] | null;
+type SelectOpenReason = 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'select' | 'dismiss' | 'blur' | 'programmatic';
+type SelectValueReason = 'pointer' | 'keyboard' | 'clear' | 'select' | 'programmatic';
+/**
+ * Why the query moved. `clear` covers both the reader emptying the field and
+ * the popup emptying it as it opens and closes — the field was emptied either
+ * way.
+ */
+type SelectSearchReason = 'keyboard' | 'select' | 'clear' | 'programmatic';
+/**
+ * Whether an option answers a query. `null` turns filtering off, which is what
+ * a list a server has already filtered needs; a function replaces the
+ * comparison; unset asks for the library's own locale-sensitive `contains`.
+ */
+type SelectFilter = ((label: string, query: string) => boolean) | null;
+type SelectHighlightReason = 'pointer' | 'keyboard' | 'programmatic';
+/** Enough to name a value the popup has never rendered. */
+interface SelectOption {
+    value: SelectOptionValue;
+    label: string;
+    disabled?: boolean;
+}
+interface SelectOptionGroup {
+    label: string;
+    options: readonly SelectOption[];
+}
+type SelectItems = readonly (SelectOption | SelectOptionGroup)[];
+interface SelectDefaults {
+    align: SelectAlign;
+    alignOffset: number;
+    clearable: boolean;
+    /** Whether the span a query matched is marked inside the option's label. */
+    highlightMatch: boolean;
+    /** Whether the popup opens onto a field the reader filters the options with. */
+    search: boolean;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    closeOnSelect: boolean;
+    collisionPadding: number;
+    disabled: boolean;
+    flip: boolean;
+    fullWidth: boolean;
+    hideWhenDetached: boolean;
+    invalid: boolean;
+    loading: boolean;
+    loop: boolean;
+    mount: SelectMount;
+    multiple: boolean;
+    portal: boolean;
+    readOnly: boolean;
+    required: boolean;
+    shift: boolean;
+    side: SelectSide;
+    sideOffset: number;
+    size: SelectSize;
+    strategy: SelectStrategy;
+    typeahead: boolean;
+    typeaheadTimeout: number;
+    variant: SelectVariant;
+    width: SelectWidth;
+}
+/**
+ * The numbers, and why they are these numbers. The reasoning is the React
+ * binding's, written out in `packages/react/src/select/select-defaults.tsx`;
+ * the two tables are checked against each other by the contract, which holds
+ * every one of them as a declared default.
+ */
+declare const SELECT_FALLBACK: SelectDefaults;
+declare const SELECT_DEFAULTS: InjectionToken<SelectDefaults>;
+/**
+ * The decisions an application takes once, in its bootstrap, rather than on
+ * every select it renders. A select that states one of them itself still wins.
+ * Its words come from the language in force (`provideSlotted`).
+ */
+declare function provideSelectDefaults(defaults: Partial<SelectDefaults>): Provider;
+declare function injectSelectDefaults(): SelectDefaults;
+
+/**
+ * The summary a consumer writes instead of the family's own.
+ *
+ * A `TemplateRef` rather than a render function, because that is what Angular
+ * has where React has a function — and it is the asymmetry
+ * `docs/history/designs/2026-09-04-select-and-combobox-design.md` §11 records
+ * rather than levels away. The context carries the values and the labels the
+ * family could resolve, so a consumer who already holds the records does not
+ * resolve them twice:
+ *
+ * ```html
+ * <ng-template slSelectValue let-values let-labels="labels">
+ *   {{ values.length }} of 40 chosen
+ * </ng-template>
+ * ```
+ */
+declare class SlSelectValue {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSelectValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlSelectValue, "[slSelectValue]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A control that shows the current choice and opens a listbox of the rest.
+ *
+ * **The host element is the control.** `sl-select` carries `data-ui` and the
+ * frame's own `data-part`, and the button, the chevron, the clear button and
+ * the hidden native `select` are its template — the same shape `text-field`
+ * has, where the frame draws the border and the ring because a ring can only be
+ * drawn by an ancestor of whatever took focus.
+ *
+ * **The popup is an `ng-template` built into the portal when it opens**, which
+ * is how `sl-menu` is built and for the same reason: a surface that has to
+ * escape its parent's clipping cannot be rendered where it was declared. It
+ * also makes `mount` a real axis here — a hundred options are not constructed
+ * until the popup is.
+ *
+ * **Focus never leaves the button.** The highlighted option is named by
+ * `aria-activedescendant`, which is what the APG's own select-only combobox
+ * example does and what this family's pair, `combobox`, has no choice about.
+ */
+declare class SlSelect implements ControlValueAccessor, Validator {
+    private static readonly flag;
+    private static readonly count;
+    /** The chosen value, or the chosen values when `multiple` is set. */
+    readonly value: _angular_core.ModelSignal<SelectSelection>;
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<SelectSelection>>;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    /** The option the highlight is on, which is not the option that is chosen. */
+    readonly highlightedValue: _angular_core.ModelSignal<string | null>;
+    readonly highlightedValueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string | null>>;
+    /**
+     * What the reader has typed into the search field. It is a value the consumer
+     * can own and it is **not** the selection: no request ever carries both.
+     */
+    readonly searchValue: _angular_core.ModelSignal<string>;
+    readonly searchValueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string>>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly form: _angular_core.InputSignal<string | undefined>;
+    /** Labels for values, so a closed control can name one it never rendered. */
+    readonly items: _angular_core.InputSignal<SelectItems | undefined>;
+    readonly total: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly size: _angular_core.InputSignal<SelectSize | undefined>;
+    readonly variant: _angular_core.InputSignal<SelectVariant | undefined>;
+    readonly side: _angular_core.InputSignal<SelectSide | undefined>;
+    readonly align: _angular_core.InputSignal<SelectAlign | undefined>;
+    readonly width: _angular_core.InputSignal<SelectWidth | undefined>;
+    readonly mount: _angular_core.InputSignal<SelectMount | undefined>;
+    readonly strategy: _angular_core.InputSignal<SelectStrategy | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the clear
+     * button, the chips, the summary, the search field, and the sentences.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<SelectMessages> | undefined>;
+    /** Whether an option answers the query. `null` turns filtering off. */
+    readonly filter: _angular_core.InputSignal<SelectFilter | undefined>;
+    /** BCP 47, for the comparison the default filter makes. */
+    /** BCP 47, for the comparison the default filter makes. The language in force when absent. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly collisionPadding: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly typeaheadTimeout: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly search: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly highlightMatch: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly typeahead: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnOutsidePress: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly flip: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly shift: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly portal: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly defaults;
+    /** The family's words in the language in force, with this select's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<SelectMessages>;
+    private readonly inForceLocale;
+    /** The locale the default filter compares in: the `locale` input, or the language in force. */
+    readonly resolvedLocale: _angular_core.Signal<string>;
+    private readonly viewContainer;
+    private readonly template;
+    private readonly triggerRef;
+    /** The summary a consumer writes instead of the family's own. */
+    readonly summaryTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /** The field around the control, whose state a bare input defers to. */
+    readonly field: SlField | null;
+    private readonly identifier;
+    readonly contentId: string;
+    /**
+     * The listbox's own identifier. Without a search field the surface is the
+     * listbox and `contentId` names it; with one the surface is a dialog and the
+     * listbox is one element in, so the two need separate names.
+     */
+    readonly listId: string;
+    readonly searchId: string;
+    /** The field's control identifier inside a field, so its label's `for` reaches the trigger. */
+    readonly triggerId: string;
+    private readonly registry;
+    private readonly optionCount;
+    private entry;
+    private pending;
+    private lastQuery;
+    private disabledByForm;
+    private view;
+    private layerNode;
+    private surfaceNode;
+    private portalRoot;
+    private positioner;
+    private layer;
+    private presence;
+    private typeaheadHandle;
+    private readonly hostLabelledBy;
+    private onChange;
+    private onTouched;
+    readonly resolvedSize: _angular_core.Signal<SelectSize>;
+    readonly resolvedVariant: _angular_core.Signal<SelectVariant>;
+    readonly resolvedAlign: _angular_core.Signal<SelectAlign>;
+    readonly resolvedSide: _angular_core.Signal<SelectSide>;
+    readonly resolvedWidth: _angular_core.Signal<SelectWidth>;
+    readonly resolvedMount: _angular_core.Signal<SelectMount>;
+    readonly resolvedMultiple: _angular_core.Signal<boolean>;
+    readonly resolvedClearable: _angular_core.Signal<boolean>;
+    readonly resolvedLoop: _angular_core.Signal<boolean>;
+    readonly resolvedSearch: _angular_core.Signal<boolean>;
+    readonly resolvedHighlightMatch: _angular_core.Signal<boolean>;
+    readonly resolvedTypeahead: _angular_core.Signal<boolean>;
+    readonly resolvedCloseOnSelect: _angular_core.Signal<boolean>;
+    readonly resolvedFullWidth: _angular_core.Signal<boolean>;
+    /** The query, which only exists while there is a field holding it. */
+    readonly query: _angular_core.Signal<string>;
+    private readonly fallbackFilter;
+    /**
+     * Three answers, and `undefined` is not one of them. Not giving `filter` asks
+     * for the library's own locale-sensitive `contains`; giving `null` turns
+     * filtering off, which is what a list a server has already filtered needs;
+     * giving a function replaces the comparison.
+     */
+    matches(label: string): boolean;
+    /** What the live region carries: the wait, or how many options survived. */
+    readonly statusMessage: _angular_core.Signal<string>;
+    /** Unset asks the field; a field that says nothing leaves the default. */
+    readonly resolvedDisabled: _angular_core.Signal<boolean>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean>;
+    readonly resolvedRequired: _angular_core.Signal<boolean>;
+    readonly resolvedInvalid: _angular_core.Signal<boolean>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    /** One value, several, or none — always read as a list, whatever was given. */
+    readonly selection: _angular_core.Signal<readonly string[]>;
+    private readonly declared;
+    readonly labels: _angular_core.Signal<string[]>;
+    readonly unmatched: _angular_core.Signal<boolean>;
+    /** The first label, then how many more. A count alone names none of them. */
+    readonly summary: _angular_core.Signal<string | undefined>;
+    readonly showClear: _angular_core.Signal<boolean>;
+    readonly empty: _angular_core.Signal<boolean>;
+    readonly activeDescendant: _angular_core.Signal<string | null>;
+    /**
+     * The trigger names the highlighted option only while it is the focused
+     * element. With a search field the field holds focus and names it instead;
+     * two elements naming one option would put the announcement on the element
+     * nobody is operating.
+     */
+    readonly triggerActiveDescendant: _angular_core.Signal<string | null>;
+    readonly labelledBy: _angular_core.Signal<string | null>;
+    readonly describedBy: _angular_core.Signal<string | null>;
+    /**
+     * The chip row, and the two measurements it needs (SL4).
+     *
+     * `createCollapse` is the same ResizeObserver arithmetic `toolbar` collapses
+     * a bar with: it hides the chips that overrun and reveals the `+N` chip from
+     * the first one that does, so the count is what the collapse reports and
+     * cannot disagree with what is on screen. `createWidthGate` answers the other
+     * question — whether the frame has room for a chip at all — because under a
+     * hundred and twenty pixels a chip is a shape with no word in it.
+     */
+    private readonly tags;
+    private readonly chipOverflow;
+    protected readonly collapsedCount: _angular_core.WritableSignal<number>;
+    protected readonly narrow: _angular_core.WritableSignal<boolean>;
+    private collapse;
+    private widthGate;
+    protected removeLabelFor(value: SelectOptionValue): string;
+    protected onRemoveChip(value: SelectOptionValue, event: MouseEvent): void;
+    constructor();
+    /** The element `aria-activedescendant` names, and the option carries. */
+    optionId(value: SelectOptionValue): string;
+    labelFor(value: SelectOptionValue): string | undefined;
+    /** An option hands over what it reads as, so the closed control can print it. */
+    registerLabel(value: SelectOptionValue, label: string): void;
+    /** Options count themselves, so the popup knows whether it holds any. */
+    recount(): void;
+    options(): HTMLElement[];
+    focus(): void;
+    /**
+     * Whether a click landed on the control's frame. A click a `label` elsewhere
+     * forwards to the button carries the label's coordinates, which lie outside it.
+     */
+    private pressedOnFrame;
+    scrollToKey(value: SelectOptionValue): void;
+    /** Asks to open or close, and reports the reason before anything moves. */
+    setOpen(next: boolean, reason: SelectOpenReason, source?: Event): void;
+    /**
+     * The query. The reset the popup performs as it opens and as it closes
+     * carries `clear`, which is what happened to the field.
+     */
+    setQuery(next: string, reason: SelectSearchReason, source?: Event): void;
+    /** The field inside the popup, which lives in an embedded view. */
+    private searchNode;
+    /** Focuses the field when there is one, and the control otherwise. */
+    focusSearch(): void;
+    setHighlighted(next: SelectOptionValue | null, reason: SelectHighlightReason, source?: Event): void;
+    /** Takes an option, or takes it back when the select holds several. */
+    toggle(value: SelectOptionValue, reason: SelectValueReason, source?: Event): void;
+    clear(reason: SelectValueReason, source?: Event): void;
+    private commit;
+    protected onTriggerClick(event: MouseEvent): void;
+    protected onClear(event: MouseEvent): void;
+    protected onBlur(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onSearchInput(event: Event): void;
+    /**
+     * The keys the field takes, and the three the closed control spends that this
+     * one cannot: `Home`, `End` and the space bar all belong to the caret while
+     * the reader is typing, and the pattern's editable branch returns them there.
+     */
+    protected onSearchKeyDown(event: KeyboardEvent): void;
+    /**
+     * Where `Tab` goes from inside the popup. The layer is portalled to the end
+     * of the document, so the browser's own next element is the end of the page
+     * rather than the element after the control: the document's tab order is read
+     * with the layer taken out of it, the trigger is found in what remains, and
+     * focus goes to the entry beside it.
+     */
+    private moveTabFrom;
+    private openWith;
+    private move;
+    private commitHighlighted;
+    /**
+     * Typeahead searches the **enabled** options and only those. The arrows step
+     * over a disabled option, so a typeahead that landed on one would let a
+     * reader reach by typing a row the family then refuses to commit.
+     */
+    private typeaheadMatch;
+    private reveal;
+    private show;
+    private build;
+    private position;
+    private bind;
+    /**
+     * Where the highlight lands as the popup opens, and where focus goes.
+     *
+     * Without a search field nothing moves: the trigger keeps focus for the whole
+     * interaction. With one, focus enters the layer — the combobox pattern's own
+     * note says a dialog popup does not support `aria-activedescendant`, so DOM
+     * focus moves into the dialog — and the field takes it however the popup was
+     * opened, a press on the trigger included.
+     */
+    private enter;
+    private hide;
+    private unbind;
+    private teardown;
+    writeValue(value: SelectSelection): void;
+    registerOnChange(fn: (value: SelectSelection) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * The one validity the family owns. `required` on a native `select` is
+     * satisfied by any non-empty option, and the hidden element this control
+     * carries always holds one — so the browser cannot answer the question and
+     * the family answers it here.
+     */
+    validate(): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSelect, "sl-select", ["slSelect"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "highlightedValue": { "alias": "highlightedValue"; "required": false; "isSignal": true; }; "searchValue": { "alias": "searchValue"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "mount": { "alias": "mount"; "required": false; "isSignal": true; }; "strategy": { "alias": "strategy"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "typeaheadTimeout": { "alias": "typeaheadTimeout"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "highlightMatch": { "alias": "highlightMatch"; "required": false; "isSignal": true; }; "typeahead": { "alias": "typeahead"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnOutsidePress": { "alias": "closeOnOutsidePress"; "required": false; "isSignal": true; }; "flip": { "alias": "flip"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "portal": { "alias": "portal"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChangeRequest": "valueChangeRequest"; "open": "openChange"; "openChangeRequest": "openChangeRequest"; "highlightedValue": "highlightedValueChange"; "highlightedValueChangeRequest": "highlightedValueChangeRequest"; "searchValue": "searchValueChange"; "searchValueChangeRequest": "searchValueChangeRequest"; }, ["summaryTemplate"], ["*"], true, never>;
+}
+
+/**
+ * One option.
+ *
+ * `role="option"` on the host, and not a button: the listbox pattern's option
+ * is not separately focusable — DOM focus stays on the trigger for the whole
+ * interaction — and a button here would put a widget inside a widget and add a
+ * tab stop the pattern excludes by name.
+ *
+ * The highlight is set by the pointer as well as by the keyboard, so exactly
+ * one option is highlighted whichever device is driving and the state a screen
+ * reader announces is the state the eye sees.
+ */
+declare class SlSelectItem {
+    readonly value: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    /** The glyph drawn in the first column, as a `Glyph` inside an `Icon` box. */
+    readonly icon: _angular_core.InputSignal<"search" | "calendar" | "upload" | "circle" | "stop" | "check" | "minus" | "plus" | "dot" | "x" | "ellipsis" | "copy" | "eye" | "eye-off" | "chevron-right" | "chevron-down" | "chevrons-right" | "panel-open" | "panel-close" | "arrow-left" | "pin" | "pin-off" | "external" | "clock" | "person" | "circle-info" | "circle-check" | "triangle-alert" | "circle-alert" | "circle-x" | "circle-question" | "inbox" | "search-x" | "lock" | "caps-lock" | "arrow-up" | "paperclip" | "pipette" | "cloud-off" | "loader-circle" | "maximize" | "minimize" | "file" | "trash" | "play" | "pause" | "rotate-ccw" | "file-image" | "file-text" | "file-spreadsheet" | "file-audio" | "file-video" | "file-archive" | "file-type" | "presentation" | "text-wrap" | "bell" | "trending-up" | "image-off" | "funnel" | "grip-vertical" | "grip-horizontal" | "star" | "check-check" | undefined>;
+    /**
+     * What typeahead matches on, what the search filters on, and what the mark
+     * splits, when the label is not plain text.
+     */
+    readonly textValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The label as text, given rather than projected.
+     *
+     * It is the one place this binding differs from its React counterpart, and it
+     * is the difference `combobox` already records: a split needs the text before
+     * the view exists, and Angular cannot read projected content that has not
+     * been created. An option that projects its content instead is filtered on
+     * `textValue` or on what it rendered, and its matched span is not marked —
+     * there is nothing to split.
+     */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly position: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly select: SlSelect;
+    private readonly host;
+    readonly optionId: _angular_core.Signal<string>;
+    readonly selected: _angular_core.Signal<boolean>;
+    readonly current: _angular_core.Signal<boolean>;
+    /** What was rendered, for an option that projected its content. */
+    private readonly rendered;
+    /**
+     * The text the filter judges: what the consumer said this option reads as,
+     * then what it actually rendered. An option the filter cannot judge — one
+     * whose content has not been created yet — is shown, which is what keeps a
+     * list whole on its first render.
+     */
+    readonly searchText: _angular_core.Signal<string>;
+    /**
+     * Each option decides whether it belongs in the results: the family holds the
+     * query and the comparison, and the option holds its own text. It hides
+     * rather than leaving, because Angular cannot decline to render a host
+     * component from inside it — and every reader of the collection takes the
+     * visible ones.
+     */
+    readonly visible: _angular_core.Signal<boolean>;
+    /**
+     * The spans the query matched, from the same collator the filter used, drawn
+     * by the `highlight` family inside this family's label. An `indexOf` beside
+     * a locale-sensitive filter marks nothing on the row it has just matched.
+     */
+    ranges(text: string): _slotted_core_highlight.HighlightRange[];
+    constructor();
+    protected onPointerEnter(event: PointerEvent): void;
+    /**
+     * Only to stop the browser moving focus off the trigger. Under
+     * `aria-activedescendant` the trigger is the focused element, and a press that
+     * took focus to the body would leave the property pointing at something that
+     * is no longer the active element (CB11).
+     */
+    protected onPointerDown(event: PointerEvent): void;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSelectItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSelectItem, "sl-select-item", ["slSelectItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "textValue": { "alias": "textValue"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * A set of options under a heading, named by `aria-labelledby` pointing at its
+ * own label — which the listbox pattern requires of every option group. The
+ * label is an input rather than a projected part, because a group with no
+ * accessible name is a pattern violation the type system can refuse.
+ */
+declare class SlSelectGroup {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly labelId: string;
+    private readonly select;
+    private readonly host;
+    protected readonly empty: _angular_core.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSelectGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSelectGroup, "sl-select-group", ["slSelectGroup"], { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * A line between two sets of options. `role="separator"` inside a listbox is a
+ * structural element and takes no orientation: the line is horizontal because
+ * the list is vertical, and saying so twice is how two families came to
+ * disagree about which axis the word names.
+ */
+declare class SlSelectSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSelectSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSelectSeparator, "sl-select-separator", ["slSelectSeparator"], {}, {}, never, never, true, never>;
+}
+
+export { SELECT_DEFAULTS, SELECT_FALLBACK, SlSelect, SlSelectGroup, SlSelectItem, SlSelectSeparator, SlSelectValue, injectSelectDefaults, provideSelectDefaults };
+export type { SelectAlign, SelectDefaults, SelectFilter, SelectHighlightReason, SelectItems, SelectMount, SelectOpenReason, SelectOption, SelectOptionGroup, SelectOptionValue, SelectSearchReason, SelectSelection, SelectSide, SelectSize, SelectStrategy, SelectValueReason, SelectVariant, SelectWidth };
+//# sourceMappingURL=slotted-angular-select.d.ts.map

package/types/slotted-angular-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-select.d.ts","sources":["../../select/src/select-defaults.ts","../../select/src/select-value.ts","../../select/src/select.ts","../../select/src/select-items.ts"],"mappings":"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","names":[]}