haze-ui 1.29.0 → 1.31.0

package/dist/types/components/Calendar/date.d.ts

@@ -59,6 +59,15 @@ export declare function getLeadingDays(year: number, month: number, weekStart: n
  * added. The result length is always a multiple of 7.
  */
 export declare function buildMonthCells(year: number, month: number, weekStart: number): CalendarCell[];
+/** ISO 8601 week identity of a civil date: the week number together with
+ * the ISO week-numbering **year** it belongs to. Days at the calendar
+ * year's edges borrow the neighbor year's numbering, so `year` here is
+ * not necessarily the civil date's own year (2025-12-31 is week 1 of
+ * 2026; 2027-01-01 is week 53 of 2026). */
+export type ISOWeek = {
+    year: number;
+    week: number;
+};
 /**
  * ISO 8601 week number of a civil date. ISO weeks run Monday–Sunday and
  * week 1 is the week containing the year's first Thursday, so days at the
@@ -71,6 +80,30 @@ export declare function buildMonthCells(year: number, month: number, weekStart:
  * spans from that ISO year's January 1.
  */
 export declare function getISOWeekNumber(year: number, month: number, day: number): number;
+/**
+ * Full ISO 8601 week identity of a civil date (`{@link getISOWeekNumber}`
+ * plus the ISO week-numbering year the week belongs to). Same Thursday
+ * anchoring: the Thursday of a date's Monday–Sunday week carries the ISO
+ * year, which is what `"YYYY-Www"` values (see
+ * {@link formatWeekValue}) number weeks against.
+ */
+export declare function getISOWeek(year: number, month: number, day: number): ISOWeek;
+/**
+ * Monday of an ISO week as a civil date — the anchor
+ * `picker="week"` derives its month view and row highlight from. January
+ * 4 always sits in week 1 (the first-Thursday rule), so Monday of week 1
+ * is `Jan 4 − (Jan 4's ISO weekday − 1)`; every later week adds whole
+ * seven-day spans. All arithmetic rides UTC milliseconds (whole days, no
+ * DST drift); the result is read back as a civil triple. Weeks beyond the
+ * year's last (52 or 53 per the ISO calendar) resolve into the neighbor
+ * year — callers validate with a `getISOWeek` round-trip (see
+ * {@link parseWeekValue}).
+ */
+export declare function getISOWeekStartDate(isoYear: number, week: number): {
+    year: number;
+    month: number;
+    day: number;
+};
 /**
  * Format a civil date as the `"YYYY-MM-DD"` string Calendar uses as its
  * value. Value semantics: the string denotes the **local** civil date — it
@@ -119,6 +152,24 @@ export declare function formatYearValue(year: number): string;
 export declare function parseYearValue(value: string): {
     year: number;
 } | null;
+/**
+ * Format an ISO week as the `"YYYY-Www"` string Calendar's
+ * `picker="week"` mode uses as its value (`isoYear` is the ISO
+ * week-numbering year — not necessarily the civil year of every day in
+ * the week — and `week` is 1-based, zero-padded: 2026 week 37 →
+ * `"2026-W37"`). Pure string math; no Date construction.
+ */
+export declare function formatWeekValue(isoYear: number, week: number): string;
+/**
+ * Parse a `"YYYY-Www"` week-picker value (`{@link formatWeekValue}`'s
+ * inverse). Accepts weeks `01`…`53` shape-wise, then rejects the ones
+ * that do not exist in the given ISO year via a round-trip: 2025 is a
+ * 52-week year, so `"2025-W53"` resolves to a Monday that belongs to
+ * 2026 week 1 and is rejected. Anything with another shape
+ * (`"2026-W1"`, `"2026-w05"`, a date/month/quarter serialization) is
+ * rejected outright.
+ */
+export declare function parseWeekValue(value: string): ISOWeek | null;
 /**
  * Parse a `"YYYY-MM-DD"` value string into a local-midnight Date — the
  * inverse of {@link formatDate} and the only safe way to turn a value into

package/dist/types/components/Calendar/index.d.ts

@@ -1,2 +1,2 @@
 export { default as Calendar } from './Calendar';
-export type { CalendarProps, CalendarPickerMode } from './Calendar';
+export type { CalendarProps, CalendarPickerMode, CalendarCellRender } from './Calendar';

package/dist/types/components/Carousel/Carousel.d.ts

@@ -4,8 +4,12 @@ type CarouselProps = {
     value?: ControlOrValue<number>;
     autoPlay?: boolean;
     interval?: number;
+    /** 切换动画形态：slide（默认，scroll-snap 轨道）/ fade（堆叠淡入淡出）。 */
+    effect?: 'slide' | 'fade';
+    /** 悬停或焦点在轮播内时暂停 autoPlay，离开后按剩余时间恢复（WCAG 2.2.1）。 */
+    pauseOnHover?: boolean;
     className?: string;
     children: ReactNode;
 };
