npm - @kouji-ui/core - Versions diffs - 0.2.0 → 0.4.0 - Mend

@kouji-ui/core 0.2.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/fesm2022/kouji-ui-core-engine-CKMr0aiZ.mjs +390 -0
package/fesm2022/kouji-ui-core-engine-CKMr0aiZ.mjs.map +1 -0
package/fesm2022/kouji-ui-core.mjs +3239 -183
package/fesm2022/kouji-ui-core.mjs.map +1 -1
package/motion/motion.css +90 -0
package/package.json +50 -2
package/types/kouji-ui-core.d.ts +2122 -69

package/types/kouji-ui-core.d.ts CHANGED Viewed

@@ -1,11 +1,15 @@
 import * as _angular_core from '@angular/core';
-import { Signal, InjectionToken, ViewContainerRef, Injector, ComponentRef, Type, ElementRef, AfterContentInit, WritableSignal, InputSignalWithTransform, Provider, ModelSignal, OnInit, OnDestroy, signal, EnvironmentProviders, TemplateRef, ResourceRef, EventEmitter } from '@angular/core';
+import { Signal, InjectionToken, ViewContainerRef, Injector, ComponentRef, Type, ElementRef, AfterContentInit, WritableSignal, EnvironmentProviders, InputSignalWithTransform, Provider, ModelSignal, OnInit, OnDestroy, signal, TemplateRef, ResourceRef, EventEmitter } from '@angular/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors, FormGroup } from '@angular/forms';
 import * as _kouji_ui_core from '@kouji-ui/core';
 import { Observable } from 'rxjs';
 import * as _tanstack_angular_table from '@tanstack/angular-table';
 import { SortingState, ColumnFiltersState, PaginationState, RowSelectionState, ColumnSizingState, VisibilityState, ColumnOrderState, ColumnPinningState, ExpandedState, GroupingState, RowData, ColumnDef, Table, Row, Column, ColumnSizingInfoState } from '@tanstack/angular-table';
