@atlastodo/shared 0.0.0-stage → 0.1.11-rc.5

package/dist/activity.d.ts

@@ -0,0 +1,23 @@
+import type { LocalStore } from "@atlastodo/client-core";
+/**
+ * Activity-feed entries: an `activity` entity recording a key task change (status, due date,
+ * assignee) with actor and timestamp, written by {@link writeActivity} and shown beside comments.
+ * Fans out like a comment on shared projects.
+ */
+export type ActivityKind = "status" | "due" | "assignee";
+export interface Activity {
+    id: string;
+    task_id: string;
+    actor_id: string;
+    kind: ActivityKind;
+    from: string | null;
+    to: string | null;
+    created_at: number;
+}
+export declare function toActivity(id: string, fields: Record<string, unknown>): Activity;
+/**
+ * Append an activity entry. No-op when `actorId` is unknown (background contexts), so only
+ * user-driven edits are recorded. The id comes from `store.newEntityId()`: Hermes has no global
+ * `crypto`, and a non-UUID id would 422 the sync batch.
+ */
+export declare function writeActivity(store: LocalStore, actorId: string | undefined, taskId: string, kind: ActivityKind, from: string | null, to: string | null, now?: number): void;

package/dist/avatarColor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Deterministic avatar colors: a string hash maps a user id to a hue with fixed saturation and
+ * lightness so white text stays readable in both themes.
+ */
+export interface AvatarColor {
+    background: string;
+    color: string;
+}
+/**
+ * The current user always renders in this fixed Atlas indigo so "me" looks the same everywhere;
+ * others get their hashed color, where occasional collisions are fine.
+ */
+export declare const SELF_AVATAR_COLOR: AvatarColor;
+export declare function avatarColor(id: string): AvatarColor;
+export declare function avatarColorFor(id: string, selfId?: string): AvatarColor;

package/dist/boardMove.d.ts

@@ -0,0 +1,14 @@
+import type { Task } from "@atlastodo/client-core";
+export interface BoardMoveWrite {
+    id: string;
+    section_id: string | null;
+    sort_order?: number;
+}
+export declare function columnCards(tasks: Task[], sectionId: string | null, excludeId?: string): Task[];
+export declare function columnRoots(tasks: Task[], sectionId: string | null, excludeId?: string): Task[];
+export declare function columnMoveWrites(tasks: Task[], activeId: string, toSection: string | null, toIndex: number): BoardMoveWrite[];
+/**
+ * Move several cards to the end of one column, in the given order: {@link columnMoveWrites} per
+ * card against a running copy, so each lands after the previous one. The last write per task wins.
+ */
+export declare function columnMoveManyWrites(tasks: Task[], ids: string[], toSection: string | null): BoardMoveWrite[];

package/dist/bugReport.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Building a bug report that carries no task content, in layers:
+ * 1. Allowlist construction: {@link buildBugReport} never spreads; every payload field is named.
+ * 2. A non-`Error` throw keeps only its type name: `throw "task \"Buy flowers\" is broken"` is a
+ *    real pattern and no string matching would be trustworthy.
+ * 3. {@link stackFrames} keeps only lines that look like stack frames.
+ * 4. {@link redactText} on every string the app did not author: quoted runs and content-shaped key
+ *    values are replaced, then truncated.
+ * 5. Breadcrumb refs and routes are allowlisted ({@link sanitizeRef}): a path or UUID, else dropped.
+ *
+ * Residual gap: an `Error` message interpolating a task title unquoted survives layers 1-3 and is
+ * only truncated. House rule: never interpolate a task title or notes into a thrown `Error`.
+ */
+import type { BreadcrumbCode, BugReportBreadcrumb, BugReportDiagnostics, BugReportKind, BugReportPayload } from "@atlastodo/client-core";
+export declare const REPORT_LIMITS: {
+    readonly message: 2000;
+    readonly stack: 16000;
+    readonly description: 4000;
+    readonly shortField: 200;
+    readonly breadcrumbs: 50;
+    readonly frame: 200;
+};
+export declare function redactText(text: string, max?: number): string;
+export declare function sanitizeRef(ref: string | undefined | null): string | undefined;
+export declare function stackFrames(stack: string | undefined | null): string | undefined;
+export interface BreadcrumbTrail {
+    add(code: BreadcrumbCode, ref: string | undefined, at: number): void;
+    list(): BugReportBreadcrumb[];
+    clear(): void;
+}
+export declare function createBreadcrumbTrail(capacity?: number): BreadcrumbTrail;
+export interface BuildReportInput {
+    id: string;
+    kind: BugReportKind;
+    thrown: unknown;
+    appVersion: string;
+    platform: string;
+    osVersion?: string;
+    route?: string;
+    description?: string;
+    deviceId?: string;
+    diagnostics: BugReportDiagnostics;
+    breadcrumbs: BugReportBreadcrumb[];
+    now: number;
+}
+export declare function buildBugReport(input: BuildReportInput): BugReportPayload;
+export declare function emptyDiagnostics(): BugReportDiagnostics;