-export default function Carousel({ value: valueControl, autoPlay, interval, className, children, }: CarouselProps): import("react").JSX.Element;
+export default function Carousel({ value: valueControl, autoPlay, interval, effect, pauseOnHover, className, children, }: CarouselProps): import("react").JSX.Element;
 export type { CarouselProps };

package/dist/types/components/Carousel/CarouselSlide.d.ts

@@ -1,7 +1,7 @@
-import type { ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
 type CarouselSlideProps = {
     className?: string;
     children: ReactNode;
-};
-export default function CarouselSlide({ className, children }: CarouselSlideProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'className' | 'children'>;
+export default function CarouselSlide({ className, children, ...rest }: CarouselSlideProps): import("react").JSX.Element;
 export type { CarouselSlideProps };

package/dist/types/components/Chart/Chart.d.ts

@@ -4,14 +4,19 @@ type ChartProps<T> = {
     /** Which recharts chart family to render. `pie` maps each datum to one
      * sector named by `xKey` and valued by each series `key`; `radar` maps
      * each datum to one spoke named by `xKey`; `scatter` plots the numeric
-     * `xKey` column against each series `key`. */
+     * `xKey` column against each series `key`. In the cartesian families
+     * the chart `type` picks the container and the default series shape —
+     * override the shape per series via `ChartSeries.type`. */
     type: ChartType;
     /** One datum per point (pie: per sector; radar: per spoke); series
      * values are read by `ChartSeries.key`. */
     data: T[];
     /** The series to plot — colors cycle through the semantic status tokens
      * when `color` is omitted. With `type='pie'` each series is one
-     * concentric ring. */
+     * concentric ring. In cartesian charts (line/area/bar) a per-series
+     * `type` overrides that series' shape for composed charts (bars under a
+     * line, a line over areas), and series sharing a `stackId` stack
+     * (Area/Bar shapes). Both are ignored by pie/radar/scatter. */
     series: ChartSeries[];
     /** Datum field driving the X axis — the cartesian categories, the pie
      * sector names, the radar spoke names, or the numeric scatter X
@@ -39,9 +44,11 @@ type ChartProps<T> = {
 } & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
 /** Token-driven chart over recharts: line, area, bar, pie, radar or
  * scatter series rendered with haze semantic colors, axis/grid/tooltip/legend chrome
- * toggles, and the default-omittable `series`/`xKey` mapping. recharts is
- * a haze-ui dependency — this module's helpers import it statically, so
- * under preserveModules only bundles that actually render Chart include
- * the dependency. */
+ * toggles, and the default-omittable `series`/`xKey` mapping. Cartesian
+ * charts double as composed charts — a per-series `type` mixes line/area/bar
+ * shapes inside one chart, and `stackId` stacks the Area/Bar series sharing
+ * an id. recharts is a haze-ui dependency — this module's helpers import it
+ * statically, so under preserveModules only bundles that actually render
+ * Chart include the dependency. */
 export default function Chart<T>({ type, data, series, xKey, height, innerRadius, layout, renderTooltip, showLegend, showGrid, showTooltip, className, style, ...rest }: ChartProps<T>): import("react").JSX.Element;
 export type { ChartProps, ChartSeries, ChartTooltipEntry, ChartTooltipPayload, ChartType, };

package/dist/types/components/Chart/chart-elements.d.ts

@@ -6,6 +6,16 @@ export type ChartSeries = {
     key: string;
     label?: string;
     color?: string;
+    /** Cartesian containers only (line/area/bar charts): overrides the
+     * element shape for this one series — bars under a line chart, a line
+     * over an area chart (composed charts). Ignored by pie/radar/scatter,
+     * which have a single series shape each. */
+    type?: CartesianChartType;
+    /** Cartesian containers only: series sharing a `stackId` stack onto the
+     * same baseline (Area and Bar shapes). Line ignores it — compose with a
+     * per-series `type: 'area'` when stacked lines are the goal. Ignored by
+     * pie/radar/scatter. */
+    stackId?: string;
 };
 /** A series after Chart's label default is applied — what reaches
  * recharts. `color` is only present when the consumer set it; the plot
@@ -15,6 +25,11 @@ export type ResolvedChartSeries = {
     key: string;
     label: string;
     color?: string;
+    /** Per-series cartesian shape override; `undefined` follows the chart
+     * type (see `ChartSeries.type`). */
+    type?: CartesianChartType;
+    /** Stacking group: Area/Bar series sharing the id stack. */
+    stackId?: string;
 };
 /** Cartesian chart shapes; each maps onto a recharts chart container and
  * its matching series element (see `chartElement` / `seriesElement`). */
@@ -59,13 +74,19 @@ export declare const LEGEND_STYLE: {
 };
 /** Applies the per-series default: `label` falls back to `key`. An
  * explicit `color` passes through untouched — the plot elements cycle
- * `SERIES_COLOR_CYCLE` when it is omitted. */
+ * `SERIES_COLOR_CYCLE` when it is omitted. `type` and `stackId` pass
+ * through untouched for the cartesian branch of `chartTree`. */
 export declare function resolveChartSeries(series: readonly ChartSeries[]): ResolvedChartSeries[];
-/** The recharts series element for one resolved entry. Line and Area carry
- * the token color as `stroke` (Area also fills with it — recharts applies
- * its default 0.6 fill opacity), Bar carries it as `fill`. Radar strokes
- * and fills its polygon — translucent, so overlapping polygons stay
- * readable — and Scatter fills its points. */
+/** The recharts series element for one resolved entry — `type` is the
+ * series' own override when set (composed charts), else the chart type.
+ * Line and Area carry the token color as `stroke` (Area also fills with
+ * it — recharts applies its default 0.6 fill opacity), Bar carries it as
+ * `fill`. Radar strokes and fills its polygon — translucent, so
+ * overlapping polygons stay readable — and Scatter fills its points.
+ * `stackId` is forwarded to Area and Bar: recharts stacks every series
+ * sharing an id onto the same baseline. Line ignores it — a stacked line
+ * chart is just a harder-to-read stacked area, so Area/Bar are the
+ * stacking shapes. */
 export declare function seriesElement(type: SeriesChartType, entry: ResolvedChartSeries, index?: number): ReactElement;
 /** Radial band for pie ring `index` of `ringCount`: a single ring spans
  * [innerRadius, 80%]; multiple rings band the radial space evenly with

package/dist/types/components/ChatMessage/ChatMessage.d.ts

@@ -6,6 +6,15 @@ type ChatMessageProps = {
     name?: ReactNode;
     timestamp?: ReactNode;
     status?: 'sending' | 'sent' | 'error';
+    /**
+     * Marks an assistant message as mid-generation: the bubble carries
+     * aria-busy and a visually hidden status live region announces what
+     * is already on screen — a "Generating" cue, a throttled snapshot
+     * while the text grows, and the complete message once it ends. Leave
+     * it false when the children announce themselves (StreamingText has
+     * this built in): two live regions would say everything twice.
+     */
+    streaming?: boolean;
     /**
      * Opt in to the built-in copy action: a button in the hover/focus
      * reveal bar that copies the message's text content (the bubble's
@@ -21,5 +30,5 @@ type ChatMessageProps = {
     children: ReactNode;
     className?: string;
 };
-export default function ChatMessage({ role, avatar, name, timestamp, status, copyable, actions, children, className, }: ChatMessageProps): import("react").JSX.Element;
+export default function ChatMessage({ role, avatar, name, timestamp, status, streaming, copyable, actions, children, className, }: ChatMessageProps): import("react").JSX.Element;
 export type { ChatMessageProps, ChatMessageRole };

package/dist/types/components/ColorPicker/ColorPicker.d.ts

@@ -1,15 +1,54 @@
 import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { ColorFormat } from './color-math';
 type ColorPickerProps = {
+    /** Color value in any supported format (hex / rgb / hsl). */
     value?: ControlOrValue<string>;
-    presets?: string[];
+    /**
+     * Value callback: streams continuously while a drag runs (Slider
+     * precedent), serialized in `format`.
+     */
     onChange?: (color: string) => void;
+    /** Floating panel visibility (floating mode only; controllable). */
+    open?: ControlOrValue<boolean>;
+    /**
+     * Always-visible panel instead of the trigger + floating panel pair.
+     * The Core-level primitive (`ColorPickerCore`) remains the native
+     * inline form for headless composition.
+     */
+    inline?: boolean;
+    /**
+     * Serialization format of the text field and emitted values
+     * (`#rrggbb`, `rgb(r, g, b)`, `hsl(h, s%, l%)`). A controlled display
+     * concern — switching it does not re-emit the current value.
+     */
+    format?: ColorFormat;
+    /**
+     * Adds the alpha rail. Values below full opacity serialize with the
+     * alpha channel (`#rrggbbaa`, `rgba()`, `hsla()`); full opacity keeps
+     * the opaque form.
+     */
+    allowAlpha?: boolean;
+    /** Swatch row pinned above the recent row; any parsable format. */
+    presets?: string[];
+    /**
+     * Tracks recently used colors (last 10, newest first) as internal
+     * state: every committed pick — drag release, swatch click, arrow
+     * key, text commit — moves its color to the front, deduplicated.
+     */
+    recent?: boolean;
     className?: string;
     /**
-     * Forwarded to the color swatch `<input type='color'>` (not the root
-     * div) — the element form bridges and `ref.current.focus()` reach.
+     * Accessible name of the trigger (floating mode) and the panel;
+     * defaults to the locale's "Pick color". Set it whenever more than
+     * one picker is on a page.
+     */
+    'aria-label'?: string;
+    /**
+     * Floating mode: the trigger swatch button. Inline mode: the panel
+     * card div — the elements `ref.current.focus()` reaches.
      */
-    ref?: Ref<HTMLInputElement>;
+    ref?: Ref<HTMLButtonElement | HTMLDivElement>;
 };