-import { EChartsOption } from 'echarts';
+import { EChartsOption, EChartsType, ECElementEvent } from 'echarts';
+import * as lexical from 'lexical';
+import { LexicalEditor, LexicalNode, LexicalCommand, CommandListenerPriority, Klass, SerializedEditorState } from 'lexical';
+import * as monaco_editor from 'monaco-editor';
+import { editor } from 'monaco-editor';
 /**
  * Applies disabled state to any element via ARIA and data attributes.
@@ -1490,6 +1494,445 @@ declare class KjVisuallyHidden {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjVisuallyHidden, "[kjVisuallyHidden]", never, {}, {}, never, never, true, never>;
 }
+/**
+ * Application-wide source of truth for **how locale-sensitive data renders** —
+ * number / currency / date formatting and the logical text direction
+ * (`ltr` / `rtl`). Every locale-aware primitive (NumberInput, DatePicker,
+ * TimePicker, Calendar, currency display) falls back to this service instead of
+ * re-reading `LOCALE_ID` or drilling a `kjLocale` prop.
+ *
+ * Configure the initial state with {@link provideKjLocale}; change it at runtime
+ * with {@link setLocale} / {@link setDirection} / {@link setCurrency} — the seam
+ * the RTL switch and language menu build on. Everything is `Intl`-backed and
+ * SSR-safe, so anything Angular's `LOCALE_ID` already supports works with zero
+ * configuration.
+ *
+ * @example
+ * ```ts
+ * private readonly locale = inject(KjLocale);
+ * readonly price = computed(() => this.locale.formatCurrency(19.9)); // '€19.90'
+ * readonly isRtl = this.locale.isRtl;
+ * ```
+ * @doc
+ * @doc-name locale
+ * @doc-category Core/Primitives
+ * @doc-description One DI provider for locale-aware number, currency, and date formatting plus the ltr/rtl direction every primitive falls back to.
+ * @doc-is-main
+ */
+declare class KjLocale {
+    private readonly defaultLocale;
+    private readonly directionality;
+    private readonly config;
+    private readonly _locale;
+    private readonly _direction;
+    private readonly _currency;
+    /** Resolved BCP-47 locale tag. Falls back to Angular's `LOCALE_ID`. */
+    readonly locale: Signal<string>;
+    /**
+     * Resolved logical text direction. When set to `'auto'`, derives from the
+     * locale script, then falls back to the document's `<html dir>`.
+     */
+    readonly direction: Signal<KjDirection>;
+    /** `true` when the resolved {@link direction} is `'rtl'`. */
+    readonly isRtl: Signal<boolean>;
+    /** Resolved default currency (ISO 4217), or `undefined`. */
+    readonly currency: Signal<string | undefined>;
+    /** Override the active locale at runtime. */
+    setLocale(tag: string): void;
+    /** Override the active direction at runtime. `'auto'` re-enables derivation. */
+    setDirection(dir: KjDirection | 'auto'): void;
+    /** Override the default currency at runtime. */
+    setCurrency(code: string | undefined): void;
+    /**
+     * Build an `Intl.NumberFormat` bound to the resolved locale. Pass options to
+     * override; `undefined` locale in options is ignored.
+     */
+    numberFormat(options?: Intl.NumberFormatOptions): Intl.NumberFormat;
+    /** Build an `Intl.DateTimeFormat` bound to the resolved locale. */
+    dateTimeFormat(options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+    /** Format a number with the resolved locale. */
+    formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+    /**
+     * Format a currency amount. Uses `currency` when given, else the provider's
+     * default {@link currency}. Returns a plain number format when neither is set.
+     */
+    formatCurrency(value: number, currency?: string, options?: Intl.NumberFormatOptions): string;
+    /** Format a `Date` with the resolved locale. */
+    formatDate(value: Date, options?: Intl.DateTimeFormatOptions): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjLocale, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KjLocale>;
+}
+/**
+ * Static configuration for the locale provider. Every field is optional — with
+ * an empty config the {@link KjLocale} service falls back to Angular's
+ * `LOCALE_ID` and the document's `<html dir>`.
+ */
+interface KjLocaleConfig {
+    /**
+     * BCP-47 language tag (e.g. `'de-DE'`, `'ar-EG'`). Defaults to the injected
+     * `LOCALE_ID` when omitted.
+     */
+    readonly locale?: string;
+    /**
+     * Logical text direction. `'auto'` (the default) derives the direction from
+     * the locale's script, then falls back to the document's `<html dir>` via
+     * `KjDirectionality`. An explicit `'ltr'` / `'rtl'` always wins.
+     */
+    readonly direction?: KjDirection | 'auto';
+    /**
+     * ISO 4217 currency code (e.g. `'EUR'`) used as the default for currency
+     * formatting when a component does not specify its own.
+     */
+    readonly currency?: string;
+}
+/**
+ * DI token for the initial locale configuration. Default factory yields an
+ * empty config, so {@link KjLocale} resolves entirely from `LOCALE_ID` and
+ * `<html dir>` when {@link provideKjLocale} is not called.
+ */
+declare const KJ_LOCALE_CONFIG: InjectionToken<KjLocaleConfig>;
+/**
+ * Configures the application (or route) locale — the single source of truth
+ * every locale-sensitive kouji-ui primitive falls back to for number, currency,
+ * and date formatting plus logical text direction.
+ *
+ * Call once at the application scope (`bootstrapApplication`'s `providers`) or
+ * on a route to scope a sub-tree. Runtime changes go through the
+ * {@link KjLocale} service (`setLocale` / `setDirection` / `setCurrency`) — the
+ * seam the upcoming RTL switch and language menu build on.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [provideKjLocale({ locale: 'de-DE', currency: 'EUR' })],
+ * });
+ * ```
+ * @doc
+ *  @doc-example Basic
+ *    Switch the active locale and watch every `Intl`-backed formatter (number,
+ *    currency, date) and the resolved direction update reactively.
+ *    @doc-file locale.basic.example.ts
+ * @doc-name locale
+ * @doc-order 1
+ */
+declare function provideKjLocale(config?: KjLocaleConfig): EnvironmentProviders;
+/**
+ * Reflects {@link KjLocale}'s resolved logical direction onto the document's
+ * `<html dir>` attribute, keeping the whole page (and every assistive
+ * technology) in sync whenever the direction changes at runtime.
+ *
+ * This is the single writer of `<html dir>`; {@link KjDirectionality} stays the
+ * *reader* that feeds `KjLocale`'s `'auto'` derivation. The write is idempotent
+ * (skipped when the attribute already matches), so it never fights an app that
+ * sets `dir` itself, and it is **SSR-safe** — on the server no DOM APIs are
+ * touched and the attribute is left to the app's own template.
+ *
+ * Register once at the application scope. It is the piece the visible RTL
+ * toggle (`KjDirectionToggle`) relies on to actually flip the layout: the toggle
+ * calls `KjLocale.setDirection(...)`, this effect propagates it to `<html dir>`.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideKjLocale({ direction: 'auto' }),
+ *     provideKjDocumentDirection(),
+ *   ],
+ * });
+ * ```
+ * @doc
+ * @doc-name locale
+ * @doc-order 2
+ */
+declare function provideKjDocumentDirection(): EnvironmentProviders;
+/**
+ * Reads the user's `prefers-reduced-motion` OS setting via `matchMedia` and
+ * exposes it as a signal that updates live when the setting flips. SSR-safe —
+ * on the server (or where `matchMedia` is unavailable) the signal returns
+ * `false` and no DOM APIs are touched.
+ *
+ * Pair this with the `motion.css` presets (which already no-op under reduced
+ * motion in pure CSS) whenever a directive needs the value in TypeScript — e.g.
+ * to shorten a JS-driven timeout, skip an imperative animation, or await
+ * `animationend` only when motion is actually running.
+ *
+ * @example
+ * ```ts
+ * private readonly motion = inject(KjReducedMotion);
+ * readonly animate = computed(() => !this.motion.prefersReducedMotion());
+ * ```
+ * @doc-category Core/Primitives
+ * @doc-name reduced-motion
+ * @doc-description SSR-safe signal of the user's prefers-reduced-motion setting.
+ */
+declare class KjReducedMotion {
+    private readonly platformId;
+    private readonly destroyRef;
+    private readonly _prefersReducedMotion;
+    /**
+     * `true` when the user has requested reduced motion. `false` on the server
+     * and as the fallback when `matchMedia` is unavailable.
+     */
+    readonly prefersReducedMotion: Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjReducedMotion, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KjReducedMotion>;
+}
+/**
+ * Direction of a motion preset — `'enter'` plays the entrance keyframe,
+ * `'exit'` plays the reverse.
+ */
+type KjMotionState = 'enter' | 'exit';
+/**
+ * Applies a named motion preset from `motion.css` to its host element. The
+ * animation itself lives entirely in CSS (keyed off the reflected
+ * `data-kj-motion` / `data-kj-motion-state` attributes and the `--kj-motion-*`
+ * custom properties); this directive is a thin, declarative opt-in.
+ *
+ * Presets are composable, pre-bundled names — `fade`, `slide-up`, `slide-down`,
+ * `slide-left`, `slide-right`, `scale`, `slide-up-fade`, `scale-spring`. Under
+ * `prefers-reduced-motion: reduce` every preset collapses to a ~1ms opacity
+ * fade with no transform (WCAG 2.1 AAA 2.3.3), so consumers never have to
+ * branch on the setting for the visual result. The `reduced()` signal is
+ * exposed for the rare case that needs to gate JS-driven timing.
+ *
+ * Requires `@kouji-ui/core/motion/motion.css` to be loaded (globally or in the
+ * component's styles).
+ *
+ * @example
+ * ```html
+ * <div kjMotion="slide-up-fade" [kjMotionState]="open() ? 'enter' : 'exit'">…</div>
+ * ```
+ *
+ * @doc-aria
+ *   data-kj-motion        — reflects the active preset name for CSS targeting
+ *   data-kj-motion-state  — "enter" | "exit"
+ *   data-kj-reduced-motion — present when the user prefers reduced motion
+ *
+ * @doc-a11y
+ *   Motion is decorative and opt-in; the directive adds no interactive
+ *   semantics (no role, no tabindex). Every preset honours
+ *   prefers-reduced-motion by collapsing to a near-instant opacity fade with no
+ *   transform, satisfying WCAG 2.1 AAA 2.3.3 (Animation from Interactions).
+ *
+ * @doc
+ *  @doc-example Presets
+ *    @doc-file motion.example.ts
+ *  @doc-example Reduced motion
+ *    @doc-file motion.reduced.example.ts
+ * @doc-category Core/Primitives
+ * @doc-name motion
+ * @doc-is-main
+ * @doc-description Applies a named, reduced-motion-aware CSS motion preset to any element.
+ */
+declare class KjMotion {
+    private readonly motion;
+    /** Named preset to apply, e.g. `'fade'`, `'slide-up-fade'`, `'scale-spring'`. */
+    readonly kjMotion: _angular_core.InputSignal<string>;
+    /** Whether to play the entrance or exit keyframe. Defaults to `'enter'`. */
+    readonly kjMotionState: _angular_core.InputSignal<KjMotionState>;
+    /** `true` when the user prefers reduced motion. Mirrors `KjReducedMotion`. */
+    readonly reduced: Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjMotion, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjMotion, "[kjMotion]", never, { "kjMotion": { "alias": "kjMotion"; "required": true; "isSignal": true; }; "kjMotionState": { "alias": "kjMotionState"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Canonical English (`en`) message catalog — the **source of truth** for
+ * kouji-ui's visible / assistive-text strings. Every translation key the
+ * library understands is spelled exactly once here; the {@link KjTranslationKey}
+ * union and the {@link KjTranslationCatalog} shape are derived from it, so a
+ * typo in any alternate catalog is a compile error and no key can be forgotten.
+ *
+ * Values may contain `{name}` placeholders — see {@link KjTranslationParams} —
+ * which {@link KjTranslateService.translate} substitutes at lookup time.
+ */
+declare const EN_CATALOG: {
+    readonly 'toast.close': "Close notification";
+    readonly 'dialog.close': "Close dialog";
+    readonly 'pagination.nav': "Pagination";
+    readonly 'pagination.previous': "Previous page";
+    readonly 'pagination.next': "Next page";
+    readonly 'pagination.first': "First page";
+    readonly 'pagination.last': "Last page";
+    readonly 'pagination.more': "More pages";
+    readonly 'pagination.page': "Page {page}";
+    readonly 'pagination.pageOf': "Page {page} of {total}";
+    readonly 'a11y.pageChanged': "Page {page} of {total}";
+    readonly 'a11y.selected': "Selected";
+    readonly 'a11y.sortApplied': "Sort applied, {rows} rows";
+};
+/**
+ * Union of every valid translation key, derived from {@link EN_CATALOG}. Using a
+ * derived union (instead of a hand-maintained enum) keeps the keys and their
+ * source-language values in a single place and makes misspelled keys fail
+ * `tsc`.
+ */
+type KjTranslationKey = keyof typeof EN_CATALOG;
+/** A complete catalog: every {@link KjTranslationKey} mapped to a string. */
+type KjTranslationCatalog = Record<KjTranslationKey, string>;
+/**
+ * Interpolation values for a translation. `{name}` placeholders in a catalog
+ * value are replaced by `params[name]`. Numbers are coerced with `String()`.
+ */
+type KjTranslationParams = Record<string, string | number>;
+/**
+ * French (`fr`) message catalog — shipped as proof that alternate locales plug
+ * in. Typed as `Partial<KjTranslationCatalog>`: a translator may omit keys and
+ * each missing one falls through to the English source at lookup time. The key
+ * union is derived from `en`, so a misspelled key here fails `tsc`.
+ *
+ * Import it explicitly and register with `provideKjTranslations({ fr: FR_CATALOG })`
+ * — because it is a plain module, bundlers tree-shake it away when unused.
+ */
+declare const FR_CATALOG: Partial<KjTranslationCatalog>;
+/**
+ * A group of alternate catalogs, keyed by BCP-47 tag or bare language subtag
+ * (e.g. `{ fr: FR_CATALOG }` or `{ 'fr-CA': FR_CA_CATALOG }`). Values are
+ * `Partial` — omitted keys fall through to the English source catalog.
+ */
+type KjTranslationCatalogs = Record<string, Partial<KjTranslationCatalog>>;
+/**
+ * Multi-provider DI token holding every registered {@link KjTranslationCatalogs}
+ * group. {@link KjTranslateService} reads it once at construction and merges the
+ * groups over the always-present English source.
+ */
+declare const KJ_TRANSLATION_CATALOGS: InjectionToken<KjTranslationCatalogs[]>;
+/**
+ * Registers one or more alternate message catalogs for the enclosing injector.
+ * The English (`en`) catalog is always available without registration, so this
+ * only adds the languages you ship. Composes — several calls accumulate.
+ *
+ * Because catalogs are plain `import`-able modules, only the languages you
+ * actually import are bundled (tree-shakable).
+ *
+ * @example
+ * ```ts
+ * import { FR_CATALOG, provideKjTranslations, provideKjLocale } from '@kouji-ui/core';
+ *
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideKjLocale({ locale: 'fr-FR' }),  // selects the catalog at runtime
+ *     provideKjTranslations({ fr: FR_CATALOG }),
+ *   ],
+ * });
+ * ```
+ * @doc
+ * @doc-name i18n
+ * @doc-order 1
+ */
+declare function provideKjTranslations(catalogs: KjTranslationCatalogs): EnvironmentProviders;
+/**
+ * Resolves kouji-ui's visible / assistive-text strings from **typed, per-locale
+ * catalogs**, selecting the active catalog from the locale that already exists —
+ * {@link KjLocale.locale} — and guaranteeing a fallback to the English source so
+ * the UI never blanks out on a missing key.
+ *
+ * Selection for a key resolves in order: exact locale tag (`fr-FR`) → bare
+ * language subtag (`fr`) → `en`; within the chosen catalog a missing key falls
+ * through to the English value, then to the key string itself. Values may carry
+ * `{name}` placeholders substituted from `params`.
+ *
+ * Register alternate catalogs with {@link provideKjTranslations}; switch locale
+ * at runtime with `KjLocale.setLocale()` — lookups are reactive, so
+ * {@link translation} signals and the {@link KjTranslate} directive re-render.
+ *
+ * @example
+ * ```ts
+ * private readonly i18n = inject(KjTranslateService);
+ * readonly closeLabel = this.i18n.translation('toast.close'); // Signal<string>
+ * readonly info = computed(() =>
+ *   this.i18n.translate('pagination.pageOf', { page: 3, total: 12 }));
+ * ```
+ * @doc
+ * @doc-name i18n
+ * @doc-is-main
+ * @doc-category Core/Accessibility
+ * @doc-description Resolves visible and ARIA strings from typed, tree-shakable per-locale catalogs, selected by KjLocale with an English fallback.
+ */
+declare class KjTranslateService {
+    private readonly locale;
+    private readonly catalogs;
+    constructor();
+    /**
+     * Register (or extend) a catalog at runtime. Merges over any catalog already
+     * registered for the same tag. Locale tags are matched case-insensitively.
+     * @param locale - BCP-47 tag or bare language subtag (e.g. `'fr'`, `'fr-CA'`).
+     * @param catalog - Partial catalog; omitted keys fall through to English.
+     */
+    register(locale: string, catalog: Partial<KjTranslationCatalog>): void;
+    /**
+     * Look up a key for the active locale and interpolate `params`. Reads
+     * {@link KjLocale.locale}, so call it inside a `computed`/`effect` (or use
+     * {@link translation}) to react to locale changes.
+     */
+    translate(key: KjTranslationKey, params?: KjTranslationParams): string;
+    /**
+     * Reactive wrapper around {@link translate} — a `Signal` that re-emits when
+     * the active locale or the resolved value changes. Ideal for host bindings
+     * and template interpolation.
+     */
+    translation(key: KjTranslationKey, params?: KjTranslationParams): Signal<string>;
+    /**
+     * Pick the best catalog for a locale tag: exact tag → bare language subtag →
+     * English. Never returns `undefined`.
+     */
+    private selectCatalog;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjTranslateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KjTranslateService>;
+}
+/**
+ * Writes a localized string into its host — either the element's text content
+ * or a named attribute (for `aria-label`, `title`, …). Fully reactive: the host
+ * re-renders when the active locale (`KjLocale.locale()`) or the interpolation
+ * params change, with no change-detection cost between changes (signals +
+ * `effect`, no pipe).
+ *
+ * The key is compile-checked against the {@link KjTranslationKey} union, so a
+ * typo fails `tsc`. Values may contain `{name}` placeholders filled from
+ * `kjTranslateParams`.
+ *
+ * @example
+ * ```html
+ * <!-- visible text -->
+ * <span [kjTranslate]="'pagination.pageOf'"
+ *       [kjTranslateParams]="{ page: page(), total: total() }"></span>
+ *
+ * <!-- localized aria-label on an icon-only button -->
+ * <button [kjTranslate]="'toast.close'" kjTranslateAttr="aria-label">×</button>
+ * ```
+ * @doc
+ *  @doc-example Basic
+ *    @doc-theme default
+ *      @doc-file i18n.basic.example.ts
+ * @doc-name i18n
+ * @doc-category Core/Accessibility
+ */
+declare class KjTranslate {
+    private readonly svc;
+    private readonly el;
+    /** Translation key to render. Compile-checked against the catalog. */
+    readonly kjTranslate: _angular_core.InputSignal<"toast.close" | "dialog.close" | "pagination.nav" | "pagination.previous" | "pagination.next" | "pagination.first" | "pagination.last" | "pagination.more" | "pagination.page" | "pagination.pageOf" | "a11y.pageChanged" | "a11y.selected" | "a11y.sortApplied">;
+    /** Values for `{name}` placeholders in the resolved string. */
+    readonly kjTranslateParams: _angular_core.InputSignal<KjTranslationParams | undefined>;
+    /**
+     * Target attribute to write (e.g. `'aria-label'`, `'title'`). When unset, the
+     * translation is written to the host's text content.
+     */
+    readonly kjTranslateAttr: _angular_core.InputSignal<string | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjTranslate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjTranslate, "[kjTranslate]", never, { "kjTranslate": { "alias": "kjTranslate"; "required": true; "isSignal": true; }; "kjTranslateParams": { "alias": "kjTranslateParams"; "required": false; "isSignal": true; }; "kjTranslateAttr": { "alias": "kjTranslateAttr"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 /**
  * Shape of the preset configuration consumed by `KjVariant`. One per consumer
  * directive, provided via `bindPresets` from a per-component config token.
@@ -2484,7 +2927,8 @@ declare class KjNumberInput implements KjNumberInputContext {
     /** @internal */
     readonly formCtrl: KjFormControl;
     private readonly el;
-    private readonly localeId;
+    /** Locale provider — the fallback source of truth for locale + currency. */
+    private readonly locale;
     private readonly group;
     /** Two-way bindable numeric model. `null` for empty. */
     readonly kjValue: _angular_core.ModelSignal<number | null>;
@@ -2511,10 +2955,13 @@ declare class KjNumberInput implements KjNumberInputContext {
     /** Opts into native `<input type="number">` mode. Disables the mask + locale formatting. */
     readonly kjUseNativeNumber: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Drives `Intl.NumberFormat` style. Ignored when `kjUseNativeNumber=true`. */
-    readonly kjFormat: _angular_core.InputSignal<"decimal" | "currency" | "percent" | "unit">;
-    /** BCP-47 tag. Falls back to the injected `LOCALE_ID`. */
+    readonly kjFormat: _angular_core.InputSignal<"decimal" | "percent" | "currency" | "unit">;
+    /** BCP-47 tag. Falls back to the `KjLocale` provider (`provideKjLocale`). */
     readonly kjLocale: _angular_core.InputSignal<string | undefined>;
-    /** ISO 4217 code (e.g. `'USD'`). Required when `kjFormat="currency"`. */
+    /**
+     * ISO 4217 code (e.g. `'USD'`). Required when `kjFormat="currency"` unless a
+     * default currency is supplied via `provideKjLocale`.
+     */
     readonly kjCurrency: _angular_core.InputSignal<string | undefined>;
     /** Currency display mode. */
     readonly kjCurrencyDisplay: _angular_core.InputSignal<"symbol" | "name" | "code" | "narrowSymbol">;
@@ -5209,6 +5656,301 @@ declare const KJ_CHAT_BUBBLE_CONFIG: InjectionToken<KjChatBubbleConfig>;
  */
 declare function provideKjChatBubble(config: Partial<KjChatBubbleConfig>): Provider[];
+/**
+ * Role of an AI-thread message. Distinct from {@link KjChatRole} in
+ * `chat.context.ts` (that type is an ARIA role for the chat-bubble kit); this
+ * one models the LLM conversation roles.
+ */
+type KjChatMessageRole = 'user' | 'assistant' | 'system' | 'tool';
+/** High-level stream status of the thread. */
+type KjChatStatus = 'idle' | 'streaming' | 'error';
+/** A source reference attached to an assistant message. */
+interface KjChatCitation {
+    /** Stable id (used as the list key and `aria` target). */
+    readonly id: string;
+    /** Human-readable title of the source. */
+    readonly title: string;
+    /** Optional link to the source. */
+    readonly url?: string;
+    /** Optional supporting snippet. */
+    readonly snippet?: string;
+}
+/** Lifecycle status of a tool call. */
+type KjChatToolStatus = 'pending' | 'running' | 'done' | 'error';
+/** A tool / function call surfaced inside an assistant turn. */
+interface KjChatToolCall {
+    /** Stable id. */
+    readonly id: string;
+    /** Tool / function name. */
+    readonly name: string;
+    /** Serialised arguments (opaque to the kit). */
+    readonly args?: unknown;
+    /** Lifecycle status. */
+    readonly status: KjChatToolStatus;
+    /** Result payload once resolved. */
+    readonly result?: unknown;
+    /** Error message when `status === 'error'`. */
+    readonly error?: string;
+}
+/** A single message in an AI thread. */
+interface KjChatMessageData {
+    /** Stable id. */
+    readonly id: string;
+    /** Conversation role. */
+    readonly role: KjChatMessageRole;
+    /** Message text (may be partial while streaming). */
+    readonly content: string;
+    /** True while this (assistant) message is being streamed in. */
+    readonly streaming?: boolean;
+    /** Error text if this turn failed. */
+    readonly error?: string | null;
+    /** Tool calls surfaced during this turn. */
+    readonly toolCalls?: readonly KjChatToolCall[];
+    /** Citations attached to this turn. */
+    readonly citations?: readonly KjChatCitation[];
+    /** Creation timestamp (epoch ms). */
+    readonly createdAt?: number;
+}
+/** Allocate a stable message id. */
+declare function nextChatMessageId(): string;
+/**
+ * Headless, **provider-agnostic** streaming chat state.
+ *
+ * Owns the `messages` signal, the stream `status`, and the append API. It has
+ * **no** LLM SDK, `fetch`, or backend — the consumer wires their own model /
+ * stream and drives this store: `sendUser()`, `beginAssistant()`, then
+ * `pushChunk()` per token/chunk, and finally `endAssistant()` (or `fail()` /
+ * `stop()`).
+ *
+ * Provided **per thread** (no `providedIn`); `KjChatThread` provides one, or
+ * the consumer provides their own to share state.
+ *
+ * @example
+ * ```ts
+ * const store = inject(KjChatStore);
+ * store.sendUser('Summarise the spec');
+ * store.beginAssistant();
+ * for await (const token of myModelStream()) store.pushChunk(token);
+ * store.endAssistant();
+ * ```
+ * @doc-category Core/AI
+ * @doc
+ * @doc-name chat-store
+ * @doc-description Headless provider-agnostic streaming chat state — messages, status, and the token-append API.
+ */
+declare class KjChatStore {
+    private readonly _messages;
+    private readonly _status;
+    private readonly _streamingId;
+    /** The full message list. */
+    readonly messages: _angular_core.Signal<readonly KjChatMessageData[]>;
+    /** Current stream status. */
+    readonly status: _angular_core.Signal<KjChatStatus>;
+    /** Id of the in-flight assistant message, or `null`. */
+    readonly streamingId: _angular_core.Signal<string | null>;
+    /** True while an assistant message is streaming. */
+    readonly isStreaming: _angular_core.Signal<boolean>;
+    /** The current thread-level error, if any. */
+    readonly error: _angular_core.Signal<string | null>;
+    /** Append a user message; returns its id. */
+    sendUser(content: string): string;
+    /** Append a system message; returns its id. */
+    addSystem(content: string): string;
+    /**
+     * Start an in-flight assistant message. Sets `status → 'streaming'` and
+     * `streamingId`. Returns the new message id.
+     */
+    beginAssistant(seed?: string): string;
+    /**
+     * Append a token / chunk to the in-flight assistant message. No-op (with a
+     * dev warning) if there is no in-flight message.
+     */
+    pushChunk(text: string): void;
+    /** Add a tool call to the in-flight assistant message. */
+    addToolCall(tc: KjChatToolCall): void;
+    /** Patch an existing tool call by id on the in-flight message. */
+    updateToolCall(toolCallId: string, patch: Partial<KjChatToolCall>): void;
+    /** Attach citations to the in-flight assistant message. */
+    addCitations(citations: readonly KjChatCitation[]): void;
+    /** Complete the in-flight message; `status → 'idle'`. */
+    endAssistant(): void;
+    /**
+     * Fail the in-flight turn. Sets `status → 'error'` and records the error on
+     * the message. The message stops streaming but keeps any partial content.
+     */
+    fail(message: string): void;
+    /**
+     * Consumer-initiated stop (abort). Freezes whatever partial content exists
+     * and returns to `idle`. The consumer is responsible for aborting their own
+     * network stream.
+     */
+    stop(): void;
+    /** Replace the whole message list (e.g. load history). */
+    setMessages(messages: readonly KjChatMessageData[]): void;
+    /** Clear the thread and return to `idle`. */
+    reset(): void;
+    private append;
+    private patch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjChatStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KjChatStore>;
+}
+/** Options for {@link coalesceAnnouncement}. */
+interface KjCoalesceOptions {
+    /**
+     * Max characters to hold without a sentence boundary before flushing at the
+     * last word boundary. Prevents a long boundary-less clause from being held
+     * silent indefinitely. Default `160`.
+     */
+    readonly maxChars?: number;
+}
+/** Result of a coalescing pass. */
+interface KjCoalesceResult {
+    /** Text ready to announce now (may be empty). */
+    readonly toAnnounce: string;
+    /** Trailing partial text to keep buffered for the next pass. */
+    readonly remainder: string;
+}
+/**
+ * Pure coalescing logic for the streaming live region — **the differentiator**.
+ *
+ * Screen readers announce every mutation of an `aria-live` region, so pushing a
+ * streamed reply char-by-char produces an unusable torrent. This function holds
+ * the streamed `buffer` and releases it only in **whole units**:
+ *
+ * 1. Flush up to and including the **last sentence boundary** (`.`, `!`, `?`,
+ *    newline). The trailing partial sentence stays in `remainder`.
+ * 2. If no boundary exists but the buffer exceeds `maxChars`, flush up to the
+ *    last **word** boundary (space) so a long clause is not held silent.
+ * 3. Otherwise announce nothing yet (`toAnnounce: ''`).
+ *
+ * The caller appends new chunks to `remainder` and calls this again; on stream
+ * completion it flushes the final remainder unconditionally (see
+ * {@link KjChatAnnouncer.flush}).
+ *
+ * @example
+ * ```ts
+ * coalesceAnnouncement('Hello there. How ar')
+ * // → { toAnnounce: 'Hello there.', remainder: ' How ar' }
+ * ```
+ */
+declare function coalesceAnnouncement(buffer: string, opts?: KjCoalesceOptions): KjCoalesceResult;
+/**
+ * Stateful wrapper around {@link coalesceAnnouncement} that exposes the current
+ * announcement as a signal for a visually-hidden `aria-live="polite"` region.
+ *
+ * `push()` accumulates streamed text and emits coalesced sentences; `flush()`
+ * (called on stream completion) releases the final remainder; `announce()`
+ * pushes a discrete status line (e.g. an error) immediately.
+ *
+ * The emitted string toggles through empty between announcements so repeated
+ * identical sentences are still re-announced by AT.
+ *
+ * @doc-category Core/AI
+ * @doc
+ * @doc-name chat-announcer
+ * @doc-description Coalesces streamed tokens into whole-sentence polite live-region announcements.
+ */
+declare class KjChatAnnouncer {
+    private buffer;
+    private readonly _message;
+    private toggle;
+    /** The current announcement text for the polite live region. */
+    readonly message: _angular_core.Signal<string>;
+    /** Max chars held without a boundary before a word-boundary flush. */
+    maxChars: number;
+    /** Append streamed text; emits any newly-completed sentence(s). */
+    push(chunk: string): void;
+    /** Force-release the buffered remainder (call on stream completion). */
+    flush(): void;
+    /** Announce a discrete status line immediately (bypasses coalescing). */
+    announce(text: string): void;
+    /** Clear buffered text and the current announcement. */
+    clear(): void;
+    private emit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjChatAnnouncer, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KjChatAnnouncer>;
+}
+/**
+ * Filter function type for the command palette.
+ * Returns a numeric score: > 0 means the item is visible, 0 means hidden.
+ * Higher scores are more relevant when sorting by score.
+ */
+type KjCommandFilter = (query: string, haystacks: readonly string[]) => number;
+/**
+ * Strip diacritic marks from a string (e.g. `café` → `cafe`).
+ * Uses NFD normalisation followed by removal of Unicode diacritic characters.
+ * Note: locale-naive for v1 (Turkish/German edge cases are documented).
+ */
+declare function stripDiacritics(str: string): string;
+/**
+ * Default filter: case- and diacritic-insensitive substring match.
+ * Returns score 1 if any haystack contains the needle, 0 otherwise.
+ * Returns 1 for empty queries (all items visible).
+ */
+declare const kjSubstringFilter: KjCommandFilter;
+/**
+ * Optional fuzzy filter: checks whether all characters of the query appear
+ * in the haystack in order (abbreviation matching).
+ * E.g. `gth` matches `git checkout`.
+ * Returns score 1 if any haystack matches, 0 otherwise.
+ * Returns 1 for empty queries.
+ *
+ * @example
+ * ```html
+ * <div kjCommandPalette [kjFilter]="kjFuzzyFilter">…</div>
+ * ```
+ */
+declare const kjFuzzyFilter: KjCommandFilter;
+/**
+ * A slash command offered in the prompt input. The slash menu is rendered by a
+ * real `KjCommandPalette` (keyboard nav, `aria-activedescendant`, listbox
+ * semantics) — this type is just the data, and matching reuses the palette's
+ * filter functions.
+ */
+interface KjSlashCommand {
+    /** Command name including the leading slash, e.g. `'/summarize'`. */
+    readonly name: string;
+    /** Short human-readable label. */
+    readonly label: string;
+    /** Optional longer description shown in the menu. */
+    readonly description?: string;
+    /** Opaque payload returned when the command is picked. */
+    readonly value?: unknown;
+}
+/** Result of parsing prompt text for an in-progress slash command. */
+interface KjSlashParse {
+    /** True while the user is typing a slash command name (no space yet). */
+    readonly active: boolean;
+    /** The query *after* the leading slash (empty string when just `/`). */
+    readonly query: string;
+}
+/**
+ * Parse prompt text for an in-progress slash command. The menu is active only
+ * when the text starts with `/` and the command token has not been completed by
+ * whitespace yet — so `/sum` is active but `/summarize now` is not.
+ *
+ * @example
+ * ```ts
+ * parseSlash('/sum')        // → { active: true, query: 'sum' }
+ * parseSlash('/sum arg')    // → { active: false, query: '' }
+ * parseSlash('hi')          // → { active: false, query: '' }
+ * ```
+ */
+declare function parseSlash(text: string): KjSlashParse;
+/**
+ * Filter slash commands against a query using the **command-palette filter**
+ * (`kjSubstringFilter` by default — case- and diacritic-insensitive). Each
+ * command's `[name, label, description]` form the haystack.
+ *
+ * @param query      the text after the leading slash
+ * @param commands   the available commands
+ * @param filter     palette filter (defaults to {@link kjSubstringFilter})
+ */
+declare function matchSlashCommands(query: string, commands: readonly KjSlashCommand[], filter?: KjCommandFilter): KjSlashCommand[];
 /**
  * Marks a paragraph as the lead-in paragraph for a section — slightly larger
  * size with a softer tone. Reflects `data-tone="lead"` so theme CSS keys off
@@ -5756,24 +6498,161 @@ declare class KjDrawer {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KjDrawer, "kj-drawer", never, {}, {}, never, ["*"], true, [{ directive: typeof KjOverlayPanel; inputs: {}; outputs: {}; }]>;
 }
-declare class KjTooltipTrigger {
-    readonly kjOpenDelay: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly kjCloseDelay: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly kjDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    constructor();
-    private readonly _overlayTrigger;
-    /** The controller of the composed `KjOverlayTrigger`, exposed for sibling `[kjFor]` panels. */
-    get controller(): KjOverlayController;
-    attachPanel(panel: KjOverlayPanel): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjTooltipTrigger, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjTooltipTrigger, "[kjTooltipTrigger]", ["kjTooltipTrigger"], { "kjOpenDelay": { "alias": "kjOpenDelay"; "required": false; "isSignal": true; }; "kjCloseDelay": { "alias": "kjCloseDelay"; "required": false; "isSignal": true; }; "kjDisabled": { "alias": "kjDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof KjOverlayTrigger; inputs: { "kjOpen": "kjOpen"; }; outputs: {}; }]>;
-}
-declare class KjTooltipContent {
-    readonly kjSide: _angular_core.InputSignal<KjSide>;
-    readonly kjAlign: _angular_core.InputSignal<KjAlign>;
-    readonly kjOffset: _angular_core.InputSignalWithTransform<number, unknown>;
-    constructor();
+/**
+ * Reference returned by `KjSheetService.open()`. Mirrors
+ * {@link import('../drawer/drawer.ref').KjDrawerRef}.
+ *
+ * Use `close(result?)` to dismiss the bottom sheet programmatically. Subscribe
+ * to `afterClosed$` for the close result, or await the `result` promise.
+ *
+ * @doc-category Core/Overlay
+ */
+declare class KjSheetRef<T, R = unknown> {
+    readonly controller: KjOverlayController;
+    private _instance;
+    private _result;
+    private resolveResult;
+    /** Promise resolving with the close result. */
+    readonly result: Promise<R | undefined>;
+    private readonly _afterOpened;
+    private readonly _afterClosed;
+    /** Emits once after the sheet has finished opening. */
+    readonly afterOpened$: Observable<void>;
+    /** Emits the close result once the sheet has finished closing. */
+    readonly afterClosed$: Observable<R | undefined>;
+    /** Reactive lifecycle state mirrored from the underlying controller. */
+    readonly state: Signal<'closed' | 'opening' | 'open' | 'closing'>;
+    /** Convenience for `state() === 'open' || 'opening'`. */
+    readonly isOpen: Signal<boolean>;
+    constructor(controller: KjOverlayController);
+    /** @internal Bind the rendered component instance for `instance`. */
+    bindInstance(instance: T): void;
+    /** The rendered sheet body component instance. */
+    get instance(): T;
+    /** Close the sheet with an optional result payload. */
+    close(result?: R): void;
+}
+/**
+ * Initial resting height of the bottom sheet.
+ *
+ * - `'auto'` — hugs its content (default).
+ * - `'half'` — opens at roughly half the viewport height.
+ * - `'full'` — opens near full height, leaving a top inset.
+ *
+ * A multi-detent snap machine (dragging between heights) is intentionally
+ * deferred; this option is forward-compatible with that follow-up.
+ */
+type KjSheetDetent = 'auto' | 'half' | 'full';
+/** Configuration options for {@link KjSheetService.open}. */
+interface KjSheetOpenOptions<D = unknown> {
+    /** Data injected into the rendered body via `SHEET_DATA`. */
+    data?: D;
+    /** Initial resting height. Defaults to `'auto'`. */
+    detent?: KjSheetDetent;
+    /** Enables grab-handle + drag-to-dismiss. Defaults to `true`. */
+    dismissible?: boolean;
+    /** Whether clicking the backdrop closes the sheet. Defaults to `true`. */
+    closeOnOutside?: boolean;
+    /** Accessible name applied when the body does not provide a heading. */
+    ariaLabel?: string;
+}
+/**
+ * Programmatic service for opening bottom sheets — a mobile-first,
+ * bottom-anchored modal surface with a grab handle and drag-to-dismiss.
+ *
+ * Composes the same overlay primitive stack as `KjDrawer` and `KjDialog`
+ * (`edgeSheet` position, `solidBackdrop`, `tabCycle` focus trap,
+ * `htmlOverflow` scroll lock) through {@link KjOverlayBuilder} — the overlay
+ * engine is reused, not reinvented.
+ *
+ * @doc-category Core/Overlay
+ */
+declare class KjSheetService {
+    private readonly builder;
+    private readonly env;
+    /**
+     * Open a component as a modal bottom sheet.
+     *
+     * @param component - The body component rendered inside the sheet.
+     * @param opts - Data, detent, dismissible, and close-on-outside controls.
+     * @returns A {@link KjSheetRef} for closing and observing the sheet.
+     */
+    open<T, R = unknown, D = unknown>(component: Type<T>, opts?: KjSheetOpenOptions<D>): KjSheetRef<T, R>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjSheetService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KjSheetService>;
+}
+/** Token for passing data to a programmatically opened sheet body. */
+declare const SHEET_DATA: InjectionToken<unknown>;
+/** Token exposing the resolved initial detent to the rendered body. */
+declare const SHEET_DETENT: InjectionToken<KjSheetDetent>;
+/** Token exposing whether drag-to-dismiss is enabled to the rendered body. */
+declare const SHEET_DISMISSIBLE: InjectionToken<boolean>;
+/** Token exposing the fallback accessible name to the rendered body. */
+declare const SHEET_ARIA_LABEL: InjectionToken<string | null>;
+/**
+ * Bottom-sheet body component. Composes {@link KjOverlayPanel} so the host
+ * inherits `role="dialog"`, `aria-modal`, `[data-state]`, and the bottom
+ * edge-sheet position from `KjSheetService.open()`.
+ *
+ * Renders a grab handle (a real `<button>` for keyboard/click dismissal) and
+ * hosts drag-to-dismiss: a downward pointer drag past 40% of the panel height
+ * or 600 px/s velocity calls `ref.close()`. The drag mechanics mirror the
+ * proven drawer bottom-drag path — no new gesture surface.
+ *
+ * @doc-category Core/Overlay
+ */
+declare class KjSheet {
+    /** Resolved initial detent (provided by `KjSheetService.open`). */
+    readonly detent: KjSheetDetent;
+    /** Whether grab-handle + drag-to-dismiss is active. */
+    readonly dismissible: boolean;
+    /** Fallback accessible name applied to the host when no heading is projected. */
+    readonly ariaLabel: string | null;
+    private readonly ref;
+    private readonly el;
+    private startY;
+    private startTime;
+    private pointerId;
+    private _dragging;
+    /** Reactive flag for the `data-kj-dragging` host binding. */
+    protected dragging: _angular_core.Signal<boolean>;
+    /** @internal */
+    onPointerDown(event: PointerEvent): void;
+    /** @internal */
+    onPointerMove(event: PointerEvent): void;
+    /** @internal */
+    onPointerUp(event: PointerEvent): void;
+    /** @internal */
+    onPointerCancel(_event: PointerEvent): void;
+    private endDrag;
+    /** Close the sheet with an optional payload. */
+    close(result?: unknown): void;
+    /** Esc closes via the overlay-stack coordinator on the controller. */
+    onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjSheet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KjSheet, "kj-sheet", never, {}, {}, never, ["*"], true, [{ directive: typeof KjOverlayPanel; inputs: {}; outputs: {}; }]>;
+}
+declare class KjTooltipTrigger {
+    readonly kjOpenDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly kjCloseDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly kjDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    private readonly _overlayTrigger;
+    /** The controller of the composed `KjOverlayTrigger`, exposed for sibling `[kjFor]` panels. */
+    get controller(): KjOverlayController;
+    attachPanel(panel: KjOverlayPanel): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjTooltipTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjTooltipTrigger, "[kjTooltipTrigger]", ["kjTooltipTrigger"], { "kjOpenDelay": { "alias": "kjOpenDelay"; "required": false; "isSignal": true; }; "kjCloseDelay": { "alias": "kjCloseDelay"; "required": false; "isSignal": true; }; "kjDisabled": { "alias": "kjDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof KjOverlayTrigger; inputs: { "kjOpen": "kjOpen"; }; outputs: {}; }]>;
+}
+declare class KjTooltipContent {
+    readonly kjSide: _angular_core.InputSignal<KjSide>;
+    readonly kjAlign: _angular_core.InputSignal<KjAlign>;
+    readonly kjOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjTooltipContent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KjTooltipContent, "kj-tooltip-content", never, { "kjSide": { "alias": "kjSide"; "required": false; "isSignal": true; }; "kjAlign": { "alias": "kjAlign"; "required": false; "isSignal": true; }; "kjOffset": { "alias": "kjOffset"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof KjOverlayPanel; inputs: { "kjFor": "kjFor"; }; outputs: {}; }]>;
 }
@@ -6850,19 +7729,29 @@ declare class KjToastViewport {
  * for new code — this directive is for cases where the dismiss target id is
  * known outside the template context.
  *
+ * Carries a **localized default `aria-label`** (from the `'toast.close'`
+ * translation key), so an icon-only close button is named for assistive tech in
+ * the active locale with no extra markup. Override per-instance with
+ * `[kjToastCloseLabel]`.
+ *
  * @example
  * ```html
- * <button [kjToastClose]="toast.id" aria-label="Dismiss">×</button>
+ * <button [kjToastClose]="toast.id">×</button>
  * ```
  * @doc-category Core/Overlay
  */
 declare class KjToastClose {
     private readonly svc;
+    private readonly i18n;
     /** The id of the toast to dismiss on click. */
     kjToastClose: _angular_core.InputSignal<string>;
+    /** Overrides the localized default `aria-label`. */
+    readonly kjToastCloseLabel: _angular_core.InputSignal<string | undefined>;
+    /** Resolved `aria-label`: explicit override, else the localized default. */
+    protected readonly closeLabel: _angular_core.Signal<string>;
     dismiss(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjToastClose, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjToastClose, "[kjToastClose]", never, { "kjToastClose": { "alias": "kjToastClose"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjToastClose, "[kjToastClose]", never, { "kjToastClose": { "alias": "kjToastClose"; "required": true; "isSignal": true; }; "kjToastCloseLabel": { "alias": "kjToastCloseLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 /**
  * Service-launched toast panel. Composes `KjOverlayPanel` as a host directive
@@ -7041,6 +7930,7 @@ declare class KjCommandInput implements OnInit, OnDestroy {
     protected readonly palette: KjCommandPalette;
     private readonly nav;
     private readonly el;
+    constructor();
     ngOnInit(): void;
     ngOnDestroy(): void;
     onKeydown(event: KeyboardEvent): void;
@@ -7204,38 +8094,6 @@ declare class KjCommandPaletteTrigger {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjCommandPaletteTrigger, "[kjCommandPaletteTrigger]", ["kjCommandPaletteTrigger"], { "kjHotkey": { "alias": "kjHotkey"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof KjOverlayTrigger; inputs: { "kjOpen": "kjOpen"; }; outputs: {}; }]>;
 }
-/**
- * Filter function type for the command palette.
- * Returns a numeric score: > 0 means the item is visible, 0 means hidden.
- * Higher scores are more relevant when sorting by score.
- */
-type KjCommandFilter = (query: string, haystacks: readonly string[]) => number;
-/**
- * Strip diacritic marks from a string (e.g. `café` → `cafe`).
- * Uses NFD normalisation followed by removal of Unicode diacritic characters.
- * Note: locale-naive for v1 (Turkish/German edge cases are documented).
- */
-declare function stripDiacritics(str: string): string;
-/**
- * Default filter: case- and diacritic-insensitive substring match.
- * Returns score 1 if any haystack contains the needle, 0 otherwise.
- * Returns 1 for empty queries (all items visible).
- */
-declare const kjSubstringFilter: KjCommandFilter;
-/**
- * Optional fuzzy filter: checks whether all characters of the query appear
- * in the haystack in order (abbreviation matching).
- * E.g. `gth` matches `git checkout`.
- * Returns score 1 if any haystack matches, 0 otherwise.
- * Returns 1 for empty queries.
- *
- * @example
- * ```html
- * <div kjCommandPalette [kjFilter]="kjFuzzyFilter">…</div>
- * ```
- */
-declare const kjFuzzyFilter: KjCommandFilter;
 /**
  * Structured filter models — a near-direct adaptation of AG-Grid's
  * `FilterModel` shape. Each built-in filter writes one of these models
@@ -8150,11 +9008,15 @@ declare class KjFieldHelp {
  *
  * Carries `role="alert"` + `aria-live="polite"` so newly-shown errors
  * are announced. Hidden via `[hidden]` when the field is not in error
- * state.
+ * state — unless `kjFieldErrorReserve` is set, in which case the element
+ * keeps its box (`data-hidden` + `visibility: hidden` styling) so error
+ * text can appear and disappear without shifting the surrounding layout.
  *
  * @example
  * ```html
  * <span kjFieldError>Please enter a valid email.</span>
+ * <!-- Reserve the line so showing the error never moves the layout: -->
+ * <span kjFieldError kjFieldErrorReserve>Please enter a valid email.</span>
  * ```
  * @doc-category Core/Inputs
  * @doc
@@ -8164,10 +9026,16 @@ declare class KjFieldError {
     /** @internal */ readonly ctx: _kouji_ui_core.KjFieldContext;
     /** Override the auto-minted host id. */
     readonly kjFieldErrorId: _angular_core.InputSignal<string | undefined>;
+    /**
+     * When set, the element keeps its layout box while the field is valid
+     * (`visibility: hidden` via `data-hidden` instead of `display: none`),
+     * so the error appearing never repositions the fields around it.
+     */
+    readonly kjFieldErrorReserve: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @internal */ readonly id: () => string;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjFieldError, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjFieldError, "[kjFieldError]", never, { "kjFieldErrorId": { "alias": "kjFieldErrorId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjFieldError, "[kjFieldError]", never, { "kjFieldErrorId": { "alias": "kjFieldErrorId"; "required": false; "isSignal": true; }; "kjFieldErrorReserve": { "alias": "kjFieldErrorReserve"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 /**
@@ -8762,6 +9630,58 @@ declare class KjForm implements KjFormContext {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjForm, "form[kjForm]", ["kjForm"], { "kjFocusOnError": { "alias": "kjFocusOnError"; "required": false; "isSignal": true; }; "kjScrollOnError": { "alias": "kjScrollOnError"; "required": false; "isSignal": true; }; "kjScrollBehavior": { "alias": "kjScrollBehavior"; "required": false; "isSignal": true; }; "kjScrollBlock": { "alias": "kjScrollBlock"; "required": false; "isSignal": true; }; "kjMarkAllAsTouchedOnSubmit": { "alias": "kjMarkAllAsTouchedOnSubmit"; "required": false; "isSignal": true; }; "kjResetOnSuccess": { "alias": "kjResetOnSuccess"; "required": false; "isSignal": true; }; "kjAsyncSubmit": { "alias": "kjAsyncSubmit"; "required": false; "isSignal": true; }; "kjSubmitting": { "alias": "kjSubmitting"; "required": false; "isSignal": true; }; }, { "kjSubmit": "kjSubmit"; "kjInvalidSubmit": "kjInvalidSubmit"; "kjSubmitting": "kjSubmittingChange"; }, never, never, true, never>;
 }
+/**
+ * Field-level error messages returned by a backend, keyed by control path
+ * (`'email'`, `'address.street'`, …). Values may be a single message or a
+ * list; {@link kjApplyServerErrors} normalizes both to `readonly string[]`.
+ */
+type KjServerErrors = Record<string, string | readonly string[]>;
+/** Options for {@link kjApplyServerErrors}. */
+interface KjApplyServerErrorsOptions {
+    /**
+     * Error key set on each control (`control.errors[errorKey]`), holding the
+     * normalized `readonly string[]` of messages. Default `'server'`.
+     */
+    errorKey?: string;
+    /** Mark each targeted control as touched so its error shows. Default `true`. */
+    markTouched?: boolean;
+}
+/**
+ * Applies backend validation errors onto a `FormGroup`'s controls: each entry
+ * whose key matches a control path gets `{ [errorKey]: string[] }` merged into
+ * that control's errors (and is marked touched by default) so field-level UI —
+ * `kj-field [kjInvalid]` + `kj-field-error` — lights up per field.
+ *
+ * The error clears itself the next time the control's validators run (any
+ * user edit), which is the behaviour you want for server-side messages.
+ *
+ * Returns the paths that did not match any control, so callers can surface
+ * those messages globally (toast, form-level error line) instead of losing
+ * them.
+ *
+ * @example
+ * ```ts
+ * const unmatched = kjApplyServerErrors(this.form, err.fields);
+ * if (unmatched.length) this.globalError.set('…');
+ * ```
+ * @doc-category Core/Inputs
+ * @doc
+ * @doc-name form
+ */
+declare function kjApplyServerErrors(form: FormGroup, errors: KjServerErrors, options?: KjApplyServerErrorsOptions): string[];
+/**
+ * Reads the messages previously set by {@link kjApplyServerErrors} from a
+ * control's errors, or `null` when none are present. Convenience for
+ * templates rendering the first (or all) server message(s) of a field.
+ *
+ * @doc-category Core/Inputs
+ * @doc
+ * @doc-name form
+ */
+declare function kjServerErrorsOf(control: {
+    errors: Record<string, unknown> | null;
+} | null | undefined, errorKey?: string): readonly string[] | null;
 /**
  * Optional companion to `KjForm` that renders a polite/assertive live-region
  * summary of the invalid controls after a failed submit. Composes
@@ -11567,7 +12487,7 @@ declare const KJ_DATE_PICKER: InjectionToken<KjDatePickerContext>;
  */
 declare class KjDatePicker implements KjDatePickerContext {
     private readonly disabledHost;
-    private readonly defaultLocale;
+    private readonly localeProvider;
     /** Current selected value. Two-way bindable — `[(kjValue)]`. */
     readonly kjValue: _angular_core.ModelSignal<Date | null>;
     /** Earliest selectable date (inclusive). */
@@ -11576,7 +12496,7 @@ declare class KjDatePicker implements KjDatePickerContext {
     readonly kjMax: _angular_core.InputSignal<Date | null>;
     /** Per-date predicate. */
     readonly kjDisabledDates: _angular_core.InputSignal<((d: Date) => boolean) | null>;
-    /** BCP-47 locale tag. Defaults to Angular's `LOCALE_ID`. */
+    /** BCP-47 locale tag. Falls back to the `KjLocale` provider (`provideKjLocale`). */
     readonly kjLocale: _angular_core.InputSignal<string>;
     /** First day of the week override (0=Sun … 6=Sat). */
     readonly kjFirstDayOfWeek: _angular_core.InputSignal<number | null>;
@@ -11691,7 +12611,195 @@ declare class KjDatePickerCalendar {
 }
 /**
- * Wraps Apache ECharts. Initializes after first render, updates reactively, disposes on destroy.
+ * A closed date interval, both bounds inclusive and normalized to
+ * `startOfDay` (day precision — matching the Calendar / Date Picker family).
+ *
+ * @doc-category Core/Data input
+ */
+interface KjDateRange {
+    /** First day of the range (inclusive, `startOfDay`). */
+    readonly start: Date;
+    /** Last day of the range (inclusive, `startOfDay`). */
+    readonly end: Date;
+}
+/**
+ * A named quick-select for a {@link KjDateRange} — the unit the presets
+ * listbox renders as one option.
+ *
+ * `getRange` is pure and receives the current instant so it is deterministic
+ * in tests and lets consumers freeze "today".
+ *
+ * @doc-category Core/Data input
+ */
+interface KjDateRangePreset {
+    /** Stable identifier, e.g. `'last-7-days'`. */
+    readonly id: string;
+    /** Human-readable label, e.g. `'Last 7 days'`. */
+    readonly label: string;
+    /** Resolves the preset to a concrete range relative to `now`. */
+    readonly getRange: (now: Date) => KjDateRange;
+}
+/**
+ * Resolves a preset against `now`, normalizing both bounds to `startOfDay`.
+ * `null` when the preset produces an inverted range (`start > end`).
+ */
+declare function resolveDateRangePreset(preset: KjDateRangePreset, now: Date): KjDateRange | null;
+/**
+ * Shared context for the Date Range Presets family. Implemented by
+ * `KjDateRangePresets` (listbox root) and consumed by
+ * `KjDateRangePresetOption`.
+ *
+ * @doc-category Core/Data input
+ */
+interface KjDateRangePresetsContext {
+    /** The presets currently rendered as options. */
+    readonly presets: Signal<readonly KjDateRangePreset[]>;
+    /** Id of the currently selected preset; `null` when none is chosen. */
+    readonly selectedId: Signal<string | null>;
+    /** Whether the listbox is disabled. */
+    readonly disabled: Signal<boolean>;
+    /** Selects a preset — resolves its range and commits `kjValue`. */
+    select(preset: KjDateRangePreset): void;
+    /** True when `id` names the selected preset. */
+    isSelected(id: string): boolean;
+}
+declare const KJ_DATE_RANGE_PRESETS: InjectionToken<KjDateRangePresetsContext>;
+/**
+ * Headless Date Range Presets listbox. Renders a set of named quick-selects
+ * ("Last 7 days", "This quarter", …) as `role="option"` children; picking one
+ * resolves its `{ start, end }` range and commits the two-way `kjValue`.
+ *
+ * Designed to slot beside a range calendar, but usable standalone against any
+ * `signal<KjDateRange | null>`.
+ *
+ * **Compound shape:**
+ *
+ * ```html
+ * <div kjDateRangePresets [(kjValue)]="range">
+ *   @for (p of presets.presets(); track p.id) {
+ *     <button kjDateRangePresetOption [kjPreset]="p">{{ p.label }}</button>
+ *   }
+ * </div>
+ * ```
+ *
+ * Composes {@link KjRovingTabindex} (vertical) so the whole list is a single
+ * tab stop with Arrow / Home / End navigation.
+ *
+ * @doc-category Core/Data input
+ * @doc
+ * @doc-name date-range-presets
+ * @doc-description Unstyled listbox of named date-range quick-selects that resolve to an inclusive `{ start, end }` range.
+ * @doc-is-main
+ */
+declare class KjDateRangePresets implements KjDateRangePresetsContext {
+    private readonly disabledHost;
+    /** Selected range. Two-way bindable — `[(kjValue)]`. `null` when empty. */
+    readonly kjValue: _angular_core.ModelSignal<KjDateRange | null>;
+    /** Presets to render as options. Defaults to {@link defaultDateRangePresets}. */
+    readonly kjPresets: _angular_core.InputSignal<readonly KjDateRangePreset[]>;
+    /** Accessible name for the listbox. */
+    readonly kjLabel: _angular_core.InputSignal<string>;
+    /**
+     * Injectable "now" for the preset math — defaults to the current instant.
+     * Pass a fixed `Date` to freeze "today" (tests, storybook, replay).
+     */
+    readonly kjNow: _angular_core.InputSignal<Date | null>;
+    /** Read-only — value displays but cannot be edited. */
+    readonly kjReadonly: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly presets: _angular_core.Signal<readonly KjDateRangePreset[]>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Id of the preset whose resolved range matches `kjValue`, or `null`. Derived
+     * from the value so an externally-set range still highlights its preset.
+     */
+    readonly selectedId: _angular_core.Signal<string | null>;
+    private now;
+    select(preset: KjDateRangePreset): void;
+    isSelected(id: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjDateRangePresets, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjDateRangePresets, "[kjDateRangePresets]", ["kjDateRangePresets"], { "kjValue": { "alias": "kjValue"; "required": false; "isSignal": true; }; "kjPresets": { "alias": "kjPresets"; "required": false; "isSignal": true; }; "kjLabel": { "alias": "kjLabel"; "required": false; "isSignal": true; }; "kjNow": { "alias": "kjNow"; "required": false; "isSignal": true; }; "kjReadonly": { "alias": "kjReadonly"; "required": false; "isSignal": true; }; }, { "kjValue": "kjValueChange"; }, never, never, true, [{ directive: typeof KjDisabled; inputs: { "kjDisabled": "kjDisabled"; }; outputs: {}; }, { directive: typeof KjRovingTabindex; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * One option inside a `[kjDateRangePresets]` listbox. Apply to a native
+ * `<button>` so Enter / Space activation comes for free; the composed
+ * {@link KjRovingTabindexItemDirective} manages its `tabindex` so the list is
+ * a single tab stop.
+ *
+ * ```html
+ * <button kjDateRangePresetOption [kjPreset]="preset">{{ preset.label }}</button>
+ * ```
+ *
+ * @doc-category Core/Data input
+ * @doc
+ * @doc-name date-range-presets
+ */
+declare class KjDateRangePresetOption {
+    /** @internal */
+    readonly ctx: _kouji_ui_core.KjDateRangePresetsContext;
+    /** The preset this option represents. */
+    readonly kjPreset: _angular_core.InputSignal<KjDateRangePreset>;
+    /** Whether this option is the selected one. */
+    readonly selected: _angular_core.Signal<boolean>;
+    /** @internal */
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjDateRangePresetOption, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjDateRangePresetOption, "button[kjDateRangePresetOption]", ["kjDateRangePresetOption"], { "kjPreset": { "alias": "kjPreset"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof KjRovingTabindexItemDirective; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * The built-in date range presets — Today, Yesterday, Last 7 / 30 days, This
+ * week / month, Last month, This quarter, Year to date, Last year.
+ *
+ * All ranges are inclusive of both bounds. `Last 7 days` spans 7 calendar days
+ * *including* today (today − 6 … today), matching how analytics tools count.
+ *
+ * @param weekStartsOn - First day of the week (0=Sun … 6=Sat) used by the
+ *   `This week` preset. Defaults to Sunday; pass the locale's week start to
+ *   align with the calendar.
+ *
+ * @doc-category Core/Data input
+ * @doc
+ * @doc-name date-range-presets
+ */
+declare function defaultDateRangePresets(weekStartsOn?: number): KjDateRangePreset[];
+/**
+ * Projects a screen-reader-only table fallback for a `KjChart`. When present
+ * inside a `[kjChart]` host, the host directive renders the template as a table
+ * *sibling* of the chart element — outside the `role="img"` subtree — so
+ * assistive technology reads structured data instead of the canvas.
+ *
+ * This directive only exposes its `TemplateRef`; `KjChart` performs the
+ * rendering (see its `_fallback` content query). Rendering it standalone,
+ * without a `[kjChart]` host, produces no output.
+ *
+ * @example
+ * ```html
+ * <div kjChart [kjChartOption]="opt()" kjChartLabel="Sales">
+ *   <ng-container *kjChartTableFallback>
+ *     <table>...</table>
+ *   </ng-container>
+ * </div>
+ * ```
+ */
+declare class KjChartTableFallback {
+    readonly tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjChartTableFallback, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjChartTableFallback, "[kjChartTableFallback]", never, {}, {}, never, never, true, never>;
+}
+/** Payload emitted by `(kjChartEvent)` — the forwarded ECharts event name and its raw params. */
+interface KjChartEvent {
+    /** The ECharts event name (as listed in `kjChartOn`), e.g. `'click'`, `'datazoom'`. */
+    readonly type: string;
+    /** The raw event object ECharts passes to the handler. Shape depends on `type`. */
+    readonly params: unknown;
+}
+/**
+ * Wraps Apache ECharts. Initializes after first render, updates reactively
+ * (resize, reduced-motion, kj theme palette), disposes on destroy.
  * Always provide `kjChartLabel` for WCAG AAA compliance.
  *
  * @example
@@ -11703,20 +12811,900 @@ declare class KjDatePickerCalendar {
  * @doc-name chart
  * @doc-description Renders a reactive ECharts chart on any sized element with an accessible label.
  * @doc-is-main
+ * @doc-example Line
+ *   @doc-file chart.example.ts
+ * @doc-example Bar
+ *   @doc-file chart.bar.example.ts
+ * @doc-example Donut
+ *   @doc-file chart.donut.example.ts
+ * @doc-example Area
+ *   @doc-file chart.area.example.ts
+ * @doc-example Sparkline
+ *   @doc-file chart.sparkline.example.ts
+ * @doc-example Events
+ *   @doc-file chart.events.example.ts
+ * @doc-example Loading
+ *   @doc-file chart.loading.example.ts
+ * @doc-example Table fallback
+ *   @doc-file chart.fallback.example.ts
+ * @doc-example Pluggable engine + general events
+ *   @doc-file chart.pluggable.example.ts
  */
 declare class KjChart {
     private readonly el;
     private readonly destroyRef;
+    private readonly vcr;
+    /** Optional consumer-supplied ECharts loader (via `provideECharts`); null → full-import fallback. */
+    private readonly echartsLoader;
     /** ECharts option object defining the chart. */
     kjChartOption: _angular_core.InputSignal<EChartsOption>;
-    /** Accessible label for the chart. Required for WCAG AAA compliance. */
+    /** Accessible short label for the chart. Required for WCAG AAA compliance. */
     kjChartLabel: _angular_core.InputSignal<string>;
-    private chart;
+    /** Longer description; rendered visually-hidden and wired via aria-describedby. */
+    kjChartDescription: _angular_core.InputSignal<string>;
+    /** Toggles ECharts showLoading/hideLoading. */
+    kjChartLoading: _angular_core.InputSignal<boolean>;
+    /** Explicit color array; falls back to kj theme palette (resolveChartPalette) when undefined. */
+    kjChartPalette: _angular_core.InputSignal<string[] | undefined>;
+    /** Honored unless prefers-reduced-motion: reduce is set. */
+    kjChartAnimate: _angular_core.InputSignal<boolean>;
+    /**
+     * ECharts event names to forward through `(kjChartEvent)`. Bound via
+     * `chart.on(name, …)` and re-bound reactively when this list changes.
+     * e.g. `['click', 'datazoom', 'legendselectchanged']`.
+     */
+    kjChartOn: _angular_core.InputSignal<readonly string[]>;
+    /** Emits the ECharts instance after its first `setOption` (ready with data). Re-emits on re-init. */
+    kjChartReady: _angular_core.OutputEmitterRef<EChartsType>;
+    /**
+     * Emits `{ type, params }` for every ECharts event named in `kjChartOn`.
+     * Use this for arbitrary events; `kjChartReady` still exposes the raw
+     * instance for full manual `.on(...)` wiring.
+     */
+    kjChartEvent: _angular_core.OutputEmitterRef<KjChartEvent>;
+    /** Emits ECharts 'click' events. Convenience — also available via `kjChartOn`. */
+    kjChartClick: _angular_core.OutputEmitterRef<ECElementEvent>;
+    /** Emits ECharts 'legendselectchanged' events. Convenience — also available via `kjChartOn`. */
+    kjChartLegendSelect: _angular_core.OutputEmitterRef<unknown>;
+    /** Unique id for the description div; used by host's aria-describedby binding. */
+    readonly descriptionId: _angular_core.Signal<string>;
+    private readonly _descSeq;
+    /** Projected `*kjChartTableFallback`, if any. Rendered as an SR table sibling. */
+    protected readonly _fallback: _angular_core.Signal<KjChartTableFallback | undefined>;
+    /** The live ECharts instance. A signal so event-binding + loading effects react to init/dispose. */
+    private readonly chart;
+    private readonly prefersReducedMotion;
+    /** Currently-bound `kjChartOn` forwarders, tracked so they can be unbound on re-bind/destroy. */
+    private forwarded;
     constructor();
+    /**
+     * (Re)binds the `kjChartOn` event forwarders: unbinds the previous set, then
+     * binds `chart.on(name, …)` for each name, emitting `(kjChartEvent)`.
+     * Idempotent — safe to call from both init and the reactive effect.
+     */
+    private bindForwardedEvents;
+    /** Merges reactive concerns (palette, reduced-motion) into the user option. */
+    private resolveOption;
+    /** Imperative resize — wraps chart.resize(). */
+    resize(): void;
+    /** Imperative dispatch — passes through to ECharts. */
+    dispatchAction(payload: Parameters<EChartsType['dispatchAction']>[0]): void;
+    /** Reads current option — passes through to ECharts. */
+    getOption(): EChartsOption | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjChart, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjChart, "[kjChart]", never, { "kjChartOption": { "alias": "kjChartOption"; "required": true; "isSignal": true; }; "kjChartLabel": { "alias": "kjChartLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjChart, "[kjChart]", ["kjChart"], { "kjChartOption": { "alias": "kjChartOption"; "required": true; "isSignal": true; }; "kjChartLabel": { "alias": "kjChartLabel"; "required": true; "isSignal": true; }; "kjChartDescription": { "alias": "kjChartDescription"; "required": false; "isSignal": true; }; "kjChartLoading": { "alias": "kjChartLoading"; "required": false; "isSignal": true; }; "kjChartPalette": { "alias": "kjChartPalette"; "required": false; "isSignal": true; }; "kjChartAnimate": { "alias": "kjChartAnimate"; "required": false; "isSignal": true; }; "kjChartOn": { "alias": "kjChartOn"; "required": false; "isSignal": true; }; }, { "kjChartReady": "kjChartReady"; "kjChartEvent": "kjChartEvent"; "kjChartClick": "kjChartClick"; "kjChartLegendSelect": "kjChartLegendSelect"; }, ["_fallback"], never, true, never>;
+}
+/**
+ * Resolves the chart color palette from kj theme tokens on the given host element.
+ * Reads `--kj-chart-1..6` first; for any empty slot, falls back to the matching
+ * intent token (`--kj-bg-primary`, `--kj-bg-accent`, `--kj-bg-success`,
+ * `--kj-bg-warning`, `--kj-bg-danger`) in that order. Slots that remain empty
+ * after fallback are dropped.
+ */
+declare function resolveChartPalette(host: HTMLElement): string[];
+/**
+ * Minimal ECharts surface {@link KjChart} needs to boot a chart: the `init`
+ * factory. Both the full `echarts` module and a tree-shaken `echarts/core`
+ * build (after `.use([...])`) structurally satisfy this, so either can be
+ * handed to {@link provideECharts}.
+ *
+ * `init` is typed to return `unknown` deliberately: `echarts` and `echarts/core`
+ * ship separate (private-field-incompatible) declarations of their instance
+ * type, so a shared structural type is the only thing both satisfy. `KjChart`
+ * narrows the result to `EChartsType` internally.
+ */
+interface KjEChartsCore {
+    init(dom: HTMLElement | null, theme?: string | object | null, opts?: object): unknown;
+}
+/**
+ * Supplies an ECharts implementation. Return it synchronously or as a
+ * `Promise` — {@link KjChart} awaits either. Typically returns the consumer's
+ * own `echarts/core` namespace with the needed charts/components/renderer
+ * already registered via `.use([...])`, trading the ~1 MB full bundle for a
+ * minimal tree-shaken one.
+ */
+type KjEChartsLoader = () => KjEChartsCore | Promise<KjEChartsCore>;
+/**
+ * DI token holding the optional {@link KjEChartsLoader}. When unset (default),
+ * {@link KjChart} falls back to a dynamic `import('echarts')` of the full
+ * build — zero-config convenience at the cost of bundle size.
+ *
+ * Prefer {@link provideECharts} over binding this token directly.
+ * @doc
+ * @doc-name chart
+ * @doc-order 2
+ */
+declare const KJ_ECHARTS: InjectionToken<KjEChartsLoader | null>;
+/**
+ * Registers a tree-shaken ECharts build for {@link KjChart}. Call at app
+ * bootstrap (or a route's `providers`) so every `[kjChart]` uses the minimal
+ * engine instead of the full `import('echarts')` fallback.
+ *
+ * @example
+ * ```ts
+ * // main.ts
+ * import { provideECharts } from '@kouji-ui/core';
+ * import * as echarts from 'echarts/core';
+ * import { LineChart, BarChart } from 'echarts/charts';
+ * import { GridComponent, TooltipComponent, LegendComponent } from 'echarts/components';
+ * import { CanvasRenderer } from 'echarts/renderers';
+ *
+ * echarts.use([LineChart, BarChart, GridComponent, TooltipComponent, LegendComponent, CanvasRenderer]);
+ *
+ * bootstrapApplication(App, {
+ *   providers: [provideECharts(() => echarts)],
+ * });
+ * ```
+ * @doc
+ * @doc-name chart
+ * @doc-order 1
+ */
+declare function provideECharts(loader: KjEChartsLoader): EnvironmentProviders;
+/**
+ * Public types for the {@link KjRichTextEditor} engine wrapper.
+ *
+ * These are framework- and engine-agnostic: they contain no Lexical runtime
+ * imports so they are safe to import eagerly (including during SSR).
+ */
+/** Inline text formats that {@link KjRichTextEditor} can toggle on a selection. */
+type KjTextFormat = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'code';
+/** Block-level node type that the current selection resolves to. */
+type KjBlockType = 'paragraph' | 'h1' | 'h2' | 'h3' | 'quote' | 'code' | 'bullet' | 'number';
+/**
+ * Snapshot of the editor's formatting state, derived from the current
+ * selection. Exposed as reactive signals on the directive.
+ */
+interface KjRichTextState {
+    /** Inline formats active on the current selection. */
+    readonly activeFormats: ReadonlySet<KjTextFormat>;
+    /** Block type of the selection's top-level element. */
+    readonly blockType: KjBlockType;
+    /** Whether an undo step is available. */
+    readonly canUndo: boolean;
+    /** Whether a redo step is available. */
+    readonly canRedo: boolean;
+    /** Whether the selection is inside a link. */
+    readonly isLink: boolean;
+    /** Whether the document has no text content. */
+    readonly empty: boolean;
+}
+/** Serialized editor content emitted whenever the document changes. */
+interface KjRichTextValue {
+    /** Content serialized to HTML. */
+    readonly html: string;
+    /** Plain-text content. */
+    readonly text: string;
+    /** Lexical `SerializedEditorState` (structurally typed as `unknown`). */
+    readonly json: unknown;
+}
+/** Descriptor for an image inserted via {@link KjRichTextEditor.insertImage}. */
+interface KjImageInsert {
+    /** Image source URL. */
+    readonly src: string;
+    /** Alternative text — always supply for WCAG 1.1.1. */
+    readonly alt?: string;
+    /** Optional intrinsic width in pixels. */
+    readonly width?: number;
+    /** Optional intrinsic height in pixels. */
+    readonly height?: number;
+}
+/**
+ * A keyboard shortcut spec, e.g. `'mod+b'`, `'mod+shift+z'`. `mod` resolves to
+ * Ctrl on Windows/Linux and Cmd on macOS.
+ */
+type KjRteShortcut = string;
+/**
+ * Context passed to a feature's `setup` and to every toolbar/overlay action.
+ * Wraps the live editor with high-level, package-agnostic helpers so features
+ * rarely touch Lexical internals directly (bold/italic never import a package).
+ */
+interface KjRichTextContext {
+    /** The live Lexical editor. */
+    readonly editor: LexicalEditor;
+    /** Current formatting state derived from the selection. */
+    readonly state: KjRichTextState;
+    /** Run a mutation in a discrete (synchronously committed) editor update. */
+    update(fn: () => void): void;
+    /** Read editor state. */
+    read<T>(fn: () => T): T;
+    /** Toggle an inline text format (uses the core `FORMAT_TEXT_COMMAND`). */
+    toggleInlineFormat(format: KjTextFormat): void;
+    /** Replace the selected block(s) with the node returned by `create`. */
+    setBlock(create: () => LexicalNode): void;
+    /** Replace the selected block(s) with a plain paragraph. */
+    setParagraph(): void;
+    /** Insert nodes produced by `create` at the selection. */
+    insertNodes(create: () => LexicalNode[]): void;
+    /** Dispatch a Lexical command (feature packages provide the command constants). */
+    dispatch<P>(command: LexicalCommand<P>, payload: P): void;
+    /** Register a command handler; returns a teardown. */
+    registerCommand<P>(command: LexicalCommand<P>, listener: (payload: P, editor: LexicalEditor) => boolean, priority: CommandListenerPriority): () => void;
+    /** Register a node transform; returns a teardown. */
+    registerNodeTransform<T extends LexicalNode>(klass: Klass<T>, listener: (node: T) => void): () => void;
+    /** Register a keyboard shortcut; returns a teardown. */
+    registerShortcut(shortcut: KjRteShortcut, run: () => void): () => void;
+    /** Undo / redo. */
+    undo(): void;
+    redo(): void;
+    /** Move focus into the editor. */
+    focus(): void;
+    /** Open a feature overlay by id, passing arbitrary data to its component. */
+    openOverlay(id: string, data?: unknown): void;
+    /** Close any open overlay. */
+    closeOverlay(): void;
+    /** Announce a message to assistive technology (aria-live). */
+    announce(message: string): void;
+}
+/** How a toolbar item behaves. */
+type KjRteToolbarKind = 'button' | 'toggle';
+/**
+ * A declarative toolbar contribution. Features own what appears in the toolbar;
+ * the components layer renders items sorted by `group` then `order`.
+ */
+interface KjRteToolbarItem {
+    /** Stable unique id. */
+    readonly id: string;
+    /** Logical group (rendered together, separated from other groups). */
+    readonly group: string;
+    /** Sort order within the group. */
+    readonly order: number;
+    /** Lucide icon name. */
+    readonly icon: string;
+    /** Accessible name + tooltip. */
+    readonly label: string;
+    /** Value for `aria-keyshortcuts` (e.g. `'Control+B'`). */
+    readonly ariaKeyshortcuts?: string;
+    /** `toggle` items expose `aria-pressed`; `button` items do not. */
+    readonly kind: KjRteToolbarKind;
+    /** Whether the toggle is currently active (drives `aria-pressed` + styling). */
+    isActive?(state: KjRichTextState): boolean;
+    /** Whether the item is currently disabled. */
+    isDisabled?(state: KjRichTextState): boolean;
+    /** Run the item's action. */
+    run(context: KjRichTextContext): void;
+}
+/**
+ * A declarative overlay/popover contribution (e.g. the link editor). Opened via
+ * `context.openOverlay(id, data)`; the component receives the `data` (via
+ * `injectRteOverlayData`) and can act through the passed callbacks.
+ */
+interface KjRteOverlay {
+    /** Id used with `context.openOverlay(id)`. */
+    readonly id: string;
+    /** Accessible name for the overlay dialog. */
+    readonly label: string;
+    /** Standalone Angular component rendered inside the overlay. */
+    readonly component: Type<unknown>;
+}
+/**
+ * Maps a Lexical decorator-node type to the Angular component that renders it.
+ * The engine's decorator bridge mounts the component into each node's DOM.
+ */
+interface KjDecoratorRegistration {
+    /** The Lexical node `getType()` value this renders. */
+    readonly nodeType: string;
+    /** The standalone Angular component to mount for each node instance. */
+    readonly component: Type<unknown>;
+}
+/**
+ * A self-contained vertical slice of editor functionality. A feature owns its
+ * **package loading** (`load`), its **nodes**, its **behaviour/activation**
+ * (`setup`), and its **UI** (`toolbar`, `overlay`).
+ *
+ * Package loading is lazy and per-feature: `load` dynamically imports the
+ * feature's own `@lexical/*` package(s), so disabling a feature means its code
+ * is never downloaded. Nodes are collected from all active features **before**
+ * the editor is created.
+ *
+ * @example
+ * ```ts
+ * export function bulletList(): KjRichTextFeature {
+ *   let mod!: typeof import('@lexical/list');
+ *   return {
+ *     name: 'bullet-list',
+ *     async load() { mod = await import('@lexical/list'); },
+ *     nodes: () => [mod.ListNode, mod.ListItemNode],
+ *     setup: (ctx) => mod.registerList(ctx.editor),
+ *     toolbar: [{ id: 'bullet-list', group: 'block', order: 1, icon: 'list',
+ *       label: 'Bullet list', kind: 'toggle',
+ *       isActive: (s) => s.blockType === 'bullet',
+ *       run: (ctx) => ctx.dispatch(mod.INSERT_UNORDERED_LIST_COMMAND, undefined) }],
+ *   };
+ * }
+ * ```
+ */
+interface KjRichTextFeature {
+    /** Unique, human-readable feature name. */
+    readonly name: string;
+    /** Lazily import this feature's own `@lexical/*` package(s). Called once at init. */
+    load?(): Promise<void>;
+    /** Node classes this feature contributes (resolved after `load`). */
+    nodes?(): ReadonlyArray<Klass<LexicalNode>>;
+    /** Register behaviour (commands, transforms, keybindings). Returns an optional teardown. */
+    setup?(context: KjRichTextContext): (() => void) | void;
+    /** Angular components to render for this feature's decorator node types. */
+    decorators?: readonly KjDecoratorRegistration[];
+    /** Declarative toolbar contributions. */
+    toolbar?: readonly KjRteToolbarItem[];
+    /** Declarative overlay contributions. */
+    overlay?: readonly KjRteOverlay[];
+}
+/**
+ * Context contract exposed by a {@link KjRichTextEditor} through {@link KJ_RICH_TEXT}.
+ *
+ * Follows the repo's signal-context pattern (root provides a token pointing to
+ * itself; descendants inject it) so that child directives and toolbars can read
+ * editor state / toolbar contributions and register features without a hard
+ * reference to the class.
+ */
+interface KjRichTextHost {
+    /** The live Lexical editor instance, or `null` before initialization. */
+    readonly editor: Signal<LexicalEditor | null>;
+    /** Current formatting state derived from the selection. */
+    readonly state: Signal<KjRichTextState>;
+    /** Toolbar items contributed by the active features, sorted by group then order. */
+    readonly toolbarItems: Signal<readonly KjRteToolbarItem[]>;
+    /**
+     * Register a feature with this editor. Must be called before the editor
+     * initializes (during a child directive's `ngOnInit`, or via
+     * {@link provideKjRichText}) for node-contributing features to take effect.
+     */
+    registerFeature(feature: KjRichTextFeature): void;
+}
+/**
+ * Context token for the rich-text editor. A {@link KjRichTextEditor} provides it
+ * pointing to itself; descendants (toolbars, feature directives) inject it.
+ */
+declare const KJ_RICH_TEXT: InjectionToken<KjRichTextHost>;
+/**
+ * Multi-provider token for app- or scope-wide rich-text features. Contribute to
+ * it with {@link provideKjRichText}; every {@link KjRichTextEditor} in that
+ * injector scope activates them.
+ */
+declare const KJ_RICH_TEXT_FEATURES: InjectionToken<KjRichTextFeature[]>;
+/** @deprecated Renamed to {@link KJ_RICH_TEXT_FEATURES}. Same token instance. */
+declare const KJ_RICH_TEXT_EXTENSIONS: InjectionToken<KjRichTextFeature[]>;
+/**
+ * Register one or more rich-text features for every editor in this injector
+ * scope (app config, a route, or a component's `providers`). Only the chosen
+ * features load their packages and contribute toolbar/overlay UI.
+ *
+ * @example
+ * ```ts
+ * providers: [provideKjRichText(bold(), italic(), link())]
+ * ```
+ */
+declare function provideKjRichText(...features: KjRichTextFeature[]): Provider[];
+/**
+ * Injection token holding the Lexical node instance being decorated. An Angular
+ * component mounted for a decorator node injects it (via {@link injectRichTextNode})
+ * to read the node's data.
+ */
+declare const KJ_RICH_TEXT_NODE: InjectionToken<unknown>;
+/** Inject the Lexical node instance a decorator-node component is rendering. */
+declare function injectRichTextNode<T = unknown>(): T;
+/** Injection token holding the data a feature passed to `context.openOverlay(id, data)`. */
+declare const KJ_RTE_OVERLAY_DATA: InjectionToken<unknown>;
+/** Inject the data supplied to the currently rendered rich-text overlay component. */
+declare function injectRteOverlayData<T = unknown>(): T;
+/** A component mounted by the decorator bridge, with a handle to tear it down. */
+interface KjMountedComponent {
+    /** The mounted component's root DOM element (to append into the node's host). */
+    readonly element: HTMLElement;
+    /** Destroy the component and detach it from change detection. */
+    destroy(): void;
+}
+/**
+ * Adapter the engine uses to mount an Angular component for a Lexical decorator
+ * node. Supplied by {@link KjRichTextEditor} so the engine stays free of Angular
+ * DI specifics (and CDK-free).
+ */
+interface KjDecoratorMountAdapter {
+    /** Mount `component`, providing `node` via {@link KJ_RICH_TEXT_NODE}. */
+    mount(component: unknown, node: unknown): KjMountedComponent;
+}
+/** A resolved open overlay: its descriptor plus the data the feature passed. */
+interface KjActiveOverlay {
+    readonly overlay: KjRteOverlay;
+    readonly data: unknown;
+}
+/** A contiguous run of toolbar items sharing a group, for rendering. */
+interface KjRteToolbarGroup {
+    readonly group: string;
+    readonly items: readonly KjRteToolbarItem[];
+}
+/**
+ * Headless, client-driven rich-text editor wrapping [Lexical](https://lexical.dev).
+ *
+ * Apply to a block element to turn it into an editable, accessible surface
+ * (`role="textbox"`, `aria-multiline`). The editor is composed from **features**
+ * (see {@link KjRichTextFeature}) supplied via {@link provideKjRichText}, the
+ * `kjFeatures` input, or `[kjRichTextExtension]` child directives. Each feature
+ * lazily loads its own `@lexical/*` package(s) in the browser, so disabling a
+ * feature keeps its code out of the bundle. SSR-safe: the engine loads via
+ * dynamic `import()` inside `afterNextRender`.
+ *
+ * Exposes the aggregated {@link toolbarItems}, reactive `state`, and imperative
+ * helpers (`runItem`, `undo`, …) for a dynamic toolbar to bind to, and
+ * implements {@link ControlValueAccessor} (HTML string model) for Angular forms.
+ *
+ * @doc-category Core/Forms
+ * @doc
+ * @doc-name rich-text-editor
+ * @doc-description Headless, feature-composed Lexical rich-text editor directive with a dynamic toolbar contract and form support.
+ * @doc-is-main
+ */
+declare class KjRichTextEditor implements ControlValueAccessor, KjRichTextHost {
+    private readonly el;
+    private readonly destroyRef;
+    private readonly platformId;
+    private readonly envInjector;
+    private readonly appRef;
+    /** App-/scope-wide features contributed via {@link provideKjRichText}. */
+    private readonly providedFeatures;
+    /** Features registered by child directives via {@link registerFeature}. */
+    private readonly childFeatures;
+    /** Initial content as an HTML string. Ongoing edits are reported via outputs / forms. */
+    readonly kjValue: _angular_core.InputSignal<string>;
+    /** Per-instance features, merged with provided + child-registered features. */
+    readonly kjFeatures: _angular_core.InputSignal<readonly KjRichTextFeature[]>;
+    /** @deprecated Renamed to {@link kjFeatures}. Still honored (merged). */
+    readonly kjExtensions: _angular_core.InputSignal<readonly KjRichTextFeature[]>;
+    /** @deprecated Renamed to {@link kjFeatures}. Still honored (merged). */
+    readonly kjPlugins: _angular_core.InputSignal<readonly KjRichTextFeature[]>;
+    /** Makes the editor non-editable while still selectable. */
+    readonly kjReadonly: _angular_core.InputSignal<boolean>;
+    /** Native spellcheck toggle. */
+    readonly kjSpellcheck: _angular_core.InputSignal<boolean>;
+    /** Lexical namespace (diagnostics only). */
+    readonly kjNamespace: _angular_core.InputSignal<string>;
+    /** Emits the serialized HTML whenever the document changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    /** Emits the plain-text content whenever the document changes. */
+    readonly textChange: _angular_core.OutputEmitterRef<string>;
+    /** Emits the Lexical `SerializedEditorState` whenever the document changes. */
+    readonly jsonChange: _angular_core.OutputEmitterRef<SerializedEditorState<lexical.SerializedLexicalNode>>;
+    /** Emits messages a feature asked to announce to assistive technology. */
+    readonly announce: _angular_core.OutputEmitterRef<string>;
+    private readonly editorSig;
+    /** The live Lexical editor instance, or `null` before initialization. */
+    readonly editor: _angular_core.Signal<LexicalEditor | null>;
+    /** Current formatting state derived from the selection. */
+    readonly state: _angular_core.WritableSignal<KjRichTextState>;
+    readonly isBold: _angular_core.Signal<boolean>;
+    readonly isItalic: _angular_core.Signal<boolean>;
+    readonly isUnderline: _angular_core.Signal<boolean>;
+    readonly isStrikethrough: _angular_core.Signal<boolean>;
+    readonly isCode: _angular_core.Signal<boolean>;
+    readonly blockType: _angular_core.Signal<KjBlockType>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    readonly isLink: _angular_core.Signal<boolean>;
+    readonly empty: _angular_core.Signal<boolean>;
+    /** All active features (provided + inputs + child-registered). */
+    private readonly features;
+    /** Toolbar items contributed by active features, sorted by group then order. */
+    readonly toolbarItems: _angular_core.Signal<readonly KjRteToolbarItem[]>;
+    /** Toolbar items grouped into contiguous runs (for rendering separators). */
+    readonly toolbarGroups: _angular_core.Signal<readonly KjRteToolbarGroup[]>;
+    /** Overlay descriptors contributed by active features. */
+    private readonly overlays;
+    /** The overlay currently open (opened by a feature), or `null`. */
+    readonly activeOverlay: _angular_core.WritableSignal<KjActiveOverlay | null>;
+    /** @internal CVA disabled flag. */
+    readonly disabledState: _angular_core.WritableSignal<boolean>;
+    private engine;
+    private pendingValue;
+    private lastHtml;
+    private applyingExternal;
+    private destroyed;
+    private onChange;
+    /** @internal blur handler wired via host bindings. */
+    onTouched: () => void;
+    constructor();
+    private emitValue;
+    private openOverlayById;
+    /** {@inheritDoc KjRichTextHost.registerFeature} */
+    registerFeature(feature: KjRichTextFeature): void;
+    /** @deprecated Renamed to {@link registerFeature}. */
+    registerExtension(feature: KjRichTextFeature): void;
+    /** Run a toolbar item's action against the live editor (no-op until ready). */
+    runItem(item: KjRteToolbarItem): void;
+    /** Whether a toggle toolbar item is currently active. */
+    itemActive(item: KjRteToolbarItem): boolean;
+    /** Whether a toolbar item is currently disabled. */
+    itemDisabled(item: KjRteToolbarItem): boolean;
+    /** Close any open feature overlay. */
+    closeOverlay(): void;
+    /** Undo the last edit. */
+    undo(): void;
+    /** Redo the last undone edit. */
+    redo(): void;
+    /** Move focus into the editor. */
+    focus(): void;
+    /** Remove all content, leaving a single empty paragraph. */
+    clear(): void;
+    /** Serialize the current content to HTML. */
+    getHtml(): string;
+    /** Replace the content from an HTML string. */
+    setHtml(html: string): void;
+    /** Serialize the current content to a Lexical `SerializedEditorState`. */
+    getJson(): SerializedEditorState | null;
+    /** Replace the content from a Lexical `SerializedEditorState`. */
+    setJson(json: SerializedEditorState): void;
+    /** Build the Angular mount adapter the engine uses for decorator-node components. */
+    private createMountAdapter;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjRichTextEditor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjRichTextEditor, "[kjRichTextEditor]", ["kjRichTextEditor"], { "kjValue": { "alias": "kjValue"; "required": false; "isSignal": true; }; "kjFeatures": { "alias": "kjFeatures"; "required": false; "isSignal": true; }; "kjExtensions": { "alias": "kjExtensions"; "required": false; "isSignal": true; }; "kjPlugins": { "alias": "kjPlugins"; "required": false; "isSignal": true; }; "kjReadonly": { "alias": "kjReadonly"; "required": false; "isSignal": true; }; "kjSpellcheck": { "alias": "kjSpellcheck"; "required": false; "isSignal": true; }; "kjNamespace": { "alias": "kjNamespace"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "textChange": "textChange"; "jsonChange": "jsonChange"; "announce": "announce"; }, never, never, true, never>;
 }
+/**
+ * Registers one or more {@link KjRichTextFeature}s with the nearest
+ * {@link KjRichTextEditor} — the signal-context pattern (like `Option`
+ * registering with `Select`).
+ *
+ * Place it on the same element as `[kjRichTextEditor]`, or on a descendant that
+ * can inject {@link KJ_RICH_TEXT} (e.g. an `<ng-container>`). Registration
+ * happens in `ngOnInit`, before the editor initializes, so node-contributing
+ * features are picked up.
+ *
+ * @example
+ * ```html
+ * <div kjRichTextEditor [kjFeatures]="[mentionFeature]"></div>
+ * <!-- or as a child directive -->
+ * <div kjRichTextEditor [kjRichTextFeature]="mentionFeature"></div>
+ * ```
+ * @doc-category Core/Forms
+ * @doc
+ * @doc-name rich-text-editor
+ */
+declare class KjRichTextExtensionDirective implements OnInit {
+    private readonly host;
+    /** The feature (or features) to register with the host editor. */
+    readonly kjRichTextFeature: _angular_core.InputSignal<KjRichTextFeature | readonly KjRichTextFeature[] | undefined>;
+    /** @deprecated Renamed to {@link kjRichTextFeature}. */
+    readonly kjRichTextExtension: _angular_core.InputSignal<KjRichTextFeature | readonly KjRichTextFeature[] | undefined>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjRichTextExtensionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjRichTextExtensionDirective, "[kjRichTextFeature], [kjRichTextExtension]", never, { "kjRichTextFeature": { "alias": "kjRichTextFeature"; "required": false; "isSignal": true; }; "kjRichTextExtension": { "alias": "kjRichTextExtension"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Configuration for {@link createKjDecoratorNode}. */
+interface KjDecoratorNodeConfig {
+    /** Unique Lexical node type string (must match the `decorators` registration). */
+    type: string;
+    /** The Angular component rendered for each node instance. */
+    component: Type<unknown>;
+    /** Render inline (`<span>`) rather than as a block (`<div>`). Default `false`. */
+    inline?: boolean;
+    /** Optional accessible name applied to the node's host element (WCAG 4.1.2). */
+    ariaLabel?: string;
+}
+/** The node class plus helpers returned by {@link createKjDecoratorNode}. */
+interface KjDecoratorNodeApi<TData extends Record<string, unknown> = Record<string, unknown>> {
+    /** The generated Lexical `DecoratorNode` subclass — pass to `nodes` in your extension. */
+    readonly Node: Klass<LexicalNode>;
+    /** Create a node instance carrying `data`. Use inside `editor.update`. */
+    $create(data?: TData): LexicalNode;
+    /** Type guard for this node. */
+    $is(node: LexicalNode | null | undefined): boolean;
+}
+/**
+ * Build a self-contained Lexical `DecoratorNode` subclass whose instances render
+ * an Angular component (mounted by the editor's decorator bridge). This is the
+ * reusable "render an Angular component as an editor node" framework — define a
+ * custom node from outside the engine in a handful of lines.
+ *
+ * The node stores an arbitrary JSON-serializable `data` object; the mounted
+ * component reads it via {@link injectRichTextNode}. `lexical` is passed in (not
+ * imported here) so this stays SSR-safe and out of the base bundle.
+ *
+ * @example
+ * ```ts
+ * const badge = createKjDecoratorNode(lexical, { type: 'badge', component: BadgeChip, inline: true });
+ * // badge.Node -> register via extension.nodes; badge.$create({ label }) -> insert
+ * ```
+ */
+declare function createKjDecoratorNode<TData extends Record<string, unknown> = Record<string, unknown>>(lexical: typeof lexical, config: KjDecoratorNodeConfig): KjDecoratorNodeApi<TData>;
+/** The image node class plus helpers returned by {@link createKjImageNode}. */
+interface KjImageNodeApi {
+    /** The generated Lexical image node class — pass to a feature's `nodes()`. */
+    readonly Node: Klass<LexicalNode>;
+    /** Create an image node. Use inside `editor.update`. */
+    $create(image: KjImageInsert): LexicalNode;
+    /** Type guard for this image node. */
+    $is(node: LexicalNode | null | undefined): boolean;
+}
+/**
+ * Build a self-rendering block image `DecoratorNode` subclass. It paints its own
+ * `<figure><img></figure>` in `createDOM` (no framework decorator infra needed)
+ * and round-trips through HTML via `importDOM`/`exportDOM`.
+ *
+ * `lexical` is passed in (not imported here) so this module carries no eager
+ * Lexical import and stays SSR-safe — the image feature calls it inside `load()`.
+ */
+declare function createKjImageNode(lexical: typeof lexical): KjImageNodeApi;
+/**
+ * @deprecated Renamed to {@link KjRichTextFeature}. Kept as an alias for
+ * backwards compatibility; will be removed in a future major.
+ */
+type KjRichTextExtension = KjRichTextFeature;
+/**
+ * @deprecated Renamed to {@link KjRichTextFeature}. Kept as an alias for
+ * backwards compatibility; will be removed in a future major.
+ */
+type KjRichTextPlugin = KjRichTextFeature;
+/**
+ * The Monaco namespace (`typeof import('monaco-editor')`). Imported as a
+ * **type only** so `monaco-editor` never becomes a runtime dependency of the
+ * base bundle — the actual module is resolved lazily by {@link KjEditorLoader}.
+ */
+type KjMonaco = typeof monaco_editor;
+/** A function that resolves a ready-to-use Monaco namespace. */
+type KjMonacoLoaderFn = () => Promise<KjMonaco>;
+/**
+ * Monaco standalone editor construction options. Re-exported under a `kj` name
+ * so consumers don't need a direct `monaco-editor` type import at call sites.
+ */
+type KjEditorOptions = editor.IStandaloneEditorConstructionOptions;
+/** The live Monaco editor instance. */
+type KjEditorInstance = editor.IStandaloneCodeEditor;
+/** Gutter line-number rendering mode. */
+type KjEditorLineNumbers = 'on' | 'off' | 'relative';
+/** Soft-wrap mode. */
+type KjEditorWordWrap = 'on' | 'off';
+/**
+ * A code language for the editor. The listed ids get editor autocomplete, but
+ * any Monaco language id (or a short alias like `ts` / `md` / `yml`, normalised
+ * for you) is accepted — hence the open `(string & {})`. This is a kj-level
+ * abstraction: callers never import a Monaco type to set a language.
+ */
+type KjEditorLanguage = 'plaintext' | 'typescript' | 'javascript' | 'json' | 'html' | 'css' | 'scss' | 'less' | 'markdown' | 'yaml' | 'xml' | 'python' | 'java' | 'go' | 'rust' | 'sql' | 'shell' | 'c' | 'cpp' | 'csharp' | 'php' | 'ruby' | (string & {});
+/**
+ * Lazily loads one language's Monaco contribution (grammar + config). The
+ * returned promise resolves once the language is registered. Typically an
+ * `import(...)` of a `monaco-editor/esm/vs/basic-languages/<lang>/<lang>.contribution`
+ * module, which self-registers into Monaco as a side effect.
+ */
+type KjMonacoLanguageLoader = () => Promise<unknown>;
+/**
+ * Headless code editor — wraps [Monaco](https://microsoft.github.io/monaco-editor/)
+ * (VS Code's editor) on its host element. Loads Monaco lazily after first
+ * render (SSR-safe), binds `kjValue` two-way, and disposes on destroy.
+ *
+ * Monaco is browser-only and heavy: it is resolved through {@link KjEditorLoader}
+ * whose source is configurable via `provideMonaco()` (defaults to a CDN loader
+ * so nothing bloats the base bundle). The styled `<kj-editor>` wrapper in
+ * `@kouji-ui/components` adds theming, a toolbar and a status bar on top.
+ *
+ * @example
+ * ```html
+ * <div kjEditor [(kjValue)]="code" kjLanguage="typescript" style="height:320px"></div>
+ * ```
+ * @doc-category Core/Data
+ * @doc
+ * @doc-name editor
+ * @doc-is-main
+ * @doc-description Headless Monaco-wrapped code editor directive — two-way value, language, options, SSR-safe lazy load.
+ */
+declare class KjEditor {
+    private readonly el;
+    private readonly destroyRef;
+    private readonly loader;
+    /** Two-way editor text. */
+    readonly kjValue: _angular_core.ModelSignal<string>;
+    /** Code language — friendly name or Monaco id; short aliases (`ts`, `md`) normalised. */
+    readonly kjLanguage: _angular_core.InputSignal<KjEditorLanguage>;
+    /** Read-only mode. */
+    readonly kjReadonly: _angular_core.InputSignal<boolean>;
+    /** Show the minimap. */
+    readonly kjMinimap: _angular_core.InputSignal<boolean>;
+    /** Gutter line-number mode. */
+    readonly kjLineNumbers: _angular_core.InputSignal<KjEditorLineNumbers>;
+    /** Soft wrap. */
+    readonly kjWordWrap: _angular_core.InputSignal<KjEditorWordWrap>;
+    /** Font size in px. */
+    readonly kjFontSize: _angular_core.InputSignal<number>;
+    /** Grow the host to fit content instead of filling its container. */
+    readonly kjAutoHeight: _angular_core.InputSignal<boolean>;
+    /** Cap for `kjAutoHeight` in px (content scrolls past it). Uncapped when unset. */
+    readonly kjMaxHeight: _angular_core.InputSignal<number | undefined>;
+    /** Explicit Monaco theme id; overrides the wrapper's auto light/dark. */
+    readonly kjTheme: _angular_core.InputSignal<string | undefined>;
+    /** Accessible name — set as Monaco `ariaLabel` and the host `aria-label`. */
+    readonly kjAriaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Start with Tab moving focus out instead of inserting a tab. Consumers who
+     * embed the editor in a form flow may prefer this so keyboard users are never
+     * trapped; the `Ctrl+M` toggle remains available either way.
+     */
+    readonly kjTabFocusMode: _angular_core.InputSignal<boolean>;
+    /** Escape hatch — merged last into Monaco's construction options. */
+    readonly kjOptions: _angular_core.InputSignal<monaco_editor.editor.IStandaloneEditorConstructionOptions>;
+    /** Emits the live Monaco editor once created, for imperative use. */
+    readonly kjReady: _angular_core.OutputEmitterRef<monaco_editor.editor.IStandaloneCodeEditor>;
+    private editor;
+    private monaco;
+    private applyingExternal;
+    /** Our tracked copy of Monaco's tabFocusMode (no public getter exists). */
+    private tabFocusOn;
+    /** Recompute-height callback, wired once auto-height is set up. */
+    private autoHeightUpdate;
+    private readonly reducedMotion;
+    constructor();
+    /** Focus the editor. */
+    focus(): void;
+    /** Relayout the editor to its host size. */
+    layout(): void;
+    /** The live Monaco editor instance, or `null` before mount / after destroy. */
+    getEditor(): KjEditorInstance | null;
+    private init;
+    /**
+     * Size the host to the editor's content height (capped by `kjMaxHeight`),
+     * updating whenever the content grows/shrinks. Mirrors the docs code-viewer
+     * behaviour so a snippet fits its lines instead of needing a fixed height.
+     */
+    private setupAutoHeight;
+    private resolveOptions;
+    /**
+     * Force Monaco's tabFocusMode to a specific state (idempotent). `tabFocusMode`
+     * is not a construction option — it's a context key flipped by the
+     * `toggleTabFocusMode` command (bound to `Ctrl+M`). We track our own copy
+     * since Monaco exposes no public getter, and only trigger the toggle when the
+     * desired state differs from what we last applied.
+     */
+    private syncTabFocus;
+    private dispose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjEditor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjEditor, "[kjEditor]", ["kjEditor"], { "kjValue": { "alias": "kjValue"; "required": false; "isSignal": true; }; "kjLanguage": { "alias": "kjLanguage"; "required": false; "isSignal": true; }; "kjReadonly": { "alias": "kjReadonly"; "required": false; "isSignal": true; }; "kjMinimap": { "alias": "kjMinimap"; "required": false; "isSignal": true; }; "kjLineNumbers": { "alias": "kjLineNumbers"; "required": false; "isSignal": true; }; "kjWordWrap": { "alias": "kjWordWrap"; "required": false; "isSignal": true; }; "kjFontSize": { "alias": "kjFontSize"; "required": false; "isSignal": true; }; "kjAutoHeight": { "alias": "kjAutoHeight"; "required": false; "isSignal": true; }; "kjMaxHeight": { "alias": "kjMaxHeight"; "required": false; "isSignal": true; }; "kjTheme": { "alias": "kjTheme"; "required": false; "isSignal": true; }; "kjAriaLabel": { "alias": "kjAriaLabel"; "required": false; "isSignal": true; }; "kjTabFocusMode": { "alias": "kjTabFocusMode"; "required": false; "isSignal": true; }; "kjOptions": { "alias": "kjOptions"; "required": false; "isSignal": true; }; }, { "kjValue": "kjValueChange"; "kjReady": "kjReady"; }, never, never, true, never>;
+}
+/**
+ * Resolves the Monaco namespace **once** and memoises the promise, so every
+ * `KjEditor` on the page shares a single Monaco instance.
+ *
+ * Resolution strategy (see {@link KjMonacoConfig}):
+ * 1. A consumer-supplied `loader` wins — self-hosted / bundled Monaco.
+ * 2. Otherwise dynamically `import('@monaco-editor/loader')` and `init()` it,
+ *    applying `vsPath` when provided. The dynamic import keeps both Monaco and
+ *    the loader out of the base bundle (their own lazy chunk).
+ *
+ * Browser-only: callers must gate `load()` behind `afterNextRender` /
+ * `isPlatformBrowser`. Naming keeps the `Loader` suffix because `KjEditor`
+ * already names the directive.
+ *
+ * @doc
+ * @doc-name editor
+ * @doc-description Loads and memoises Monaco for the code editor; source is configurable via provideMonaco.
+ */
+declare class KjEditorLoader {
+    private readonly config;
+    private readonly languageLoaders;
+    private promise;
+    private readonly loadedLanguages;
+    /** Resolve Monaco (cached after the first call). */
+    load(): Promise<KjMonaco>;
+    /**
+     * Ensure a language's contribution is loaded before it's used. Runs the loader
+     * registered via {@link provideMonacoLanguages} for this id (once, memoised).
+     * No-ops when no loader is registered — the default CDN Monaco already ships
+     * every language, so this only does work for lean/self-hosted setups.
+     */
+    ensureLanguage(language: string): Promise<void>;
+    private loadFromCdn;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjEditorLoader, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KjEditorLoader>;
+}
+/**
+ * Configures where the code editor gets Monaco from. Provide via
+ * {@link provideMonaco}. Left unset, the library dynamically imports
+ * `@monaco-editor/loader` and initialises Monaco from its default CDN — no
+ * esbuild worker wiring, and Monaco stays out of the base bundle.
+ */
+interface KjMonacoConfig {
+    /**
+     * Custom loader returning a ready Monaco namespace. Wins over `vsPath`.
+     * Use this to point at a **self-hosted or bundled** Monaco instead of a CDN
+     * (e.g. `() => import('monaco-editor')` once you've wired MonacoEnvironment
+     * workers yourself). A library must never hard-lock consumers to a CDN.
+     */
+    loader?: KjMonacoLoaderFn;
+    /**
+     * Override the AMD `vs` base URL used by the default `@monaco-editor/loader`
+     * path — e.g. `'/assets/monaco/vs'` to serve Monaco from your own origin.
+     * Ignored when `loader` is set.
+     */
+    vsPath?: string;
+}
+/** DI token holding the resolved {@link KjMonacoConfig}. Defaults to `{}`. */
+declare const KJ_MONACO_CONFIG: InjectionToken<KjMonacoConfig>;
+/**
+ * Configure the Monaco source for `KjEditor` / `<kj-editor>`. Call once at the
+ * app (or route) level. With no arguments the editor loads Monaco from the
+ * default CDN via `@monaco-editor/loader`.
+ *
+ * @example
+ * // Default CDN loader (nothing to install beyond the peer deps):
+ * provideMonaco()
+ *
+ * @example
+ * // Self-hosted Monaco assets:
+ * provideMonaco({ vsPath: '/assets/monaco/vs' })
+ *
+ * @example
+ * // Fully custom / bundled Monaco (you own the worker setup):
+ * provideMonaco({ loader: () => import('monaco-editor') })
+ *
+ * @doc
+ * @doc-name editor
+ * @doc-order 1
+ */
+declare function provideMonaco(config?: KjMonacoConfig): EnvironmentProviders;
+/**
+ * Registered per-language lazy loaders, keyed by (normalised) language id.
+ * `multi` so several `provideMonacoLanguages` calls compose; later
+ * registrations win on key collision. Consumed by `KjEditorLoader.ensureLanguage`.
+ */
+declare const KJ_MONACO_LANGUAGE_LOADERS: InjectionToken<Record<string, KjMonacoLanguageLoader>[]>;
+/**
+ * Register lazy loaders for individual Monaco languages so only the languages an
+ * editor actually uses are downloaded, and only when first used. This keeps the
+ * base editor lean when you bundle a **minimal** Monaco (the `provideMonaco({ loader })`
+ * path); with the default CDN loader every language is already bundled, so
+ * registering loaders is optional (a missing id simply falls back to the
+ * built-in language).
+ *
+ * @example
+ * provideMonacoLanguages({
+ *   python: () => import('monaco-editor/esm/vs/basic-languages/python/python.contribution'),
+ *   rust:   () => import('monaco-editor/esm/vs/basic-languages/rust/rust.contribution'),
+ * })
+ *
+ * @doc
+ * @doc-name editor
+ * @doc-order 2
+ */
+declare function provideMonacoLanguages(loaders: Record<string, KjMonacoLanguageLoader>): EnvironmentProviders;
+/** Map a friendly/alias language name to the canonical Monaco language id. */
+declare function normalizeLanguage(lang: string | undefined | null): string;
 /**
  * Orientation of the divider rule.
  */
@@ -11900,7 +13888,7 @@ declare class KjLink {
      * underline entirely (e.g. icon-text links inside breadcrumb separators).
      * Reflects `[attr.data-underline]`.
      */
-    readonly kjUnderline: _angular_core.InputSignal<"none" | "hover" | "always">;
+    readonly kjUnderline: _angular_core.InputSignal<"none" | "always" | "hover">;
     /**
      * External-link tri-state. `undefined` (default) auto-detects from the
      * host's `target` attribute (`target="_blank"` → external). `true` forces
@@ -11969,6 +13957,71 @@ declare const KJ_LINK_CONFIG: InjectionToken<KjLinkConfig>;
  */
 declare function provideKjLink(config: Partial<KjLinkConfig>): Provider[];
+/**
+ * Headless "skip to content" link. Turns a native `<a>` into a
+ * [WCAG 2.4.1 Bypass Blocks](https://www.w3.org/TR/WCAG21/#bypass-blocks)
+ * mechanism: a fragment link that, when activated, moves **keyboard focus** to
+ * the page's main-content landmark — not merely the scroll position.
+ *
+ * Owns the two behaviours a CSS-only skip link cannot deliver:
+ *
+ * 1. **Fragment `href`.** `[attr.href]` reflects `#<target-id>`, so the element
+ *    is a real anchor (role=link, Enter activates) and carries the id in the
+ *    SSR-prerendered HTML.
+ * 2. **Deterministic focus move.** On `click` (which Enter also fires on an
+ *    anchor) the directive `preventDefault()`s the navigation, looks the target
+ *    up by id, makes it programmatically focusable via `tabindex="-1"` when it
+ *    has no `tabindex`, and calls `focus()` (which also scrolls it into view).
+ *
+ *    `preventDefault()` is required, not optional: under a `<base href="/">`
+ *    (the norm for Angular SPAs) a fragment-only reference like `#main-content`
+ *    resolves against the **base URL**, not the current document — so the native
+ *    click would navigate to `/#main-content` (the root route), swapping the
+ *    page out and discarding focus. Moving focus programmatically is both the
+ *    correct behaviour and immune to that gotcha.
+ *
+ * Styling (visually-hidden-until-focused) is a component-layer concern; see
+ * `KjSkipLinkComponent` in `@kouji-ui/components`.
+ *
+ * @example
+ * ```html
+ * <a kjSkipLink>Skip to main content</a>
+ * <main id="main-content" tabindex="-1">…</main>
+ * ```
+ * @example
+ * ```html
+ * <a kjSkipLink="page-body">Skip to content</a>
+ * <section id="page-body" tabindex="-1">…</section>
+ * ```
+ *
+ * @doc-category Core/Navigation
+ * @doc
+ * @doc-name skip-link
+ * @doc-description Turns a native anchor into a focus-moving "skip to content" bypass link.
+ * @doc-is-main
+ */
+declare class KjSkipLink {
+    private readonly document;
+    /**
+     * `id` of the element to move focus to. Aliased to the selector attribute so
+     * `<a kjSkipLink="page-body">` sets it directly. Defaults to `'main-content'`.
+     *
+     * The `transform` maps an empty value to the default: a bare `<a kjSkipLink>`
+     * binds the attribute as `''` (the selector attribute is present but valueless),
+     * which would otherwise shadow the initial value.
+     */
+    readonly kjSkipLink: _angular_core.InputSignalWithTransform<string, string | undefined>;
+    /**
+     * Moves keyboard focus to the target landmark. Suppresses the anchor's native
+     * navigation (see class docs — it is base-relative and would leave the page),
+     * then adds `tabindex="-1"` when the target is not already focusable so
+     * `focus()` succeeds while keeping it out of the sequential tab order.
+     */
+    protected onActivate(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KjSkipLink, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KjSkipLink, "a[kjSkipLink]", never, { "kjSkipLink": { "alias": "kjSkipLink"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 /** Public-facing token interface representing a registered crumb item. */
 interface KjBreadcrumbItemContext {
     /** Index of the item among registered items (0-based, document order). */
@@ -13548,5 +15601,5 @@ declare const KJ_ALERT_CONFIG: InjectionToken<KjAlertConfig>;
  */
 declare function provideKjAlert(config: Partial<KjAlertConfig>): Provider[];
-export { DRAWER_DATA, DRAWER_DRAG, DRAWER_SIDE, KJ_ACCORDION, KJ_ACCORDION_ITEM, KJ_ALERT, KJ_ALERT_CONFIG, KJ_ALERT_DEFAULTS, KJ_AVATAR, KJ_AVATAR_GROUP, KJ_BREADCRUMB, KJ_BREADCRUMB_CONFIG, KJ_BREADCRUMB_DEFAULTS, KJ_BUTTON_CONFIG, KJ_BUTTON_DEFAULTS, KJ_BUTTON_GROUP, KJ_CALENDAR, KJ_CAROUSEL, KJ_CAROUSEL_INDICATORS, KJ_CAROUSEL_SLIDE, KJ_CASCADE_SELECT, KJ_CHAT, KJ_CHAT_BUBBLE_CONFIG, KJ_CHAT_BUBBLE_DEFAULTS, KJ_CHAT_LOG, KJ_COLOR_PICKER, KJ_CONFIRM_POPUP, KJ_DATE_PICKER, KJ_DROPDOWN_MENU, KJ_FIELD, KJ_FILE_UPLOAD, KJ_FILE_UPLOAD_DEFAULT_MESSAGES, KJ_FILE_UPLOAD_ITEM, KJ_FORM, KJ_FORM_FIELD, KJ_ICON_CSS_PATH, KJ_ICON_ENTRIES, KJ_ICON_LOADER, KJ_ICON_REGISTRY, KJ_ICON_RESOLVER, KJ_INPUT_GROUP, KJ_INPUT_MASK_PRESETS, KJ_INPUT_MASK_TOKENS, KJ_INPUT_OTP, KJ_KBD_SIZE_PRESET, KJ_LINK_CONFIG, KJ_LINK_DEFAULTS, KJ_LIST, KJ_LIST_FOCUS_MODE, KJ_LIST_NAVIGATOR_CONFIG, KJ_LIST_ROW, KJ_MENUBAR, KJ_NUMBER_INPUT, KJ_OVERLAY_BACKDROP_STRATEGY, KJ_OVERLAY_BADGE, KJ_OVERLAY_FOCUS_TRAP_STRATEGY, KJ_OVERLAY_LIVE_ANNOUNCER_STRATEGY, KJ_OVERLAY_MOUNT_STRATEGY, KJ_OVERLAY_PANEL_ROLE, KJ_OVERLAY_POSITION_STRATEGY, KJ_OVERLAY_SCROLL_LOCK_STRATEGY, KJ_OVERLAY_TRIGGER_EVENT_STRATEGY, KJ_PAGINATION, KJ_PAGINATION_CONFIG, KJ_PAGINATION_DEFAULTS, KJ_PASSWORD_INPUT, KJ_PROGRESS_BAR, KJ_PROGRESS_BAR_CONFIG, KJ_PROGRESS_BAR_DEFAULTS, KJ_PROSE_CSS_PATH, KJ_RADIO_GROUP, KJ_ROVING_TABINDEX, KJ_SELECT, KJ_SIZE_PRESET, KJ_SLIDER, KJ_SPEED_DIAL, KJ_SPINNER_CONFIG, KJ_SPINNER_DEFAULTS, KJ_STEP, KJ_STEPPER, KJ_TABLE, KJ_TABLE_STORAGE, KJ_TABS, KJ_TAG, KJ_TAG_CONFIG, KJ_TAG_DEFAULTS, KJ_TAG_LIST, KJ_TEXTAREA_CONFIG, KJ_TEXTAREA_DEFAULTS, KJ_TIME_PICKER, KJ_TOAST_LIST_STRATEGY, KJ_TOAST_SONNER_STRATEGY, KJ_TOAST_STRATEGY, KJ_TREE_SELECT, KJ_VARIANT_PRESET, KjAccordion, KjAccordionContent, KjAccordionItem, KjAccordionTrigger, KjAlert, KjAlertActions, KjAlertDescription, KjAlertDismiss, KjAlertIcon, KjAlertTitle, KjAriaDescribedBy, KjAriaLabelledBy, KjAvatar, KjAvatarFallback, KjAvatarGroup, KjAvatarImage, KjBackdrop, KjBadge, KjBlockquote, KjBreadcrumb, KjBreadcrumbCurrent, KjBreadcrumbEllipsis, KjBreadcrumbItem, KjBreadcrumbLink, KjBreadcrumbList, KjBreadcrumbSeparator, KjButton, KjButtonGroup, KjCalendar, KjCalendarDay, KjCalendarGrid, KjCalendarHeader, KjCarousel, KjCarouselAutoplay, KjCarouselIndicator, KjCarouselIndicators, KjCarouselNext, KjCarouselPauseToggle, KjCarouselPrevious, KjCarouselSlide, KjCarouselViewport, KjCascadeSelect, KjCascadeSelectOption, KjCascadeSelectPanel, KjCascadeSelectSubPanel, KjCascadeSelectTrigger, KjChart, KjChat, KjChatAvatar, KjChatBubble, KjChatFooter, KjChatHeader, KjChatLog, KjCheckbox, KjCode, KjColorPicker, KjColorPickerAlphaSlider, KjColorPickerArea, KjColorPickerHueSlider, KjColorPickerInput, KjColorPickerPanel, KjColorPickerTrigger, KjCombobox, KjComboboxInput, KjComboboxListbox, KjComboboxOption, KjCommandEmpty, KjCommandGroup, KjCommandInput, KjCommandItem, KjCommandList, KjCommandPalette, KjCommandPaletteDialog, KjCommandPaletteTrigger, KjCommandSeparator, KjConfirmPopup, KjConfirmPopupAction, KjConfirmPopupCancel, KjConfirmPopupContent, KjConfirmPopupMessage, KjConfirmPopupTrigger, KjDatePicker, KjDatePickerCalendar, KjDatePickerTrigger, KjDialog$1 as KjDialog, KjDialogRef, KjDialog as KjDialogService, KjDirectionality, KjDisabled, KjDivider, KjDrawer, KjDrawerRef, KjDrawerService, KjDropdownMenu, KjDropdownMenuContent, KjDropdownMenuGroup, KjDropdownMenuItem, KjDropdownMenuLabel, KjDropdownMenuSeparator, KjDropdownMenuTrigger, KjField, KjFieldError, KjFieldGroup, KjFieldHelp, KjFieldLabel, KjFileUpload, KjFileUploadDropzone, KjFileUploadItem, KjFileUploadList, KjFileUploadTrigger, KjFilterableList, KjFocusRing, KjFocusTrap, KjForm, KjFormControl, KjFormError, KjFormErrorSummary, KjFormField, KjFormLabel, KjIconDirective, KjId, KjInput, KjInputGroup, KjInputGroupAddon, KjInputMask, KjInputOtp, KjInputOtpCell, KjKbd, KjLead, KjLink, KjList, KjListGroup, KjListGroupLabel, KjListItem, KjListNavigator, KjListRow, KjListSeparator, KjLiveRegion, KjMenubar, KjMenubarItem, KjMuted, KjNumberInput, KjNumberInputGroup, KjNumberStepper, KjOption, KjOverlayBadge, KjOverlayBadgeContent, KjOverlayBuilder, KjOverlayController, KjOverlayHandle, KjOverlayPanel, KjOverlayStack, KjOverlayTrigger, KjOverlayWrapper, KjPagination, KjPaginationEllipsis, KjPaginationFirst, KjPaginationInfo, KjPaginationItem, KjPaginationLast, KjPaginationNext, KjPaginationPrevious, KjPasswordCapsLockWarning, KjPasswordInput, KjPasswordInputScope, KjPasswordStrength, KjPasswordToggle, KjPopoverArrow, KjPopoverClose, KjPopoverContent, KjPopoverTitle, KjPopoverTrigger, KjProgressBar, KjProgressBarFill, KjRadio, KjRadioGroup, KjRovingTabindex, KjRovingTabindexItemDirective, KjSelect, KjSelectContent, KjSelectTrigger, KjSelectionModel, KjSize, KjSkeleton, KjSlider, KjSliderRange, KjSliderThumb, KjSliderTrack, KjSpeedDial, KjSpeedDialAction, KjSpeedDialActions, KjSpeedDialTrigger, KjSpinner, KjStep, KjStepContent, KjStepLabel, KjStepper, KjStepperNext, KjStepperPrevious, KjStepperReset, KjTab, KjTabList, KjTabPanel, KjTable, KjTableCell, KjTableFilterOutlet, KjTableHeader, KjTableKeyboardNav, KjTableRow, KjTabs, KjTag, KjTagList, KjTagRemove, KjTextarea, KjTimePicker, KjTimePickerHours, KjTimePickerMeridiem, KjTimePickerMinutes, KjTimePickerSeconds, KjToast, KjToastClose, KjToastPanel, KjToastRef, KjToastService, KjToastViewport, KjToggle, KjTooltipArrow, KjTooltipContent, KjTooltipGroup, KjTooltipTrigger, KjTreeSelect, KjTreeSelectContent, KjTreeSelectNode, KjTreeSelectToggle, KjTreeSelectTrigger, KjTruncate, KjTypeAhead, KjVariant, KjVisuallyHidden, MaskEngine, addDays, addMonths, addYears, anchoredTo, assertive, bindPresets, blurredBackdrop, bodyPortal, buildMonthMatrix, compareDay, compileMask, corner, cssClip, defaultMaskTokens, defaultPasswordScorer, edgeSheet, endOfMonth, firstDayOfWeek, formatDateLong, formatDateShort, formatMonthYear, getIconMode, htmlOverflow, inContainer, inMemoryAdapter, inPlace, inPlaceSibling, inertBased, injectFilterableList, injectKjFilterParams, injectKjIconResolver, injectListItem, injectSelectionModel, isInRange, isKjFilterModel, isSameDay, isSameMonth, kjColumn, kjColumnGroup, kjContainsFilter, kjDateFilterFn, kjFileMatchesAccept, kjFuzzyFilter, kjHsvToHsl, kjHsvToRgb, kjMultiFilterFn, kjNumberFilterFn, kjParseHex, kjRgbToHex, kjRgbToHsv, kjSetFilterFn, kjStartsWithFilter, kjSubstringFilter, kjTableResource, kjTextFilterFn, localStorageAdapter, nextCascadeId, nextDropdownMenuLabelId, nextPopoverTitleId, noBackdrop, noScrollLock, noTrap, onClick, onContextMenu, onFocus, onFocusOrInput, onHotkey, onHover, parseDate, pointAt, polite, programmatic, provideIconLoader, provideIconResolver, provideIcons, provideKjAlert, provideKjBreadcrumb, provideKjButton, provideKjChatBubble, provideKjFilterParams, provideKjInputMaskTokens, provideKjLink, provideKjPagination, provideKjProgressBar, provideKjSpinner, provideKjTableStorage, provideKjTag, provideKjTextarea, provideKjToastListStrategy, provideKjToastSonnerStrategy, provideKjToastStrategy, sessionStorageAdapter, silent, solidBackdrop, startOfDay, startOfMonth, stripDiacritics, tabCycle, toDeepSignal, viewportCentered, weekdayLongNames, weekdayShortNames };
-export type { CompiledMask, DeepSignal, IconLoader, IconMode, IconResolver, InvalidControlInfo, KjAccordionContext, KjAccordionItemContext, KjAccordionType, KjAggregation, KjAggregationFn, KjAggregationKind, KjAlertConfig, KjAlertContext, KjAlertMode, KjAlign, KjAnchoredToOpts, KjAnchoredToStrategy, KjAriaHasPopup, KjAsyncSubmitHandler, KjAttachOptions, KjAvatarGroupAriaLabelFormat, KjAvatarGroupContext, KjAvatarGroupDirection, KjAvatarShape, KjBackdropStrategy, KjBadgeVariant, KjBindablePresetConfig, KjBreadcrumbConfig, KjBreadcrumbContext, KjBreadcrumbItemContext, KjButtonConfig, KjButtonGroupContext, KjButtonGroupOrientation, KjCalendarContext, KjCarouselAlign, KjCarouselContext, KjCarouselControlPattern, KjCarouselIndicatorsContext, KjCarouselOrientation, KjCarouselSlideContext, KjCascadeNode, KjCascadeSelectContext, KjChatBubbleConfig, KjChatContext, KjChatLogContext, KjChatRole, KjChatSide, KjChatState, KjCloseReason, KjColorFormat, KjColorPickerContext, KjColorPreset, KjColorValue, KjColumnApi, KjColumnDef, KjColumnGroupingApi, KjColumnMeta, KjColumnOrderApi, KjColumnPin, KjColumnPinningApi, KjColumnSizingApi, KjColumnType, KjColumnVisibilityApi, KjCommandActivateEvent, KjCommandFilter, KjCompareFn, KjConfirmPopupContext, KjConfirmPopupDefaultFocus, KjContainerTarget, KjCornerPosition, KjDateFilterModel, KjDateFilterType, KjDatePickerContext, KjDensityApi, KjDialogOpenOptions, KjDirection, KjDividerAlign, KjDividerOrientation, KjDrawerOpenOptions, KjDrawerSide, KjDropdownMenuCloseReason, KjDropdownMenuContext, KjDropdownMenuMount, KjDropdownMenuTriggerKind, KjEditorRef, KjExpansionApi, KjFieldContext, KjFileRejectReason, KjFileRejection, KjFileStatus, KjFileUploadAggregateStatus, KjFileUploadContext, KjFileUploadItemContext, KjFileUploadValidationMessages, KjFilterApi, KjFilterFn, KjFilterModel, KjFilterParams, KjFilterRenderer, KjFilterUiRef, KjFocusTrapStrategy, KjFormContext, KjFormControlRegistration, KjFormFieldContext, KjGlobalFilterApi, KjGridApi, KjGridFilterModel, KjGroupingApi, KjHourCycle, KjHsl, KjHsv, KjIconColor, KjIconSize, KjInputGroupContext, KjInputOtpContext, KjLinkConfig, KjListAs, KjListContext, KjListFocusMode, KjListNavigatorConfig, KjListOrientation, KjListRowContext, KjListSelectionMode, KjLiveAnnouncerStrategy, KjLivePoliteness, KjMenubarContext, KjMenubarItemContext, KjMountStrategy, KjMultiConditionFilterModel, KjNumberFilterModel, KjNumberFilterType, KjNumberInputContext, KjOnContextMenuOpts, KjOnContextMenuStrategy, KjOnHoverOpts, KjOnHoverStrategy, KjOverlayBadgeContext, KjOverlayBadgePosition, KjOverlayBuilderConfig, KjOverlayContext, KjLivePoliteness$1 as KjOverlayLivePoliteness, KjOverlayRegistration, KjOverlayStackHandle, KjOverlayState, KjOverlayStrategies, KjOverlayTriggerLike, KjPageToken, KjPaginationApi, KjPaginationConfig, KjPaginationContext, KjPanelRole, KjPasswordAutocomplete, KjPasswordInputContext, KjPasswordScore, KjPasswordScoreLabel, KjPlacement, KjPointAtOpts, KjPopoverTriggerKind, KjPositionStrategy, KjProgressBarConfig, KjProgressBarContext, KjRadioContext, KjResourceResult, KjRgb, KjRowsApi, KjScrollLockStrategy, KjSelectionApi, KjSetFilterModel, KjSheetSide, KjSide, KjSizePreset, KjSkeletonAnimation, KjSkeletonShape, KjSliderContext, KjSliderSource, KjSliderThumbHandle, KjSolidBackdropOpts, KjSolidBackdropStrategy, KjSortApi, KjSortDirection, KjSpeedDialContext, KjSpeedDialDirection, KjSpinnerAnimation, KjSpinnerConfig, KjStepContext, KjStepperContext, KjStorageAdapter, KjStrategy, KjTabCycleOpts, KjTabCycleStrategy, KjTableState, KjTabsActivationMode, KjTabsContext, KjTabsOrientation, KjTagConfig, KjTagContext, KjTagListContext, KjTagListRole, KjTextFilterModel, KjTextFilterType, KjTextareaAutoresize, KjTextareaConfig, KjTextareaResize, KjTimePickerContext, KjToastContext, KjToastItem, KjToastOptions, KjToastPositionX, KjToastPositionY, KjToastRenderable, KjToastStrategy, KjToastSugarVariant, KjToastTemplateContext, KjToastVariant, KjTreeNode, KjTreeSelectContext, KjTreeShape, KjTriggerEventStrategy, KjUploadableFile, KjVariantPreset, MaskEngineCallbacks, MaskEngineOptions, Slot, TimeParts };
+export { DRAWER_DATA, DRAWER_DRAG, DRAWER_SIDE, EN_CATALOG, FR_CATALOG, KJ_ACCORDION, KJ_ACCORDION_ITEM, KJ_ALERT, KJ_ALERT_CONFIG, KJ_ALERT_DEFAULTS, KJ_AVATAR, KJ_AVATAR_GROUP, KJ_BREADCRUMB, KJ_BREADCRUMB_CONFIG, KJ_BREADCRUMB_DEFAULTS, KJ_BUTTON_CONFIG, KJ_BUTTON_DEFAULTS, KJ_BUTTON_GROUP, KJ_CALENDAR, KJ_CAROUSEL, KJ_CAROUSEL_INDICATORS, KJ_CAROUSEL_SLIDE, KJ_CASCADE_SELECT, KJ_CHAT, KJ_CHAT_BUBBLE_CONFIG, KJ_CHAT_BUBBLE_DEFAULTS, KJ_CHAT_LOG, KJ_COLOR_PICKER, KJ_CONFIRM_POPUP, KJ_DATE_PICKER, KJ_DATE_RANGE_PRESETS, KJ_DROPDOWN_MENU, KJ_ECHARTS, KJ_FIELD, KJ_FILE_UPLOAD, KJ_FILE_UPLOAD_DEFAULT_MESSAGES, KJ_FILE_UPLOAD_ITEM, KJ_FORM, KJ_FORM_FIELD, KJ_ICON_CSS_PATH, KJ_ICON_ENTRIES, KJ_ICON_LOADER, KJ_ICON_REGISTRY, KJ_ICON_RESOLVER, KJ_INPUT_GROUP, KJ_INPUT_MASK_PRESETS, KJ_INPUT_MASK_TOKENS, KJ_INPUT_OTP, KJ_KBD_SIZE_PRESET, KJ_LINK_CONFIG, KJ_LINK_DEFAULTS, KJ_LIST, KJ_LIST_FOCUS_MODE, KJ_LIST_NAVIGATOR_CONFIG, KJ_LIST_ROW, KJ_LOCALE_CONFIG, KJ_MENUBAR, KJ_MONACO_CONFIG, KJ_MONACO_LANGUAGE_LOADERS, KJ_NUMBER_INPUT, KJ_OVERLAY_BACKDROP_STRATEGY, KJ_OVERLAY_BADGE, KJ_OVERLAY_FOCUS_TRAP_STRATEGY, KJ_OVERLAY_LIVE_ANNOUNCER_STRATEGY, KJ_OVERLAY_MOUNT_STRATEGY, KJ_OVERLAY_PANEL_ROLE, KJ_OVERLAY_POSITION_STRATEGY, KJ_OVERLAY_SCROLL_LOCK_STRATEGY, KJ_OVERLAY_TRIGGER_EVENT_STRATEGY, KJ_PAGINATION, KJ_PAGINATION_CONFIG, KJ_PAGINATION_DEFAULTS, KJ_PASSWORD_INPUT, KJ_PROGRESS_BAR, KJ_PROGRESS_BAR_CONFIG, KJ_PROGRESS_BAR_DEFAULTS, KJ_PROSE_CSS_PATH, KJ_RADIO_GROUP, KJ_RICH_TEXT, KJ_RICH_TEXT_EXTENSIONS, KJ_RICH_TEXT_FEATURES, KJ_RICH_TEXT_NODE, KJ_ROVING_TABINDEX, KJ_RTE_OVERLAY_DATA, KJ_SELECT, KJ_SIZE_PRESET, KJ_SLIDER, KJ_SPEED_DIAL, KJ_SPINNER_CONFIG, KJ_SPINNER_DEFAULTS, KJ_STEP, KJ_STEPPER, KJ_TABLE, KJ_TABLE_STORAGE, KJ_TABS, KJ_TAG, KJ_TAG_CONFIG, KJ_TAG_DEFAULTS, KJ_TAG_LIST, KJ_TEXTAREA_CONFIG, KJ_TEXTAREA_DEFAULTS, KJ_TIME_PICKER, KJ_TOAST_LIST_STRATEGY, KJ_TOAST_SONNER_STRATEGY, KJ_TOAST_STRATEGY, KJ_TRANSLATION_CATALOGS, KJ_TREE_SELECT, KJ_VARIANT_PRESET, KjAccordion, KjAccordionContent, KjAccordionItem, KjAccordionTrigger, KjAlert, KjAlertActions, KjAlertDescription, KjAlertDismiss, KjAlertIcon, KjAlertTitle, KjAriaDescribedBy, KjAriaLabelledBy, KjAvatar, KjAvatarFallback, KjAvatarGroup, KjAvatarImage, KjBackdrop, KjBadge, KjBlockquote, KjBreadcrumb, KjBreadcrumbCurrent, KjBreadcrumbEllipsis, KjBreadcrumbItem, KjBreadcrumbLink, KjBreadcrumbList, KjBreadcrumbSeparator, KjButton, KjButtonGroup, KjCalendar, KjCalendarDay, KjCalendarGrid, KjCalendarHeader, KjCarousel, KjCarouselAutoplay, KjCarouselIndicator, KjCarouselIndicators, KjCarouselNext, KjCarouselPauseToggle, KjCarouselPrevious, KjCarouselSlide, KjCarouselViewport, KjCascadeSelect, KjCascadeSelectOption, KjCascadeSelectPanel, KjCascadeSelectSubPanel, KjCascadeSelectTrigger, KjChart, KjChartTableFallback, KjChat, KjChatAnnouncer, KjChatAvatar, KjChatBubble, KjChatFooter, KjChatHeader, KjChatLog, KjChatStore, KjCheckbox, KjCode, KjColorPicker, KjColorPickerAlphaSlider, KjColorPickerArea, KjColorPickerHueSlider, KjColorPickerInput, KjColorPickerPanel, KjColorPickerTrigger, KjCombobox, KjComboboxInput, KjComboboxListbox, KjComboboxOption, KjCommandEmpty, KjCommandGroup, KjCommandInput, KjCommandItem, KjCommandList, KjCommandPalette, KjCommandPaletteDialog, KjCommandPaletteTrigger, KjCommandSeparator, KjConfirmPopup, KjConfirmPopupAction, KjConfirmPopupCancel, KjConfirmPopupContent, KjConfirmPopupMessage, KjConfirmPopupTrigger, KjDatePicker, KjDatePickerCalendar, KjDatePickerTrigger, KjDateRangePresetOption, KjDateRangePresets, KjDialog$1 as KjDialog, KjDialogRef, KjDialog as KjDialogService, KjDirectionality, KjDisabled, KjDivider, KjDrawer, KjDrawerRef, KjDrawerService, KjDropdownMenu, KjDropdownMenuContent, KjDropdownMenuGroup, KjDropdownMenuItem, KjDropdownMenuLabel, KjDropdownMenuSeparator, KjDropdownMenuTrigger, KjEditor, KjEditorLoader, KjField, KjFieldError, KjFieldGroup, KjFieldHelp, KjFieldLabel, KjFileUpload, KjFileUploadDropzone, KjFileUploadItem, KjFileUploadList, KjFileUploadTrigger, KjFilterableList, KjFocusRing, KjFocusTrap, KjForm, KjFormControl, KjFormError, KjFormErrorSummary, KjFormField, KjFormLabel, KjIconDirective, KjId, KjInput, KjInputGroup, KjInputGroupAddon, KjInputMask, KjInputOtp, KjInputOtpCell, KjKbd, KjLead, KjLink, KjList, KjListGroup, KjListGroupLabel, KjListItem, KjListNavigator, KjListRow, KjListSeparator, KjLiveRegion, KjLocale, KjMenubar, KjMenubarItem, KjMotion, KjMuted, KjNumberInput, KjNumberInputGroup, KjNumberStepper, KjOption, KjOverlayBadge, KjOverlayBadgeContent, KjOverlayBuilder, KjOverlayController, KjOverlayHandle, KjOverlayPanel, KjOverlayStack, KjOverlayTrigger, KjOverlayWrapper, KjPagination, KjPaginationEllipsis, KjPaginationFirst, KjPaginationInfo, KjPaginationItem, KjPaginationLast, KjPaginationNext, KjPaginationPrevious, KjPasswordCapsLockWarning, KjPasswordInput, KjPasswordInputScope, KjPasswordStrength, KjPasswordToggle, KjPopoverArrow, KjPopoverClose, KjPopoverContent, KjPopoverTitle, KjPopoverTrigger, KjProgressBar, KjProgressBarFill, KjRadio, KjRadioGroup, KjReducedMotion, KjRichTextEditor, KjRichTextExtensionDirective, KjRovingTabindex, KjRovingTabindexItemDirective, KjSelect, KjSelectContent, KjSelectTrigger, KjSelectionModel, KjSheet, KjSheetRef, KjSheetService, KjSize, KjSkeleton, KjSkipLink, KjSlider, KjSliderRange, KjSliderThumb, KjSliderTrack, KjSpeedDial, KjSpeedDialAction, KjSpeedDialActions, KjSpeedDialTrigger, KjSpinner, KjStep, KjStepContent, KjStepLabel, KjStepper, KjStepperNext, KjStepperPrevious, KjStepperReset, KjTab, KjTabList, KjTabPanel, KjTable, KjTableCell, KjTableFilterOutlet, KjTableHeader, KjTableKeyboardNav, KjTableRow, KjTabs, KjTag, KjTagList, KjTagRemove, KjTextarea, KjTimePicker, KjTimePickerHours, KjTimePickerMeridiem, KjTimePickerMinutes, KjTimePickerSeconds, KjToast, KjToastClose, KjToastPanel, KjToastRef, KjToastService, KjToastViewport, KjToggle, KjTooltipArrow, KjTooltipContent, KjTooltipGroup, KjTooltipTrigger, KjTranslate, KjTranslateService, KjTreeSelect, KjTreeSelectContent, KjTreeSelectNode, KjTreeSelectToggle, KjTreeSelectTrigger, KjTruncate, KjTypeAhead, KjVariant, KjVisuallyHidden, MaskEngine, SHEET_ARIA_LABEL, SHEET_DATA, SHEET_DETENT, SHEET_DISMISSIBLE, addDays, addMonths, addYears, anchoredTo, assertive, bindPresets, blurredBackdrop, bodyPortal, buildMonthMatrix, coalesceAnnouncement, compareDay, compileMask, corner, createKjDecoratorNode, createKjImageNode, cssClip, defaultDateRangePresets, defaultMaskTokens, defaultPasswordScorer, edgeSheet, endOfMonth, firstDayOfWeek, formatDateLong, formatDateShort, formatMonthYear, getIconMode, htmlOverflow, inContainer, inMemoryAdapter, inPlace, inPlaceSibling, inertBased, injectFilterableList, injectKjFilterParams, injectKjIconResolver, injectListItem, injectRichTextNode, injectRteOverlayData, injectSelectionModel, isInRange, isKjFilterModel, isSameDay, isSameMonth, kjApplyServerErrors, kjColumn, kjColumnGroup, kjContainsFilter, kjDateFilterFn, kjFileMatchesAccept, kjFuzzyFilter, kjHsvToHsl, kjHsvToRgb, kjMultiFilterFn, kjNumberFilterFn, kjParseHex, kjRgbToHex, kjRgbToHsv, kjServerErrorsOf, kjSetFilterFn, kjStartsWithFilter, kjSubstringFilter, kjTableResource, kjTextFilterFn, localStorageAdapter, matchSlashCommands, nextCascadeId, nextChatMessageId, nextDropdownMenuLabelId, nextPopoverTitleId, noBackdrop, noScrollLock, noTrap, normalizeLanguage, onClick, onContextMenu, onFocus, onFocusOrInput, onHotkey, onHover, parseDate, parseSlash, pointAt, polite, programmatic, provideECharts, provideIconLoader, provideIconResolver, provideIcons, provideKjAlert, provideKjBreadcrumb, provideKjButton, provideKjChatBubble, provideKjDocumentDirection, provideKjFilterParams, provideKjInputMaskTokens, provideKjLink, provideKjLocale, provideKjPagination, provideKjProgressBar, provideKjRichText, provideKjSpinner, provideKjTableStorage, provideKjTag, provideKjTextarea, provideKjToastListStrategy, provideKjToastSonnerStrategy, provideKjToastStrategy, provideKjTranslations, provideMonaco, provideMonacoLanguages, resolveChartPalette, resolveDateRangePreset, sessionStorageAdapter, silent, solidBackdrop, startOfDay, startOfMonth, stripDiacritics, tabCycle, toDeepSignal, viewportCentered, weekdayLongNames, weekdayShortNames };
+export type { CompiledMask, DeepSignal, IconLoader, IconMode, IconResolver, InvalidControlInfo, KjAccordionContext, KjAccordionItemContext, KjAccordionType, KjActiveOverlay, KjAggregation, KjAggregationFn, KjAggregationKind, KjAlertConfig, KjAlertContext, KjAlertMode, KjAlign, KjAnchoredToOpts, KjAnchoredToStrategy, KjApplyServerErrorsOptions, KjAriaHasPopup, KjAsyncSubmitHandler, KjAttachOptions, KjAvatarGroupAriaLabelFormat, KjAvatarGroupContext, KjAvatarGroupDirection, KjAvatarShape, KjBackdropStrategy, KjBadgeVariant, KjBindablePresetConfig, KjBlockType, KjBreadcrumbConfig, KjBreadcrumbContext, KjBreadcrumbItemContext, KjButtonConfig, KjButtonGroupContext, KjButtonGroupOrientation, KjCalendarContext, KjCarouselAlign, KjCarouselContext, KjCarouselControlPattern, KjCarouselIndicatorsContext, KjCarouselOrientation, KjCarouselSlideContext, KjCascadeNode, KjCascadeSelectContext, KjChartEvent, KjChatBubbleConfig, KjChatCitation, KjChatContext, KjChatLogContext, KjChatMessageData, KjChatMessageRole, KjChatRole, KjChatSide, KjChatState, KjChatStatus, KjChatToolCall, KjChatToolStatus, KjCloseReason, KjCoalesceOptions, KjCoalesceResult, KjColorFormat, KjColorPickerContext, KjColorPreset, KjColorValue, KjColumnApi, KjColumnDef, KjColumnGroupingApi, KjColumnMeta, KjColumnOrderApi, KjColumnPin, KjColumnPinningApi, KjColumnSizingApi, KjColumnType, KjColumnVisibilityApi, KjCommandActivateEvent, KjCommandFilter, KjCompareFn, KjConfirmPopupContext, KjConfirmPopupDefaultFocus, KjContainerTarget, KjCornerPosition, KjDateFilterModel, KjDateFilterType, KjDatePickerContext, KjDateRange, KjDateRangePreset, KjDateRangePresetsContext, KjDecoratorMountAdapter, KjDecoratorNodeApi, KjDecoratorNodeConfig, KjDecoratorRegistration, KjDensityApi, KjDialogOpenOptions, KjDirection, KjDividerAlign, KjDividerOrientation, KjDrawerOpenOptions, KjDrawerSide, KjDropdownMenuCloseReason, KjDropdownMenuContext, KjDropdownMenuMount, KjDropdownMenuTriggerKind, KjEChartsCore, KjEChartsLoader, KjEditorInstance, KjEditorLanguage, KjEditorLineNumbers, KjEditorOptions, KjEditorRef, KjEditorWordWrap, KjExpansionApi, KjFieldContext, KjFileRejectReason, KjFileRejection, KjFileStatus, KjFileUploadAggregateStatus, KjFileUploadContext, KjFileUploadItemContext, KjFileUploadValidationMessages, KjFilterApi, KjFilterFn, KjFilterModel, KjFilterParams, KjFilterRenderer, KjFilterUiRef, KjFocusTrapStrategy, KjFormContext, KjFormControlRegistration, KjFormFieldContext, KjGlobalFilterApi, KjGridApi, KjGridFilterModel, KjGroupingApi, KjHourCycle, KjHsl, KjHsv, KjIconColor, KjIconSize, KjImageInsert, KjImageNodeApi, KjInputGroupContext, KjInputOtpContext, KjLinkConfig, KjListAs, KjListContext, KjListFocusMode, KjListNavigatorConfig, KjListOrientation, KjListRowContext, KjListSelectionMode, KjLiveAnnouncerStrategy, KjLivePoliteness, KjLocaleConfig, KjMenubarContext, KjMenubarItemContext, KjMonaco, KjMonacoConfig, KjMonacoLanguageLoader, KjMonacoLoaderFn, KjMotionState, KjMountStrategy, KjMountedComponent, KjMultiConditionFilterModel, KjNumberFilterModel, KjNumberFilterType, KjNumberInputContext, KjOnContextMenuOpts, KjOnContextMenuStrategy, KjOnHoverOpts, KjOnHoverStrategy, KjOverlayBadgeContext, KjOverlayBadgePosition, KjOverlayBuilderConfig, KjOverlayContext, KjLivePoliteness$1 as KjOverlayLivePoliteness, KjOverlayRegistration, KjOverlayStackHandle, KjOverlayState, KjOverlayStrategies, KjOverlayTriggerLike, KjPageToken, KjPaginationApi, KjPaginationConfig, KjPaginationContext, KjPanelRole, KjPasswordAutocomplete, KjPasswordInputContext, KjPasswordScore, KjPasswordScoreLabel, KjPlacement, KjPointAtOpts, KjPopoverTriggerKind, KjPositionStrategy, KjProgressBarConfig, KjProgressBarContext, KjRadioContext, KjResourceResult, KjRgb, KjRichTextContext, KjRichTextExtension, KjRichTextFeature, KjRichTextHost, KjRichTextPlugin, KjRichTextState, KjRichTextValue, KjRowsApi, KjRteOverlay, KjRteShortcut, KjRteToolbarGroup, KjRteToolbarItem, KjRteToolbarKind, KjScrollLockStrategy, KjSelectionApi, KjServerErrors, KjSetFilterModel, KjSheetDetent, KjSheetOpenOptions, KjSheetSide, KjSide, KjSizePreset, KjSkeletonAnimation, KjSkeletonShape, KjSlashCommand, KjSlashParse, KjSliderContext, KjSliderSource, KjSliderThumbHandle, KjSolidBackdropOpts, KjSolidBackdropStrategy, KjSortApi, KjSortDirection, KjSpeedDialContext, KjSpeedDialDirection, KjSpinnerAnimation, KjSpinnerConfig, KjStepContext, KjStepperContext, KjStorageAdapter, KjStrategy, KjTabCycleOpts, KjTabCycleStrategy, KjTableState, KjTabsActivationMode, KjTabsContext, KjTabsOrientation, KjTagConfig, KjTagContext, KjTagListContext, KjTagListRole, KjTextFilterModel, KjTextFilterType, KjTextFormat, KjTextareaAutoresize, KjTextareaConfig, KjTextareaResize, KjTimePickerContext, KjToastContext, KjToastItem, KjToastOptions, KjToastPositionX, KjToastPositionY, KjToastRenderable, KjToastStrategy, KjToastSugarVariant, KjToastTemplateContext, KjToastVariant, KjTranslationCatalog, KjTranslationCatalogs, KjTranslationKey, KjTranslationParams, KjTreeNode, KjTreeSelectContext, KjTreeShape, KjTriggerEventStrategy, KjUploadableFile, KjVariantPreset, MaskEngineCallbacks, MaskEngineOptions, Slot, TimeParts };