package/dist/calendar.d.ts

@@ -0,0 +1,23 @@
+import type { Task } from "@atlastodo/client-core";
+export interface DayCell {
+    date: number;
+    day: number;
+    inMonth: boolean;
+}
+export declare function weekdayLabels(weekStartsOn: number): string[];
+export declare function monthGrid(year: number, month: number, weekStartsOn: number, timeZone?: string): DayCell[][];
+export declare function weekDays(anchorMs: number, weekStartsOn: number, timeZone?: string): DayCell[];
+export declare function isoWeek(ms: number, timeZone?: string): number;
+export declare function tasksByDay(tasks: Task[], timeZone?: string): Map<number, Task[]>;
+export declare function isAllDayTask(dueAt: number, timeZone?: string): boolean;
+export interface TimedTaskInfo {
+    task: Task;
+    startHour: number;
+    startMinute: number;
+    durationMin: number;
+}
+export interface DayTasksPartition {
+    allDay: Task[];
+    timed: TimedTaskInfo[];
+}
+export declare function partitionDayTasks(tasks: Task[], timeZone?: string): DayTasksPartition;

package/dist/comments.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A `comment` entity synced like any other. Pure mapping only; the author id is stamped by the
+ * hook from the current session.
+ */
+export interface Comment {
+    id: string;
+    task_id: string;
+    author_id: string;
+    body: string;
+    created_at: number;
+    /** When the comment was last edited (Unix ms), or null if never. */
+    edited_at: number | null;
+}
+export declare function toComment(id: string, fields: Record<string, unknown>): Comment;

package/dist/countdown.d.ts

@@ -0,0 +1,14 @@
+export interface Countdown {
+    remaining: number;
+    overdue: boolean;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    magnitude: string;
+    label: string;
+}
+export declare function countdownTo(target: number, now: number): Countdown;
+export type CountdownPresetId = "weekend" | "month_end" | "year_end";
+export declare const COUNTDOWN_PRESETS: CountdownPresetId[];
+export declare function presetTarget(id: CountdownPresetId, now: number, timeZone?: string): number;

package/dist/cursor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Move the j/k task-list cursor over an ordered list of ids. `current` may be null or an id no
+ * longer in the list (completed or filtered away); both resolve to an end of the list. Movement
+ * clamps at the ends and does not wrap.
+ */
+export declare function cursorStep(ids: string[], current: string | null, dir: 1 | -1): string | null;

package/dist/dataTransfer.d.ts

@@ -0,0 +1,19 @@
+import { type EntityKind, type LocalStore } from "@atlastodo/client-core";
+export declare const PORTABLE_KINDS: EntityKind[];
+export interface BundleEntity {
+    id: string;
+    fields: Record<string, unknown>;
+}
+export interface ExportBundle {
+    app: "atlas-todo";
+    version: 1;
+    exportedAt: number;
+    entities: Record<string, BundleEntity[]>;
+}
+export declare function exportData(store: LocalStore, now?: number): ExportBundle;
+export declare function serializeBundle(bundle: ExportBundle): string;
+export declare function bundleFilename(now?: number): string;
+export declare function parseBundle(text: string): ExportBundle;
+export declare function importBundle(store: LocalStore, kick: () => void, bundle: ExportBundle): {
+    count: number;
+};

package/dist/duplicateProject.d.ts

@@ -0,0 +1,19 @@
+import type { EntityKind, Project, Section, Task } from "@atlastodo/client-core";
+export interface EntityWrite {
+    kind: EntityKind;
+    id: string;
+    field: string;
+    value: unknown;
+}
+export interface DuplicateProjectPlan {
+    newProjectId: string;
+    writes: EntityWrite[];
+}
+export declare function pushOpenTaskCopies(writes: EntityWrite[], openTasks: Task[], projectId: string, newSectionId: (task: Task) => string | undefined, opts: {
+    mkId: () => string;
+    now: number;
+}): void;
+export declare function planProjectDuplicate(project: Project, sections: Section[], tasks: Task[], opts: {
+    mkId: () => string;
+    now: number;
+}): DuplicateProjectPlan;