-export default function ColorPicker({ value: valueControl, presets, onChange, className, ref, }: ColorPickerProps): import("react").JSX.Element;
+export default function ColorPicker({ value: valueControl, onChange, open: openControl, inline, format, allowAlpha, presets, recent, className, 'aria-label': ariaLabel, ref, }: ColorPickerProps): import("react").JSX.Element;
 export type { ColorPickerProps };

package/dist/types/components/ColorPicker/ColorPickerPanel.d.ts

@@ -0,0 +1,28 @@
+import type { ColorFormat } from './color-math';
+type ColorPickerPanelProps = {
+    /** Current color in any supported format; unparsable values fall back to black. */
+    value: string;
+    /**
+     * Continuous value callback — fires for every drag move (Slider
+     * precedent: values stream while the gesture runs), always serialized
+     * in `format`.
+     */
+    onChange: (value: string) => void;
+    /**
+     * "The user settled on this color": gesture release, discrete pick
+     * (preset/recent swatch, arrow keys) or committed text. The
+     * recent-colors bookkeeping in the sugar layer rides on this.
+     */
+    onCommit?: (value: string) => void;
+    /** Serialization format of the text field and every emitted value. */
+    format?: ColorFormat;
+    /** Adds the alpha rail; alpha serializes into the value when below 1. */
+    allowAlpha?: boolean;
+    /** Swatch row pinned above the recent row; any parsable format. */
+    presets?: string[];
+    /** Recent-color swatches to render (owned by the sugar layer). */
+    recentColors?: string[];
+    className?: string;
+};
+export default function ColorPickerPanel({ value, onChange, onCommit, format, allowAlpha, presets, recentColors, className, }: ColorPickerPanelProps): import("react").JSX.Element;
+export type { ColorPickerPanelProps };

