@lilydesignsystem/angular-date-time-picker 0.1.0

package/types/lilydesignsystem-angular-date-time-picker.d.ts

@@ -0,0 +1,558 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+/**
+ * Default button glyph: U+1F4C5 CALENDAR, followed by U+FE0E VARIATION
+ * SELECTOR-15 to request text (monochrome) presentation.
+ *
+ * Same construction as locale-picker's globe. The variation selector is a
+ * hint, not a guarantee — several platforms ignore it and render the emoji
+ * anyway — but where it is honoured the glyph inherits the page's text
+ * colour and stops looking like a sticker among the siblings' ◑, "A" and
+ * ➤. Written as an escape, never as a bare character: a variation
+ * selector has no visual form at all, so a bare one is invisible in an
+ * editor and trivially lost to a careless edit.
+ */
+declare const CALENDAR = "\uD83D\uDCC5\uFE0E";
+/** What the control collects. */
+type DateTimeMode = "date" | "time" | "datetime";
+/**
+ * A civil date: no time zone, no instant.
+ *
+ * The whole component works in these rather than in `Date`, because a
+ * `Date` is an instant and a calendar day is not. `new Date(2026, 2, 1)`
+ * is midnight *local*, and in a zone whose DST transition falls at
+ * midnight that instant can land on the previous day — so a picker built
+ * on local-midnight `Date` values shows the wrong day to some users a
+ * couple of times a year. Arithmetic here goes through UTC epoch days,
+ * which has no such edge.
+ */
+type CivilDate = {
+    year: number;
+    month: number;
+    day: number;
+};
+/** A wall-clock time, 24-hour, no seconds. */
+type CivilTime = {
+    hour: number;
+    minute: number;
+};
+/** One quick-pick button in the dialog. */
+type DateTimeShortcut = {
+    /** Stable identifier, passed back on the `shortcut` output. */
+    id: string;
+    /** Visible button text. Consumer-supplied, so it localises. */
+    label: string;
+    /** Days from today. Mutually exclusive with `months` and `date`. */
+    days?: number;
+    /** Calendar months from today. */
+    months?: number;
+    /** An absolute ISO date, for shortcuts that are not relative. */
+    date?: string;
+};
+/**
+ * Every user-facing string the dialog needs.
+ *
+ * Grouped into one object rather than spread across a dozen flat inputs.
+ * The sibling helpers use flat inputs because they need two or three
+ * strings; this one needs ten, and ten flat inputs is a call site nobody
+ * can read. One object also maps cleanly onto a translation bundle, which
+ * is how these strings actually arrive.
+ *
+ * The four navigation labels and the two footer labels are required: they
+ * name buttons that always render, and a button whose accessible name we
+ * invented in English is precisely the defect this package exists to
+ * avoid. The rest gate optional UI.
+ */
+type DateTimePickerLabels = {
+    /** Accessible name for the previous-year button. */
+    previousYear: string;
+    /** Accessible name for the previous-month button. */
+    previousMonth: string;
+    /** Accessible name for the previous-week button. */
+    previousWeek: string;
+    /** Accessible name for the previous-day button. */
+    previousDay: string;
+    /** Accessible name for the next-day button. */
+    nextDay: string;
+    /** Accessible name for the next-week button. */
+    nextWeek: string;
+    /** Accessible name for the next-month button. */
+    nextMonth: string;
+    /** Accessible name for the next-year button. */
+    nextYear: string;
+    /** Visible text of the commit button. */
+    confirm: string;
+    /** Visible text of the dismiss button. */
+    cancel: string;
+    /** Label for the hour select. Required when `mode` includes a time. */
+    hour?: string;
+    /** Label for the minute select. Required when `mode` includes a time. */
+    minute?: string;
+    /** Label for the AM/PM select, when `hour12` resolves true. */
+    meridiem?: string;
+    /** Column heading for week numbers. Required when `showWeekNumbers`. */
+    week?: string;
+    /** Visible text of the clear button. The button renders only when set. */
+    clear?: string;
+    /**
+     * Label for the time-zone select. The select renders only when set, for
+     * the same reason `clear` gates its button: a zone list is an opt-in
+     * part of the form, and we will not name it in English.
+     */
+    timeZone?: string;
+    /**
+     * Message announced when typed text will not parse or is out of range.
+     * When set, a `role="status"` live region renders after the field and
+     * is wired to it via `aria-errormessage` — without it, `aria-invalid`
+     * flips silently and a screen-reader user who has already left the
+     * field never hears that their date was refused.
+     */
+    invalid?: string;
+    /**
+     * Keyboard help for the dialog, e.g. "Use the arrow keys to choose a
+     * date". When set, it renders inside the dialog and becomes the
+     * dialog's `aria-describedby`, so a screen reader speaks it once on
+     * open — the APG date-picker dialog ships exactly this affordance.
+     */
+    instructions?: string;
+};
+/** Context passed to a projected icon `<ng-template>` (the button glyph). */
+type ChildArgs = {
+    /** The committed value, in ISO form. */
+    value: string;
+    /** Is the dialog open? */
+    open: boolean;
+    /** The value as the user sees it in the field. */
+    display: string;
+};
+/** Payload of the `shortcut` output. */
+type ShortcutEvent = {
+    /** The chosen shortcut's `id`. */
+    id: string;
+    /** The ISO date the shortcut resolved to. */
+    isoDate: string;
+};
+/** Zero-pad to `width`. */
+declare function pad(n: number, width?: number): string;
+/** Days in a month. `month` is 1-12. */
+declare function daysInMonth(year: number, month: number): number;
+/** `{2026, 3, 1}` → `"2026-03-01"`. */
+declare function formatIsoDate(date: CivilDate): string;
+/**
+ * `"2026-03-01"` → `{2026, 3, 1}`, or null.
+ *
+ * Rejects impossible components rather than rolling them over, so
+ * `"2026-02-31"` is null and not the 3rd of March. A field that silently
+ * reinterprets an impossible date is worse than one that refuses it.
+ */
+declare function parseIsoDate(text: string): CivilDate | null;
+/** Days since the Unix epoch. The unit all date arithmetic goes through. */
+declare function toEpochDay(date: CivilDate): number;
+/** Inverse of `toEpochDay`. */
+declare function fromEpochDay(epochDay: number): CivilDate;
+/** Shift an ISO date by whole days. */
+declare function addDays(isoDate: string, days: number): string;
+/**
+ * Shift an ISO date by whole months, clamping the day.
+ *
+ * 31 January + 1 month is 28 February (29 in a leap year), not 3 March.
+ * Rolling over is what `Date.prototype.setMonth` does and it is almost
+ * never what someone paging a calendar means.
+ */
+declare function addMonths(isoDate: string, months: number): string;
+/** Day of week: 0 = Sunday … 6 = Saturday. */
+declare function weekdayOf(isoDate: string): number;
+/**
+ * ISO-8601 week number.
+ *
+ * Weeks start Monday and week 1 is the one containing the first Thursday,
+ * which is why this pivots on Thursday rather than counting from 1
+ * January. Public-sector and clinical rotas quote ISO week numbers, so
+ * the column is worth getting exactly right.
+ */
+declare function isoWeek(isoDate: string): number;
+/** `"09:30"` → `{9, 30}`, or null. */
+declare function parseIsoTime(text: string): CivilTime | null;
+/** `{9, 30}` → `"09:30"`. */
+declare function formatIsoTime(time: CivilTime): string;
+/** Pull the date and time halves out of a mode-appropriate ISO value. */
+declare function splitValue(value: string, mode: DateTimeMode): {
+    date: string;
+    time: string;
+};
+/** Recombine the halves. Returns "" when the value is incomplete. */
+declare function joinValue(date: string, time: string, mode: DateTimeMode): string;
+/** Is `isoDate` inside the inclusive [min, max] window? Empty bounds pass. */
+declare function withinRange(isoDate: string, min?: string, max?: string): boolean;
+/**
+ * First day of the week for a locale: 0 = Sunday … 6 = Saturday.
+ *
+ * `Intl.Locale.prototype.getWeekInfo` is the right answer, but it is
+ * recent enough that a fallback still earns its place — and it is
+ * missing from some SSR runtimes entirely. The fallback is a short
+ * region table plus a Monday default, Monday being both the ISO-8601
+ * rule and the majority convention worldwide.
+ */
+declare function firstDayOfWeekFor(locale?: string): number;
+/**
+ * The dates of one month's grid, always six rows of seven.
+ *
+ * Fixed height on purpose. A grid sized to its month runs four to six
+ * rows, so the footer — and the confirm button in it — moves vertically
+ * as you page months. That is a Fitts's-law tax on every subsequent click
+ * and it makes the dialog jump under the pointer. A constant six rows
+ * costs at most one extra trailing week.
+ */
+declare function monthMatrix(year: number, month: number, firstDayOfWeek: number): string[][];
+/** Long and short month names for a locale, index 0 = January. */
+declare function monthNames(locale?: string): {
+    long: string[];
+    short: string[];
+};
+/**
+ * The order a locale writes a numeric date in — `["day","month","year"]`
+ * for en-GB, `["month","day","year"]` for en-US.
+ */
+declare function numericFieldOrder(locale?: string): ("day" | "month" | "year")[];
+/**
+ * Parse typed text into an ISO date.
+ *
+ * Accepts, in order: ISO `YYYY-MM-DD`; a numeric form whose field order
+ * follows the locale, so `03/04/2026` is 3 April in en-GB and 4 March in
+ * en-US — which is what each user means; and a form with a written month
+ * matched against the locale's own long and short month names, which is
+ * what lets DHCW's `27-Jun-2025` round-trip.
+ *
+ * Anything else is null. Guessing harder than this is how date fields
+ * silently record the wrong day.
+ */
+declare function parseDateInput(text: string, locale?: string): string | null;
+/** Accepts `9:30`, `09:30`, `0930`, `9.30`, and a trailing am/pm. */
+declare function parseTimeInput(text: string): string | null;
+/** Stable per-instance id prefix; SSR-safe (no Math.random / Date.now). */
+declare function nextDateTimePickerId(): string;
+/**
+ * Optional marker for the projected icon template. Gives consumers typed
+ * `let-` variables:
+ *
+ * ```html
+ * <lily-date-time-picker label="Choose a date" [labels]="labels">
+ *   <ng-template lilyDateTimePickerIcon let-args>{{ args.open ? "×" : "📅" }}</ng-template>
+ * </lily-date-time-picker>
+ * ```
+ *
+ * The component queries any projected `<ng-template>`, so the marker is
+ * for type-checking and readability, not for matching.
+ */
+declare class DateTimePickerIcon {
+    static ngTemplateContextGuard(_dir: DateTimePickerIcon, _ctx: unknown): _ctx is ChildArgs & {
+        $implicit: ChildArgs;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimePickerIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DateTimePickerIcon, "ng-template[lilyDateTimePickerIcon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * DateTimePicker — a headless date / time / datetime control.
+ *
+ * A typeable text field plus an icon button that opens a WAI-ARIA APG
+ * **Date Picker Dialog**: a month grid with a full keyboard contract.
+ * Locale-correct by construction — month names, weekday names, first day
+ * of week, numeric field order, 12- vs 24-hour clock and day-period names
+ * all come from `Intl`. See `spec/index.md` for the full contract.
+ *
+ * Unlike the three preference helpers this is a **form control**, not a
+ * page-header preference control, and it persists nothing.
+ */
+declare class DateTimePicker {
+    /** Accessible name for the trigger button and the dialog. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Every other user-facing string. See `spec/index.md` §4.2. */
+    readonly labels: _angular_core.InputSignal<DateTimePickerLabels>;
+    /** What to collect: a date, a time, or both. */
+    readonly mode: _angular_core.InputSignal<DateTimeMode>;
+    /** ISO value: `YYYY-MM-DD`, `HH:MM`, or `YYYY-MM-DDTHH:MM`. Two-way bindable. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** BCP 47 tag driving month names, weekday names and first weekday. */
+    readonly locale: _angular_core.InputSignal<string>;
+    /** Earliest selectable date, ISO. */
+    readonly min: _angular_core.InputSignal<string>;
+    /** Latest selectable date, ISO. */
+    readonly max: _angular_core.InputSignal<string>;
+    /** Veto individual dates — true means "cannot be picked". */
+    readonly isDateDisabled: _angular_core.InputSignal<((isoDate: string) => boolean) | undefined>;
+    /** 0 = Sunday … 6 = Saturday. Defaults to the locale's convention. */
+    readonly firstDayOfWeek: _angular_core.InputSignal<number | undefined>;
+    /** Granularity of the minute select. */
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    /** 12-hour clock. Defaults to the locale's convention. */
+    readonly hour12: _angular_core.InputSignal<boolean | undefined>;
+    /** Render an ISO-8601 week-number column. */
+    readonly showWeekNumbers: _angular_core.InputSignal<boolean>;
+    /** Quick-pick buttons. */
+    readonly shortcuts: _angular_core.InputSignal<DateTimeShortcut[]>;
+    /** Commit and close as soon as a day is chosen. Defaults to date-only. */
+    readonly confirmOnSelect: _angular_core.InputSignal<boolean | undefined>;
+    /** `name` of the hidden input that carries the value in a form post. */
+    readonly name: _angular_core.InputSignal<string>;
+    /**
+     * Selected IANA time zone (e.g. `Europe/London`), or `""` for none.
+     * Two-way bindable via `[(timeZone)]`, matching `value`. Rides its own
+     * hidden input `{name}-time-zone` and is reflected as `data-time-zone`
+     * on the root. It is metadata about WHERE the civil value applies, not
+     * part of the value — converting to an instant stays the consumer's
+     * job. Never guessed from the runtime: the picker no more picks a zone
+     * than `locale-picker` picks a locale.
+     */
+    readonly timeZone: _angular_core.ModelSignal<string>;
+    /**
+     * Zones offered by the select. Defaults to every zone the runtime
+     * knows via `Intl.supportedValuesOf("timeZone")` — never a bundled
+     * table, the rule month and weekday names already follow.
+     */
+    readonly timeZones: _angular_core.InputSignal<string[] | undefined>;
+    /** Display text per zone id; a zone without an entry shows its id. */
+    readonly timeZoneLabels: _angular_core.InputSignal<Record<string, string>>;
+    /** `id` of the text field, so a consumer `<label for>` can name it. */
+    readonly inputId: _angular_core.InputSignal<string>;
+    /** Forwarded to the text field as `aria-describedby`. */
+    readonly describedBy: _angular_core.InputSignal<string>;
+    /** Placeholder for the text field. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Disable the whole control. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Show the value but refuse edits.
+     *
+     * Named `readOnly` (not `readonly`) so the Angular input has an
+     * unambiguous identifier distinct from the TypeScript `readonly`
+     * modifier — the one Angular-forced rename beyond `class` → `className`.
+     */
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    /** Mark the field required. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** Override how a committed value is rendered into the text field. */
+    readonly formatValue: _angular_core.InputSignal<((value: string) => string) | undefined>;
+    /** Override how typed text is turned back into an ISO value. */
+    readonly parseInput: _angular_core.InputSignal<((text: string) => string | null) | undefined>;
+    /** Extra CSS class on the root `<div>`. */
+    readonly className: _angular_core.InputSignal<string>;
+    /** Fires after a new value is committed. */
+    readonly change: _angular_core.OutputEmitterRef<string>;
+    /** Fires when a shortcut is used, before the value settles. */
+    readonly shortcut: _angular_core.OutputEmitterRef<ShortcutEvent>;
+    /** Fires when typed text cannot be parsed. */
+    readonly invalidInput: _angular_core.OutputEmitterRef<string>;
+    /** Projected icon template; replaces the default glyph when supplied. */
+    protected readonly iconTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private readonly rootRef;
+    private readonly buttonRef;
+    private readonly dialogRef;
+    /** Optional: the grid renders only when `mode` includes a date. */
+    private readonly gridRef;
+    protected readonly glyph = "\uD83D\uDCC5\uFE0E";
+    /**
+     * For rendering the view synchronously before a focus move.
+     *
+     * Svelte updates the DOM synchronously when state changes, so the
+     * canonical helper can focus a freshly-paged month from a microtask.
+     * Angular renders later — after the microtask queue drains, whether the
+     * app is zone-based or zoneless — so a queued focus into a month that
+     * has not rendered yet finds nothing (or, worse, finds and focuses a
+     * cell that the next render destroys, dropping focus to `<body>`).
+     * `cdr.detectChanges()` inside the event handler is the Angular
+     * equivalent of Svelte's synchronous flush.
+     */
+    private readonly cdr;
+    private readonly baseId;
+    protected readonly dialogId: string;
+    protected readonly periodId: string;
+    protected readonly hourId: string;
+    protected readonly minuteId: string;
+    protected readonly meridiemId: string;
+    protected readonly statusId: string;
+    protected readonly instructionsId: string;
+    protected readonly timeZoneId: string;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly invalid: _angular_core.WritableSignal<boolean>;
+    /**
+     * The element that opened the dialog, so close can return focus to it.
+     *
+     * The APG rule is "focus returns to the element that invoked the
+     * dialog" — which is the trigger button on a click, but the *text
+     * field* when the user pressed Alt+ArrowDown. Always refocusing the
+     * button strands a keyboard user one Tab stop past where they were.
+     */
+    private openerEl;
+    /**
+     * Text the user has typed but not yet resolved.
+     *
+     * `null` means "no pending edit, show the formatted value". An empty
+     * string is a real state (the user cleared the field) and must not
+     * collapse into `null`.
+     */
+    protected readonly typed: _angular_core.WritableSignal<string | null>;
+    /**
+     * The pending selection, live only while the dialog is open.
+     *
+     * Kept separate from `value` so Cancel and Escape can genuinely revert.
+     * A picker that writes through on every arrow key has no cancel — only
+     * an undo the user has to perform by hand, from memory.
+     */
+    protected readonly pendingDate: _angular_core.WritableSignal<string>;
+    protected readonly pendingTime: _angular_core.WritableSignal<string>;
+    /** The month on screen. */
+    protected readonly viewYear: _angular_core.WritableSignal<number>;
+    protected readonly viewMonth: _angular_core.WritableSignal<number>;
+    /** The day the grid's roving tabindex sits on. */
+    protected readonly cursor: _angular_core.WritableSignal<string>;
+    /**
+     * Today, sampled once at open and refreshed on the initial effect below.
+     * Not re-read per cell: the grid asks "is this today?" 42 times a
+     * render, and a clock read per cell buys nothing over a clock read per
+     * open.
+     */
+    protected readonly today: _angular_core.WritableSignal<string>;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly committed: _angular_core.Signal<{
+        date: string;
+        time: string;
+    }>;
+    protected readonly weekStart: _angular_core.Signal<number>;
+    protected readonly commitOnDay: _angular_core.Signal<boolean>;
+    protected readonly usesDate: _angular_core.Signal<boolean>;
+    protected readonly usesTime: _angular_core.Signal<boolean>;
+    protected readonly clock12: _angular_core.Signal<boolean>;
+    /**
+     * `aria-describedby` for the field: the consumer's hint, plus — while
+     * invalid, with `labels().invalid` supplied — the status region, for
+     * the assistive technologies that read `aria-describedby` but not the
+     * newer `aria-errormessage`.
+     */
+    protected readonly fieldDescribedBy: _angular_core.Signal<string | null>;
+    /** The text shown in the field. A pending edit wins until resolved. */
+    protected readonly display: _angular_core.Signal<string>;
+    /** The "March 2026" heading. */
+    /**
+     * `Intl.supportedValuesOf` is guarded rather than called bare: an empty
+     * select beats a throw at mount on an older embedded runtime that
+     * lacks the method entirely.
+     */
+    protected readonly zoneOptions: _angular_core.Signal<string[]>;
+    protected readonly periodText: _angular_core.Signal<string>;
+    /** Column headings, in this locale, starting on `weekStart`. */
+    protected readonly weekdays: _angular_core.Signal<{
+        short: string;
+        long: string;
+    }[]>;
+    protected readonly weeks: _angular_core.Signal<string[][]>;
+    protected readonly pendingHour: _angular_core.Signal<number>;
+    protected readonly pendingMinute: _angular_core.Signal<number>;
+    /**
+     * The hours offered.
+     *
+     * On a 12-hour clock this lists only the half of the day the meridiem
+     * select is currently on, so the two controls together name exactly one
+     * hour. Listing 1-12 once and letting the meridiem reinterpret it is
+     * the same thing, but it makes "12 AM" ambiguous at precisely the point
+     * where users already get it wrong.
+     */
+    protected readonly hourOptions: _angular_core.Signal<{
+        value: number;
+        label: string;
+    }[]>;
+    protected readonly minuteOptions: _angular_core.Signal<number[]>;
+    protected readonly childContext: _angular_core.Signal<{
+        /** The committed value, in ISO form. */
+        value: string;
+        /** Is the dialog open? */
+        open: boolean;
+        /** The value as the user sees it in the field. */
+        display: string;
+        $implicit: ChildArgs;
+    }>;
+    private initialised;
+    constructor();
+    protected pad2(n: number): string;
+    protected isoWeekOf(isoDate: string): number;
+    /** Per-cell derived values for the grid template's `@let`. */
+    protected parseCell(isoDate: string): {
+        day: string;
+        outside: boolean;
+    };
+    /** Accessible name for one day cell, e.g. "Sunday 1 March 2026". */
+    protected dayLabel(isoDate: string): string;
+    /** The locale's own AM / PM strings, so neither is hardcoded. */
+    protected dayPeriodName(pm: boolean): string;
+    private formatTimeForDisplay;
+    /** Render an ISO value the way this locale writes it. */
+    private defaultFormat;
+    protected dayDisabled(isoDate: string): boolean;
+    /** The nearest selectable day to `isoDate`, searching outwards. */
+    private nearestSelectable;
+    protected openDialog(): void;
+    /** Where an unset time starts: now, snapped down to the step. */
+    private defaultTime;
+    /** Focus the grid cursor, or the first control when there is no grid. */
+    private focusInitial;
+    protected closeDialog(refocus?: boolean): void;
+    /** Commit the pending selection to `value` and notify. */
+    protected commit(): void;
+    protected clear(): void;
+    /**
+     * Move the cursor, paging the view when the target is off-screen.
+     *
+     * Disabled days are still reachable — the cursor lands on them and the
+     * button is `aria-disabled` (so it takes real focus and announces), so
+     * arrowing across a blocked range works. What is refused is leaving
+     * the min/max window entirely, because there is nothing out there to
+     * navigate to.
+     */
+    private moveCursor;
+    private focusCursor;
+    protected selectDay(isoDate: string): void;
+    protected shiftMonth(delta: number): void;
+    protected shiftYear(delta: number): void;
+    /**
+     * Week/day steps are the fine end of the header: unlike month/year,
+     * which move the GRID and merely carry the cursor, these move the
+     * pending day itself by ±7 / ±1 civil days and page the grid only
+     * when the new day leaves the shown month. A step off the min/max
+     * window is refused outright; a step onto a vetoed day moves the
+     * cursor — vetoed days are reachable, as with the arrow keys — but
+     * leaves the pending selection where it was. No commit even under
+     * `confirmOnSelect`.
+     */
+    protected shiftDays(delta: number): void;
+    protected onTimeZoneSelect(event: Event): void;
+    /**
+     * A plain index expression (`timeZoneLabels()[zone] ?? zone`) trips
+     * NG8102: without `noUncheckedIndexedAccess`, TypeScript types a
+     * `Record<string, string>` index as always `string`, so the compiler
+     * sees the `??` as dead code even though a real, unlisted zone id is
+     * exactly the case it exists for. The cast documents that the index
+     * genuinely can miss.
+     */
+    protected zoneLabel(zone: string): string;
+    protected onGridKeydown(event: KeyboardEvent): void;
+    /** Everything tabbable inside the dialog, in DOM order. */
+    private focusables;
+    protected onDialogKeydown(event: KeyboardEvent): void;
+    /** Default text parsing, per mode. */
+    private parseTypedForMode;
+    /** Resolve typed text on blur or Enter. */
+    protected resolveTyped(): void;
+    protected onFieldKeydown(event: KeyboardEvent): void;
+    protected setHour(hour: number): void;
+    protected setMinute(minute: number): void;
+    /** Cross between AM and PM without changing the minute of the hour. */
+    protected setMeridiem(pm: boolean): void;
+    protected applyShortcut(shortcut: DateTimeShortcut): void;
+    protected onDocumentClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateTimePicker, "lily-date-time-picker", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "labels": { "alias": "labels"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "isDateDisabled": { "alias": "isDateDisabled"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "hour12": { "alias": "hour12"; "required": false; "isSignal": true; }; "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; "isSignal": true; }; "shortcuts": { "alias": "shortcuts"; "required": false; "isSignal": true; }; "confirmOnSelect": { "alias": "confirmOnSelect"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "timeZones": { "alias": "timeZones"; "required": false; "isSignal": true; }; "timeZoneLabels": { "alias": "timeZoneLabels"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "describedBy": { "alias": "describedBy"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "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; }; "formatValue": { "alias": "formatValue"; "required": false; "isSignal": true; }; "parseInput": { "alias": "parseInput"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "timeZone": "timeZoneChange"; "change": "change"; "shortcut": "shortcut"; "invalidInput": "invalidInput"; }, ["iconTemplate"], never, true, never>;
+}
+
+export { CALENDAR, DateTimePicker, DateTimePickerIcon, addDays, addMonths, daysInMonth, firstDayOfWeekFor, formatIsoDate, formatIsoTime, fromEpochDay, isoWeek, joinValue, monthMatrix, monthNames, nextDateTimePickerId, numericFieldOrder, pad, parseDateInput, parseIsoDate, parseIsoTime, parseTimeInput, splitValue, toEpochDay, weekdayOf, withinRange };
+export type { ChildArgs, CivilDate, CivilTime, DateTimeMode, DateTimePickerLabels, DateTimeShortcut, ShortcutEvent };
+//# sourceMappingURL=lilydesignsystem-angular-date-time-picker.d.ts.map

package/types/lilydesignsystem-angular-date-time-picker.d.ts.map

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