package/dist/duplicateSection.d.ts

@@ -0,0 +1,15 @@
+import type { Section, Task } from "@atlastodo/client-core";
+import { type EntityWrite } from "./duplicateProject.js";
+export interface DuplicateSectionPlan {
+    newSectionId: string;
+    writes: EntityWrite[];
+}
+/**
+ * The field writes for duplicating one section and its open tasks (completed and trashed ones
+ * dropped, like {@link planProjectDuplicate}). Only the section name gets "(copy)"; a sub-task
+ * keeps its parent only when the parent is in the copy. Pure given `mkId`/`now`.
+ */
+export declare function planSectionDuplicate(section: Section, tasks: Task[], opts: {
+    mkId: () => string;
+    now: number;
+}): DuplicateSectionPlan;

package/dist/filterQuery.d.ts

@@ -0,0 +1,64 @@
+import type { Priority, Task } from "@atlastodo/client-core";
+/**
+ * A small query language for saved filters and smart lists, e.g. `@work & due:week & p1`,
+ * `#home | (p1 & !due:none)`.
+ *
+ * Grammar (NOT binds tightest, then AND, then OR; adjacency means AND):
+ *
+ *   or    := and ( ('|' | 'or') and )*
+ *   and   := not ( ('&' | 'and')? not )*
+ *   not   := ('!' | 'not') not | term
+ *   term  := '(' or ')' | atom
+ *   atom  := pN | @label | #project | due:WHEN | due:Nd | overdue | text
+ *
+ * `due:WHEN` is today/tomorrow/week/month/weekend/next-week/overdue/none; `due:Nd` is the next N
+ * days. `parse` never throws: invalid input returns `{ ok: false, error, at }`.
+ */
+export type DueWhen = "today" | "tomorrow" | "week" | "month" | "weekend" | "next-week" | "overdue" | "none";
+export type FilterNode = {
+    type: "and";
+    left: FilterNode;
+    right: FilterNode;
+} | {
+    type: "or";
+    left: FilterNode;
+    right: FilterNode;
+} | {
+    type: "not";
+    child: FilterNode;
+} | {
+    type: "priority";
+    value: Priority;
+} | {
+    type: "label";
+    name: string;
+} | {
+    type: "project";
+    name: string;
+} | {
+    type: "due";
+    when: DueWhen;
+} | {
+    type: "dueWithin";
+    days: number;
+} | {
+    type: "text";
+    value: string;
+};
+export type ParseResult = {
+    ok: true;
+    ast: FilterNode;
+} | {
+    ok: false;
+    error: string;
+    at: number;
+};
+export declare function parse(input: string): ParseResult;
+export interface EvalContext {
+    now: number;
+    labelsOf: (task: Task) => string[];
+    projectNameOf: (task: Task) => string | null;
+    timeZone?: string;
+    weekStartsOn?: number;
+}
+export declare function evaluate(node: FilterNode, task: Task, ctx: EvalContext): boolean;

package/dist/focus.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Focus (pomodoro) session records: pure helpers over `focus_session` entities that log tracked
+ * time against tasks.
+ */
+export interface FocusSession {
+    id: string;
+    task_id: string;
+    started_at: number;
+    ended_at: number;
+    /** Tracked focused duration in ms (less than ended - started if paused). */
+    duration_ms: number;
+    created_at: number;
+}
+export declare function toFocusSession(id: string, fields: Record<string, unknown>): FocusSession;
+export declare function trackedMsForTask(sessions: FocusSession[], taskId: string): number;
+/** Format a millisecond duration compactly as `Hh Mm` / `Mm` / `<1m`. */
+export declare function formatDuration(ms: number): string;