package/dist/types/components/ColorPicker/color-math.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Pure color math for the ColorPicker family: tolerant parsing of CSS
+ * color strings (hex / rgb / hsl), serialization per format, and the
+ * HSV <-> RGB <-> HSL conversions the saturation/value panel runs on.
+ *
+ * Deliberately independent of `../../tokens/oklch`: that module routes
+ * through OKLab floats (its `parseHex` returns OKLCH), which would make
+ * a hex -> hsv -> hex round trip quantization-lossy. Here hex channels
+ * stay exact 8-bit integers and every conversion is the classic
+ * rational form, so a value round-trips byte-identically.
+ */
+export type ColorFormat = 'hex' | 'rgb' | 'hsl';
+/** 8-bit sRGB channels (`r`/`g`/`b` are integers 0..255) plus a normalized alpha (0..1, optional). */
+export type Rgb = {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+};
+/** Hue in degrees (0..360), saturation and value as 0..1 fractions. */
+export type Hsv = {
+    h: number;
+    s: number;
+    v: number;
+    a?: number;
+};
+/** Hue in degrees (0..360), saturation and lightness as 0..1 fractions. */
+export type Hsl = {
+    h: number;
+    s: number;
+    l: number;
+    a?: number;
+};
+export type ParsedColor = {
+    format: ColorFormat;
+    rgb: Rgb;
+};
+/**
+ * Parse a CSS color string — `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`,
+ * `rgb()/rgba()` and `hsl()/hsla()` with comma or modern slash syntax,
+ * percentage channels and percentage alphas. Returns the source format
+ * plus normalized RGBA, or `null` when nothing matches (invalid input
+ * stays a no-op for the component).
+ */
+export declare function parseColor(input: string): ParsedColor | null;
+/**
+ * Serialize RGBA in a format. The alpha channel is appended only when
+ * `withAlpha` is set and it is below 1 — full opacity serializes as the
+ * opaque form (`#rrggbb` / `rgb()` / `hsl()`), matching CSS equivalence.
+ */
+export declare function formatColor(rgb: Rgb, format: ColorFormat, withAlpha: boolean): string;
+/** A paintable CSS color: always `rgba()` so transparency survives. */
+export declare function cssColor(rgb: Rgb): string;
+/**
+ * Canonical equality key: lowercase 8-digit hex. Two values in any mix
+ * of formats compare equal iff their RGBA rounds equal — the preset
+ * active state and the recent-colors dedupe both ride on this.
+ */
+export declare function rgbHexKey(rgb: Rgb): string;
+export declare function rgbToHsv({ r, g, b }: Rgb): Hsv;
+export declare function hsvToRgb({ h, s, v }: Hsv): Rgb;
+export declare function rgbToHsl({ r, g, b }: Rgb): Hsl;
+export declare function hslToRgb({ h, s, l }: Hsl): Rgb;

