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

package/types/slotted-angular-time-range-picker.d.ts

@@ -0,0 +1,401 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, TimeRangePickerMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, TemplateRef, ElementRef } from '@angular/core';
+import * as _slotted_core_date from '@slotted/core/date';
+import { PlainTime, TimeGranularity, TimeRangeValue, TimeOption } from '@slotted/core/date';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { SlTimeField, TimeFieldChangeRequest } from '@slotted/angular/time-field';
+
+/** A run of times, either end of which may be open. */
+type TimeRange = TimeRangeValue;
+/** Where the surface opens, before the positioner has read the room. */
+type TimeRangePickerPlacement = 'bottom-start' | 'bottom' | 'bottom-end' | 'top-start' | 'top' | 'top-end';
+/**
+ * Whether choosing closes the surface. `auto` closes when the work becomes
+ * whole — by a press in a list, by `now` or by a preset — and stays open
+ * while an end is still missing, because the next press has to reach the
+ * same surface.
+ */
+type TimeRangePickerCloseOnSelect = 'auto' | 'always' | 'never';
+/** What a time a bound or the predicate refuses looks like in a list. */
+type TimeRangePickerUnavailableOptions = 'disable' | 'hide';
+type TimeRangePickerSize = 'sm' | 'md' | 'lg';
+type TimeRangePickerVariant = 'outline' | 'subtle' | 'plain';
+type TimeRangePickerHourCycle = 12 | 24;
+/** The end being edited: the field and the panel carrying `data-current`. */
+type TimeRangePickerPosition = 'start' | 'end';
+/** The highlighted option of each list. */
+interface TimeRangePickerHighlight {
+    readonly start: PlainTime | null;
+    readonly end: PlainTime | null;
+}
+/** A quarter of an hour, the step every surveyed panel defaults to within a factor of two. */
+declare const TIME_RANGE_PICKER_STEP = 900;
+/** A whole day at a one-minute step: the finest whole-day list any surveyed implementation offers. */
+declare const TIME_RANGE_PICKER_MAX_OPTIONS = 1440;
+/** "2 hr 30 min": the duration the band and the rows say, in the family's locale. */
+declare function timeRangePickerLengthLabel(seconds: number, locale?: string): string;
+interface TimeRangePickerDefaults {
+    closeOnSelect: TimeRangePickerCloseOnSelect;
+    granularity: TimeGranularity;
+    hourCycle: TimeRangePickerHourCycle | undefined;
+    /** "2 hr 30 min", in the product's own words; seconds in, and the family's locale. */
+    lengthLabel: (seconds: number, locale: string | undefined) => string;
+    maxOptions: number;
+    placement: TimeRangePickerPlacement;
+    size: TimeRangePickerSize;
+    step: number;
+    timeZone: string | undefined;
+    unavailableOptions: TimeRangePickerUnavailableOptions;
+    variant: TimeRangePickerVariant;
+}
+declare const TIME_RANGE_PICKER_DEFAULTS: InjectionToken<TimeRangePickerDefaults>;
+/**
+ * An application decides once what its times look like, what step its lists
+ * offer and how a duration is written — rather than repeating the same inputs
+ * on every picker in a form. The locale and the words come from the language
+ * in force (`provideSlotted`).
+ */
+declare function provideTimeRangePickerDefaults(defaults: Partial<TimeRangePickerDefaults>): {
+    provide: InjectionToken<TimeRangePickerDefaults>;
+    useFactory: () => TimeRangePickerDefaults;
+};
+/** What a time range picker renders as here, before it states anything of its own. */
+declare function injectTimeRangePickerDefaults(): TimeRangePickerDefaults;
+
+declare function isSameTimeRange(a: TimeRange | null, b: TimeRange | null): boolean;
+/**
+ * A one-line frame — the value in words, a clear and the trigger — and behind
+ * it one end at a time: two tabs, the field of the current end, a hint, and
+ * the list of that end.
+ *
+ * **The frame is one line at any width.** Two segmented fields stood in it
+ * first and were withdrawn at the visual gate: a segment cannot shrink, and
+ * two of them broke the frame into two lines in any form column narrower than
+ * they are. The field lives in the panel's band, where the reader types.
+ *
+ * **One end at a time.** Two lists side by side were refused at the release
+ * gate as too much interface at once for a lay reader and for a phone. The
+ * tab says which end, the panel shows only that end, and choosing one end
+ * moves to the other — the end list appears already striking what the chosen
+ * start refuses, every row saying the duration the run would have.
+ *
+ * **A press that leaves the work with one end is not the value.** The press
+ * that completes it emits the whole run; `Escape`, an outside press and the
+ * trigger abandon the work. An end typed in the field is a value on its own.
+ */
+declare class SlTimeRangePicker implements ControlValueAccessor, Validator, OnInit {
+    readonly value: _angular_core.InputSignal<_slotted_core_date.TimeRangeValue | null | undefined>;
+    readonly defaultValue: _angular_core.InputSignal<_slotted_core_date.TimeRangeValue | null | undefined>;
+    /** Present means the consumer owns whether the surface is showing. */
+    readonly open: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Present means the consumer owns which end is being edited. */
+    readonly position: _angular_core.InputSignal<TimeRangePickerPosition | undefined>;
+    readonly defaultPosition: _angular_core.InputSignal<TimeRangePickerPosition>;
+    /** Where the reader is in each list. Present means the consumer owns it. */
+    readonly highlighted: _angular_core.InputSignal<TimeRangePickerHighlight | undefined>;
+    readonly defaultHighlighted: _angular_core.InputSignal<TimeRangePickerHighlight | undefined>;
+    readonly min: _angular_core.InputSignal<PlainTime | undefined>;
+    readonly max: _angular_core.InputSignal<PlainTime | undefined>;
+    readonly isTimeUnavailable: _angular_core.InputSignal<((time: PlainTime) => boolean) | undefined>;
+    /**
+     * Whether a run may cross an unavailable time. On, and with a start chosen,
+     * the options beyond the first unavailable one are refused in the end list.
+     */
+    readonly contiguous: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The shortest and longest run allowed, in seconds. */
+    readonly minLength: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly maxLength: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly lengthLabel: _angular_core.InputSignal<((seconds: number, locale: string | undefined) => string) | undefined>;
+    /** Seconds between two offered times. Ignored when `options` states the list. */
+    readonly step: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** The times to offer, stated rather than stepped; the same list for both ends. */
+    readonly options: _angular_core.InputSignal<readonly PlainTime[] | undefined>;
+    readonly maxOptions: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly unavailableOptions: _angular_core.InputSignal<TimeRangePickerUnavailableOptions | undefined>;
+    /** BCP 47. Unset, the language in force (`provideSlotted`) decides. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    readonly hourCycle: _angular_core.InputSignal<TimeRangePickerHourCycle | undefined>;
+    readonly granularity: _angular_core.InputSignal<_slotted_core_date.TimeGranularity | undefined>;
+    /** What "now" is, for a story or a test; the clock otherwise. */
+    readonly referenceTime: _angular_core.InputSignal<PlainTime | undefined>;
+    readonly size: _angular_core.InputSignal<TimeRangePickerSize | undefined>;
+    readonly variant: _angular_core.InputSignal<TimeRangePickerVariant | undefined>;
+    readonly placement: _angular_core.InputSignal<TimeRangePickerPlacement | undefined>;
+    readonly closeOnSelect: _angular_core.InputSignal<TimeRangePickerCloseOnSelect | undefined>;
+    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>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Draws one clear on the frame, which empties both ends. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the two fields in the band take the relative expression. */
+    readonly relative: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * trigger's names, the two ends, the hint, the limit, and what a panel says
+     * when it is empty or cut short.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<TimeRangePickerMessages> | undefined>;
+    /** The names of the two hidden inputs a plain form post reads. */
+    readonly startName: _angular_core.InputSignal<string | undefined>;
+    readonly endName: _angular_core.InputSignal<string | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<_slotted_core_date.TimeRangeValue | null>>;
+    readonly openChange: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly positionChange: _angular_core.OutputEmitterRef<ChangeRequest<TimeRangePickerPosition>>;
+    readonly highlightedChange: _angular_core.OutputEmitterRef<ChangeRequest<TimeRangePickerHighlight>>;
+    /** What one row draws; a template, because it is re-rendered once per option. */
+    protected optionTemplate?: TemplateRef<unknown>;
+    protected layer?: ElementRef<HTMLElement>;
+    /** Whether the lists were scrolled to their highlight since the surface opened. */
+    private revealed;
+    protected triggerRef?: ElementRef<HTMLButtonElement>;
+    protected field?: SlTimeField;
+    protected fieldBox?: ElementRef<HTMLElement>;
+    private readonly element;
+    protected readonly defaults: TimeRangePickerDefaults;
+    private readonly appLocale;
+    /** The family's words in the language in force, with this picker's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<TimeRangePickerMessages>;
+    private readonly injector;
+    private readonly destroyRef;
+    private readonly enclosing;
+    protected readonly contentId: string;
+    protected readonly positions: readonly TimeRangePickerPosition[];
+    private readonly ownOpen;
+    private readonly ownValue;
+    private readonly ownPosition;
+    private readonly ownHighlight;
+    private readonly formDisabled;
+    private readonly clock;
+    protected readonly positioned: _angular_core.WritableSignal<boolean>;
+    protected readonly sheet: _angular_core.WritableSignal<boolean>;
+    /**
+     * The work: the two ends as the reader left them while the panel is open. A
+     * press in a list writes it; the value is asked for when it is whole. Closed
+     * by anything, it is rebuilt from the value on the next open.
+     */
+    protected readonly work: _angular_core.WritableSignal<_slotted_core_date.TimeRangeValue>;
+    /** The option under the pointer, which enters the duration and nothing else. */
+    protected readonly hovered: _angular_core.WritableSignal<{
+        position: TimeRangePickerPosition;
+        time: PlainTime;
+    } | null>;
+    /** Whether the list holds focus, so its highlight is the pending end. */
+    protected readonly listFocused: _angular_core.WritableSignal<boolean>;
+    /** Where focus lands once the surface is drawn. */
+    private focusOnOpen;
+    private positioner;
+    private dismissable;
+    private readonly typeaheads;
+    private onChangeFn;
+    private onTouchedFn;
+    private onValidatorChangeFn;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    protected readonly held: _angular_core.Signal<_slotted_core_date.TimeRangeValue | null>;
+    /** The range the picker holds. Public, so a preset can compare itself to it. */
+    readonly selection: _angular_core.Signal<_slotted_core_date.TimeRangeValue | null>;
+    protected readonly currentPosition: _angular_core.Signal<TimeRangePickerPosition>;
+    protected readonly highlight: _angular_core.Signal<TimeRangePickerHighlight>;
+    protected readonly start: _angular_core.Signal<PlainTime | null>;
+    protected readonly end: _angular_core.Signal<PlainTime | null>;
+    protected readonly startIso: _angular_core.Signal<string>;
+    protected readonly endIso: _angular_core.Signal<string>;
+    protected readonly resolvedLocale: _angular_core.Signal<string>;
+    protected readonly resolvedTimeZone: _angular_core.Signal<string | undefined>;
+    protected readonly resolvedHourCycle: _angular_core.Signal<TimeRangePickerHourCycle | undefined>;
+    protected readonly resolvedGranularity: _angular_core.Signal<_slotted_core_date.TimeGranularity>;
+    protected readonly resolvedSize: _angular_core.Signal<TimeRangePickerSize>;
+    protected readonly resolvedVariant: _angular_core.Signal<TimeRangePickerVariant>;
+    protected readonly resolvedPlacement: _angular_core.Signal<TimeRangePickerPlacement>;
+    protected readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    protected readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    protected readonly resolvedRequired: _angular_core.Signal<boolean | undefined>;
+    protected readonly editable: _angular_core.Signal<boolean>;
+    private readonly format;
+    private readonly anchor;
+    private readonly lengthOf;
+    /**
+     * Validity the family owns, beside the validity the consumer states: the
+     * bounds, the predicate, the order of the two ends and the duration.
+     */
+    private readonly problems;
+    protected readonly reversed: _angular_core.Signal<boolean>;
+    protected readonly resolvedInvalid: _angular_core.Signal<boolean | undefined>;
+    private readonly workOrdered;
+    protected readonly startMax: _angular_core.Signal<PlainTime | undefined>;
+    protected readonly endMin: _angular_core.Signal<PlainTime | undefined>;
+    private readonly listOptions;
+    private readonly base;
+    protected readonly truncated: _angular_core.Signal<boolean>;
+    /**
+     * The list of one end: the shared list, and what the other end of the work
+     * refuses of it — the options on the wrong side of it, those whose duration
+     * would fall outside the limits, and with `contiguous` those beyond the
+     * first refused option after it. The search runs over the list, never over
+     * the seconds.
+     */
+    protected readonly lists: _angular_core.Signal<Record<TimeRangePickerPosition, TimeOption[]>>;
+    protected readonly labels: _angular_core.Signal<Record<TimeRangePickerPosition, string[]>>;
+    private listFor;
+    protected highlightIndex(position: TimeRangePickerPosition): number;
+    protected isSelected(position: TimeRangePickerPosition, option: TimeOption): boolean;
+    /** The name of one end: the field's, its tab's and the hint's `{end}`. */
+    protected labelFor(position: TimeRangePickerPosition): string;
+    /** The end written short in the tab, or a dash. */
+    protected tabValue(position: TimeRangePickerPosition): string;
+    /** The problems of the work as it stands, once it is whole. */
+    private readonly workProblems;
+    protected readonly workReversed: _angular_core.Signal<boolean>;
+    protected readonly hintProblem: _angular_core.Signal<_slotted_core_date.DateRangeProblem | undefined>;
+    /**
+     * What the next press should be, or what is wrong: the difference between a
+     * panel that refuses and a panel that explains. Empty while the work is
+     * whole and valid, when the length says the duration.
+     */
+    protected readonly hint: _angular_core.Signal<string>;
+    /** The duration a row would make with the other end as it stands, or `null`. */
+    protected durationOf(position: TimeRangePickerPosition, option: TimeOption): string | null;
+    protected contextFor(position: TimeRangePickerPosition, option: TimeOption, index: number): {
+        $implicit: PlainTime;
+        current: boolean;
+        duration: string | null;
+        label: string;
+        position: TimeRangePickerPosition;
+        selected: boolean;
+        unavailable: boolean;
+    };
+    /**
+     * The pending end: the option under the pointer, or the highlighted option
+     * of the list that has focus.
+     */
+    protected readonly pending: _angular_core.Signal<{
+        position: TimeRangePickerPosition;
+        time: PlainTime;
+    } | null>;
+    protected readonly spokenLength: _angular_core.Signal<string>;
+    protected readonly limitText: _angular_core.Signal<string | null>;
+    /** The trigger's accessible name: focus returns here when the surface closes. */
+    protected readonly triggerLabel: _angular_core.Signal<string>;
+    /** The value in words, one line; `null` while nothing is chosen. */
+    protected readonly summary: _angular_core.Signal<string | null>;
+    constructor();
+    ngOnInit(): void;
+    writeValue(value: TimeRange | null | undefined): void;
+    registerOnChange(fn: (value: TimeRange | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnValidatorChange(fn: () => void): void;
+    /**
+     * The rules no other validator can see: the bounds, the predicate, the
+     * order of the two ends and the duration. `required` is left to Angular's
+     * own, because a form already has a word for it.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    /** Puts focus on the trigger, which is the frame. */
+    focus(): void;
+    openSurface(source?: Event): void;
+    closeSurface(source?: Event): void;
+    /** A preset writes its range through here, with the `select` reason. */
+    choose(range: TimeRange, source?: Event): void;
+    protected toggle(source: Event): void;
+    protected clear(source: Event): void;
+    protected onTriggerKeyDown(event: KeyboardEvent): void;
+    protected selectTab(position: TimeRangePickerPosition, source: Event): void;
+    /** Automatic activation: the arrow moves the position with it. */
+    protected onTabKeyDown(event: KeyboardEvent): void;
+    /**
+     * The way out of a sheet that fills the screen, and of an edit left half
+     * way: a whole work is the value; one end alone stays as it is.
+     */
+    protected done(source: Event): void;
+    protected onControlFocusOut(event: FocusEvent): void;
+    protected onListFocusOut(event: FocusEvent): void;
+    protected hover(position: TimeRangePickerPosition, option: TimeOption): void;
+    /**
+     * A field in the band writes its end to the work at every request it emits,
+     * with the field's own reason, and an open end is a value on its own.
+     */
+    protected onFieldValue(request: TimeFieldChangeRequest): void;
+    protected chooseNow(source: Event): void;
+    protected select(position: TimeRangePickerPosition, option: TimeOption, source: Event): void;
+    /**
+     * A press in a list, or on `now`: the end of that list is written to the
+     * work. Whole, the work is the value and the panel closes when the press
+     * completed it; incomplete, focus carries to the end that is missing.
+     */
+    private writeEnd;
+    private closeAfter;
+    /** Where a list opens: on its end, on the nearest step to now, or on the first available option. */
+    private openingIndex;
+    /**
+     * Into the list of one end: the tab moves there when it is not the current
+     * one, and focus lands on its highlight after the render that drew it.
+     */
+    private enterList;
+    private focusOption;
+    /** The list scrolled to its highlight: centred as the surface opens, by the least after. */
+    private revealHighlights;
+    /** The field, or the list where the field is not drawn (a coarse pointer). */
+    private focusField;
+    protected onListKeyDown(position: TimeRangePickerPosition, event: KeyboardEvent): void;
+    private commit;
+    private setPosition;
+    private setHighlight;
+    private setOpen;
+    /** Places the layer and puts it in the single stack. */
+    private attach;
+    private release;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimeRangePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTimeRangePicker, "[slTimeRangePicker]", ["slTimeRangePicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "defaultPosition": { "alias": "defaultPosition"; "required": false; "isSignal": true; }; "highlighted": { "alias": "highlighted"; "required": false; "isSignal": true; }; "defaultHighlighted": { "alias": "defaultHighlighted"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "isTimeUnavailable": { "alias": "isTimeUnavailable"; "required": false; "isSignal": true; }; "contiguous": { "alias": "contiguous"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "lengthLabel": { "alias": "lengthLabel"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "maxOptions": { "alias": "maxOptions"; "required": false; "isSignal": true; }; "unavailableOptions": { "alias": "unavailableOptions"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "referenceTime": { "alias": "referenceTime"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "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; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "relative": { "alias": "relative"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "startName": { "alias": "startName"; "required": false; "isSignal": true; }; "endName": { "alias": "endName"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "openChange": "openChange"; "positionChange": "positionChange"; "highlightedChange": "highlightedChange"; }, ["optionTemplate"], ["[slTimeRangePickerPresets]", "[slTimeRangePickerFooter]"], true, never>;
+}
+/**
+ * One shortcut. It writes its range with the `select` reason and carries
+ * `data-selected` while the value equals it. The list is the product's — "the
+ * morning shift" is a business clock — and the family ships the button, not
+ * the list.
+ */
+declare class SlTimeRangePickerPreset {
+    /** The range the press writes, or a function resolving it at the press. */
+    readonly range: _angular_core.InputSignal<_slotted_core_date.TimeRangeValue | (() => TimeRange)>;
+    private readonly picker;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected choose(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimeRangePickerPreset, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimeRangePickerPreset, "button[slTimeRangePickerPreset]", ["slTimeRangePickerPreset"], { "range": { "alias": "slTimeRangePickerPreset"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The consumer's own shortcuts, beside the two lists where there is room and
+ * above them where there is not. Each one is a `slTimeRangePickerPreset` button.
+ */
+declare class SlTimeRangePickerPresets {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimeRangePickerPresets, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimeRangePickerPresets, "[slTimeRangePickerPresets]", ["slTimeRangePickerPresets"], {}, {}, never, never, true, never>;
+}
+/** The consumer's own actions, under the two lists. */
+declare class SlTimeRangePickerFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimeRangePickerFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimeRangePickerFooter, "[slTimeRangePickerFooter]", ["slTimeRangePickerFooter"], {}, {}, never, never, true, never>;
+}
+/**
+ * What one row of a list draws.
+ *
+ * The row is the family's — its role, its states, its keyboard and its target
+ * size — and what is written inside it is the consumer's. It is a template
+ * rather than a projected slot because it is re-rendered once per option. The
+ * context carries the time as `$implicit`, plus `position`, `label`,
+ * `duration`, `selected`, `current` and `unavailable`.
+ */
+declare class SlTimeRangePickerOption {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimeRangePickerOption, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimeRangePickerOption, "[slTimeRangePickerOption]", ["slTimeRangePickerOption"], {}, {}, never, never, true, never>;
+}
+
+export { SlTimeRangePicker, SlTimeRangePickerFooter, SlTimeRangePickerOption, SlTimeRangePickerPreset, SlTimeRangePickerPresets, TIME_RANGE_PICKER_DEFAULTS, TIME_RANGE_PICKER_MAX_OPTIONS, TIME_RANGE_PICKER_STEP, injectTimeRangePickerDefaults, isSameTimeRange, provideTimeRangePickerDefaults, timeRangePickerLengthLabel };
+export type { TimeRange, TimeRangePickerCloseOnSelect, TimeRangePickerDefaults, TimeRangePickerHighlight, TimeRangePickerHourCycle, TimeRangePickerPlacement, TimeRangePickerPosition, TimeRangePickerSize, TimeRangePickerUnavailableOptions, TimeRangePickerVariant };
+//# sourceMappingURL=slotted-angular-time-range-picker.d.ts.map

package/types/slotted-angular-time-range-picker.d.ts.map

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