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

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

@@ -0,0 +1,480 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, CurrencyFieldMessages } from '@slotted/core/i18n';
+import * as _slotted_angular_currency_field from '@slotted/angular/currency-field';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { CurrencyChangeRequest } from '@slotted/core/currency';
+
+/** The type step the control sits at, matching the field around it. */
+type CurrencyFieldSize = 'sm' | 'md' | 'lg';
+/**
+ * How much frame the control shows. The three every framed control in this
+ * library ships: `outline` takes the ground it is placed on, `subtle` sinks
+ * into the page, and `plain` shows nothing at rest, which is what a dense
+ * table of amounts needs.
+ */
+type CurrencyFieldVariant = 'outline' | 'subtle' | 'plain';
+/**
+ * How the reader types the amount.
+ *
+ * `cents` is the cash register: digits enter at the minor unit and shift left,
+ * so `1234` is `R$ 12,34`. The separator is never typed and the caret has one
+ * legal position. `natural` is the spreadsheet, and the model `number-field`
+ * uses: the text is the reader's until a commit.
+ */
+type CurrencyFieldEntry = 'cents' | 'natural';
+/**
+ * Which edge the amount is set against. `end` by default: a column of amounts
+ * is compared on its last digit, and the cents-first caret already lives there.
+ */
+type CurrencyFieldAlign = 'end' | 'start';
+/**
+ * Where the two steppers sit, when a product asks for them. They are withdrawn
+ * by default on this family: an invoice total is typed, not nudged.
+ */
+type CurrencyFieldStepper = 'stacked' | 'split' | 'none';
+/**
+ * What happens to an amount outside `min`…`max`. `blur` returns it to the range
+ * at the commit, `strict` refuses the keystroke that would leave it, and `none`
+ * keeps the amount where the reader put it and reports `aria-invalid`.
+ */
+type CurrencyFieldClamp = 'blur' | 'strict' | 'none';
+/**
+ * When the text takes the locale's shape, under `entry="natural"`.
+ *
+ * `change` regroups on every keystroke, so an amount is scannable while it is
+ * being typed; `commit` holds the reader's own text until blur, `Enter` or a
+ * step. It is `number-field`'s axis, and it is here because `entry="natural"`
+ * is `number-field`'s model.
+ *
+ * Under `entry="cents"` the text is generated from the digits after every edit,
+ * so it has always taken the locale's shape as it is typed and this decides
+ * nothing.
+ */
+type CurrencyFieldFormatOn = 'change' | 'commit';
+/**
+ * How the currency is written beside the amount, or `none` when it is not
+ * written at all: the amount becomes a plain decimal with the currency's own
+ * fraction digits, so the symbol can live in a `slCurrencyFieldStart` adornment
+ * instead of inside the value.
+ */
+type CurrencyFieldDisplay = 'symbol' | 'narrowSymbol' | 'code' | 'name' | 'none';
+interface CurrencyFieldDefaults {
+    align: CurrencyFieldAlign;
+    clamp: CurrencyFieldClamp;
+    /** The currency every field under the token is in, unless it says otherwise. */
+    currency: string | undefined;
+    currencyDisplay: CurrencyFieldDisplay;
+    entry: CurrencyFieldEntry;
+    formatOn: CurrencyFieldFormatOn;
+    size: CurrencyFieldSize;
+    stepper: CurrencyFieldStepper;
+    variant: CurrencyFieldVariant;
+}
+declare const CURRENCY_FIELD_DEFAULTS: InjectionToken<CurrencyFieldDefaults>;
+/**
+ * An application decides once which currency it charges in and how its
+ * amounts are typed, rather than repeating the same inputs on every amount in a
+ * form. A control that states any of them itself still wins. The locale and the
+ * two buttons' words come from the language in force (`provideSlotted`).
+ *
+ * `currency` is the one worth setting first, and the only one a field cannot be
+ * built without: a product has one currency in nine screens out of ten, and the
+ * tenth states its own.
+ */
+declare function provideCurrencyFieldDefaults(defaults: Partial<CurrencyFieldDefaults>): {
+    provide: InjectionToken<CurrencyFieldDefaults>;
+    useFactory: () => CurrencyFieldDefaults;
+};
+/** What a currency field renders as here, before it states anything of its own. */
+declare function injectCurrencyFieldDefaults(): CurrencyFieldDefaults;
+/**
+ * What the frame needs to know about the control inside it, and what the
+ * control needs the frame to call.
+ *
+ * It is an abstract class rather than an import so the two directives can
+ * depend on each other without a cycle — the shape `field`, `text-field` and
+ * `number-field` already have. The input provides itself as this, and the
+ * frame queries it.
+ */
+declare abstract class SlCurrencyFieldControl {
+    /** The identifier the steppers point `aria-controls` at. */
+    abstract readonly controlId: Signal<string | null>;
+    /** Whether a step up would leave the range, which is what disables a button. */
+    abstract readonly atMax: Signal<boolean>;
+    /** Whether a step down would. */
+    abstract readonly atMin: Signal<boolean>;
+    /** The submission name the frame's hidden input carries, if there is one. */
+    abstract readonly submissionName: Signal<string | null>;
+    /** The form that hidden input belongs to, when it is not the ancestor one. */
+    abstract readonly submissionForm: Signal<string | null>;
+    /** The amount in major units, for the hidden input the frame renders. */
+    abstract readonly numberValue: Signal<number | null>;
+    abstract readonly resolvedDisabled: Signal<boolean | undefined>;
+    abstract readonly resolvedReadOnly: Signal<boolean | undefined>;
+    abstract readonly resolvedInvalid: Signal<boolean | undefined>;
+    /** How the reader types, which the frame paints and the control owns. */
+    abstract readonly resolvedEntry: Signal<CurrencyFieldEntry>;
+    /** Moves the amount by one step and returns focus to it. */
+    abstract stepBy(direction: 1 | -1, source: Event | undefined): void;
+    /**
+     * Moves the amount by whole steps a `scrub` drag travelled, signed, by the
+     * large step under `Shift` and the small one under `Alt`.
+     */
+    abstract scrubBy(steps: number, source: PointerEvent): void;
+    /** The native element, which a scrub focuses and reads the direction from. */
+    abstract readonly inputElement: HTMLInputElement;
+}
+
+/**
+ * The frame: one amount, and the two buttons that move it when a product asks
+ * for them.
+ *
+ * **It is not the control.** The element carrying `data-ui` is the consumer's
+ * own box with no role; the `input` inside it holds the amount, the identifier
+ * and the APG's `spinbutton` role. WAI-ARIA settles the shape: a `spinbutton`
+ * may hold only non-interactive presentational children, so the two steppers
+ * are the control's siblings rather than its children.
+ *
+ * **The steppers are withdrawn by default**, where `number-field` ships them:
+ * an invoice total is typed, not nudged.
+ *
+ * **Angular pays one element for the frame, and React pays none.** React can
+ * render a wrapper from inside a component; an Angular directive cannot create
+ * a box around its own host. `slCurrencyFieldInput` injects this class, so a
+ * control written without the frame is a compile-time failure rather than a
+ * silent one.
+ */
+declare class SlCurrencyField {
+    /** Defaults to the field, then to the token, then to `md`. */
+    readonly size: _angular_core.InputSignal<CurrencyFieldSize | undefined>;
+    /** Defaults to the token, then to `outline`. */
+    readonly variant: _angular_core.InputSignal<CurrencyFieldVariant | undefined>;
+    /** Which edge the amount is set against. Defaults to the token, then `end`. */
+    readonly align: _angular_core.InputSignal<CurrencyFieldAlign | undefined>;
+    /** Where the two steppers sit. Defaults to the token, then `none`. */
+    readonly stepper: _angular_core.InputSignal<CurrencyFieldStepper | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * `increment` and `decrement` buttons' accessible names.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<CurrencyFieldMessages> | undefined>;
+    private readonly defaults;
+    private readonly field;
+    /**
+     * The control inside. It provides itself as `SlCurrencyFieldControl`, so the
+     * frame can read the bounds, the submission name and the shared states
+     * without either directive importing the other.
+     */
+    readonly control: _angular_core.Signal<SlCurrencyFieldControl | undefined>;
+    readonly resolvedSize: _angular_core.Signal<CurrencyFieldSize>;
+    readonly resolvedVariant: _angular_core.Signal<CurrencyFieldVariant>;
+    readonly resolvedAlign: _angular_core.Signal<CurrencyFieldAlign>;
+    readonly resolvedStepper: _angular_core.Signal<CurrencyFieldStepper>;
+    /**
+     * The entry model belongs to the control, because it is behaviour before it
+     * is an axis: the frame only paints what the control resolved. Two inputs
+     * for one decision would let the box and the element disagree about how the
+     * next keystroke is read.
+     */
+    readonly resolvedEntry: _angular_core.Signal<_slotted_angular_currency_field.CurrencyFieldEntry>;
+    /** The family's words in the language in force, with this field's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<CurrencyFieldMessages>;
+    /** Whether a `slCurrencyFieldScrub` inside is being dragged. */
+    readonly scrubbing: _angular_core.WritableSignal<boolean>;
+    /** A control nobody can change has two buttons that would lie about it. */
+    readonly inert: _angular_core.Signal<boolean>;
+    protected readonly incrementDisabled: _angular_core.Signal<boolean>;
+    protected readonly decrementDisabled: _angular_core.Signal<boolean>;
+    protected readonly hiddenValue: _angular_core.Signal<string>;
+    private delay;
+    private interval;
+    constructor();
+    /**
+     * One step now, then repeating while the button is held. A coarse pointer
+     * waits longer before the first repeat, because a finger that is starting to
+     * scroll rests on the button first.
+     */
+    protected press(direction: 1 | -1, event: PointerEvent): void;
+    protected release(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCurrencyField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCurrencyField, "[slCurrencyField]", ["slCurrencyField"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "stepper": { "alias": "stepper"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, ["control"], ["[slCurrencyFieldStart]", "*", "[slCurrencyFieldEnd]"], true, never>;
+}
+
+/**
+ * The control itself: the amount, the currency, the identifier, and everything
+ * the field around it says.
+ *
+ * **The element is `type="text"` and carries the APG's `spinbutton` role.**
+ * `type="number"` empties itself whenever the text is not a valid
+ * floating-point number, so no grouping separator and no currency symbol
+ * survives it.
+ *
+ * **Under `entry="cents"` the digits are the amount.** After every edit the
+ * directive reads the digits out of the text and divides by the currency's
+ * minor units, so `1234` is `R$ 12,34`. The text is generated rather than
+ * typed, which is why rewriting it on every keystroke is legal here and
+ * forbidden in `number-field`: there is no typed text to protect, and the caret
+ * has exactly one legal position.
+ *
+ * **Unset means ask the field.** `disabled`, `readOnly` and `invalid` default to
+ * `undefined` rather than `false`. A value the consumer wrote as a static
+ * attribute is read before the host binding computes.
+ */
+declare class SlCurrencyFieldInput implements ControlValueAccessor, OnInit, SlCurrencyFieldControl {
+    /**
+     * An ISO 4217 code. It decides the symbol, the minor units and therefore how
+     * far a digit shifts. Required here or on the token: a field that guessed two
+     * minor digits would write `¥12,34`.
+     */
+    readonly currency: _angular_core.InputSignal<string | undefined>;
+    /** How the currency is written beside the amount. Defaults to the token, then `symbol`. */
+    readonly currencyDisplay: _angular_core.InputSignal<CurrencyFieldDisplay | undefined>;
+    /** Overrides the currency's own minor units, for a unit price quoted finer. */
+    readonly fractionDigits: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * Present means the consumer owns the amount, for the life of the component.
+     * `null` is empty, and `undefined` is the absence that makes the control
+     * uncontrolled — the two are different answers.
+     */
+    readonly value: _angular_core.InputSignalWithTransform<number | null | undefined, unknown>;
+    /** The amount the control starts from when nobody else writes one. */
+    readonly defaultValue: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    /** How the reader types. Defaults to the token, then `cents`. */
+    readonly entry: _angular_core.InputSignal<CurrencyFieldEntry | undefined>;
+    /**
+     * When the text takes the locale's shape under `entry="natural"`. Defaults to
+     * the token, then `change`. Cents-first entry generates the text after every
+     * edit, so it decides nothing there.
+     */
+    readonly formatOn: _angular_core.InputSignal<CurrencyFieldFormatOn | undefined>;
+    readonly min: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly max: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** What the arrows and the two buttons move by, in major units. */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The amount `Shift` and the page keys move by. Defaults to `step * 10`. */
+    readonly largeStep: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** The amount `Alt` moves by. Defaults to `step / 10`. */
+    readonly smallStep: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Where an empty control starts stepping from. Defaults to `min`, then nought. */
+    readonly stepFrom: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Where an amount outside the range goes, and when. Defaults to the token, then `blur`. */
+    readonly clamp: _angular_core.InputSignal<CurrencyFieldClamp | undefined>;
+    /** Any other `Intl.NumberFormatOptions`. Every key here wins over the family's own. */
+    readonly format: _angular_core.InputSignal<Intl.NumberFormatOptions | undefined>;
+    /**
+     * BCP 47. Decides the separators and the numbering system, never the symbol.
+     * Defaults to the language in force (`provideSlotted`).
+     */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Lets the wheel move the amount while the control has focus. Off by default:
+     * a reader scrolling a form must not change a total by passing over it.
+     */
+    readonly wheel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether an emptied control holds nothing, or nought.
+     *
+     * Off, because an amount is not an optional number: a total, a price and a
+     * balance are all nought when nothing is in them. Cleared, the control shows
+     * `0,00` and emits `0`. On, it can be left empty and emits `null`.
+     */
+    readonly allowEmpty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Unstated rather than `false`, so the control defers to the field. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * One output for one transition, carrying the amount, the amount it replaces,
+     * the currency, the exact integer of minor units, the reason, the originating
+     * event and `cancel()`. There is no `[(value)]`, because a two-way binding has
+     * one slot and can carry none of those.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<CurrencyChangeRequest>;
+    private readonly element;
+    /**
+     * The frame around the control. Injected without `optional`, so an `input`
+     * written without it fails at construction rather than silently losing its
+     * border and its ring.
+     */
+    readonly currencyField: SlCurrencyField;
+    private readonly field;
+    private readonly defaults;
+    private readonly appLocale;
+    private readonly writtenId;
+    private readonly writtenName;
+    private readonly writtenForm;
+    private readonly writtenInputMode;
+    private readonly writtenAutocomplete;
+    private readonly writtenDescribedBy;
+    private readonly writtenInvalid;
+    private readonly writtenRequired;
+    private readonly writtenReadonly;
+    /** What the family holds when nobody else owns it. */
+    private readonly own;
+    /** What the element is showing. Never a second copy of the amount. */
+    private readonly text;
+    private readonly formDisabled;
+    /**
+     * The sign, while the field holds nothing to carry it. Typing `-` into an
+     * empty amount and then a digit produces a debit, which a sign derived from
+     * the text alone could not express.
+     */
+    private pendingNegative;
+    private onChangeFn;
+    private onTouchedFn;
+    /**
+     * One formatter, rebuilt only when something it reads actually changes. The
+     * options object is read through a signal, so an inline object handed on
+     * every change detection does not rebuild the parser.
+     */
+    private readonly formatter;
+    /** Present means the consumer owns it; absent means the directive does. */
+    private readonly controlled;
+    readonly numberValue: _angular_core.Signal<number | null>;
+    readonly valueText: _angular_core.Signal<string | null>;
+    readonly resolvedEntry: _angular_core.Signal<CurrencyFieldEntry>;
+    protected readonly resolvedFormatOn: _angular_core.Signal<CurrencyFieldFormatOn>;
+    readonly resolvedClamp: _angular_core.Signal<CurrencyFieldClamp>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedInvalid: _angular_core.Signal<boolean | undefined>;
+    readonly controlId: _angular_core.Signal<string | null>;
+    readonly submissionName: _angular_core.Signal<string | null>;
+    readonly submissionForm: _angular_core.Signal<string | null>;
+    private readonly parsedText;
+    readonly atMax: _angular_core.Signal<boolean>;
+    readonly atMin: _angular_core.Signal<boolean>;
+    /** Whether the range admits a debit at all. There is no `allowNegative`. */
+    private readonly allowNegative;
+    /**
+     * The software keyboard, derived from the props rather than from the user
+     * agent. Cents-first entry types neither a separator nor a sign into the
+     * digits, so the numeric keypad is complete for the task.
+     */
+    protected readonly resolvedInputMode: _angular_core.Signal<string>;
+    /**
+     * `transaction-amount` is the token a payment amount belongs to, and the
+     * default is `off`: most amounts in a back office are not payment amounts,
+     * and a browser filling an invoice total is worse than no help at all.
+     */
+    protected readonly resolvedAutocomplete: _angular_core.Signal<string>;
+    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<"" | null>;
+    protected readonly readonlyAttribute: _angular_core.Signal<"" | null>;
+    constructor();
+    /**
+     * Angular creates every directive in a template before it binds any input, so
+     * the starting amount is read here rather than in the constructor: read
+     * there, `defaultValue` is always its own default and the control starts
+     * empty.
+     */
+    ngOnInit(): void;
+    /** The native element, for `focus()`, `select()` and `setSelectionRange()`. */
+    get inputElement(): HTMLInputElement;
+    /** Steps up by one step and reports `programmatic`. */
+    increment(): void;
+    /** Steps down by one step and reports `programmatic`. */
+    decrement(): void;
+    /** What a `slCurrencyFieldScrub` drag calls, once per whole step travelled. */
+    scrubBy(steps: number, source: PointerEvent): void;
+    /** What the frame's two buttons call. Focus returns to the amount. */
+    stepBy(direction: 1 | -1, source: Event | undefined): void;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onInput(event: Event): void;
+    /**
+     * The keystroke filter. `beforeinput` is where a keystroke, a paste and a
+     * drop all arrive before the element changes, and it is the only place a
+     * character that cannot be part of an amount can be refused without moving
+     * the caret.
+     */
+    protected onBeforeInput(event: InputEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    /**
+     * The wheel, when it is asked for, and never otherwise. It is a native
+     * listener rather than a host binding because the event has to be cancelled,
+     * and a host listener on `wheel` is passive in some browsers.
+     */
+    private attachWheel;
+    /** The sign at the moment of the edit, rather than at the last render. */
+    private negativeNow;
+    /** Formats what the reader typed and puts the amount back in range. */
+    private commit;
+    private move;
+    /**
+     * Asks to move, and says whether anything did. A refused request answers
+     * `false`, and the caller uses that to decide what the element shows.
+     */
+    private request;
+    /** Nothing, or the nought it means. The one rule `allowEmpty` decides. */
+    private settledAmount;
+    private settle;
+    /**
+     * One place the element's text is written, so the signal never drifts from
+     * it. Under cents-first entry the caret goes back after the last digit —
+     * before whatever affix the locale writes at the end — because that is the
+     * only position where the next keystroke means anything.
+     */
+    private write;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCurrencyFieldInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCurrencyFieldInput, "input[slCurrencyFieldInput]", ["slCurrencyFieldInput"], { "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "currencyDisplay": { "alias": "currencyDisplay"; "required": false; "isSignal": true; }; "fractionDigits": { "alias": "fractionDigits"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "entry": { "alias": "entry"; "required": false; "isSignal": true; }; "formatOn": { "alias": "formatOn"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "largeStep": { "alias": "largeStep"; "required": false; "isSignal": true; }; "smallStep": { "alias": "smallStep"; "required": false; "isSignal": true; }; "stepFrom": { "alias": "stepFrom"; "required": false; "isSignal": true; }; "clamp": { "alias": "clamp"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "wheel": { "alias": "wheel"; "required": false; "isSignal": true; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * An adornment before the amount in the reading direction: a currency mark, a
+ * period, an icon. Named for the direction rather than for a side, so the same
+ * markup puts the mark before the amount in both directions.
+ *
+ * It is a sibling of the number rather than part of it. A symbol that belongs
+ * *inside* the amount is what `currency` and `currencyDisplay` write, and it is
+ * selected, copied and parsed with the amount; this one is none of those
+ * things.
+ */
+declare class SlCurrencyFieldStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCurrencyFieldStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCurrencyFieldStart, "[slCurrencyFieldStart]", ["slCurrencyFieldStart"], {}, {}, never, never, true, never>;
+}
+/** An adornment after the amount in the reading direction. */
+declare class SlCurrencyFieldEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCurrencyFieldEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCurrencyFieldEnd, "[slCurrencyFieldEnd]", ["slCurrencyFieldEnd"], {}, {}, never, never, true, never>;
+}
+/**
+ * A mark that moves the amount when it is dragged sideways — the design
+ * tools' gesture, shared with `slNumberFieldScrub`. Placed inside
+ * `slCurrencyFieldStart` or `slCurrencyFieldEnd`, where the frame it belongs
+ * to is its ancestor; the currency symbol, with `currencyDisplay="none"` on
+ * the control, is the natural mark:
+ *
+ * ```html
+ * <span slCurrencyFieldStart><span slCurrencyFieldScrub>R$</span></span>
+ * ```
+ *
+ * Each `sensitivity` pixels towards the inline end is one step up; `Shift`
+ * moves by the large step and `Alt` by the small one, as on the keyboard. It
+ * is hidden from assistive technology and takes no focus: the input's arrow
+ * keys are the same movement.
+ */
+declare class SlCurrencyFieldScrub {
+    /** Pixels of horizontal travel per step. Defaults to 2. */
+    readonly sensitivity: _angular_core.InputSignal<number>;
+    private readonly frame;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    private travel;
+    protected begin(event: PointerEvent): void;
+    protected drag(event: PointerEvent): void;
+    protected end(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCurrencyFieldScrub, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCurrencyFieldScrub, "[slCurrencyFieldScrub]", ["slCurrencyFieldScrub"], { "sensitivity": { "alias": "sensitivity"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CURRENCY_FIELD_DEFAULTS, SlCurrencyField, SlCurrencyFieldControl, SlCurrencyFieldEnd, SlCurrencyFieldInput, SlCurrencyFieldScrub, SlCurrencyFieldStart, injectCurrencyFieldDefaults, provideCurrencyFieldDefaults };
+export type { CurrencyFieldAlign, CurrencyFieldClamp, CurrencyFieldDefaults, CurrencyFieldDisplay, CurrencyFieldEntry, CurrencyFieldFormatOn, CurrencyFieldSize, CurrencyFieldStepper, CurrencyFieldVariant };
+//# sourceMappingURL=slotted-angular-currency-field.d.ts.map

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

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