package/dist/format.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Locale, timezone and format-aware date, time and number formatting: the single place display
+ * strings are produced so language, timezone, 12/24h and date-format preferences apply everywhere.
+ * Pure; `makeFormatters(config)` builds the `Intl` formatters.
+ */
+export type TimeFormatPref = "auto" | "12h" | "24h";
+export type DateFormatPref = "auto" | "short" | "medium" | "long";
+export declare function isTimeFormat(v: unknown): v is TimeFormatPref;
+export declare function isDateFormat(v: unknown): v is DateFormatPref;
+/**
+ * Resolve the BCP-47 formatting locale: the region preference wins (an English UI can format dates
+ * as en-GB), then the UI language, then the device default (undefined). Blank means "follow the
+ * device".
+ */
+export declare function resolveLocale(region?: string, language?: string): string | undefined;
+export interface FormatConfig {
+    locale?: string;
+    timeZone?: string;
+    timeFormat?: TimeFormatPref;
+    dateFormat?: DateFormatPref;
+}
+export interface Formatters {
+    dueChip(ms: number): string;
+    time(ms: number): string;
+    dateTime(ms: number): string;
+    date(ms: number): string;
+    monthYear(year: number, month: number): string;
+    number(n: number): string;
+}
+export declare function makeFormatters(config?: FormatConfig): Formatters;

package/dist/fuzzy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tiny fuzzy matcher for the command palette. Pure and DOM-free so ranking is unit-testable.
+ * A query matches if its characters appear in order (subsequence) in the item's text; contiguous
+ * and early matches score higher. An empty query keeps every item in its original order.
+ */
+export interface FuzzyItem {
+    label: string;
+    /** Extra searchable text (synonyms, group name) that doesn't show in the label. */
+    keywords?: string;
+}
+/** Score a subsequence match of `query` against `text`, or null if not all chars appear in order. */
+export declare function scoreMatch(text: string, query: string): number | null;
+/** Filter and rank items by a fuzzy query, best first. Stable for equal scores. */
+export declare function filterActions<T extends FuzzyItem>(query: string, items: T[]): T[];

package/dist/grouping.d.ts

@@ -0,0 +1,24 @@
+import type { Task } from "@atlastodo/client-core";
+export type GroupBy = "none" | "date" | "priority" | "label" | "project" | "completed";
+export type SortBy = "manual" | "due" | "priority" | "alpha" | "created" | "modified";
+export declare const GROUP_BYS: GroupBy[];
+export declare const SORT_BYS: SortBy[];
+export declare function isGroupBy(v: unknown): v is GroupBy;
+export declare function isSortBy(v: unknown): v is SortBy;
+export interface TaskGroup {
+    key: string;
+    kind: GroupBy;
+    accent?: "danger";
+    tasks: Task[];
+}
+export declare function taskComparator(sortBy: SortBy): (a: Task, b: Task) => number;
+export declare function sortTasks(tasks: Task[], sortBy: SortBy): Task[];
+export interface GroupContext {
+    now: number;
+    timeZone?: string;
+    sortBy: SortBy;
+    projectOrder: string[];
+    labelOrder: string[];
+}
+export declare function completedBucket(completedAt: number, now: number, timeZone?: string): string;
+export declare function groupTasks(tasks: Task[], groupBy: GroupBy, ctx: GroupContext): TaskGroup[];

package/dist/habitGroups.d.ts

@@ -0,0 +1,46 @@
+import { type CheckinStates, type CompletionRate, type Habit } from "./habits.js";
+import { hiddenProjectIds } from "./projectTree.js";
+export type HabitListRow = {
+    kind: "group";
+    key: string;
+    group: Habit;
+    memberCount: number;
+    expanded: boolean;
+} | {
+    kind: "habit";
+    key: string;
+    habit: Habit;
+    depth: 0 | 1;
+};
+export declare const hiddenHabitIds: typeof hiddenProjectIds;
+export declare function habitGroupMembers(habits: Habit[], groupId: string): Habit[];
+export declare function habitSiblings(habits: Habit[], habit: Habit): Habit[];
+export declare function flattenHabitGroups(habits: Habit[], isExpanded?: (groupId: string) => boolean): HabitListRow[];
+export declare function moveHabitTarget(habits: Habit[], id: string, groupId: string | null): {
+    id: string;
+    parent_id: string | null;
+    sort_order: number;
+} | null;
+export interface HabitGroupMember {
+    habit: Habit;
+    states: CheckinStates;
+}
+export interface HabitGroupDay {
+    date: string;
+    due: number;
+    done: number;
+    excluded: boolean;
+    met: boolean;
+    inProgress: boolean;
+    missing: string[];
+}
+export declare function habitGroupDays(members: readonly HabitGroupMember[], fromKey: string, toKey: string, todayKey: string, weekStartsOn?: number): HabitGroupDay[];
+export declare function habitGroupStreak(members: readonly HabitGroupMember[], todayMs: number, weekStartsOn?: number): number;
+export declare function habitGroupBestStreak(members: readonly HabitGroupMember[], todayMs: number, weekStartsOn?: number): number;
+export interface HabitGroupBreak {
+    date: string;
+    missing: string[];
+}
+export declare function habitGroupBreak(members: readonly HabitGroupMember[], todayMs: number, weekStartsOn?: number): HabitGroupBreak | null;
+export declare function habitGroupToday(members: readonly HabitGroupMember[], todayMs: number, weekStartsOn?: number): HabitGroupDay | null;
+export declare function habitGroupRate(members: readonly HabitGroupMember[], fromMs: number, toMs: number, weekStartsOn?: number): CompletionRate;

