@book.dev/ui 1.60.0

package/dist/components/WorkspaceSelectMenu.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The workspace switcher. `variant` controls the trigger only:
+ *  - `sidebar` (default) — the full-width, two-line button at the top of the
+ *    sidebar (web);
+ *  - `titlebar` — a compact icon + name button for the desktop titlebar.
+ * The dropdown contents (workspace list + "add a workspace") are identical.
+ */
+export default function WorkspaceSelectMenu({ variant }: {
+    variant?: 'sidebar' | 'titlebar';
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/__tests__/AppearanceSettings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/__tests__/PageIcon.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/__tests__/SettingsPanel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/__tests__/buildTree.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/__tests__/profileAvatar.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/appearance/AppearanceControls.d.ts

@@ -0,0 +1,33 @@
+import { type ComponentType, type ReactNode } from 'react';
+import { type Level } from '@/lib/themes';
+/** A compact segmented button row — the shared shape for every appearance knob. */
+export declare function Segmented<T extends string | number>({ options, value, onChange, className, }: {
+    options: Array<{
+        value: T;
+        label: string;
+        icon?: ComponentType<{
+            className?: string;
+        }>;
+    }>;
+    value: T;
+    onChange: (value: T) => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** A labelled section wrapper used throughout the appearance UI. */
+export declare function Field({ label, hint, children }: {
+    label: string;
+    hint?: string;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** The accent-palette picker: swatches grouped by bold / pastel / neutral. */
+export declare function AccentPicker({ value, onChange, scheme, }: {
+    value: string;
+    onChange: (id: string) => void;
+    scheme: 'light' | 'dark';
+}): import("react/jsx-runtime").JSX.Element;
+/** A 0–3 level picker (interface intensity / control intensity). */
+export declare function LevelPicker({ value, onChange, labels, }: {
+    value: Level;
+    onChange: (v: Level) => void;
+    labels: [string, string, string, string];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/appearance/PageCustomiseBody.d.ts

@@ -0,0 +1,29 @@
+import { type CSSProperties } from 'react';
+/**
+ * Compose this page's effective appearance (the app's appearance with the
+ * page's override merged on top) into a scoped CSS-variable `style`, or
+ * `undefined` when the page just follows the app. Spread onto the page wrapper
+ * so the override recolors the page content while the app chrome stays global.
+ */
+export declare function usePageThemeStyle(pageId: string): CSSProperties | undefined;
+/** Whether a page sets its own canvas background tint (drives `.ob-page-bg`). */
+export declare function usePageHasBackground(pageId: string): boolean;
+/**
+ * Per-page customisation. A whole-page theme preset (#4) sets control colour,
+ * font, background, and cover at once; the individual pickers (#5) then tweak
+ * each aspect. Writes page-scoped overrides (theme via {@link writePageTheme},
+ * fonts via {@link writePageFonts}, cover via {@link writePageCover}); the app
+ * chrome is out of scope — a page override only restyles that page.
+ */
+export declare function PageAppearanceControls({ pageId }: {
+    pageId: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * The page-customisation side pane body (the {@link CUSTOMISE_PANE_ID} pane).
+ * Reads the page being customised from the `pageCustomise` bridge and renders
+ * its appearance + typeface controls — the same side-pane mechanism the block
+ * settings use, rather than a cramped popover.
+ */
+export declare function PageCustomiseBody(): import("react/jsx-runtime").JSX.Element;
+/** Whether a page carries any per-page customisation (theme knob or font). */
+export declare const hasPageCustomisation: (pageId: string) => boolean;

package/dist/components/brand/OpenBookLogo.d.ts

@@ -0,0 +1,11 @@
+import { type CSSProperties } from 'react';
+export interface OpenBookLogoProps {
+    /** Rendered width & height (the mark is square-ish, 220×214 viewBox). */
+    size?: number | string;
+    className?: string;
+    style?: CSSProperties;
+    /** Accessible label; pass `null`/'' to mark decorative. */
+    title?: string | null;
+}
+export declare function OpenBookLogo({ size, className, style, title }: OpenBookLogoProps): import("react/jsx-runtime").JSX.Element;
+export default OpenBookLogo;

package/dist/components/brand/index.d.ts

@@ -0,0 +1 @@
+export { OpenBookLogo, type OpenBookLogoProps } from './OpenBookLogo';

package/dist/components/database/DatabaseCard.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+/**
+ * The extensible **database card** — a compact preview of an entity used for
+ * hover and popovers. It's deliberately generic: an optional cover, an icon +
+ * title, and a list of `fields` (label + node). {@link useRowCard} builds one
+ * from a database row, but any caller can assemble its own `fields` to reuse the
+ * card for mentions, search results, or other entities.
+ */
+export interface CardField {
+    id: string;
+    label: string;
+    node: React.ReactNode;
+}
+export interface DatabaseCardData {
+    title: string;
+    icon?: string;
+    /** A CSS background for the cover band (gradient or image), or none. */
+    cover?: React.CSSProperties;
+    fields: CardField[];
+}
+export declare const DatabaseCard: React.FC<{
+    data: DatabaseCardData;
+    onOpen?: () => void;
+}>;
+/** Build (and cache) a {@link DatabaseCardData} for a database row, fetched on demand. */
+export declare function useRowCard(rowId: string, active: boolean): DatabaseCardData | null;
+/**
+ * Wrap a trigger so hovering it (after a short delay) reveals the row's
+ * {@link DatabaseCard} in a popover. Built on {@link Popover} with hover
+ * handlers (no focus stealing); clicking the card title opens the row.
+ */
+export declare const RowHoverCard: React.FC<{
+    rowId: string;
+    children: React.ReactNode;
+    openDelay?: number;
+}>;

package/dist/components/database/DatabasePicker.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+/**
+ * The inline prompt a fresh database block shows until it has a database: create
+ * a new one, or link an existing database (chosen via {@link DatabasePicker}).
+ * Rendered via a portal inside the document providers, so it reads the live page
+ * list and triggers the block's create/link actions.
+ */
+export declare const InlineDatabaseChooser: React.FC<{
+    onCreate: () => void;
+    onPick: (pageId: string) => void;
+}>;
+export default InlineDatabaseChooser;

package/dist/components/database/DatabaseRowProperties.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+/**
+ * The database-row half of the page-view properties panel. When a page is a
+ * database row, its columns appear here as editable fields — organised into
+ * collapsible **property groups**, with per-property and per-group show/hide.
+ * Reuses {@link useDatabase} (keyed on the row's database) so edits round-trip
+ * through the same path as the table and stay live with it.
+ */
+export declare const DatabaseRowProperties: React.FC<{
+    pageId: string;
+    databaseId: string;
+}>;
+export default DatabaseRowProperties;

package/dist/components/database/DatabaseView.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+/** Focus a (possibly not-yet-rendered) row's title input, retrying briefly. */
+export declare function focusRowTitle(rowId: string, attempt?: number): void;
+export declare const DatabaseView: React.FC<{
+    pageId: string;
+    databaseIdHint?: string | null;
+    inline?: boolean;
+}>;
+export default DatabaseView;

package/dist/components/database/InlineDatabaseBlock.d.ts

@@ -0,0 +1,3 @@
+/** Register the inline database block. Called from BlockPageDocument, where the
+ *  data/navigation providers the embedded view needs are in scope. */
+export declare function registerDatabaseBlock(): void;

package/dist/components/database/__tests__/InlineDatabaseBlock.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/database/databaseCells.d.ts

@@ -0,0 +1,57 @@
+import React from 'react';
+import { type DatabaseProperty, type DatabaseRow, type DatabaseSelectOption } from '@book.dev/sdk';
+/**
+ * The raw value to feed a property cell: the stored value for editable types,
+ * and the *derived* value for the read-only ones — `expr` (a reactive export),
+ * `formula` (computed from sibling properties; needs the full property list),
+ * and the `created_time`/`last_edited_time` timestamps (from the row page).
+ */
+export declare function cellValue(row: DatabaseRow, property: DatabaseProperty, properties?: DatabaseProperty[], rows?: DatabaseRow[]): unknown;
+/** The current user's display name, used to stamp owner/verification. */
+export declare function useIdentity(): string;
+/** A person value rendered as an avatar chip. */
+export declare const PersonChip: React.FC<{
+    name: string;
+}>;
+/** A verification badge (verified / not). */
+export declare const VerificationBadge: React.FC<{
+    value: unknown;
+}>;
+/** A colored select-option chip. */
+export declare const SelectChip: React.FC<{
+    option: DatabaseSelectOption;
+}>;
+export declare function formatCellValue(property: DatabaseProperty, value: unknown): string;
+/** Render a computed rollup value (a list for "show original", else a number). */
+export declare function formatRollupValue(property: DatabaseProperty, value: unknown): string;
+/** Render a computed formula value, surfacing errors and honouring number format. */
+export declare function formatFormulaValue(value: unknown, format?: DatabaseProperty['numberFormat']): string;
+/** Compact, human-readable rendering of an arbitrary exported expression value. */
+export declare function formatExprValue(value: unknown, format?: DatabaseProperty['numberFormat']): string;
+/** Serialise rows to CSV — a header of "Name" + column names, then a row each.
+ *  Values are flattened and RFC-4180-escaped. Pure (shared by the export action). */
+export declare function rowsToCsv(rows: DatabaseRow[], columns: DatabaseProperty[], properties: DatabaseProperty[]): string;
+/** Parse CSV text into a grid of cells (RFC-4180: quotes, escaped quotes,
+ *  embedded commas/newlines). Pure — shared by the import action and tests. */
+export declare function parseCsv(text: string): string[][];
+export interface PropertyValueCellProps {
+    property: DatabaseProperty;
+    value: unknown;
+    /** Live exported value (expr columns are read-only and use this). */
+    exprValue?: unknown;
+    onChange: (value: unknown) => void;
+    /** Create a new select option (returns it), used by the select editor. */
+    onAddOption?: (label: string) => Promise<DatabaseSelectOption | null>;
+    /** Candidate rows for a `dependency` cell (the database's own rows, sans self). */
+    rowOptions?: {
+        id: string;
+        label: string;
+        icon?: string;
+    }[];
+}
+/**
+ * An inline, type-aware editor for one row's value of one property. Manual
+ * types edit in place; `expr` columns are read-only and show the live exported
+ * value projected from the row page's reactive store.
+ */
+export declare const PropertyValueCell: React.FC<PropertyValueCellProps>;

package/dist/components/database/databaseCharts.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { type DatabaseProperty, type DatabaseView as DbView } from '@book.dev/sdk';
+import type { UseDatabase } from './useDatabase';
+/**
+ * A horizontal bar chart: one bar per group of the view's `groupByPropertyId`,
+ * sized by its aggregate (count by default, else sum/avg/min/max of a numeric
+ * property). A `breakdownPropertyId` splits each bar into stacked segments. Bars
+ * are interactive — hover for a readout, click to drill into the underlying rows.
+ * Dependency-free — just flexbox bars — so it renders identically in the web app
+ * and the desktop WKWebView.
+ */
+export declare const BarChartView: React.FC<{
+    db: UseDatabase;
+    view: DbView;
+    properties: DatabaseProperty[];
+}>;
+/**
+ * A pie chart drawn with a CSS `conic-gradient` plus an interactive legend. Each
+ * slice is a group of the view's `groupByPropertyId`. With a `breakdownPropertyId`
+ * it becomes a two-ring sunburst: the inner disc is the primary groups, the outer
+ * ring their breakdown segments, and the legend nests each group's segments. Every
+ * legend row hovers for a readout and clicks to drill into its rows.
+ */
+export declare const PieChartView: React.FC<{
+    db: UseDatabase;
+    view: DbView;
+    properties: DatabaseProperty[];
+}>;

package/dist/components/database/databaseColors.d.ts

@@ -0,0 +1,12 @@
+import type { ChartDatum } from '@book.dev/sdk';
+/**
+ * Concrete colors for charts/boards. The `select` swatch tokens
+ * ({@link SELECT_COLORS}) render as Tailwind classes elsewhere (see
+ * `COLOR_CLASSES` in `databaseCells`), but charts need raw color values for
+ * inline `conic-gradient` / SVG fills, so this maps each token to a hex color.
+ */
+export declare const SWATCH_HEX: Record<string, string>;
+/** Fallback palette for groups that carry no swatch token (cycled by index). */
+export declare const CHART_PALETTE: string[];
+/** Resolve a chart slice/bar color: the group's swatch if any, else the palette. */
+export declare const chartColor: (datum: Pick<ChartDatum, "color">, index: number) => string;

package/dist/components/database/databaseGraph.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { type DatabaseProperty, type DatabaseView as DbView } from '@book.dev/sdk';
+import type { UseDatabase } from './useDatabase';
+/**
+ * Dependency graph view: rows as nodes in a left-to-right DAG, laid out by the
+ * pure {@link dependencyGraph} layering (every node sits to the right of all its
+ * predecessors). Edges are arrows predecessor → dependent; clicking a node opens
+ * the row. Best paired with a `dependency` property (the view's
+ * `dependencyPropertyId`).
+ */
+export declare const GraphView: React.FC<{
+    db: UseDatabase;
+    view: DbView;
+    properties: DatabaseProperty[];
+}>;
+export default GraphView;

package/dist/components/database/databaseLayouts.d.ts

@@ -0,0 +1,84 @@
+import React from 'react';
+import { type DatabaseProperty, type DatabaseRow, type DatabaseView as DbView, type RowGroup } from '@book.dev/sdk';
+import type { UseDatabase } from './useDatabase';
+/** The emoji to render beside a group's label, or `null` (non-page groups). */
+export declare const groupGlyph: (group: RowGroup, prop: DatabaseProperty | undefined, groupByParent: boolean) => string | null;
+/** A group's display label — the linked page's title for relation groups (whose
+ *  SDK label is the raw page id), otherwise the group's own label (parent-item
+ *  groups already carry the row name). */
+export declare const groupHeading: (group: RowGroup, prop: DatabaseProperty | undefined) => string;
+/**
+ * Whether a group reads as collapsed. Empty groups fold by default (the view's
+ * `collapseEmptyGroups`, on unless set false); the `collapsed` Set stores
+ * *deviations* from that default, so a user can still fold a populated group or
+ * unfold an empty one with the same toggle.
+ */
+export declare const groupCollapsed: (group: RowGroup, collapsed: Set<string>, collapseEmpty: boolean) => boolean;
+/** The collapsed-Set membership that makes every group display as `collapse`
+ *  (used by the board/table "Collapse all" / "Expand all" toggles). */
+export declare const setAllGroupsCollapsed: (groups: RowGroup[], collapse: boolean, collapseEmpty: boolean) => Set<string>;
+/**
+ * Register the titles + icons of relation group properties' target rows so the
+ * group headers resolve to page titles/icons (mirrors the relation cell). A no-op
+ * unless a passed property is a relation with a target database; safe to pass the
+ * primary and sub-group properties together.
+ */
+export declare function useRelationGroupTitles(...props: Array<DatabaseProperty | undefined>): void;
+/**
+ * Compact, read-only chips summarising a row's property values. Shared by the
+ * list, gallery, and board layouts so a row reads the same wherever it appears.
+ */
+export declare const RowChips: React.FC<{
+    row: DatabaseRow;
+    properties: DatabaseProperty[];
+    rows?: DatabaseRow[];
+    labelled?: boolean;
+}>;
+/** The card-edge tint for a row from a `select`/`status` colour property, or undefined. */
+export declare function cardAccent(row: DatabaseRow, colorProperty: DatabaseProperty | undefined): string | undefined;
+/**
+ * The row/card edge tint for a row under a view's conditional formatting: the
+ * first matching {@link ColorRule}'s colour, else the `cardColorPropertyId`
+ * select-option colour. The single source of row colouring across every layout.
+ */
+export declare function rowColor(row: DatabaseRow, view: DbView, properties: DatabaseProperty[], rows?: DatabaseRow[]): string | undefined;
+/**
+ * Right-click any card (board / gallery) for the same quick row actions as the
+ * table — open, insert below, duplicate, delete — without opening the row first.
+ */
+export declare const RowContextMenu: React.FC<{
+    db: UseDatabase;
+    rowId: string;
+    children: React.ReactNode;
+}>;
+/** Gallery: a responsive grid of cards, one per row, with optional cover images.
+ *  When the view names a `groupByPropertyId`, cards split into titled sections. */
+export declare const GalleryView: React.FC<{
+    db: UseDatabase;
+    view: DbView;
+    properties: DatabaseProperty[];
+}>;
+/**
+ * Board (kanban): columns from the view's group-by property. Cards drag between
+ * columns to change their group value (when grouping on a `select`). A per-column
+ * "+ New" creates a row already set to that column. When the view also names a
+ * `subGroupByPropertyId`, the board splits into horizontal **swimlanes** (one per
+ * sub-group value, spanning all columns — the Notion model); dropping a card into
+ * a (column, lane) cell sets both the column and the lane property in one
+ * transaction. Lanes are collapsible and their collapsed state persists.
+ */
+export declare const BoardView: React.FC<{
+    db: UseDatabase;
+    view: DbView;
+    properties: DatabaseProperty[];
+    /** The view's visible property set, shown as card chips (defaults to all). */
+    cardProperties?: DatabaseProperty[];
+}>;
+/** Calendar: rows laid out on a month grid by a date property. */
+export declare const CalendarView: React.FC<{
+    db: UseDatabase;
+    view: DbView;
+    properties: DatabaseProperty[];
+    /** Properties to show as chips under each tile's title (the date drives placement). */
+    cardProperties?: DatabaseProperty[];
+}>;

package/dist/components/database/databaseMap.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { type DatabaseProperty, type DatabaseView as DbView } from '@book.dev/sdk';
+import type { UseDatabase } from './useDatabase';
+/**
+ * Map view: rows with resolvable coordinates rendered as markers on Leaflet +
+ * OpenStreetMap raster tiles. Markers are coloured by the view's
+ * `groupByPropertyId` (shared with every other layout via {@link groupRowsBy} +
+ * {@link SWATCH_HEX}), with a legend below the map and clustering at low zoom for
+ * dense data. Clicking a marker opens the row (the same affordance other views
+ * use). Rows without coordinates collect into an "unplaced" affordance — which,
+ * when an address property is configured, can geocode them on demand (opt-in,
+ * cached — see `geocode.ts`) rather than silently dropping them.
+ */
+export declare const MapView: React.FC<{
+    db: UseDatabase;
+    view: DbView;
+    properties: DatabaseProperty[];
+    /** The view's visible property set, shown as chips in the unplaced list. */
+    cardProperties?: DatabaseProperty[];
+}>;
+export default MapView;

package/dist/components/database/databaseMapLeaflet.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import 'leaflet.markercluster';
+import 'leaflet/dist/leaflet.css';
+import 'leaflet.markercluster/dist/MarkerCluster.css';
+import type { DatabaseRow } from '@book.dev/sdk';
+/** A row resolved to a placed marker, pre-coloured by its group. */
+export interface PlacedMarker {
+    row: DatabaseRow;
+    lat: number;
+    lng: number;
+    /** The hex colour from the group-by swatch (or a neutral default). */
+    color: string;
+    /** Marker tooltip / aria label. */
+    label: string;
+}
+/**
+ * The Leaflet map itself: OpenStreetMap raster tiles + the marker layer. Lazily
+ * loaded by {@link MapView} so Leaflet's bundle + CSS only arrive with a real map
+ * view and never during SSR.
+ */
+declare const LeafletMap: React.FC<{
+    markers: PlacedMarker[];
+    clustered: boolean;
+    onOpen: (rowId: string) => void;
+}>;
+export default LeafletMap;

package/dist/components/database/databaseMenus.d.ts

@@ -0,0 +1,97 @@
+import React from 'react';
+import { type DatabaseProperty, type DatabaseView, type DatabaseViewType, type StoredDatabase, type SummaryType } from '@book.dev/sdk';
+import type { NewPropertyInput, UseDatabase } from './useDatabase';
+/** Per-view-type display metadata (icon + label), shared by the toolbar + menus. */
+export declare const VIEW_TYPES: {
+    value: DatabaseViewType;
+    label: string;
+    Icon: React.ComponentType<{
+        className?: string;
+    }>;
+}[];
+export declare const viewIcon: (type: DatabaseViewType) => React.ComponentType<{
+    className?: string;
+}>;
+export declare const AddPropertyMenu: React.FC<{
+    onAdd: (input: NewPropertyInput) => void;
+}>;
+/**
+ * Per-column header editor: rename, change type, edit select options / formula /
+ * number format, reorder, and delete the property. Opens from the `⋯` in a
+ * column header.
+ */
+export declare const PropertyMenu: React.FC<{
+    property: DatabaseProperty;
+    db: UseDatabase;
+    index: number;
+    count: number;
+}>;
+interface MenuProps {
+    database: StoredDatabase;
+    view: DatabaseView;
+    onChange: (patch: Partial<DatabaseView>) => void;
+}
+/** Filter editor: a nested and/or tree of conditions applied to the current view. */
+export declare const FilterMenu: React.FC<MenuProps>;
+/** Sort editor: ordered sort keys applied to the current view. */
+export declare const SortMenu: React.FC<MenuProps>;
+/**
+ * A table column-footer summary control: shows the computed value (`display`)
+ * and, on click, a menu to choose the calculation (count/sum/avg/…). Shows a
+ * subtle "Calculate" affordance on hover when no summary is set.
+ */
+export declare const SummaryPicker: React.FC<{
+    current: SummaryType;
+    display: string;
+    onChange: (t: SummaryType) => void;
+}>;
+/** Conditional-formatting editor: rules that tint each row/card edge. */
+export declare const ColorRulesEditor: React.FC<{
+    db: UseDatabase;
+    view: DatabaseView;
+}>;
+/**
+ * Dashboard metric cards above a database view: each is an aggregate (count, sum,
+ * average, …) over the view's *filtered* rows, so they update live as filters and
+ * data change. Rendered only when the view defines metrics; a trailing "+" adds
+ * another (defaulting to a row count — a sensible first metric).
+ */
+export declare const MetricsBar: React.FC<{
+    db: UseDatabase;
+    view: DatabaseView;
+}>;
+/** Add the first metric card to a view (a row count) — the dashboard entry point. */
+export declare function addFirstMetric(db: UseDatabase, view: DatabaseView): void;
+/**
+ * Active-filter chips: each top-level condition of the view's filter as a small
+ * removable pill, so the filters added from the toolbar or a cell's right-click
+ * menu are visible at a glance and one click to drop. Nested filter groups stay
+ * managed in the Filter menu (a single "advanced" pill stands in for them).
+ */
+export declare const FilterChips: React.FC<{
+    db: UseDatabase;
+    view: DatabaseView;
+}>;
+/**
+ * Active-sort chips: each sort key as a removable pill — click the label to flip
+ * its direction, the × to drop it. Mirrors {@link FilterChips} so the otherwise
+ * hidden sort state is visible and editable at a glance.
+ */
+export declare const SortChips: React.FC<{
+    db: UseDatabase;
+    view: DatabaseView;
+}>;
+/** The `+` next to the view tabs: add a new view of a chosen layout. */
+export declare const AddViewMenu: React.FC<{
+    onAdd: (type: DatabaseViewType) => void;
+}>;
+/**
+ * The active view's settings: rename, switch layout, configure layout-specific
+ * options (board/chart grouping, chart aggregation, calendar date, visible
+ * columns), duplicate, and delete.
+ */
+export declare const ViewOptionsMenu: React.FC<{
+    db: UseDatabase;
+    view: DatabaseView;
+}>;
+export {};

package/dist/components/database/databaseTimeline.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { type DatabaseProperty, type DatabaseView as DbView } from '@book.dev/sdk';
+import type { UseDatabase } from './useDatabase';
+/** The timeline's zoom level. Drives the day width and the header granularity. */
+export type TimelineScale = 'day' | 'week' | 'month' | 'quarter' | 'year';
+/**
+ * Timeline (Gantt) view: each dated row is a bar on a horizontal day axis, sized
+ * by its date span (a `dateRange` property, or a start + end property). Bars are
+ * drag-to-reschedule (drag the body to move, an edge to resize) and drag-to-link
+ * (the finish-edge handle onto another bar adds a dependency). The axis is
+ * zoomable (daily…yearly), today is marked and centred, and the canvas scrolls
+ * indefinitely either way. Clicking empty canvas places an item — a new row at
+ * that date, or the row armed from the "Unscheduled" tray.
+ *
+ * `TimelineView` resolves the date configuration and early-returns a hint when it
+ * can't lay anything out; the hook-bearing work lives in `TimelineCanvas`, which
+ * is only mounted once a start-date property exists (so its hooks run
+ * unconditionally).
+ */
+export declare const TimelineView: React.FC<{
+    db: UseDatabase;
+    view: DbView;
+    properties: DatabaseProperty[];
+    /** Properties to show as chips under each rail label (the dates drive placement). */
+    cardProperties?: DatabaseProperty[];
+}>;
+export default TimelineView;

package/dist/components/database/geocode.d.ts

@@ -0,0 +1,24 @@
+import type { LocationValue } from '@book.dev/sdk';
+/** A cached miss is recorded as `null` so we don't retry hopeless addresses. */
+type CacheEntry = {
+    lat: number;
+    lng: number;
+} | null;
+/** A cached coordinate for an address without touching the network, or `undefined`
+ *  when the address has never been looked up. A cached miss reads as `null`. */
+export declare function cachedGeocode(address: string): CacheEntry | undefined;
+/**
+ * Geocode one address to coordinates, consulting the cache first. Returns null
+ * for an unresolvable address (also cached, to avoid retry storms). Only called
+ * behind an explicit user action — never during a passive render.
+ */
+export declare function geocodeAddress(address: string): Promise<{
+    lat: number;
+    lng: number;
+} | null>;
+/** Build the {@link LocationValue} for a geocoded address (keeps the source string). */
+export declare function locationFromGeocode(address: string, coords: {
+    lat: number;
+    lng: number;
+}): LocationValue;
+export {};