package/dist/types/components/ColorPicker/color-picker-styles.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Card skin for the panel — the same visual recipe as Popover's panel,
+ * at the AntD-aligned 240px picker width (a component dimension, like
+ * Popover's `min-width: 200px`, not a themeable value).
+ */
+export declare const panelVisuals: import("@linaria/core").LinariaClassName;
+/** Content column inside the card (also the inline-mode root). */
+export declare const panelContent: import("@linaria/core").LinariaClassName;
+/**
+ * Saturation/value surface: a dynamic two-layer gradient painted through
+ * inline style (hue base + white/black overlays); this class carries the
+ * interaction chrome. Pointer-dragged (`touch-action: none` keeps
+ * touch drags from scrolling the page).
+ */
+export declare const svArea: import("@linaria/core").LinariaClassName;
+/**
+ * Thumb ring over the SV surface. The white border + dark halo is a
+ * functional exception to the token rule — the thumb must read over
+ * EVERY color, bright or dark, in both themes (same class of exception
+ * as the hue spectrum below).
+ */
+export declare const svThumb: import("@linaria/core").LinariaClassName;
+/** Shared shape of the hue/alpha rails. */
+export declare const track: import("@linaria/core").LinariaClassName;
+/**
+ * The full hue spectrum. Functional color values by definition (the
+ * component's subject matter, like a preset swatch), not theme
+ * decoration — no token exists for "red through violet".
+ */
+export declare const hueTrack: import("@linaria/core").LinariaClassName;
+/** Transparency underlay: theme-neutral checkerboard from tokens. */
+export declare const checkerboard: import("@linaria/core").LinariaClassName;
+/** The dynamic transparent→opaque color layer of the alpha rail. */
+export declare const trackFill: import("@linaria/core").LinariaClassName;
+/** Thumb on the hue/alpha rails (svThumb's ring recipe, rail-sized). */
+export declare const trackThumb: import("@linaria/core").LinariaClassName;
+/** Format-aware color code input (Core's text input recipe). */
+export declare const valueInput: import("@linaria/core").LinariaClassName;
+/** Heading over a swatch row (presets / recent colors). */
+export declare const groupLabel: import("@linaria/core").LinariaClassName;
+export declare const swatchRow: import("@linaria/core").LinariaClassName;
+/**
+ * One swatch: a checkerboard base (so translucent fills read) with the
+ * paint on an inset child layer.
+ */
+export declare const swatchBtn: import("@linaria/core").LinariaClassName;
+export declare const swatchFill: import("@linaria/core").LinariaClassName;
+export declare const swatchActive: import("@linaria/core").LinariaClassName;
+/** The floating-mode trigger: a color swatch button. */
+export declare const trigger: import("@linaria/core").LinariaClassName;

package/dist/types/components/ConfigProvider/ConfigContext.d.ts

@@ -0,0 +1,67 @@
+import type { ToastPlacement } from '../Toast/ToastContainer';
+/**
+ * Component default overrides, keyed by the exported component name —
+ * a simplified AntD-v6 `ConfigProvider` channel scoped to prop defaults
+ * (theming stays on the token classes, i18n on `LocaleProvider`).
+ *
+ * Each section names the defaults of one component; an explicit prop on
+ * the component itself always beats anything set here, and a missing
+ * provider leaves every component on its built-in defaults.
+ */
+type HazeConfig = {
+    /** `Button` prop defaults. */
+    Button?: {
+        /** Default `size` when the prop is omitted (built-in `'md'`). */
+        size?: 'sm' | 'md' | 'lg';
+    };
+    /** `ButtonLink` prop defaults — the anchor wearing Button's skin. */
+    ButtonLink?: {
+        /** Default `size` when the prop is omitted (built-in `'md'`). */
+        size?: 'sm' | 'md' | 'lg';
+    };
+    /**
+     * Toast defaults. `duration` covers toasts fired through `useToast()`;
+     * the module-level `toast()` runs outside any React tree and keeps its
+     * own 3000ms default regardless of config. `loading()` toasts keep
+     * their persistent (0ms) semantics — config never re-arms them.
+     */
+    Toast?: {
+        /** Auto-dismiss budget in ms when a call omits `duration` (3000). */
+        duration?: number;
+        /** Viewport edge the stack is pinned to (`'bottom-right'`). */
+        placement?: ToastPlacement;
+        /** Max simultaneous toasts; oldest dropped on overflow (unbounded). */
+        maxCount?: number;
+    };
+    /** `Tooltip` prop defaults. */
+    Tooltip?: {
+        /** Hover/focus delay in ms before the tooltip appears (150). */
+        delay?: number;
+    };
+    /** `HoverCard` prop defaults. */
+    HoverCard?: {
+        /** Hover/focus dwell in ms before the card opens (200). */
+        openDelay?: number;
+        /**
+         * Grace period in ms after the pointer leaves before the card
+         * closes — the travel window into the panel (120).
+         */
+        closeDelay?: number;
+    };
+};
+/**
+ * The fully merged config visible below a `ConfigProvider`. The
+ * provider resolves nesting itself (inner sections shallow-merge over
+ * outer ones), so the context always carries one flat value — consumers
+ * never walk a chain.
+ */
+declare const ConfigContext: import("react").Context<HazeConfig | undefined>;
+/**
+ * Per-section shallow merge for nested providers: keys the inner
+ * provider names win, keys it leaves unset keep the outer value, and
+ * sections present on only one side pass through untouched. Pure — no
+ * DOM access, SSR-safe.
+ */
+declare function mergeConfig(outer: HazeConfig | undefined, inner: HazeConfig | undefined): HazeConfig;
+export { ConfigContext, mergeConfig };
+export type { HazeConfig };

package/dist/types/components/ConfigProvider/ConfigProvider.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import type { HazeConfig } from './ConfigContext';
+type ConfigProviderProps = {
+    /**
+     * Component defaults, keyed by exported component name (see
+     * `HazeConfig`). Nested providers layer: the inner provider's keys win
+     * per component section (shallow merge), keys it leaves unset keep the
+     * outer value. Explicit props on a component always beat config values.
+     */
+    defaults?: HazeConfig;
+    children: ReactNode;
+};
+/**
+ * Supplies library-wide component defaults to the subtree — the
+ * AntD-v6-ConfigProvider idea, scoped to defaults only. Theming stays on
+ * the token classes (`lightTheme` / brand themes) and copy on
+ * `LocaleProvider`; the two providers are independent contexts and may
+ * be mounted in either order, nested in one another, or used alone.
+ *
+ * Renders no DOM and touches no browser API — safe under SSR (string
+ * render and hydration alike). A client-boundary module (React context):
+ * the lib build stamps `'use client'` on it.
+ */
+export default function ConfigProvider({ defaults, children, }: ConfigProviderProps): import("react").JSX.Element;
+export type { ConfigProviderProps };

package/dist/types/components/ConfigProvider/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './ConfigProvider';
+export type { ConfigProviderProps } from './ConfigProvider';
+export { useConfigDefaults } from './useConfigDefaults';
+export type { HazeConfig } from './ConfigContext';

package/dist/types/components/ConfigProvider/useConfigDefaults.d.ts

@@ -0,0 +1,28 @@
+import type { HazeConfig } from './ConfigContext';
+/**
+ * Reads one component's resolved defaults from the enclosing
+ * `ConfigProvider` chain. Returns a frozen empty object when no provider
+ * is mounted; callers fall through to their built-in defaults, so wiring
+ * a component never changes its provider-less behavior.
+ *
+ * ## Wiring a new component (the internal pattern)
+ *
+ * 1. Declare a section in `HazeConfig` (`ConfigContext.ts`) named after
+ *    the exported component:
+ *
+ *    ```ts
+ *    MyComponent?: { size?: 'sm' | 'md' | 'lg' };
+ *    ```
+ *
+ * 2. In the component, drop the destructuring default for each wired
+ *    prop and resolve three tiers — explicit prop, config, built-in:
+ *
+ *    ```ts
+ *    const config = useConfigDefaults('MyComponent');
+ *    const size = sizeProp ?? config.size ?? 'md';
+ *    ```
+ *
+ *    The built-in stays last so a missing provider renders exactly what
+ *    the component rendered before the wiring (byte-identical).
+ */
+export declare function useConfigDefaults<K extends keyof HazeConfig>(component: K): Readonly<NonNullable<HazeConfig[K]>>;

package/dist/types/components/ConversationList/ConversationList.d.ts

@@ -1,7 +1,16 @@
 import type { ReactNode } from 'react';
 type ConversationListProps = {
     children: ReactNode;
+    /**
+     * Infinite-scroll trigger on the list's scrollport: fired when the
+     * scroll position comes within 200px of the end. Entering the zone
+     * fires once; staying inside does not re-fire; scrolling back out
+     * re-arms, and growth of the rendered children re-arms too, so a
+     * still-short list chains straight into the next page. Typical use:
+     * append the next page of conversations. Ignored when not provided.
+     */
+    onLoadMore?: () => void;
     className?: string;
 };
-export default function ConversationList({ children, className }: ConversationListProps): import("react").JSX.Element;
+export default function ConversationList({ children, onLoadMore, className }: ConversationListProps): import("react").JSX.Element;
 export type { ConversationListProps };

package/dist/types/components/Datepicker/Datepicker.d.ts

@@ -1,26 +1,39 @@
 import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { CalendarPickerMode } from '../Calendar/Calendar';
+import type { CalendarCellRender, CalendarPickerMode } from '../Calendar/Calendar';
 import type { DatepickerPreset } from './DatepickerCore';
 type DatepickerProps = {
     value?: ControlOrValue<string>;
     open?: ControlOrValue<boolean>;
-    /** Calendar granularity — 'date' (default), 'month', 'quarter' or
-     * 'year'. `value` serializes per mode: "YYYY-MM-DD", "YYYY-MM",
-     * "YYYY-Qn" or "YYYY". */
+    /** Calendar granularity — 'date' (default), an ISO week 'week',
+     * 'month', 'quarter' or 'year'. `value` serializes per mode:
+     * "YYYY-MM-DD", "YYYY-Www", "YYYY-MM", "YYYY-Qn" or "YYYY". */
     picker?: CalendarPickerMode;
     min?: string;
     max?: string;
     /** Disables individual dates on the calendar panel (see Calendar's
-     * `disabledDate`). */
+     * `disabledDate`) — day grid and header drill-down grids alike. */
     disabledDate?: (date: Date) => boolean;
     /** Shortcut rows at the top of the panel; clicking applies the
      * preset's value and closes the panel. */
     presets?: DatepickerPreset[];
-    /** Adds a time input (hour/minute) below the calendar; `value`
-     * serializes as `"YYYY-MM-DD HH:mm"` instead of `"YYYY-MM-DD"`
-     * (plain-date values stay accepted). Date granularity only. */
-    showTime?: boolean;
+    /** Adds a time input (hour/minute, or seconds with
+     * `{ seconds: true }`) below the calendar; `value` serializes as
+     * `"YYYY-MM-DD HH:mm"` / `"YYYY-MM-DD HH:mm:ss"` instead of
+     * `"YYYY-MM-DD"` (plain-date values stay accepted). Date granularity
+     * only. */
+    showTime?: boolean | {
+        seconds?: boolean;
+    };
+    /** Custom serialization for picks, replacing the built-in value
+     * format (see DatepickerCore's `format`). */
+    format?: (date: Date) => string;
+    /** Reads a custom-formatted value back into the calendar (see
+     * DatepickerCore's `parse`). */
+    parse?: (text: string) => Date | null;
+    /** Appends custom content inside the panel's picker cells (see
+     * Calendar's `cellRender`). */
+    cellRender?: CalendarCellRender;
     locale?: string;
     weekStartsOn?: 0 | 1;
     placeholder?: string;
@@ -29,5 +42,5 @@ type DatepickerProps = {
      * element form bridges and `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
 };
-export default function Datepicker({ value: valueControl, open: openControl, picker, min, max, disabledDate, presets, showTime, locale, weekStartsOn, placeholder, className, ref, }: DatepickerProps): import("react").JSX.Element;
+export default function Datepicker({ value: valueControl, open: openControl, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DatepickerProps): import("react").JSX.Element;
 export type { DatepickerProps };