package/dist/habitSchedule.d.ts

@@ -0,0 +1,4 @@
+import { type CheckinStates, type Habit } from "./habits.js";
+import type { ScheduledReminder } from "./reminderSchedule.js";
+export declare function habitReminderId(habitId: string, date: string): string;
+export declare function habitReminders(habits: Habit[], statesOf: (habitId: string) => CheckinStates, now: number, weekStartsOn?: number, horizonDays?: number): ScheduledReminder[];

package/dist/habits.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Habits and streaks: pure, date-based logic with an injected `now`.
+ *
+ * Check-ins are keyed by local calendar date, ignoring the `timezone` preference (re-keying would
+ * rewrite streaks). Date arithmetic uses the UTC calendar helpers, which are DST-safe.
+ *
+ * Every goal kind reduces to periods wanting `target` check-ins: `daily` (one per day, `days` picks
+ * weekdays), `weekly` (aligned to `week_starts_on`, so changing it redraws past weeks), `interval`
+ * (`target`-day blocks tiled from creation).
+ *
+ * A short in-progress period neither counts nor breaks a streak. Skipped days shrink the target;
+ * a period whose target falls to 0 is dropped and bridged.
+ */
+export type HabitGoalKind = "daily" | "weekly" | "interval";
+export type HabitKind = "habit" | "group";
+export type CheckinState = "done" | "skip";
+export interface HabitSchedule {
+    from: string;
+    goal_kind: HabitGoalKind;
+    days: number[];
+    target: number;
+}
+export interface Habit {
+    id: string;
+    name: string;
+    kind: HabitKind;
+    parent_id: string | null;
+    goal_kind: HabitGoalKind;
+    days: number[];
+    target: number;
+    color: string;
+    icon: string;
+    notes: string;
+    steps: string[];
+    unit: string;
+    reminder_time: string | null;
+    schedule_history: HabitSchedule[];
+    archived_at: number | null;
+    created_at: number;
+    sort_order: number;
+}
+export interface HabitCheckin {
+    id: string;
+    habit_id: string;
+    date: string;
+    state: CheckinState;
+    value: number;
+    note: string;
+    created_at: number;
+}
+export type CheckinStates = ReadonlyMap<string, CheckinState>;
+export declare const MAX_SCAN_DAYS: number;
+export declare const MAX_STEPS = 50;
+export declare const MAX_SCHEDULE_HISTORY = 200;
+export declare function dateKey(d: Date): string;
+export declare function dateKeyFromMs(ms: number): string;
+export declare function shiftDateKey(key: string, days: number): string;
+export declare function daysBetweenKeys(a: string, b: string): number;
+export declare function dateKeyToMs(key: string): number;
+export declare function weekdayOfKey(key: string): number;
+export declare function startOfWeekKey(key: string, weekStartsOn: number): string;
+export declare function toHabit(id: string, fields: Record<string, unknown>): Habit;
+export declare function toHabitCheckin(id: string, fields: Record<string, unknown>): HabitCheckin;
+export declare function isBackfilled(checkin: HabitCheckin): boolean;
+type GoalShape = Pick<Habit, "goal_kind" | "days" | "target">;
+export declare function isScheduledOn(habit: Habit, key: string, weekStartsOn?: number): boolean;
+export declare function goalFrequency(habit: GoalShape): number;
+export interface ScheduleSegment {
+    schedule: HabitSchedule;
+    from: string;
+    until: string | null;
+}
+export declare function scheduleSegments(habit: Habit, weekStartsOn?: number): ScheduleSegment[];
+export declare function effectiveSchedule(habit: Habit, key: string, weekStartsOn?: number): HabitSchedule;
+export declare function appendScheduleChange(habit: Habit, patch: Partial<GoalShape>, nowMs: number): HabitSchedule[] | null;
+export interface HabitPeriod {
+    from: string;
+    to: string;
+    scheduled: string[];
+    goal: number;
+}
+export interface PeriodResult {
+    period: HabitPeriod;
+    done: number;
+    skipped: number;
+    target: number;
+    met: boolean;
+    inProgress: boolean;
+}
+export declare function periodsBetween(habit: Habit, fromKey: string, toKey: string, weekStartsOn?: number): HabitPeriod[];
+export declare function evaluatePeriods(states: CheckinStates, periods: HabitPeriod[], todayKey: string): PeriodResult[];
+export declare function currentStreak(habit: Habit, states: CheckinStates, todayMs: number, weekStartsOn?: number): number;
+export declare function currentPeriod(habit: Habit, states: CheckinStates, todayMs: number, weekStartsOn?: number): PeriodResult | null;
+export declare function isActiveToday(habit: Habit, states: CheckinStates, todayMs: number, weekStartsOn?: number): boolean;
+export declare function bestStreak(habit: Habit, states: CheckinStates, todayMs: number, weekStartsOn?: number): number;
+export interface CompletionRate {
+    periods: number;
+    met: number;
+    rate: number;
+}
+export declare function completionRate(habit: Habit, states: CheckinStates, fromMs: number, toMs: number, weekStartsOn?: number): CompletionRate;
+export declare function totalCheckins(states: CheckinStates): number;
+export declare function nextDue(habit: Habit, states: CheckinStates, todayMs: number, weekStartsOn?: number): string | null;
+export interface StrengthPoint {
+    date: string;
+    score: number;
+}
+/**
+ * Loop Habit Tracker's strength curve: an exponential moving average that dips on a miss but never
+ * resets. `multiplier = 0.5 ** (sqrt(frequency) / 13)` per day, raised to the period length.
+ * Skipped, off-schedule and short in-progress periods carry the score forward.
+ */
+export declare function strengthSeries(habit: Habit, states: CheckinStates, fromMs: number, toMs: number, weekStartsOn?: number): StrengthPoint[];
+export declare function currentStrength(habit: Habit, states: CheckinStates, todayMs: number, weekStartsOn?: number): number;
+export {};

