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

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

@@ -0,0 +1,449 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, ComboboxMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, OnInit } 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 ComboboxSize = 'sm' | 'md' | 'lg';
+type ComboboxVariant = 'outline' | 'subtle' | 'plain';
+type ComboboxSide = 'bottom' | 'top' | 'inline-start' | 'inline-end' | 'left' | 'right';
+type ComboboxAlign = 'start' | 'center' | 'end';
+type ComboboxWidth = 'anchor' | 'content';
+type ComboboxMount = 'active' | 'lazy' | 'eager';
+type ComboboxStrategy = 'absolute' | 'fixed';
+/** The pattern's own three values for `aria-autocomplete`. */
+type ComboboxAutocomplete = 'none' | 'list' | 'both';
+/**
+ * When the popup opens on its own: as the reader types or presses the input, on
+ * every focus and press, or never.
+ */
+type ComboboxOpenOn = 'input' | 'focus' | 'manual';
+type ComboboxOptionValue = string;
+type ComboboxOpenReason = 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'select' | 'dismiss' | 'blur' | 'programmatic';
+type ComboboxValueReason = 'pointer' | 'keyboard' | 'clear' | 'select' | 'blur' | 'programmatic';
+type ComboboxInputReason = 'keyboard' | 'select' | 'clear' | 'blur' | 'programmatic';
+type ComboboxHighlightReason = 'pointer' | 'keyboard' | 'programmatic';
+/**
+ * Whether an option answers a query. `null` turns filtering off entirely, which
+ * is what a list a server has already filtered needs.
+ */
+type ComboboxFilter = ((label: string, query: string) => boolean) | null;
+interface ComboboxOption {
+    value: ComboboxOptionValue;
+    label: string;
+    disabled?: boolean;
+}
+interface ComboboxOptionGroup {
+    label: string;
+    options: readonly ComboboxOption[];
+}
+type ComboboxItems = readonly (ComboboxOption | ComboboxOptionGroup)[];
+interface ComboboxDefaults {
+    align: ComboboxAlign;
+    alignOffset: number;
+    allowsCustomValue: boolean;
+    autocomplete: ComboboxAutocomplete;
+    autoHighlight: boolean;
+    clearable: boolean;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    closeOnSelect: boolean;
+    collisionPadding: number;
+    disabled: boolean;
+    flip: boolean;
+    fullWidth: boolean;
+    hideWhenDetached: boolean;
+    highlightMatch: boolean;
+    invalid: boolean;
+    loading: boolean;
+    loop: boolean;
+    mount: ComboboxMount;
+    openOn: ComboboxOpenOn;
+    portal: boolean;
+    readOnly: boolean;
+    required: boolean;
+    shift: boolean;
+    side: ComboboxSide;
+    sideOffset: number;
+    size: ComboboxSize;
+    strategy: ComboboxStrategy;
+    variant: ComboboxVariant;
+    width: ComboboxWidth;
+}
+/**
+ * The numbers, and why they are these numbers. The reasoning is the React
+ * binding's, in `packages/react/src/combobox/combobox-defaults.tsx`; the two
+ * tables are held to each other by the contract, which declares every one of
+ * them as a default.
+ */
+declare const COMBOBOX_FALLBACK: ComboboxDefaults;
+declare const COMBOBOX_DEFAULTS: InjectionToken<ComboboxDefaults>;
+/**
+ * The decisions an application takes once. Its words come from the language in
+ * force (`provideSlotted`).
+ */
+declare function provideComboboxDefaults(defaults: Partial<ComboboxDefaults>): Provider;
+declare function injectComboboxDefaults(): ComboboxDefaults;
+
+/**
+ * A text input with a listbox of options filtered by what was typed.
+ *
+ * **The host element is the control**, as `sl-select`'s is: the frame carries
+ * `data-ui`, and the input, the clear button, the trigger and the hidden
+ * submission field are its template. The popup is an `ng-template` built into
+ * the portal when it opens.
+ *
+ * **The typed text and the chosen key are two contracts.** `inputValue` and
+ * `value` are separate models, each with its own request, because a list whose
+ * labels are not unique cannot derive one from the other.
+ *
+ * **Every text-editing key stays the browser's.** The key handler binds the
+ * arrows, `Enter`, `Escape` and the page keys, and nothing else — the pattern's
+ * IMPORTANT note asks exactly that.
+ */
+declare class SlCombobox implements ControlValueAccessor, OnInit, Validator {
+    private static readonly flag;
+    private static readonly count;
+    /** The chosen option's key. */
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string | null>>;
+    /** What an unbound `value` starts from, read once. It seeds the key and not the text. */
+    readonly defaultValue: _angular_core.InputSignal<string | null | undefined>;
+    /** The characters in the field, which are not the chosen key. */
+    readonly inputValue: _angular_core.ModelSignal<string>;
+    readonly inputValueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string>>;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly highlightedValue: _angular_core.ModelSignal<string | null>;
+    readonly highlightedValueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string | null>>;
+    /** The last option came into view; the consumer fetches the next page. */
+    readonly loadMore: _angular_core.OutputEmitterRef<void>;
+    /** The text the field refused, and why (CB7). */
+    readonly inputReset: _angular_core.OutputEmitterRef<{
+        rejected: string;
+        reason: "blur";
+    }>;
+    /** The query the reader asked to add. The collection is the consumer's (CB8). */
+    readonly create: _angular_core.OutputEmitterRef<{
+        query: string;
+        reason: ComboboxValueReason;
+    }>;
+    /** Whether the consumer will take a value the collection does not hold (CB8). */
+    readonly creatable: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    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>;
+    readonly items: _angular_core.InputSignal<ComboboxItems | undefined>;
+    readonly total: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /** BCP 47, for the comparison the default filter makes. The language in force when absent. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly filter: _angular_core.InputSignal<ComboboxFilter | undefined>;
+    readonly size: _angular_core.InputSignal<ComboboxSize | undefined>;
+    readonly variant: _angular_core.InputSignal<ComboboxVariant | undefined>;
+    readonly side: _angular_core.InputSignal<ComboboxSide | undefined>;
+    readonly align: _angular_core.InputSignal<ComboboxAlign | undefined>;
+    readonly width: _angular_core.InputSignal<ComboboxWidth | undefined>;
+    readonly mount: _angular_core.InputSignal<ComboboxMount | undefined>;
+    readonly strategy: _angular_core.InputSignal<ComboboxStrategy | undefined>;
+    readonly autocomplete: _angular_core.InputSignal<ComboboxAutocomplete | undefined>;
+    readonly openOn: _angular_core.InputSignal<ComboboxOpenOn | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * clear and trigger buttons, the offer to create, the empty, loading and
+     * count sentences.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<ComboboxMessages> | 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 allowsCustomValue: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly autoHighlight: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly highlightMatch: _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 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 combobox's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<ComboboxMessages>;
+    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 injector;
+    private readonly template;
+    private readonly controlRef;
+    readonly field: SlField | null;
+    private readonly identifier;
+    readonly contentId: string;
+    private readonly ownId;
+    private readonly registry;
+    readonly optionCount: _angular_core.WritableSignal<number>;
+    /**
+     * The completion `autocomplete="both"` shows: the rest of the first match, or
+     * `null`. It is part of what the input renders rather than a write onto the
+     * element, so nothing has to fight Angular for the value.
+     */
+    readonly completion: _angular_core.WritableSignal<string | null>;
+    private wantsCompletion;
+    private entry;
+    private view;
+    private layerNode;
+    private surfaceNode;
+    private portalRoot;
+    private positioner;
+    private layer;
+    private presence;
+    private observer;
+    private disabledByForm;
+    private readonly hostId;
+    private onChange;
+    private onTouched;
+    readonly resolvedSize: _angular_core.Signal<ComboboxSize>;
+    readonly resolvedVariant: _angular_core.Signal<ComboboxVariant>;
+    readonly resolvedAlign: _angular_core.Signal<ComboboxAlign>;
+    readonly resolvedSide: _angular_core.Signal<ComboboxSide>;
+    readonly resolvedWidth: _angular_core.Signal<ComboboxWidth>;
+    readonly resolvedMount: _angular_core.Signal<ComboboxMount>;
+    readonly resolvedAutocomplete: _angular_core.Signal<ComboboxAutocomplete>;
+    readonly resolvedOpenOn: _angular_core.Signal<ComboboxOpenOn>;
+    readonly resolvedLoop: _angular_core.Signal<boolean>;
+    readonly resolvedClearable: _angular_core.Signal<boolean>;
+    readonly resolvedFullWidth: _angular_core.Signal<boolean>;
+    readonly resolvedCloseOnSelect: _angular_core.Signal<boolean>;
+    readonly resolvedAllowsCustomValue: _angular_core.Signal<boolean>;
+    readonly resolvedAutoHighlight: _angular_core.Signal<boolean>;
+    readonly resolvedHighlightMatch: _angular_core.Signal<boolean>;
+    /**
+     * The offer to add what was typed (CB8): the query, while the consumer will
+     * take one, the reader typed something and nothing in the collection matched
+     * it. It is one expression, so the row and the commit cannot disagree about
+     * whether an offer is standing.
+     */
+    readonly creating: _angular_core.Signal<string | null>;
+    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>;
+    readonly controlId: _angular_core.Signal<string>;
+    readonly describedBy: _angular_core.Signal<string | null>;
+    readonly display: _angular_core.Signal<string>;
+    private readonly declared;
+    /**
+     * The query the options filter against, and it is not always the typed text:
+     * once an option has been committed the input holds its label, and filtering
+     * on that would leave the popup showing the one option already chosen.
+     */
+    readonly query: _angular_core.Signal<string>;
+    private readonly fallbackFilter;
+    readonly showClear: _angular_core.Signal<boolean>;
+    readonly activeDescendant: _angular_core.Signal<string | null>;
+    readonly statusMessage: _angular_core.Signal<string>;
+    constructor();
+    /**
+     * The uncontrolled start, read once. It is read here rather than in the
+     * constructor because that is where Angular has finished writing the inputs.
+     * A `value` the consumer bound is already in the model and wins; the seed
+     * fills a model still at its declared default, and leaves `inputValue`
+     * alone because the text and the key are two contracts.
+     */
+    ngOnInit(): void;
+    optionId(value: ComboboxOptionValue): string;
+    labelFor(value: ComboboxOptionValue): string | undefined;
+    registerLabel(value: ComboboxOptionValue, label: string): void;
+    /**
+     * Three answers, and `undefined` is not one of them: an absent `filter` asks
+     * for the library's own locale-sensitive `contains`, `null` turns filtering
+     * off, and a function replaces the comparison.
+     */
+    matches(label: string): boolean;
+    recount(): void;
+    options(): HTMLElement[];
+    focus(): void;
+    scrollToKey(value: ComboboxOptionValue): void;
+    setOpen(next: boolean, reason: ComboboxOpenReason, source?: Event): void;
+    setHighlighted(next: ComboboxOptionValue | null, reason: ComboboxHighlightReason, source?: Event): void;
+    setInputValue(next: string, reason: ComboboxInputReason, source?: Event): void;
+    select(next: ComboboxOptionValue | null, reason: ComboboxValueReason, source?: Event): void;
+    clear(reason: ComboboxValueReason, source?: Event): void;
+    /** Takes an option: the key, the label into the field, and the popup shut. */
+    commitOption(value: ComboboxOptionValue, reason: ComboboxValueReason, source?: Event): void;
+    protected onInput(event: Event): void;
+    protected onFocus(): void;
+    protected onClick(event: MouseEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    /**
+     * The option whose label *is* the text, by the same collator the filter used:
+     * a reader who typed an option in full has chosen it, and comparing with
+     * `===` would refuse `resume` for `Resumé` on a page the filter had just
+     * matched.
+     */
+    private valueForLabel;
+    /**
+     * What becomes of text that matched no option, at the moment the reader
+     * leaves the field (CB7). `combobox`'s React binding states the reasoning;
+     * the three answers are the same, in the same order. Text that *is* an option
+     * is that option; text that is not, in a field that allows one of its own, is
+     * the value; text that is not, in a field that does not, is undone and the
+     * caller is told what was refused.
+     */
+    private settleInput;
+    protected onClear(event: MouseEvent): void;
+    protected onToggle(event: MouseEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    private onEscape;
+    private commitFromKeyboard;
+    /**
+     * An option refuses the press, and this one is an option (CB11). The rule
+     * itself lives on `SlComboboxOption`; the offer is written by this template,
+     * so it repeats the one line rather than the reason.
+     */
+    protected onOptionPointerDown(event: PointerEvent): void;
+    protected onCreateClick(query: string, event: MouseEvent): void;
+    /**
+     * Taking the offer reports the query and selects nothing: the collection does
+     * not hold the value yet, and a control naming an option that does not exist
+     * is a control whose value and picture disagree — the fault CB7 fixed at the
+     * other end. What the consumer does with it is the consumer's (CB8).
+     */
+    private takeOffer;
+    private labelOf;
+    private openWith;
+    private move;
+    /** The filter took the highlighted option away, so the highlight goes too. */
+    private dropStaleHighlight;
+    private applyCompletion;
+    private show;
+    private build;
+    private position;
+    private bind;
+    /**
+     * The last row came into view, so there is more to fetch. An observer rather
+     * than a scroll listener: the question is whether the end of the list is
+     * visible, and a scroll handler answers it by measuring on every frame.
+     */
+    private observeEnd;
+    private enter;
+    /**
+     * Where the highlight lands: the chosen option, or — with `autoHighlight`,
+     * when none is showing — the first match. The contract's `focus.onOpen`
+     * asks it of every opening, a press or a focus included, and of every query
+     * typed while the popup stays open, so `Enter` always has a match under it.
+     */
+    private land;
+    private hide;
+    private unbind;
+    private teardown;
+    writeValue(value: ComboboxOptionValue | null): void;
+    registerOnChange(fn: (value: ComboboxOptionValue | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Two validities the family owns, and neither is one a native input can
+     * describe: a required control with nothing chosen, and a control holding
+     * text that matches no option when a custom value is not allowed.
+     */
+    validate(): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCombobox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCombobox, "sl-combobox", ["slCombobox"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "inputValue": { "alias": "inputValue"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "highlightedValue": { "alias": "highlightedValue"; "required": false; "isSignal": true; }; "creatable": { "alias": "creatable"; "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; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "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; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "openOn": { "alias": "openOn"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "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; }; "allowsCustomValue": { "alias": "allowsCustomValue"; "required": false; "isSignal": true; }; "autoHighlight": { "alias": "autoHighlight"; "required": false; "isSignal": true; }; "highlightMatch": { "alias": "highlightMatch"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "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"; "inputValue": "inputValueChange"; "inputValueChangeRequest": "inputValueChangeRequest"; "open": "openChange"; "openChangeRequest": "openChangeRequest"; "highlightedValue": "highlightedValueChange"; "highlightedValueChangeRequest": "highlightedValueChangeRequest"; "loadMore": "loadMore"; "inputReset": "inputReset"; "create": "create"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The first column, holding an element of the consumer's own — an avatar, a
+ * logo — where the `icon` input names only a glyph. React's `icon` prop takes
+ * any element, and this is the same column in the same part.
+ */
+declare class SlComboboxItemIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlComboboxItemIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlComboboxItemIcon, "[slComboboxItemIcon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * One option, and the one that decides whether it belongs in the results.
+ *
+ * **Each option filters itself.** The family holds the query and the
+ * comparison; the option holds its own label. An option that does not match
+ * renders nothing at all, so the popup's DOM *is* the result set — which is
+ * what makes the count, the keyboard model and the empty row read one answer.
+ *
+ * `label` is an input rather than projected content here, and that is the one
+ * place this binding differs from its React counterpart: a comparison and a
+ * split both need the text before the view exists, and Angular has no way to
+ * read projected content that has not been created.
+ */
+declare class SlComboboxItem {
+    readonly value: _angular_core.InputSignal<string>;
+    /** What the reader sees, what the filter compares, and what the mark splits. */
+    readonly label: _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. An
+     * element of the consumer's own goes there through `slComboboxItemIcon`.
+     */
+    readonly icon: _angular_core.InputSignal<"calendar" | "upload" | "search" | "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>;
+    readonly position: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly combobox: SlCombobox;
+    private readonly host;
+    readonly optionId: _angular_core.Signal<string>;
+    readonly selected: _angular_core.Signal<boolean>;
+    readonly current: _angular_core.Signal<boolean>;
+    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.
+     */
+    readonly ranges: _angular_core.Signal<_slotted_core_highlight.HighlightRange[]>;
+    constructor();
+    protected onPointerEnter(event: PointerEvent): void;
+    /**
+     * Only to stop the browser moving focus off the input: an option cannot hold
+     * focus, so a press on it would take focus to the body — and the settling of
+     * CB7 would run on the query the reader was in the middle of choosing from,
+     * before the click arrived (CB11).
+     */
+    protected onPointerDown(event: PointerEvent): void;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlComboboxItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlComboboxItem, "sl-combobox-item", ["slComboboxItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "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; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["[slComboboxItemIcon]"], true, never>;
+}
+/**
+ * A set of options under a heading, named by `aria-labelledby` pointing at its
+ * own label. A group whose every option was filtered away is hidden: a heading
+ * with no options under it says a category matched when none did.
+ */
+declare class SlComboboxGroup {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly labelId: string;
+    private readonly host;
+    private readonly combobox;
+    readonly empty: _angular_core.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlComboboxGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlComboboxGroup, "sl-combobox-group", ["slComboboxGroup"], { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** A line between two sets of options. */
+declare class SlComboboxSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlComboboxSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlComboboxSeparator, "sl-combobox-separator", ["slComboboxSeparator"], {}, {}, never, never, true, never>;
+}
+
+export { COMBOBOX_DEFAULTS, COMBOBOX_FALLBACK, SlCombobox, SlComboboxGroup, SlComboboxItem, SlComboboxItemIcon, SlComboboxSeparator, injectComboboxDefaults, provideComboboxDefaults };
+export type { ComboboxAlign, ComboboxAutocomplete, ComboboxDefaults, ComboboxFilter, ComboboxHighlightReason, ComboboxInputReason, ComboboxItems, ComboboxMount, ComboboxOpenOn, ComboboxOpenReason, ComboboxOption, ComboboxOptionGroup, ComboboxOptionValue, ComboboxSide, ComboboxSize, ComboboxStrategy, ComboboxValueReason, ComboboxVariant, ComboboxWidth };
+//# sourceMappingURL=slotted-angular-combobox.d.ts.map

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

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