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

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

@@ -0,0 +1,535 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { FamilyTranslator, FieldMessages, PartialMessages } from '@slotted/core/i18n';
+import * as _slotted_angular_field from '@slotted/angular/field';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterContentChecked } from '@angular/core';
+import { InlineMessageTone, InlineMessageLive, InlineMessageMark } from '@slotted/angular/inline-message';
+import * as i1 from '@slotted/angular/tooltip';
+
+/** The type step the field sits at, matching the control it wraps. */
+type FieldSize = 'sm' | 'md' | 'lg';
+/**
+ * Where the label sits relative to the control. `side` reflows to `top` when
+ * the field's own inline size falls below 320 pixels, so a field in a drawer
+ * stacks while the same field in a page grid stays beside its control.
+ */
+type FieldLabelPlacement = 'top' | 'side';
+/**
+ * How necessity is said. `mark` draws the asterisk every surveyed
+ * implementation draws on a required field; `optional` writes `(optional)` on
+ * the fields a reader may skip and nothing on the others, which is what GOV.UK
+ * and Carbon recommend for a form where most fields are required; `words`
+ * writes `(required)` on a required field and `(optional)` on one that is not;
+ * `none` says nothing, for a form where every field is required and the form
+ * says so once.
+ */
+type FieldNecessity = 'mark' | 'optional' | 'words' | 'none';
+/** The identifiers a field derives from one base. */
+interface FieldIds {
+    control: string;
+    counter: string;
+    description: string;
+    error: string;
+    help: string;
+    indicator: string;
+    label: string;
+}
+/**
+ * The parts that join the control's `aria-describedby`, in the order the
+ * contract reads them: what qualifies the field, the help behind the icon, the
+ * description, the count, the error.
+ */
+type FieldDescribedSlot = 'indicator' | 'help' | 'description' | 'counter' | 'error';
+declare const FIELD_DESCRIBED_ORDER: readonly FieldDescribedSlot[];
+interface FieldDefaults {
+    disabled: boolean | undefined;
+    labelPlacement: FieldLabelPlacement;
+    necessity: FieldNecessity;
+    readOnly: boolean | undefined;
+    size: FieldSize;
+}
+declare const FIELD_DEFAULTS: InjectionToken<FieldDefaults>;
+/**
+ * An application decides once what its fields look like, rather than repeating
+ * the same inputs on every field in a form. Their words come from the language
+ * in force (`provideSlotted`).
+ * `SlFieldGroup` provides an overriding value for its own subtree, so a compact
+ * section — or a disabled one — is one attribute rather than one per field.
+ *
+ * Among the surveyed implementations only Angular Material ships
+ * application-wide defaults, and this is that idea taken to both bindings.
+ *
+ * `disabled` and `readOnly` are here and `invalid` and `required` are not. The
+ * first two describe a context a whole section can be in; the second two are
+ * facts about one value, and a token that set them would mark every field in an
+ * application as required for a reason no field could name.
+ */
+declare function provideFieldDefaults(defaults: Partial<FieldDefaults>): {
+    provide: InjectionToken<FieldDefaults>;
+    useFactory: () => FieldDefaults;
+};
+/** What a field renders as here, before it states anything of its own. */
+declare function injectFieldDefaults(): FieldDefaults;
+/**
+ * A component in the tree answering for the fields under it, which is what
+ * `field-group` is. It exists as a class of its own so `@slotted/angular/field`
+ * never has to know that `field-group` exists — the dependency runs one way,
+ * from the group to the field.
+ *
+ * It is read rather than snapshotted, because Angular creates every directive
+ * in a template before it binds any input: a group that handed its fields a
+ * value in its constructor would hand them the value its inputs had before the
+ * consumer's bindings ran, which is the default for all six.
+ */
+declare abstract class SlFieldDefaultsSource {
+    abstract fieldDefaults(): FieldDefaults;
+}
+/** The identifiers a field derives from its base, in one place. */
+declare function deriveFieldIds(base: string): FieldIds;
+/**
+ * What the necessity mark says, and whether a reader hears it. The asterisk is
+ * hidden, because `aria-required` on the control already carries the fact and a
+ * form of twenty required fields does not need "asterisk" twenty times; the
+ * words are not, because `(optional)` is information rather than decoration.
+ * `null` when nothing is drawn. `slFieldGroupLegend` draws its mark with the
+ * same answer.
+ */
+declare function necessityMark(necessity: FieldNecessity, required: boolean, t: FamilyTranslator<FieldMessages>): {
+    hidden: boolean;
+    text: string;
+} | null;
+/**
+ * The field as the parts that live in a module `field.ts` imports see it — the
+ * counter today. Provided by `SlField` as itself, so the counter reaches the
+ * field's identifiers without importing it, which would be a cycle.
+ */
+declare abstract class SlFieldContext {
+    abstract ids(): FieldIds;
+}
+/**
+ * The parts the field looks for without importing them. Each part provides
+ * its marker as itself, and the field queries the marker; importing the part
+ * classes into `field.ts` would be a cycle, since every one of them injects
+ * `SlField`.
+ */
+declare abstract class SlFieldHeaderSlot {
+}
+declare abstract class SlFieldHelpSlot {
+}
+declare abstract class SlFieldIndicatorSlot {
+}
+/**
+ * Application-scoped rather than module-scoped, for the reason `inline-message`
+ * records: a module-level counter produces colliding sequences when two
+ * applications render in one server process, and the server and the client
+ * sequences must match for hydration.
+ */
+declare class SlFieldIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * What a control tells the field about its own value, so the field can draw the
+ * count in the spare column of its label row. The control counts and the field
+ * places it: the number belongs to the value, and the row belongs to the field.
+ *
+ * `length` is in UTF-16 code units, which is what `maxLength` counts, so an
+ * emoji counts as two. A counter that disagreed with the limit the browser
+ * enforces would be wrong at exactly the moment it is read.
+ */
+interface FieldCount {
+    length: number;
+    max: number | undefined;
+}
+/**
+ * How a count reads: `12/280` when there is a limit and `12` when there is
+ * none. Carbon and Polaris both write the pair; Angular Material writes it in
+ * the subscript, where a count that appears on the first keystroke shares a row
+ * with the error and pushes it.
+ */
+declare function formatFieldCount(count: FieldCount): string;
+/** Whether a count has passed the limit it was given. */
+declare function isFieldCountOver(count: FieldCount): boolean;
+/**
+ * A count the page writes itself, at the end of the label row — which is where
+ * Carbon puts it. Angular Material puts it in the subscript beside the error,
+ * where a count that appears on the first keystroke shares a row with the
+ * message and pushes it.
+ *
+ * A field whose control publishes a count gets a counter drawn by the field, so
+ * this directive is for the page that counts something the control cannot:
+ * words, bytes, line items. Writing one withdraws the field's own, because two
+ * counters in one row is one row too many.
+ *
+ * It lives in a module of its own so `field.ts` can look for it without
+ * importing the parts that inject `SlField`, which would be a cycle; it reaches
+ * the field through `SlFieldContext` for the same reason.
+ */
+declare class SlFieldCounter {
+    private readonly field;
+    private readonly writtenId;
+    /**
+     * The identifier the field's description reads the count by, which
+     * `docs/component-features.md` §2.8 requires of a counter. A consumer's own
+     * `id` wins.
+     */
+    protected readonly counterId: _angular_core.Signal<string | null>;
+    /**
+     * The count has passed its limit. It is the counter's own state rather than
+     * the field's: a count can pass its maximum while validation has not run, and
+     * a counter that only turned at submit would say nothing at the moment it is
+     * being read.
+     */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldCounter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFieldCounter, "[slFieldCounter]", ["slFieldCounter"], { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * What the page wants said, and how — carried by the element the page writes
+ * and read by the field, which renders the `inline-message` around it.
+ *
+ * The field renders the message rather than the page, because `SlInlineMessage`
+ * takes its values as `input()` signals and nothing outside the template that
+ * instantiates it can write one. A directive sharing the element could only set
+ * attributes the component's own host bindings would then overwrite, and the
+ * identifier the field derives is exactly such a value.
+ */
+declare abstract class SlFieldMessage implements AfterContentChecked {
+    /** Replaces the message's own tone. `inline-message` owns the five. */
+    readonly tone: _angular_core.InputSignal<InlineMessageTone | undefined>;
+    /** Whether the message announces itself when it arrives. */
+    readonly live: _angular_core.InputSignal<InlineMessageLive | undefined>;
+    /**
+     * Which mark the message draws. A field's messages default to `none`, and
+     * `glyph` asks for the tone's own silhouette, `dot` for one neutral bullet.
+     */
+    readonly mark: _angular_core.InputSignal<InlineMessageMark | undefined>;
+    /** The word read before the message; the empty string removes it. */
+    readonly prefix: _angular_core.InputSignal<string | undefined>;
+    /** Draws no mark, for a message that carries its own artwork. */
+    readonly hideIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Holds one line box open so nothing below moves when the message arrives. */
+    readonly reserve: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly host;
+    private readonly content;
+    /**
+     * Whether the message has text to say. An empty one — a `reserve` line
+     * waiting for its text — keeps its box and describes nothing, which is what
+     * React's messages register.
+     *
+     * It is read after the template that declares the message writes its text
+     * and before the host bindings of that template run, so the first render,
+     * the only one a server performs, names exactly the messages that have text.
+     * In the browser an observer also reports text that arrives from anywhere
+     * else.
+     */
+    readonly hasContent: _angular_core.Signal<boolean>;
+    constructor();
+    ngAfterContentChecked(): void;
+    private read;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldMessage, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFieldMessage, never, never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "mark": { "alias": "mark"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "hideIcon": { "alias": "hideIcon"; "required": false; "isSignal": true; }; "reserve": { "alias": "reserve"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Help about the field, projected into the `inline-message` the field renders.
+ *
+ * It arrives with a tone, a mark, a clipped severity word an application
+ * translates once and a reserved line — none of which the field reimplements.
+ * `docs/process/build-order.md` states that as the reason `inline-message` was built
+ * in wave 2.
+ */
+declare class SlFieldDescription extends SlFieldMessage {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFieldDescription, "[slFieldDescription]", ["slFieldDescription"], {}, {}, never, never, true, never>;
+}
+/**
+ * What is wrong with the value, in words — which is what WCAG 2.2 SC 3.3.1
+ * requires and what colour and a mark alone do not satisfy.
+ *
+ * `tone` accepts the other four, so a warning that does not block submission is
+ * the same part in another tone rather than a member of its own. Fluent spends
+ * a `validationState` axis on that distinction and Carbon a second component.
+ */
+declare class SlFieldError extends SlFieldMessage {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldError, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFieldError, "[slFieldError]", ["slFieldError"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * One control, its name, its necessity, its help and its error — and the
+ * identifiers that bind the four together.
+ *
+ * **Every shared state is unset rather than `false`.** `disabled`, `invalid`,
+ * `required` and `readOnly` default to `undefined`, so a field defers to the
+ * `slFieldGroup` around it and the group to the application. A field that
+ * defaulted to `false` could not be told from a consumer saying "not disabled",
+ * and it would quietly override a disabled section.
+ *
+ * **The identifiers are derived, not registered.** One base yields four, so
+ * `label[for]` resolves to the identifier the control will use with no ordering
+ * dependency between siblings and nothing to coordinate during hydration.
+ *
+ * **The field renders its own messages.** The page writes what it wants said —
+ * `<span slFieldError>` — and the field puts it inside an `inline-message` it
+ * renders itself, with the identifier, the step and the disabled state already
+ * resolved. `SlInlineMessage` takes its values as `input()` signals, and nothing
+ * outside the template that instantiates it can write one; a directive sharing
+ * the element could only set attributes its host bindings would overwrite. A
+ * message the page did not write is not drawn, which is the DOM React's
+ * `FieldDescription` and `FieldError` produce.
+ */
+declare class SlField {
+    /** Defaults to the token, then to `md`. */
+    readonly size: _angular_core.InputSignal<FieldSize | undefined>;
+    /** Defaults to the token, then to `top`. */
+    readonly labelPlacement: _angular_core.InputSignal<FieldLabelPlacement | undefined>;
+    /** Defaults to the token, then to `mark`. */
+    readonly necessity: _angular_core.InputSignal<FieldNecessity | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * necessity words (`optional`, `required`) and the help control's name (`help`).
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<FieldMessages> | undefined>;
+    /**
+     * Unstated rather than `false`, so the field defers to its group and the group
+     * to the application. Stated, it wins, and it reaches the control as the
+     * native attribute: removing it from the tab order and from submission is what
+     * the word means.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Unstated rather than `false`. Reaches the control as `aria-invalid`. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Unstated rather than `false`. Reaches the control as `aria-required` and
+     * never as the native `required`, which would engage browser constraint
+     * validation and change submit behaviour.
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Unstated rather than `false`. Reaches the control as the native `readonly`. */
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * What the control inside published about its value. A control this library
+     * ships calls `setCount`; the field draws the counter in the spare column of
+     * its label row — the header draws it at its own end when there is one — and
+     * only when the page wrote none of its own.
+     */
+    private readonly countState;
+    /** The counter the page wrote, anywhere in the field. */
+    readonly writtenCounter: _angular_core.Signal<SlFieldCounter | undefined>;
+    protected readonly header: _angular_core.Signal<SlFieldHeaderSlot | undefined>;
+    protected readonly help: _angular_core.Signal<SlFieldHelpSlot | undefined>;
+    protected readonly indicator: _angular_core.Signal<SlFieldIndicatorSlot | undefined>;
+    protected readonly drawnCount: _angular_core.Signal<FieldCount | undefined>;
+    protected readonly countOver: _angular_core.Signal<boolean>;
+    protected readonly formatCount: typeof formatFieldCount;
+    /** The count a control this library ships publishes, whenever its value changes. */
+    setCount(count: FieldCount | undefined): void;
+    /** What the control published, for a page that draws the counter itself. */
+    readonly count: _angular_core.Signal<FieldCount | undefined>;
+    private readonly token;
+    /**
+     * The group around this field, if there is one. It answers before the
+     * application's own token, and it is read on every change rather than
+     * captured, because Angular binds a component's inputs after it has created
+     * the directives its template declares.
+     */
+    private readonly source;
+    private readonly defaults;
+    /**
+     * The base every identifier is derived from. A consumer's own `id` is the
+     * base and stays on the element; the generated one is not written anywhere,
+     * because the field is addressable through its parts rather than as a box.
+     */
+    private readonly base;
+    readonly ids: _angular_core.Signal<_slotted_angular_field.FieldIds>;
+    /**
+     * Direct content rather than any descendant: a field nested inside another
+     * field's control — a composed control, a fieldset of its own — must not have
+     * its message read as this field's.
+     */
+    protected readonly description: _angular_core.Signal<SlFieldDescription | undefined>;
+    protected readonly error: _angular_core.Signal<SlFieldError | undefined>;
+    readonly resolvedSize: _angular_core.Signal<FieldSize>;
+    readonly resolvedLabelPlacement: _angular_core.Signal<FieldLabelPlacement>;
+    readonly resolvedNecessity: _angular_core.Signal<FieldNecessity>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    /** The field's words in the language in force, with this field's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<FieldMessages>;
+    /**
+     * A message is quieter than the control it is about, so it starts one step
+     * below and only the largest field's message reaches the second step.
+     */
+    protected readonly messageSize: _angular_core.Signal<"sm" | "md">;
+    /**
+     * The contract's order, and only the parts with something to say: the
+     * indicator, the help, the description, the count, the error. Known slots
+     * have one correct reading order, so it is stated rather than read from the
+     * DOM. The count is there whenever one is drawn — the page's, or the one the
+     * field or its header draws from what the control published.
+     */
+    readonly describedBy: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlField, "[slField]", ["slField"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; "isSignal": true; }; "necessity": { "alias": "necessity"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, {}, ["writtenCounter", "header", "help", "indicator", "description", "error"], ["[slFieldLabel], [slFieldHeader]", "[slFieldCounter]", "*", "[slFieldDescription]", "[slFieldError]"], true, never>;
+}
+
+/**
+ * Names the control, and says whether it has to be answered.
+ *
+ * The association is explicit — `for` pointing at the control's identifier —
+ * because the APG's naming practice records that some combinations of assistive
+ * technology and browser fail to treat the implicit form, wrapping the control
+ * in the label, as having an accessible name at all.
+ *
+ * The necessity marker is drawn here rather than written by the page. The glyph
+ * is `aria-hidden`, because `aria-required` on the control already carries the
+ * semantics and a reader working a form of twenty required fields does not need
+ * to hear "asterisk" twenty times; the two word forms are not hidden, because
+ * `(optional)` is information rather than decoration.
+ */
+declare class SlFieldLabel {
+    private readonly field;
+    private readonly writtenFor;
+    private readonly writtenId;
+    protected readonly labelFor: _angular_core.Signal<string>;
+    protected readonly labelId: _angular_core.Signal<string>;
+    private readonly necessity;
+    protected readonly markHidden: _angular_core.Signal<boolean>;
+    protected readonly mark: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldLabel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlFieldLabel, "label[slFieldLabel]", ["slFieldLabel"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Applies the field's wiring to a control the library does not own.
+ *
+ * Controls this library ships read the field themselves and need no directive,
+ * which is what
+ * `docs/history/designs/2026-08-31-field-aware-controls-design.md` decides.
+ * This exists for the two cases that cannot: a plain native element, and a
+ * component written before this library.
+ *
+ * Every value the consumer wrote wins. A host binding beats a static attribute
+ * in Angular, so each written value is read before the binding is computed
+ * rather than after — the asymmetry with React, where a consumer's prop simply
+ * spreads over the family's.
+ */
+declare class SlFieldControl {
+    private readonly field;
+    private readonly writtenId;
+    private readonly writtenDescribedBy;
+    private readonly writtenInvalid;
+    private readonly writtenRequired;
+    private readonly writtenDisabled;
+    private readonly writtenReadonly;
+    protected readonly controlId: _angular_core.Signal<string>;
+    /** Merged after the consumer's own, so a tour step is read before the help. */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<string | null>;
+    protected readonly ariaRequired: _angular_core.Signal<string | null>;
+    protected readonly disabledAttribute: _angular_core.Signal<string | null>;
+    protected readonly readonlyAttribute: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFieldControl, "[slFieldControl]", ["slFieldControl"], {}, {}, never, never, true, never>;
+}
+/**
+ * A link or a button at the end of the label row — `Forgot password?`,
+ * `Generate` — written on the consumer's own `a` or `button`. On a `button` the
+ * directive writes `type="button"` unless the page wrote a type, so it never
+ * submits the form it sits in; on a link it writes nothing. The field does not
+ * disable it with the control: what it does is the page's.
+ */
+declare class SlFieldAction {
+    private readonly writtenType;
+    protected readonly type: string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFieldAction, "[slFieldAction]", ["slFieldAction"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The label row, when the label has company: the help, an indicator, an action
+ * and the counter beside it. ReUI writes the same row by hand in four of its
+ * examples; here it is a part, so its alignment, its gap and its place in a
+ * side layout are the family's.
+ *
+ * It draws the count the control published at its own end when the page wrote
+ * no counter, which is where a field without a header puts it too.
+ */
+declare class SlFieldHeader {
+    protected readonly field: SlField;
+    protected readonly drawnCount: _angular_core.Signal<_slotted_angular_field.FieldCount | undefined>;
+    protected readonly countOver: _angular_core.Signal<boolean>;
+    protected readonly formatCount: typeof formatFieldCount;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlFieldHeader, "[slFieldHeader]", ["slFieldHeader"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * What qualifies the field — `Beta`, `Pro`, `New` — as one or more `slBadge`s
+ * after the label. It stands outside the `label`, so the necessity mark stays
+ * against the label's last word, and it joins the control's description, so a
+ * reader on the control hears it.
+ */
+declare class SlFieldIndicator {
+    private readonly field;
+    private readonly writtenId;
+    protected readonly indicatorId: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlFieldIndicator, "[slFieldIndicator]", ["slFieldIndicator"], {}, {}, never, never, true, never>;
+}
+/**
+ * The help beside the label: the button itself, drawing `circle-question`, with
+ * the hint in a tooltip. The hint is the directive's value —
+ * `<button slFieldHelp="Dias corridos."></button>` — because it is written once
+ * and read in two places: the tooltip's layer, and a hidden node inside the
+ * button that describes the button and the control while the layer is closed. A
+ * directly referenced hidden element still enters the description (accname 1.2,
+ * step 2A), and the tooltip is asked to describe nothing, so the hint is not
+ * read twice.
+ *
+ * **A press is the hint.** A tooltip opens on a coarse pointer only by a long
+ * press, because a tap is the trigger's own action; this button has no other
+ * action, so the tooltip is composed on the button as host directives and run
+ * by hand (`openOn: 'manual'`, provided here): a press pins the hint open and a
+ * second press closes it, while hover and keyboard focus open it the way every
+ * tooltip opens. It is Carbon's toggletip. `[(open)]` and `(openChangeRequest)`
+ * are the tooltip's own, exposed on the button.
+ *
+ * **It stays operable on a disabled field.** The help is often where the reason
+ * the field is off is written.
+ */
+declare class SlFieldHelp {
+    /** The hint. */
+    readonly slFieldHelp: _angular_core.InputSignal<string>;
+    private readonly field;
+    private readonly tooltip;
+    private readonly writtenLabel;
+    private readonly writtenDescribedBy;
+    private readonly fallbackId;
+    /** The field family's words, for a help control outside a field. */
+    private readonly own;
+    protected readonly textId: _angular_core.Signal<string>;
+    protected readonly label: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string>;
+    /** Whether a press opened the hint; a hover-opened hint closes when the pointer leaves. */
+    private readonly pinned;
+    constructor();
+    protected enter(event: PointerEvent): void;
+    protected leave(event: PointerEvent): void;
+    /** `:focus-visible` rather than every focus: a press focuses the button too. */
+    protected focus(event: FocusEvent): void;
+    protected blur(event: FocusEvent): void;
+    /**
+     * A click synthesised by the keyboard reports no detail; a real one reports
+     * the click count, which is how `Enter` and `Space` are told from a press.
+     */
+    protected press(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlFieldHelp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlFieldHelp, "button[slFieldHelp]", ["slFieldHelp"], { "slFieldHelp": { "alias": "slFieldHelp"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.SlTooltip; inputs: { "open": "open"; "side": "side"; }; outputs: { "openChange": "openChange"; "openChangeRequest": "openChangeRequest"; }; }, { directive: typeof i1.SlTooltipTrigger; inputs: {}; outputs: {}; }]>;
+}
+
+export { FIELD_DEFAULTS, FIELD_DESCRIBED_ORDER, SlField, SlFieldAction, SlFieldContext, SlFieldControl, SlFieldCounter, SlFieldDefaultsSource, SlFieldDescription, SlFieldError, SlFieldHeader, SlFieldHeaderSlot, SlFieldHelp, SlFieldHelpSlot, SlFieldIdFactory, SlFieldIndicator, SlFieldIndicatorSlot, SlFieldLabel, SlFieldMessage, deriveFieldIds, formatFieldCount, injectFieldDefaults, isFieldCountOver, necessityMark, provideFieldDefaults };
+export type { FieldCount, FieldDefaults, FieldDescribedSlot, FieldIds, FieldLabelPlacement, FieldNecessity, FieldSize };
+//# sourceMappingURL=slotted-angular-field.d.ts.map

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

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