@nxgt/material 3.56.0 → 3.58.0

package/dist/lib/components/ui/widgets/editor/extensions/custom/action-card/action-card-tile.d.ts

@@ -0,0 +1,10 @@
+import { ActionCardItemAttrs, ActionCardVariant } from './const.js';
+export type ActionCardTileProps = {
+    item: ActionCardItemAttrs;
+    variant: ActionCardVariant;
+    isEditable: boolean;
+    onUpdate: (attrs: Partial<ActionCardItemAttrs>) => void;
+    onRemove: () => void;
+};
+/** One card of the block: a link when read-only, with Edit and Remove when editable. */
+export declare function ActionCardTile({ item, variant, isEditable, onUpdate, onRemove, }: ActionCardTileProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/editor/extensions/custom/select-card/select-card-tile.d.ts

@@ -0,0 +1,11 @@
+import { SelectCardOptionAttrs } from './const.js';
+export type SelectCardTileProps = {
+    option: SelectCardOptionAttrs;
+    active: boolean;
+    isEditable: boolean;
+    onToggle: () => void;
+    onUpdate: (attrs: Partial<SelectCardOptionAttrs>) => void;
+    onRemove: () => void;
+};
+/** One option of the selector: a card that toggles, with Edit and Remove when editable. */
+export declare function SelectCardTile({ option, active, isEditable, onToggle, onUpdate, onRemove, }: SelectCardTileProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/editor/extensions/custom/select-card/toggle-selection.d.ts

@@ -0,0 +1,3 @@
+import { SelectCardMode } from './const.js';
+/** The selected values after a click on `target`: it joins or leaves; a single selector holds one at most. */
+export declare function toggleSelection(mode: SelectCardMode, value: string[], target: string): string[];

package/dist/lib/components/ui/widgets/editor/extensions/custom/shared/use-node-list.d.ts

@@ -0,0 +1,11 @@
+import { ReactNodeViewProps } from '@tiptap/react';
+/**
+ * The list a block keeps in one node attribute (items, options…), with the
+ * three edits every block offers: change one, remove one, add one.
+ */
+export declare function useNodeList<T>(props: ReactNodeViewProps<HTMLDivElement>, attribute: string, makeItem: (count: number) => T): {
+    items: T[];
+    update: (index: number, attrs: Partial<T>) => void;
+    remove: (index: number) => void;
+    add: () => void;
+};

package/dist/lib/components/ui/widgets/editor/extensions/emoji/use-emoji-groups.d.ts

@@ -0,0 +1,13 @@
+import { EmojiItem } from '@tiptap/extension-emoji';
+/**
+ * The picker's tabs (all, recent, general, then one per group) and the
+ * handler that inserts an emoji and moves it to the front of the recents.
+ */
+export declare function useEmojiGroups(emojis: EmojiItem[], onSelect: (value: string) => void): {
+    groups: {
+        all: EmojiItem[];
+        recent: EmojiItem[];
+        general: EmojiItem[];
+    };
+    handleEmojiUpdate: (emojiName: string) => () => void;
+};

package/dist/lib/components/ui/widgets/editor/presets/compact-editor-parts.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { EditorLook } from '../core/editor-look.js';
+/** The small toolbar above the text, docked to the card. */
+export declare function CompactEditorHead({ look }: {
+    look: EditorLook;
+}): import("react").JSX.Element;
+/** The strip under the text: the character counter and your `actions`. */
+export declare function CompactEditorFooter({ actions }: {
+    actions: ReactNode;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/editor/presets/document-editor-frame-parts.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { EditorLook } from '../core/editor-look.js';
+/** The side rail: a sticky column that stays below the sticky header. */
+export declare function Rail({ side, children, }: {
+    side: 'start' | 'end';
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The frame's surface: a bordered card, a column when it holds a floating bar. */
+export declare function frameClass(look: EditorLook, hasBar: boolean, className?: string): string;
+/** The sticky header: who else is editing, the toolbar, the panels. */
+export declare function FrameHeader({ presence, panels, children, }: {
+    presence?: ReactNode;
+    panels?: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The comment threads, in a margin rail beside the text. */
+export declare function FrameComments({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/editor/presets/document-editor-layout.d.ts

@@ -0,0 +1,5 @@
+import { documentEditorSlots } from './document-editor-slots.js';
+type Slots = Parameters<typeof documentEditorSlots>[0];
+/** The text in its surface: the docked frame or the page, with the slots the props call for. */
+export declare function DocumentEditorLayout(props: Slots): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/editor/presets/document-editor-overlays.d.ts

@@ -0,0 +1,6 @@
+import { DocumentEditorProps } from './document-editor-types.js';
+/** What floats over the document: the upload signal, menus, panels, comment sync. */
+export declare function DocumentEditorOverlays({ onUpload, onUploadingChange, withComments, commentsAdapter, }: Pick<DocumentEditorProps, 'onUpload' | 'onUploadingChange'> & {
+    withComments: boolean;
+    commentsAdapter?: NonNullable<DocumentEditorProps['comments']>['adapter'];
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/editor/presets/document-editor-page-parts.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+import { PageMode } from '../partials/page-mode-switch.js';
+import { ViewerComponents } from '../viewer/types.js';
+/** The sticky header: the Write / Preview / Markdown switch, the toolbar, the panels. */
+export declare function PageHeader({ mode, onModeChange, showSwitch, presence, panels, children, }: {
+    mode: PageMode;
+    onModeChange: (mode: PageMode) => void;
+    showSwitch: boolean;
+    presence?: ReactNode;
+    panels?: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The sheet: the editor while writing, else the chosen view of its content. */
+export declare function PageSheet({ expressive, handleGutter, mode, previewComponents, children, }: {
+    expressive: boolean;
+    handleGutter: boolean;
+    mode: PageMode;
+    previewComponents?: ViewerComponents;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Under the sheet; after the floating bar when there is one. */
+export declare function PageFooter({ floating, children, }: {
+    floating: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/editor/presets/rich-chat-composer/composer-class.d.ts

@@ -0,0 +1,8 @@
+import { EditorLook } from '../../core/editor-look.js';
+/** The composer card: a pill when collapsed, else rounded by look. */
+export declare function composerClass({ pill, look, editable, className, }: {
+    pill: boolean;
+    look: EditorLook;
+    editable: boolean;
+    className?: string;
+}): string;

package/dist/lib/components/ui/widgets/editor/presets/rich-chat-composer/partials/composer-toolbar.d.ts

@@ -0,0 +1,6 @@
+import { EditorLook } from '../../../core/editor-look.js';
+/** The small formatting toolbar the format toggle reveals above the tools. */
+export declare function ComposerToolbar({ id, look, }: {
+    id: string;
+    look: EditorLook;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/editor/presets/rich-chat-composer/partials/format-buttons.d.ts

@@ -0,0 +1,8 @@
+/** The format toggle that shows the small toolbar, and `@` when there are people to mention. */
+export declare function FormatButtons({ formatOpen, toolbarId, onFormatToggle, mentionable, }: {
+    formatOpen: boolean;
+    /** The id of the toolbar the format toggle reveals. */
+    toolbarId: string;
+    onFormatToggle: () => void;
+    mentionable: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/editor/presets/use-document-features.d.ts

@@ -0,0 +1,15 @@
+import { DocumentEditorProps } from './document-editor-types.js';
+type Input = Pick<DocumentEditorProps, 'features' | 'mentions' | 'outline' | 'onUpload' | 'uploadOptions' | 'onAssist' | 'assistOptions' | 'comments' | 'collaboration'>;
+/**
+ * The document editor's feature set: the document kit, then yours, the
+ * outline, and the upload, assistant, comments and collaboration features
+ * the props turn on.
+ */
+export declare function useDocumentFeatures({ features, mentions, outline, onUpload, uploadOptions, onAssist, assistOptions, comments, collaboration, }: Input): {
+    defaults: import('../index.js').EditorFeature[];
+    commentsFeature: (import('../index.js').EditorFeature & {
+        key: string;
+    }) | undefined;
+    editorFeatures: import('../index.js').FeatureInput;
+};
+export {};

package/dist/lib/components/ui/widgets/education/questions/partials/question-body.d.ts

@@ -0,0 +1,5 @@
+import { QuestionProps } from '../types.js';
+/** The answer control for the question's kind. */
+export declare function QuestionBody(props: QuestionProps & {
+    labelledBy: string;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/education/questions/partials/question-content.d.ts

@@ -0,0 +1,3 @@
+import { QuestionProps } from '../types.js';
+/** A question's fieldset: prompt, header, media, hint, the answer body and the feedback. */
+export declare function QuestionContent({ question, value, onValueChange, revealed: revealedProp, verdict, points, feedback, disabled, variant, density, showShortcuts, number, showFeedback, }: QuestionProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/education/questions/partials/question-extras.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+/** The hint box a question opens on demand. */
+export declare function QuestionHint({ id, children, }: {
+    id: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The explanation shown once revealed when the feedback block is off. */
+export declare function QuestionExplanation({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/education/questions/partials/question-outcome.d.ts

@@ -0,0 +1,7 @@
+import { QuestionProps } from '../types.js';
+type Props = Pick<QuestionProps, 'question' | 'value' | 'verdict' | 'points' | 'feedback' | 'showFeedback'> & {
+    revealed: boolean;
+};
+/** What follows a revealed answer: the server's verdict, or the local feedback, or just the explanation when feedback is off. */
+export declare function QuestionOutcome({ question, value, verdict, points, feedback, revealed, showFeedback, }: Props): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/education/questions/question-options.keyboard.d.ts

@@ -0,0 +1,17 @@
+import { KeyboardEvent } from 'react';
+import { QuestionProps } from './types.js';
+/**
+ * Arrow keys move the focus between the option tiles (wrapping); on a
+ * single-choice question that is not revealed, the focused tile is picked.
+ */
+export declare function moveOptionFocus(event: KeyboardEvent<HTMLDivElement>, { multiple, revealed, onToggle, }: {
+    multiple: boolean;
+    revealed: boolean;
+    onToggle: (id: string) => void;
+}): void;
+/** The tiles' grid: four columns of pictures, a side-by-side pair, or one or two columns. */
+export declare function optionsGridClass({ pictures, pair, density, }: {
+    pictures: boolean;
+    pair: boolean;
+    density: QuestionProps['density'];
+}): string;

package/dist/lib/components/ui/widgets/education/questions/question.d.ts

@@ -1,2 +1,2 @@
 import { QuestionProps } from './types.js';
-export declare function QuestionCard({ question, value, onValueChange, revealed: revealedProp, verdict, points, feedback, disabled, className, variant, density, showShortcuts, number, showFeedback, }: QuestionProps): import("react").JSX.Element;
+export declare function QuestionCard({ question, value, onValueChange, revealed, verdict, points, feedback, disabled, className, variant, density, showShortcuts, number, showFeedback, }: QuestionProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/education/questions/types.d.ts

@@ -19,7 +19,7 @@ export type QuestionMedia = QuestionImage & {
     name?: string;
 };
 /** The server's verdict on an answer: shown as given, never recomputed. */
-export type QuestionVerdict = 'correct' | 'incorrect' | 'pending';
+export type QuestionVerdict = 'correct' | 'incorrect' | 'pending' | 'unanswered';
 /** Points earned out of the points the question is worth. */
 export type QuestionPoints = {
     awarded: number;
@@ -62,7 +62,8 @@ export type QuestionProps = {
     /**
      * The verdict the server gave, shown as given (no comparison with
      * `question.correct` in the browser). It reveals the card; `pending` is a
-     * free answer still waiting for a grader. `question.correct` may still
+     * free answer still waiting for a grader; `unanswered` is a question left
+     * blank (no value is shown, the points read 0). `question.correct` may still
      * be passed to highlight the correct choices.
      */
     verdict?: QuestionVerdict;

package/dist/lib/components/ui/widgets/education/quizzes/partials/quiz-shortcuts.d.ts

@@ -0,0 +1,6 @@
+import { Question } from '../../questions/types.js';
+/** The keyboard hints under the nav: 1-N to answer, Enter to continue. Large containers only. */
+export declare function QuizShortcuts({ current, revealed, }: {
+    current: Question | undefined;
+    revealed: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/education/quizzes/partials/results-actions.d.ts

@@ -0,0 +1,7 @@
+/** The results' buttons: retry the wrong answers (when there are some) and try again. */
+export declare function ResultsActions({ wrong, onRetryWrong, onReset, }: {
+    /** How many questions were answered wrong. */
+    wrong: number;
+    onRetryWrong: () => void;
+    onReset: () => void;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/education/quizzes/partials/results-ring.d.ts

@@ -0,0 +1,5 @@
+/** The wavy score ring with the percentage in its middle. */
+export declare function ResultsRing({ percent, tone, }: {
+    percent: number;
+    tone: 'success' | 'primary' | 'warning';
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/education/quizzes/quiz.flow.d.ts

@@ -0,0 +1,29 @@
+import { QuestionAnswer } from '../questions/types.js';
+import { QuizProps } from './types.js';
+export type QuizPrimary = 'check' | 'next' | 'submit';
+/**
+ * The primary button of the nav: Check (practice, once there is something to
+ * check), else Next, else Submit on the last question; and whether it can act.
+ */
+export declare function quizPrimary({ mode, revealed, answer, blocked, last, canNext, canSubmit, }: {
+    mode: NonNullable<QuizProps['mode']>;
+    revealed: boolean;
+    answer: QuestionAnswer | null;
+    blocked: boolean;
+    last: boolean;
+    canNext: boolean;
+    canSubmit: boolean;
+}): {
+    primary: QuizPrimary;
+    canPrimary: boolean;
+};
+/** The quiz props the model passes on as they are, with the defaults of density and shortcuts. */
+export declare function quizConfig(props: QuizProps): {
+    readonly title: import('react').ReactNode;
+    readonly description: import('react').ReactNode;
+    readonly timeLimit: number | undefined;
+    readonly timerPaused: boolean | undefined;
+    readonly passingScore: number | undefined;
+    readonly density: "comfortable" | "compact";
+    readonly showShortcuts: boolean;
+};

package/dist/lib/components/ui/widgets/education/quizzes/quiz.slice.d.ts

@@ -1,4 +1,5 @@
 import { PayloadAction } from '@reduxjs/toolkit';
+import { BoundSliceActions } from '../../../../../lib/redux/bind-slice-actions.js';
 import { QuestionAnswer } from '../questions/types.js';
 import { QuizChromeState } from './types.js';
 /** The chrome with every field present. */
@@ -202,6 +203,8 @@ export declare const quizActions: import('@reduxjs/toolkit').CaseReducerActions<
     }, action: PayloadAction<string[]>) => void;
     reset: () => Required<QuizChromeState>;
 }, "quiz">;
+/** The quiz slice's actions bound to its dispatch, as `useSliceReducer` hands them. */
+export type QuizActions = BoundSliceActions<typeof quizActions>;
 export declare const quizSelectors: {
     selectCanNext: (state: QuizChromeState, length: number) => boolean;
     selectCanPrev: (state: QuizChromeState) => boolean;

package/dist/lib/components/ui/widgets/education/quizzes/use-quiz-actions.d.ts

@@ -0,0 +1,20 @@
+import { Question, QuestionAnswer } from '../questions/types.js';
+import { QuizPrimary } from './quiz.flow.js';
+import { QuizActions } from './quiz.slice.js';
+import { QuizProps } from './types.js';
+/** Submit, next and the primary button's action (check, next or submit). */
+export declare function useQuizActions({ actions, questions, answers, current, answer, roundLength, primary, canPrimary, onSubmit, }: {
+    actions: QuizActions;
+    questions: Question[];
+    answers: Record<string, QuestionAnswer>;
+    current: Question | undefined;
+    answer: QuestionAnswer | null;
+    roundLength: number;
+    primary: QuizPrimary;
+    canPrimary: boolean;
+    onSubmit: QuizProps['onSubmit'];
+}): {
+    submit: (timedOut?: boolean) => void;
+    next: () => void;
+    runPrimary: () => void;
+};

package/dist/lib/components/ui/widgets/education/quizzes/use-quiz-flow.d.ts

@@ -0,0 +1,29 @@
+import { Question } from '../questions/types.js';
+import { QuizState } from './quiz.slice.js';
+import { QuizProps } from './types.js';
+/**
+ * What the quiz derives from its state: the current question and its answer,
+ * whether its verdict shows, the score, the wrong ids, and what the primary
+ * button (check, next or submit) is and can do.
+ */
+export declare function useQuizFlow({ questions, round, state, mode, }: {
+    questions: Question[];
+    round: Question[];
+    state: QuizState;
+    mode: NonNullable<QuizProps['mode']>;
+}): {
+    current: Question;
+    answer: string | string[] | null;
+    revealed: boolean;
+    score: {
+        correct: number;
+        total: number;
+        percent: number;
+    };
+    wrong: string[];
+    answered: number;
+    canNext: boolean;
+    canSubmit: boolean;
+    primary: import('./quiz.flow.js').QuizPrimary;
+    canPrimary: boolean;
+};

package/dist/lib/components/ui/widgets/education/quizzes/use-quiz-lifecycle.d.ts

@@ -0,0 +1,12 @@
+import { Question } from '../questions/types.js';
+import { QuizActions, QuizState } from './quiz.slice.js';
+import { scoreQuiz } from './quiz.utils.js';
+import { QuizProps } from './types.js';
+/** The questions of the current round (all, or a retry's), keeping the index inside them. */
+export declare function useQuizRound(questions: Question[], retryIds: string[] | null, currentIndex: number, actions: QuizActions): Question[];
+/** Calls `onComplete` once per submission, with the score and the answers. */
+export declare function useQuizComplete({ state, score, onComplete, }: {
+    state: QuizState;
+    score: ReturnType<typeof scoreQuiz>;
+    onComplete: QuizProps['onComplete'];
+}): void;

package/dist/lib/components/ui/widgets/education/quizzes/use-quiz.d.ts

@@ -1,8 +1,9 @@
 import { Question, QuestionAnswer } from '../questions/types.js';
+import { QuizPrimary } from './quiz.flow.js';
 import { QuizState } from './quiz.slice.js';
 import { scoreQuiz } from './quiz.utils.js';
 import { QuizProps } from './types.js';
-export type QuizPrimary = 'check' | 'next' | 'submit';
+export type { QuizPrimary };
 export type QuizModel = Pick<QuizProps, 'title' | 'description' | 'timeLimit' | 'timerPaused' | 'passingScore'> & {
     questions: Question[];
     /** The questions of this round: all of them, or a retry's. */

package/dist/lib/components/ui/widgets/event-calendar/partials/calendar-step-buttons.d.ts

@@ -0,0 +1,2 @@
+/** The previous and next arrows: one period back or forward. */
+export declare function CalendarStepButtons(): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/partials/month-day-cell-class.d.ts

@@ -0,0 +1,9 @@
+/** The classes of a month cell: its height by density, and the washes for weekend, outside, today and the drag range. */
+export declare function monthDayCellClass({ compact, outside, isToday, painting, disabled, weekend, }: {
+    compact: boolean;
+    outside: boolean;
+    isToday: boolean;
+    painting: boolean;
+    disabled: boolean;
+    weekend: boolean;
+}): string;

package/dist/lib/components/ui/widgets/event-calendar/partials/month-day-parts.d.ts

@@ -0,0 +1,12 @@
+import { CalendarEvent } from '../types.js';
+/** The day number in a month cell: a filled disc today, a ring on the phone's chosen day. */
+export declare function MonthDayNumber({ day, isToday, isCursor, outside, }: {
+    day: Date;
+    isToday: boolean;
+    isCursor: boolean;
+    outside: boolean;
+}): import("react").JSX.Element;
+/** Up to three coloured dots standing for the day's events on a phone. */
+export declare function MonthDayDots({ items }: {
+    items: CalendarEvent[];
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/use-month-day.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What a month cell derives and does: its events, its flags (today, outside
+ * the month, the cursor, inside the dragged range), its spoken label, and
+ * what a click or key does (choose the day on a phone, open the day's
+ * dialog, or start a new event).
+ */
+export declare function useMonthDay({ day, month, draft, }: {
+    day: Date;
+    month: Date;
+    draft: {
+        from: Date;
+        to: Date;
+    } | null;
+}): {
+    items: import('./types.js').CalendarEvent[];
+    outside: boolean;
+    isToday: boolean;
+    isCursor: boolean;
+    compact: boolean;
+    label: string;
+    painting: boolean;
+    open: boolean;
+    setOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    activate: (target: EventTarget | null) => void;
+    onKeyDown: (event: import('react').KeyboardEvent<HTMLElement>, day: Date) => void;
+};

package/dist/lib/components/ui/widgets/kanban/kanban.drag.d.ts

@@ -0,0 +1,15 @@
+import { DragEndEvent } from '@dnd-kit/core';
+import { KanbanColumn, KanbanItem } from './types.js';
+type Board = {
+    columns: KanbanColumn[];
+    itemsById: Map<string, KanbanItem>;
+    moveItem: (itemId: string, toColumnId: string, beforeId?: string, toGroupId?: string | null) => void;
+    reorderColumns: (activeId: string, overId: string) => void;
+};
+/**
+ * What a drop does: reorders the columns when a column was dragged, else
+ * moves the card into the group, the column, or before the card it was
+ * dropped on.
+ */
+export declare function applyKanbanDragEnd(event: DragEndEvent, { columns, itemsById, moveItem, reorderColumns }: Board): void;
+export {};

package/dist/lib/components/ui/widgets/kanban/partials/kanban-card-tile.d.ts

@@ -0,0 +1,7 @@
+import { KanbanItem } from '../types.js';
+/** A card's default look: title, subtitle, drag handle and icon, colour dot. */
+export declare function KanbanCardTile({ item, inert, dragLabel, }: {
+    item: KanbanItem;
+    inert: boolean;
+    dragLabel: string;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/kanban/partials/kanban-column-cards.d.ts

@@ -0,0 +1,8 @@
+import { KanbanColumn } from '../types.js';
+/** An ungrouped column's cards (or its empty state) and the composer when it is open here. */
+export declare function KanbanColumnCards({ column, ids, composing, }: {
+    column: KanbanColumn;
+    /** The visible cards' ids, after the search. */
+    ids: string[];
+    composing: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/kanban/partials/kanban-drag-preview.d.ts

@@ -0,0 +1,8 @@
+import { KanbanColumn, KanbanItem, KanbanRenderCard } from '../types.js';
+/** What follows the pointer while a column or a card is dragged. */
+export declare function KanbanDragPreview({ activeId, columns, itemsById, renderCard, }: {
+    activeId: string;
+    columns: KanbanColumn[];
+    itemsById: Map<string, KanbanItem>;
+    renderCard?: KanbanRenderCard;
+}): string | number | bigint | boolean | Iterable<import('react').ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<import('react').ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;

package/dist/lib/components/ui/widgets/kanban/partials/kanban-group-header.d.ts

@@ -0,0 +1,8 @@
+import { KanbanColumn, KanbanGroup } from '../types.js';
+/** A group's header in a column: collapse toggle, colour dot, title, count and add button. */
+export declare function KanbanGroupHeader({ column, group, count, collapsed, }: {
+    column: KanbanColumn;
+    group: KanbanGroup | null;
+    count: number;
+    collapsed: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/kanban/use-kanban-item-actions.d.ts

@@ -0,0 +1,20 @@
+import { KanbanChange, KanbanColumn, KanbanItem } from './types.js';
+/**
+ * Moves a card to a column (before another card, into a group) and reports
+ * the move once, with the items when its group changed.
+ */
+export declare function useKanbanMoveItem({ board, commit, disabled, items, itemsById, onItemsChange, }: {
+    board: KanbanColumn[];
+    commit: (next: KanbanColumn[], change?: Omit<KanbanChange, 'columns'>) => void;
+    disabled: boolean;
+    items: KanbanItem[];
+    itemsById: Map<string, KanbanItem>;
+    onItemsChange?: (items: KanbanItem[]) => void;
+}): (itemId: string, toColumnId: string, beforeId?: string, toGroupId?: string | null) => void;
+/** Patches one card's fields through `onItemsChange`, unless the board or the card is locked. */
+export declare function useKanbanUpdateItem({ disabled, items, itemsById, onItemsChange, }: {
+    disabled: boolean;
+    items: KanbanItem[];
+    itemsById: Map<string, KanbanItem>;
+    onItemsChange?: (items: KanbanItem[]) => void;
+}): (itemId: string, patch: Partial<KanbanItem>) => void;

package/dist/lib/components/ui/widgets/native-charts/core/base-props-types.d.ts

@@ -0,0 +1,64 @@
+import { ReactNode } from 'react';
+import { ChartRow } from './types.js';
+/** A point a tooltip, a click or the keyboard lands on. */
+export interface ChartPoint {
+    seriesKey: string;
+    seriesLabel: string;
+    /** The row index (or the slice, step or cell index). */
+    index: number;
+    /** The formatted x value or category. */
+    label: string;
+    value: number;
+    formatted: string;
+    row?: ChartRow;
+}
+/**
+ * The series colours: `'default'` draws from `--chart-1..5`; `'soft'` from
+ * `--chart-soft-1..5`, each filled mark a soft fill with a crisp outline in
+ * the colour's ink (lines, points and swatches in the ink).
+ */
+export type ChartPalette = 'default' | 'soft';
+/** What every chart accepts. */
+export interface ChartBaseProps {
+    /** The card's title, and the chart's accessible name. */
+    title: string;
+    /** A line under the title. */
+    description?: ReactNode;
+    /** The big number line under the header. */
+    headline?: ReactNode;
+    /** The screen-reader summary; default generated from the data. */
+    summary?: string | ((auto: string) => string);
+    /** The plot's height in pixels; default 260 (220 under 480px wide); a radar 340, a gauge by its `size`. */
+    height?: number;
+    /** Where the legend goes; default `'top'`. Always below on a phone. */
+    legend?: 'top' | 'bottom' | false;
+    /** The hidden series' keys, controlled. */
+    hidden?: string[];
+    defaultHidden?: string[];
+    onHiddenChange?: (hidden: string[]) => void;
+    /** Shapes, dashes and fill patterns beside the colours. */
+    patterns?: boolean;
+    /**
+     * The series colours. Unset, a chart follows `data-chart-palette="soft"`
+     * on an ancestor (an app-wide switch), else the default palette; set, it
+     * wins over the ancestor both ways. A `tone` is the same in either.
+     */
+    palette?: ChartPalette;
+    /** Default `'dotted'`; `'hairline'` draws thin solid lines. */
+    grid?: 'dotted' | 'hairline' | 'none';
+    /** The "View data" button and its table; default true. */
+    dataTable?: boolean;
+    /** `false` draws no tooltip; a function renders its content. */
+    tooltip?: false | ((points: ChartPoint[]) => ReactNode);
+    /** A pointer click, or Enter or Space on a focused point. */
+    onPointClick?: (point: ChartPoint) => void;
+    /** The entry motion; default true. Reduced motion always wins. */
+    animate?: boolean;
+    /** Shows a skeleton instead of the plot. */
+    loading?: boolean;
+    /** Shown when there is no data. */
+    emptyState?: ReactNode;
+    /** Default `'card'`, a 12px card; `'plain'` draws no surface. */
+    surface?: 'card' | 'plain';
+    className?: string;
+}