package/dist/hotkeys.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Keyboard-shortcut dispatch: pure and DOM-free. [`HOTKEY_BINDINGS`] is the single source of truth,
+ * walked by `dispatchHotkey` and rendered by the help UIs.
+ *
+ * Cmd/Ctrl-K fires even while typing; every other binding is inert then, and any modifier
+ * suppresses single-key shortcuts. A missing or declining (`false`) handler reports unhandled so the
+ * browser default survives. Escape clears a multi-selection but never reports handled, so an open
+ * dialog still closes.
+ */
+export interface HotkeyInput {
+    key: string;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    typing: boolean;
+}
+export type HotkeyHandler = () => void | boolean;
+export interface HotkeyHandlers {
+    openPalette?: HotkeyHandler;
+    focusSearch?: HotkeyHandler;
+    openHelp?: HotkeyHandler;
+    focusQuickAdd?: HotkeyHandler;
+    cursorNext?: HotkeyHandler;
+    cursorPrev?: HotkeyHandler;
+    openCursor?: HotkeyHandler;
+    completeCursor?: HotkeyHandler;
+    rescheduleCursor?: HotkeyHandler;
+    deleteCursor?: HotkeyHandler;
+    clearSelection?: HotkeyHandler;
+    selectAll?: HotkeyHandler;
+    copySelection?: HotkeyHandler;
+    duplicateSelection?: HotkeyHandler;
+    cutSelection?: HotkeyHandler;
+}
+export type HotkeyGroup = "global" | "navigation" | "taskActions" | "selection";
+export declare const HOTKEY_GROUPS: readonly HotkeyGroup[];
+export interface HotkeyBinding {
+    action: keyof HotkeyHandlers;
+    triggerKeys: string[];
+    displayKeys: string[];
+    descriptionKey: string;
+    group: HotkeyGroup;
+    mod?: boolean;
+    /** Fires even while focus is in a text field (only Cmd/Ctrl-K). */
+    whileTyping?: boolean;
+    /** Fires, but reports unhandled so the event is not preventDefaulted (Escape). */
+    noPreventDefault?: boolean;
+}
+export declare const HOTKEY_BINDINGS: readonly HotkeyBinding[];
+export declare function dispatchHotkey(input: HotkeyInput, h: HotkeyHandlers): boolean;