@k2b/ui 0.21.0 → 0.23.0

package/dist/types/content/calendar-messages.d.ts

@@ -1,8 +1,27 @@
 /**
- * The month view's own strings. They live beside the calendar instead of in the shared catalog, so applications that
+ * The calendar's own strings. They live beside the calendar instead of in the shared catalog, so applications that
  * never render a calendar do not ship them.
  */
 declare const calendarMessages: import("@k2b/stdlib").Catalog<{
+    calendarView: string;
+    openDate: ({ label }: {
+        label: string;
+    }) => string;
+    createEventOn: ({ label }: {
+        label: string;
+    }) => string;
+    hiddenOverlappingEvents: ({ count }: {
+        count: number;
+    }) => string;
+    calendarEventTime: ({ title, start, end }: {
+        title: string;
+        start: string;
+        end: string;
+    }) => string;
+    weekShort: string;
+    noEvents: string;
+    moveEvent: string;
+    resizeEvent: string;
     calendarMoreEvents: ({ count }: {
         count: number;
     }) => string;
@@ -33,6 +52,105 @@ declare const calendarMessages: import("@k2b/stdlib").Catalog<{
         day: number;
         month?: string;
     }) => string;
+    calendarDuration: ({ minutes }: {
+        minutes: number;
+    }) => string;
+    calendarFree: ({ duration }: {
+        duration: string;
+    }) => string;
+    calendarCreateAt: ({ start, end }: {
+        start: string;
+        end: string;
+    }) => string;
+    calendarFreeAction: ({ duration, from, to, start, end, }: {
+        duration: string;
+        from: string;
+        to: string;
+        start: string;
+        end: string;
+    }) => string;
+    calendarRemaining: ({ duration }: {
+        duration: string;
+    }) => string;
+    calendarSoon: ({ title, duration }: {
+        title: string;
+        duration: string;
+    }) => string;
+    calendarNight: ({ from, to }: {
+        from: string;
+        to: string;
+    }) => string;
+    calendarNightHours: ({ from, to }: {
+        from: string;
+        to: string;
+    }) => string;
+    calendarFoldNight: string;
+    calendarOpenNight: string;
+    calendarFoldNights: string;
+    calendarOpenNights: ({ from, to }: {
+        from: string;
+        to: string;
+    }) => string;
+    calendarUntil: ({ time }: {
+        time: string;
+    }) => string;
+    calendarNothingPlannedShort: string;
+    calendarUnfoldDays: ({ count }: {
+        count: number;
+    }) => string;
+    calendarDayCount: ({ count }: {
+        count: number;
+    }) => string;
+    calendarDaySummary: ({ events, tasks }: {
+        events: number;
+        tasks: number;
+    }) => string;
+    calendarMoreDays: string;
+    calendarAllDayRow: string;
+    calendarAllDayRowShort: string;
+    calendarAllDayAndDue: string;
+    calendarDone: ({ title }: {
+        title: string;
+    }) => string;
+    calendarAllDone: string;
+    calendarAllDoneShort: string;
+    calendarDue: ({ time }: {
+        time: string;
+    }) => string;
+    calendarFits: string;
+    calendarTooShort: ({ duration }: {
+        duration: string;
+    }) => string;
+    calendarOverlaps: ({ title }: {
+        title: string;
+    }) => string;
+    calendarWeekNumber: ({ week }: {
+        week: number;
+    }) => string;
+    calendarWeek: string;
+    calendarDays: string;
+    calendarKeyboardHelp: string;
+    calendarDayKeyboardHelp: string;
+    calendarShortcuts: string;
+    calendarShortcutsNote: string;
+    calendarCommandToday: string;
+    calendarCommandTodayDescription: string;
+    calendarCommandNext: string;
+    calendarCommandNextDescription: string;
+    calendarCommandPrevious: string;
+    calendarCommandPreviousDescription: string;
+    calendarCommandView: ({ view }: {
+        view: string;
+    }) => string;
+    calendarCommandViewDescription: ({ view }: {
+        view: string;
+    }) => string;
+    calendarCommandGoTo: string;
+    calendarCommandGoToDescription: string;
+    calendarGoToPlaceholder: string;
+    calendarGoToHint: string;
+    calendarGoToUnknown: string;
+    calendarGoToGo: string;
 }>;
 export type CalendarMessages = ReturnType<(typeof calendarMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale, like the rest of @k2b/ui. */

package/dist/types/content/calendar-pointer.d.ts

@@ -10,8 +10,17 @@ type CalendarPointerSessionOptions<T> = {
     onPreview: (value: T) => void;
     onCommit: (value: T) => void;
     onCancel?: () => void;
+    /** Called once whenever the session ends, even before activation, after onCommit or onCancel. */
+    onEnd?: () => void;
     scrollContainer?: HTMLElement;
     threshold?: number;
+    /**
+     * The edges scroll only once the pointer has been well inside the container, and only while it is over it, so a drag
+     * that comes in from outside, such as from a list below, does not scroll on its way in.
+     */
+    armAutoScroll?: boolean;
+    /** Called on every move once the gesture is active, such as to move a token with the pointer. */
+    onMove?: (clientX: number, clientY: number) => void;
 };
 /**
  * Owns one pointer gesture from threshold crossing through commit or cancel.

package/dist/types/content/calendar-shared.d.ts

@@ -0,0 +1,69 @@
+import { type DateContext } from "@k2b/stdlib";
+import type { JSX } from "solid-js";
+import type { CalendarEvent, CalendarProps } from "./Calendar";
+/** One piece of an event in one day, with the times of the whole event. */
+export type NormalizedEvent = CalendarEvent & {
+    startDate: Date;
+    endDate: Date;
+    dayKey: string;
+    sourceStartDate: Date;
+    sourceEndDate: Date;
+};
+/** A keyboard stop of the week grid. */
+export type CalendarStop = {
+    id: string;
+    column: number;
+    minute: number;
+};
+/** What the built-in views read from the props: they only ever link to built-in views. */
+export type CalendarOwner = Omit<CalendarProps, "view" | "customViews" | "children">;
+export declare const ownerDateConfig: (owner: CalendarOwner) => DateContext;
+export declare const parseDate: (value: Date | string, context?: DateContext) => Date;
+export declare const validDate: (value: Date) => boolean;
+export declare const formatTime: (date: Date, context?: DateContext) => string;
+export declare const eventHref: (props: CalendarOwner, event: CalendarEvent) => string | undefined;
+/** Places a calendar popover below its anchor when there is room and above it otherwise, inside the viewport. */
+export declare const placeCalendarPopover: (anchor: Element | DOMRect, popover: HTMLElement) => void;
+/** Follows a calendar link the way the calendar's own links do: through the host's navigation when it has one. */
+export declare const followCalendarHref: (owner: CalendarOwner, href: string) => void;
+export declare const EventChip: (props: {
+    event: NormalizedEvent;
+    owner: CalendarOwner;
+    href?: string;
+    compact?: boolean;
+    fill?: boolean;
+    moving?: boolean;
+    /** Replaces the title and time at the start of the accessible name, for example with the dates a long event spans. */
+    label?: string;
+    /** A bar of a long event that goes on before or after the week row it sits in. */
+    continuesBefore?: boolean;
+    continuesAfter?: boolean;
+    /** Month view: an all-day or multi-day entry drawn as a bar. */
+    bar?: boolean;
+    /** Short dates at the torn ends of a bar, where it continues in another week row. */
+    hintStart?: string;
+    hintEnd?: string;
+    /** Month view: the start time before the title. */
+    leadingTime?: string;
+    /** Day and week views: what is left of a running event, such as "27 min left". */
+    remaining?: string;
+    /** Day and week views: the calendar draws the event's checkbox beside the chip. */
+    checkbox?: boolean;
+    /** Day and week views with `dayHours`: the chip is a band, a deadline, or an all-day entry of a timeline. */
+    timeline?: boolean;
+    /** Text after the content, such as the time of a deadline. */
+    trailing?: JSX.Element;
+    /** Day and week views: the time as they write it, such as "10:30–11:15", shown whatever the length. */
+    timeLabel?: string;
+    /** Day view: a band tall enough shows its place below the time. */
+    showLocation?: boolean;
+    /** Week view: the grid's one tab stop decides which chip takes Tab. */
+    tabIndex?: number;
+    /** A keyboard stop of the week grid: its id, its day column, and its minute for moving between columns. */
+    stop?: CalendarStop;
+    /** Day and week views: Space on the chip checks the box the calendar draws beside it, as on the box itself. */
+    onCheck?: () => void;
+    onMovePointerDown?: (event: PointerEvent, onActivate: () => void) => void;
+}) => JSX.Element;
+/** The width of a text in a font, from a canvas, so a bar can tell whether its title leaves room for a date hint. */
+export declare const textWidth: (text: string, font: string) => number;

package/dist/types/content/calendar-time-view.d.ts

@@ -0,0 +1,252 @@
+import { type DateContext } from "@k2b/stdlib";
+import type { CalendarController, CalendarEvent, CalendarEventTimeChange, CalendarExternalDrag, CalendarLabels } from "./Calendar";
+import { type CalendarDayHours, type DayGap, type DayGeometry, type DayLane, type DayModel, type DaySpan } from "./calendar-days";
+import { type CalendarOwner, type CalendarStop, type NormalizedEvent } from "./calendar-shared";
+/**
+ * Shared state and parts of the day and week views with `dayHours`: the time model of the loaded days, the selection,
+ * the quick create, pointer gestures, and the pieces both views draw into a day's timeline.
+ */
+export type TodayDirection = "left" | "right" | "up" | "down" | "";
+/** What the header and the calendar's controller ask of the active day or week view. */
+export type TimeViewHandle = {
+    /** The first and last day the reader sees. */
+    visibleKeys: () => {
+        first: string;
+        last: string;
+    };
+    /** Moves by a day (day view) or a week (week view) when that is loaded; `false` leaves it to the header's link. */
+    step: (direction: -1 | 1) => boolean;
+    /** Shows a day when it is loaded; `false` leaves it to navigation. */
+    goTo: (key: string) => boolean;
+    /** Shows today and now when they are loaded. */
+    today: () => boolean;
+    todayDirection: () => TodayDirection;
+    controller: CalendarController;
+};
+export type TimeViewProps = {
+    owner: CalendarOwner;
+    view: "day" | "week";
+    date: Date;
+    now: Date;
+    events: readonly CalendarEvent[];
+    labels: Required<CalendarLabels>;
+    hours: CalendarDayHours;
+    register: (handle: TimeViewHandle | null) => void;
+};
+export type TimeSelection = {
+    key: string;
+    start?: number;
+    end?: number;
+};
+type Ghost = {
+    key: string;
+    start: number;
+    end: number;
+    title: string;
+    time: string;
+    colorHex?: string;
+    color?: string;
+    warn?: boolean;
+    fit?: {
+        fits: boolean;
+        text: string;
+    };
+};
+type QuickCreate = {
+    range: CalendarEventTimeChange;
+    anchor: Element | DOMRect;
+    create?: string;
+    key: string;
+    start?: number;
+    end?: number;
+};
+export type BodyHit = {
+    key: string;
+    element: HTMLElement;
+    geometry: DayGeometry;
+    minute: number;
+};
+export declare const eventAccent: (event: Pick<CalendarEvent, "color" | "colorHex">) => string;
+export declare const reducedMotion: () => boolean;
+/** Swallows the click a browser sends right after a gesture ends, never the next one. */
+export declare const swallowNextClick: () => void;
+export declare const createTimeView: (props: TimeViewProps) => {
+    props: TimeViewProps;
+    messages: () => import("./calendar-messages").CalendarMessages;
+    dateConfig: import("solid-js").Accessor<DateContext>;
+    hours: () => CalendarDayHours;
+    wake: import("solid-js").Accessor<number>;
+    range: import("solid-js").Accessor<{
+        first: string;
+        last: string;
+    }>;
+    anchorKey: import("solid-js").Accessor<string>;
+    days: import("solid-js").Accessor<Map<string, DayModel<CalendarEvent>>>;
+    dayOf: (key: string) => DayModel<CalendarEvent>;
+    keyOf: (date: Date) => string;
+    parseKey: (key: string) => Date;
+    nowKey: import("solid-js").Accessor<string>;
+    nowMinute: import("solid-js").Accessor<number>;
+    nowIn: (key: string) => number;
+    calendarToday: import("solid-js").Accessor<string>;
+    clock: (minute: number) => string;
+    duration: (minutes: number) => string;
+    instant: (key: string, minute: number) => Date;
+    normalized: (event: CalendarEvent, key: string) => NormalizedEvent;
+    checkedOf: (event: CalendarEvent) => boolean | undefined;
+    toggleCheck: (event: CalendarEvent) => void;
+    checkOf: (event: CalendarEvent) => (() => void) | undefined;
+    justChecked: import("solid-js").Accessor<ReadonlySet<string>>;
+    cheered: import("solid-js").Accessor<string | null>;
+    selection: import("solid-js").Accessor<TimeSelection | null>;
+    setSelection: import("solid-js").Setter<TimeSelection | null>;
+    touchDraft: import("solid-js").Accessor<{
+        key: string;
+        start: number;
+        end: number;
+    } | null>;
+    setTouchDraft: import("solid-js").Setter<{
+        key: string;
+        start: number;
+        end: number;
+    } | null>;
+    activeKey: import("solid-js").Accessor<string | null>;
+    setActiveKey: import("solid-js").Setter<string | null>;
+    ghost: import("solid-js").Accessor<Ghost | null>;
+    gapHit: import("solid-js").Accessor<{
+        key: string;
+        start: number;
+        fits: boolean;
+        text: string;
+    } | null>;
+    movingId: import("solid-js").Accessor<string>;
+    dragging: import("solid-js").Accessor<"" | "draw" | "end" | "external" | "move" | "start">;
+    nightOpen: (key: string, model: DayModel<CalendarEvent>) => boolean;
+    setNight: (key: string, open: boolean) => {
+        [x: string]: boolean;
+    };
+    quick: import("solid-js").Accessor<QuickCreate | null>;
+    setQuick: import("solid-js").Setter<QuickCreate | null>;
+    openQuickCreate: (key: string, start: number | undefined, end: number | undefined, anchor: Element | DOMRect, create?: string) => void;
+    canCreate: () => boolean;
+    createTarget: (visible: {
+        first: string;
+        last: string;
+    }) => {
+        key: string;
+        start: number;
+        end: number;
+    };
+    rangeOfSelection: (value: TimeSelection) => CalendarEventTimeChange;
+    registerBody: (key: string, element: HTMLElement, expanded: () => boolean) => void;
+    bodyAt: (clientX: number, clientY: number) => BodyHit | null;
+    limitOf: (key: string) => number;
+    startMove: (pointerEvent: PointerEvent, event: CalendarEvent, key: string, start: number, end: number, scroller?: HTMLElement) => void;
+    startResize: (pointerEvent: PointerEvent, event: CalendarEvent, key: string, start: number, end: number, edge: "start" | "end", scroller?: HTMLElement) => void;
+    startDraw: (pointerEvent: PointerEvent, key: string, scroller?: HTMLElement) => void;
+    dragIn: (pointerEvent: PointerEvent, item: CalendarExternalDrag, onDrop: (slot: CalendarEventTimeChange) => void, scroller?: HTMLElement) => void;
+    dayStartMinute: (hour: number) => number;
+};
+export type TimeView = ReturnType<typeof createTimeView>;
+/**
+ * German short dates read "Fr 9. Okt", without the dots of the abbreviations; with `comma`, a title such as
+ * "Fr, 9. Okt 2026" keeps the comma after the day.
+ */
+export declare const compactGermanDate: (text: string, locale: string | undefined, comma?: boolean) => string;
+/** A short day such as "Fri 9" or "Fr 9.", in the calendar's locale. */
+export declare const shortDay: (view: TimeView, key: string, withMonth?: boolean) => string;
+/** A long day such as "Friday, October 9", with the year when it is not this year's. */
+export declare const longDay: (view: TimeView, key: string) => string;
+/** A to-do's checkbox: it draws its check, and the title beside it strikes through. */
+export declare const TimeCheck: (props: {
+    view: TimeView;
+    event: CalendarEvent;
+    tabIndex?: number;
+}) => import("solid-js").JSX.Element;
+/** A timed entry in a day's timeline: a band as long as the entry, side by side with overlapping ones. */
+export declare const TimeBand: (props: {
+    view: TimeView;
+    band: DayLane<CalendarEvent>;
+    dayKey: string;
+    expanded: boolean;
+    compact?: boolean;
+    /** Day view: a tall band shows its place. */
+    showLocation?: boolean;
+    /** The height of an hour on a wide screen, for the band's size class and title lines. */
+    hourPx: number;
+    tabIndex?: number;
+    stop?: CalendarStop;
+    scroller?: () => HTMLElement | undefined;
+}) => import("solid-js").JSX.Element;
+/** A point in time such as a deadline: a dashed line across the day and a pill with its checkbox and title. */
+export declare const TimeMarker: (props: {
+    view: TimeView;
+    event: CalendarEvent;
+    minute: number;
+    dayKey: string;
+    expanded: boolean;
+    above: boolean;
+    /** The pill's place among deadlines whose pills would cover each other, from the left. */
+    lane: number;
+    lanes: number;
+    showTime: boolean;
+    tabIndex?: number;
+    stop?: CalendarStop;
+    scroller?: () => HTMLElement | undefined;
+}) => import("solid-js").JSX.Element;
+/** Free time between entries, labelled from an hour on; activating it creates there. */
+export declare const TimeGap: (props: {
+    view: TimeView;
+    gap: DayGap;
+    dayKey: string;
+    expanded: boolean;
+    /** A deadline pill near the middle moves the label aside. */
+    aside: boolean;
+    tabIndex?: number;
+    stop?: CalendarStop;
+}) => import("solid-js").JSX.Element;
+/** The preview of a drag, a draw, or an entry dragged in, and the selected slot. */
+export declare const TimeOverlays: (props: {
+    view: TimeView;
+    dayKey: string;
+    expanded: boolean;
+}) => import("solid-js").JSX.Element;
+/** Free time of a day with the gap of now trimmed, as both views draw it. */
+export declare const dayGaps: (view: TimeView, key: string) => DayGap[];
+/** The bands of a day with their lanes, cut to what its timeline draws. */
+export declare const dayBands: (view: TimeView, key: string, expanded: boolean) => DayLane<CalendarEvent>[];
+/** Entries the folded night hides, as chips with their time. */
+export declare const foldedEntries: (view: TimeView, key: string) => {
+    event: CalendarEvent;
+    time: string;
+}[];
+/** The quick create at a slot or gap, as in the month view. */
+export declare const TimeQuickCreate: (props: {
+    view: TimeView;
+}) => import("solid-js").JSX.Element;
+/** All-day entries of a day as chips: bars with torn ends where they go on, and points due that day. */
+export declare const AllDayChips: (props: {
+    view: TimeView;
+    dayKey: string;
+    spans: readonly DaySpan<CalendarEvent>[];
+}) => import("solid-js").JSX.Element;
+/** Hour labels and lines of a day's timeline with the night open, and the date at midnight. */
+export declare const nightHours: (wake: number) => number[];
+export declare const isNearNow: (view: TimeView, key: string, minute: number) => boolean;
+/** Whether a marker sits right above a band's start, so its pill goes above the line. */
+export declare const markerAbove: (model: DayModel<CalendarEvent>, minute: number) => boolean;
+/** Whether a deadline pill sits near the middle of a gap, so the gap's label moves aside. */
+export declare const gapAside: (model: DayModel<CalendarEvent>, gap: DayGap) => boolean;
+/** A day's counts for its header: events and all-day entries, to-dos and deadlines. */
+export declare const daySummary: (view: TimeView, key: string) => string;
+/** What starts within the next hour today, such as "Planning in 12 min". */
+export declare const soonNote: (view: TimeView, key: string) => string;
+/** The busy minutes of a day's waking hours, merged, with the color of the first entry, for the thin load line. */
+export declare const dayLoad: (view: TimeView, key: string) => {
+    start: number;
+    end: number;
+    color: string;
+}[];
+/** Day keys of the week that holds a day, from its first day. */
+export declare const weekKeysOf: (view: TimeView, key: string) => string[];
+export {};

package/dist/types/content/chart-messages.d.ts

@@ -0,0 +1,37 @@
+declare const chartMessages: import("@k2b/stdlib").Catalog<{
+    chartView: string;
+    chartDiagram: string;
+    chartData: string;
+    chartSeries: string;
+    chartOnly: string;
+    chartShowAll: string;
+    chartShowing: string;
+    chartSelectedDatum: string;
+    chartReference: string;
+    chartCurrent: string;
+    chartPinReference: string;
+    chartRemoveComparison: string;
+    chartPreviousData: string;
+    chartCopyData: string;
+    chartCopyFailed: string;
+    chartLegend: string;
+    chartRowsShown: ({ shown, total }: {
+        shown: string;
+        total: string;
+    }) => string;
+    interactiveLineChart: string;
+    interactiveChart: string;
+    chartFields: ({ key }: {
+        key: string;
+    }) => string;
+    interactiveMap: string;
+    interactiveTimeline: string;
+    series: string;
+    resetMapView: string;
+    resetTimelineView: string;
+}>;
+export type ChartMessages = ReturnType<(typeof chartMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useChartMessages: () => (() => ChartMessages);
+export declare const checkChartMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/data-table-messages.d.ts

@@ -0,0 +1,10 @@
+declare const dataTableMessages: import("@k2b/stdlib").Catalog<{
+    dataTable: string;
+    noColumns: string;
+    noRecords: string;
+}>;
+export type DataTableMessages = ReturnType<(typeof dataTableMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useDataTableMessages: () => (() => DataTableMessages);
+export declare const checkDataTableMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/docs-messages.d.ts

@@ -0,0 +1,10 @@
+declare const docsMessages: import("@k2b/stdlib").Catalog<{
+    codeLabel: ({ title }: {
+        title: string;
+    }) => string;
+}>;
+export type DocsMessages = ReturnType<(typeof docsMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useDocsMessages: () => (() => DocsMessages);
+export declare const checkDocsMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/feed-messages.d.ts

@@ -0,0 +1,15 @@
+declare const feedMessages: import("@k2b/stdlib").Catalog<{
+    feedJumpToLatest: string;
+    feedJumpToLatestCount: ({ count }: {
+        count: number;
+    }) => string;
+    feedNewItems: ({ count }: {
+        count: number;
+    }) => string;
+    feedNewMarker: string;
+}>;
+export type FeedMessages = ReturnType<(typeof feedMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useFeedMessages: () => (() => FeedMessages);
+export declare const checkFeedMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/file-browser-messages.d.ts

@@ -0,0 +1,33 @@
+declare const fileBrowserMessages: import("@k2b/stdlib").Catalog<{
+    downloadAsZip: string;
+    rename: string;
+    addFileFolderUpload: string;
+    files: string;
+    chooseFileToPreview: string;
+    discardChanges: string;
+    discardUnsavedFile: string;
+    downloadFailed: string;
+    folderEmpty: string;
+    folderSelected: string;
+    newFile: string;
+    newFileName: string;
+    newFolder: string;
+    newFolderName: string;
+    fileActions: string;
+    actionsFor: ({ name }: {
+        name: string;
+    }) => string;
+    pickFileFromTree: string;
+    selectFile: string;
+    spaceEmpty: string;
+    uploadFiles: string;
+    loadingFiles: string;
+    noFiles: string;
+}>;
+export type FileBrowserMessages = ReturnType<(typeof fileBrowserMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useFileBrowserMessages: () => (() => FileBrowserMessages);
+/** Imperative UI inherits the document locale when no locale is supplied. */
+export declare const resolveFileBrowserMessages: (locale?: string) => FileBrowserMessages;
+export declare const checkFileBrowserMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/file-view-messages.d.ts

@@ -0,0 +1,30 @@
+declare const fileViewMessages: import("@k2b/stdlib").Catalog<{
+    column: ({ number }: {
+        number: number;
+    }) => string;
+    fileSaved: string;
+    noPreview: string;
+    binaryFile: string;
+    csvSettings: string;
+    csvEncoding: string;
+    csvSeparator: string;
+    csvDefaultSeparator: string;
+    csvComma: string;
+    csvSemicolon: string;
+    csvTab: string;
+    csvView: string;
+    csvRaw: string;
+    delimitedFileEmpty: string;
+    emptyFile: string;
+    failedLoadFile: string;
+    noInlinePreview: string;
+    previewMoreLines: (n: number) => string;
+    previewColumnsLimited: string;
+    textEditor: string;
+    audioUnsupported: string;
+}>;
+export type FileViewMessages = ReturnType<(typeof fileViewMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useFileViewMessages: () => (() => FileViewMessages);
+export declare const checkFileViewMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/index.d.ts

@@ -1,8 +1,8 @@
-export type { CalendarAttendee, CalendarCustomView, CalendarDayBadge, CalendarEvent, CalendarEventColor, CalendarEventRenderContext, CalendarEventTimeChange, CalendarLabels, CalendarProps, CalendarQuickCreateControls, CalendarRecurrence, CalendarResource, CalendarSelectionControls, CalendarView, } from "./Calendar";
+export type { CalendarAttendee, CalendarCommand, CalendarController, CalendarCustomView, CalendarDayBadge, CalendarEvent, CalendarEventColor, CalendarEventRenderContext, CalendarEventTimeChange, CalendarExternalDrag, CalendarLabels, CalendarProps, CalendarQuickCreateControls, CalendarRange, CalendarRecurrence, CalendarResource, CalendarSelectionControls, CalendarView, } from "./Calendar";
 export { default as Calendar } from "./Calendar";
 export type { ChartKind, ChartLabels, ChartProps, ChartRenderOptions } from "./Chart";
 export { default as Chart } from "./Chart";
-export type { ChartExplorerColumn, ChartExplorerProps } from "./ChartExplorer";
+export type { ChartExplorerColumn, ChartExplorerProps, ChartLegendEntry } from "./ChartExplorer";
 export { ChartExplorer } from "./ChartExplorer";
 export type { ChartExplorerControlsProps } from "./ChartExplorerControls";
 export { ChartExplorerControls } from "./ChartExplorerControls";

package/dist/types/content/lightbox-messages.d.ts

@@ -0,0 +1,16 @@
+declare const lightboxMessages: import("@k2b/stdlib").Catalog<{
+    closeLightbox: string;
+    downloadImage: string;
+    imageLightbox: string;
+    imageNavigation: string;
+    nextImage: string;
+    previousImage: string;
+    goToImage: ({ index }: {
+        index: number;
+    }) => string;
+}>;
+export type LightboxMessages = ReturnType<(typeof lightboxMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useLightboxMessages: () => (() => LightboxMessages);
+export declare const checkLightboxMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/log-entries-messages.d.ts

@@ -0,0 +1,8 @@
+declare const logEntriesMessages: import("@k2b/stdlib").Catalog<{
+    noLogEntries: string;
+}>;
+export type LogEntriesMessages = ReturnType<(typeof logEntriesMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useLogEntriesMessages: () => (() => LogEntriesMessages);
+export declare const checkLogEntriesMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/markdown-info-block-messages.d.ts

@@ -0,0 +1,12 @@
+declare const markdownInfoBlockMessages: import("@k2b/stdlib").Catalog<{
+    infoBlockNote: string;
+    infoBlockInfo: string;
+    infoBlockSuccess: string;
+    infoBlockWarning: string;
+    infoBlockDanger: string;
+}>;
+export type MarkdownInfoBlockMessages = ReturnType<(typeof markdownInfoBlockMessages)["resolve"]>["t"];
+/** Imperative UI inherits the document locale when no locale is supplied. */
+export declare const resolveMarkdownInfoBlockMessages: (locale?: string) => MarkdownInfoBlockMessages;
+export declare const checkMarkdownInfoBlockMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};