@alfadocs/ui-kit 0.69.0 → 0.71.0

package/dist/components/task-card/task-card.d.ts

@@ -2,6 +2,8 @@ import { type HTMLAttributes, type ReactNode } from 'react';
 import { type VariantProps } from 'class-variance-authority';
 export type TaskStatus = 'open' | 'in-progress' | 'done';
 export type TaskPriority = 'low' | 'normal' | 'high';
+/** Which entity the task links to. The platform `DoctorReminder` links to exactly one of these (or none). */
+export type TaskLinkType = 'patient' | 'company' | 'operator';
 export interface TaskItem {
     /** Unique identifier for the task. */
     id: string;
@@ -16,11 +18,17 @@ export interface TaskItem {
      */
     dueLabel?: string;
     /**
-     * Linked-entity line (the patient / company / operator the task points
-     * at). Rendered as an eyebrow under the description; localised by the
-     * consumer (e.g. "Patient: Mario Rossi").
+     * Linked-entity NAME (the patient / company / operator the task points at) —
+     * e.g. "Mario Rossi". When `linkType` is set the card renders it as a typed
+     * chip (a per-type glyph + an accessible "Patient/Company/Operator:" prefix);
+     * otherwise it renders as a plain eyebrow line. The consumer composes the
+     * name only — no prefix.
      */
     linkedLabel?: string;
+    /** Type of the linked entity — drives the leading glyph + the accessible prefix on the linked chip. */
+    linkType?: TaskLinkType;
+    /** Localised assignee display name (host-composed, e.g. "Dr. Alfa"). Renders an assignee chip on the meta line. */
+    assigneeLabel?: string;
     /** Free-text note attached to the task — muted body line, clamped. */
     note?: string;
     /** Lifecycle state — drives the leading icon. */
@@ -33,8 +41,8 @@ export interface TaskItem {
 export interface TaskCardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onClick' | 'role' | 'title'>, VariantProps<typeof taskCardVariants> {
     /** The task to render. */
     item: TaskItem;
-    /** Visual density. */
-    size?: 'sm' | 'md';
+    /** Visual density. `xs` is the compact rail row (Control Room); `sm`/`md` for in-page lists. */
+    size?: 'xs' | 'sm' | 'md';
     /** Fires when the row is activated (click / Enter / Space). */
     onActivate?: (item: TaskItem) => void;
     /**
@@ -45,7 +53,7 @@ export interface TaskCardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onC
     actions?: ReactNode;
 }
 declare const taskCardVariants: (props?: ({
-    size?: "sm" | "md" | null | undefined;
+    size?: "sm" | "md" | "xs" | null | undefined;
     interactive?: boolean | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export declare function isSafeTaskUrl(url: string): boolean;

package/dist/components/task-tray/index.js

@@ -1,4 +1,4 @@
-import { T as s, t } from "../../_chunks/task-tray-qOEQflu4.js";
+import { T as s, t } from "../../_chunks/task-tray-DNVejijD.js";
 export {
   s as TaskTray,
   t as taskTrayAgent

package/dist/components/tasks-panel/index.d.ts

@@ -0,0 +1,4 @@
+export { TasksPanel } from './tasks-panel';
+export type { TasksPanelProps, TasksPanelHandle, TasksPanelItem, TasksPanelSize, TasksPanelScope, TasksPanelStatusFilter, } from './tasks-panel';
+export { tasksPanelAgent } from './tasks-panel.agent';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/tasks-panel/index.js

@@ -0,0 +1,6 @@
+import { T as e, t } from "../../_chunks/tasks-panel-C9odmawT.js";
+export {
+  e as TasksPanel,
+  t as tasksPanelAgent
+};
+//# sourceMappingURL=index.js.map

package/dist/components/tasks-panel/tasks-panel.agent.d.ts

@@ -0,0 +1,4 @@
+import type { AgentAdapter } from '../../agent/types';
+import type { TasksPanelHandle } from './tasks-panel';
+export declare const tasksPanelAgent: AgentAdapter<TasksPanelHandle>;
+//# sourceMappingURL=tasks-panel.agent.d.ts.map

package/dist/components/tasks-panel/tasks-panel.d.ts

@@ -0,0 +1,152 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import { type VariantProps } from 'class-variance-authority';
+import { type TaskItem } from '../task-card';
+/** Which set of tasks the panel shows — the host owns the actual feed. */
+export type TasksPanelScope = 'patient' | 'mine';
+/** Status segment value. Mirrors the platform `done` filter (default `todo`). */
+export type TasksPanelStatusFilter = 'todo' | 'done' | 'all';
+/**
+ * Panel-local extension of the card's `TaskItem`. The extra fields here drive
+ * bucketing + filtering; the row's display fields (the typed link via
+ * `linkType` + `linkedLabel`, the `assigneeLabel`, `dueLabel`) live on
+ * `TaskItem` and are rendered by `TaskCard` itself. The host maps the platform
+ * `DoctorReminder` → this shape — composing `title` (a summary, NOT the bare
+ * type), `note`, the linked entity, the assignee, and `dueLabel`.
+ */
+export interface TasksPanelItem extends TaskItem {
+    /** ISO-8601 due/scheduled instant (platform `DoctorReminder.date`). Buckets + orders the list. */
+    dueIso: string;
+    /** System or custom task-type key (`recall` | `payment` | `collection` | `other` | `custom-*`). Drives the type filter + badge. */
+    type?: string;
+    /**
+     * Localised type label, required for CUSTOM types (the panel resolves system
+     * keys itself). Falls back to the system label for the four known keys.
+     */
+    typeLabel?: string;
+    /**
+     * Assignee id (the platform `practiceUser`). Omit ⇒ unassigned; give pool
+     * tasks a shared sentinel value (e.g. `'unassigned'`) if you want the pool
+     * itself filterable. Drives the assignee FILTER (exact match); the displayed
+     * name is `TaskItem.assigneeLabel`.
+     */
+    assignee?: string;
+    /** Provenance — manual vs workflow-created. Filter only. */
+    createdBy?: 'user' | 'workflow';
+}
+/** Curated imperative handle — identifiers + structural state only, no PHI. */
+export interface TasksPanelHandle {
+    getItems: () => Array<{
+        id: string;
+        status: string;
+    }>;
+    selectItem: (id: string) => void;
+    toggleDone: (id: string) => void;
+    dismiss: (id: string) => void;
+    jumpToOverdue: () => void;
+    setFilter: (next: {
+        status?: TasksPanelStatusFilter;
+        type?: string | null;
+        assignee?: string | null;
+        overdueOnly?: boolean;
+    }) => void;
+    /** Switch the task scope segment (patient ↔ mine). The host re-feeds items. */
+    changeScope: (next: TasksPanelScope) => void;
+    /** Request the host to append the next page of tasks (mirrors onLoadMore). */
+    loadMore: () => void;
+}
+interface FilterOption {
+    /** Stable value passed back through the matching `on…Change`. */
+    value: string;
+    /** Localised label. */
+    label: string;
+}
+export interface TasksPanelProps extends Omit<HTMLAttributes<HTMLElement>, 'onClick' | 'id' | 'title'> {
+    /** Stable instance id, surfaced as `data-component-id`. */
+    id?: string;
+    /** Tasks to render — any order; bucketed + sorted internally (due ASC, Done last). */
+    items: TasksPanelItem[];
+    /** ISO-8601 "now" anchor — buckets + overdue compute against it. Defaults to the current instant; stories pass a fixed value. */
+    nowIso?: string;
+    /** Panel heading. Defaults to the localised "Tasks". */
+    title?: string;
+    /** Visual density forwarded to each TaskCard. Defaults to `xs` — the compact rail row. */
+    size?: 'xs' | 'sm' | 'md';
+    /** Fires when a row is activated. */
+    onOpenTask?: (item: TasksPanelItem) => void;
+    /** Fires when the host should toggle a task's done state. */
+    onToggleDone?: (item: TasksPanelItem) => void;
+    /** Fires when the host should open the task editor. Omit to hide the per-row edit action. */
+    onEditTask?: (item: TasksPanelItem) => void;
+    /** Fires when the host should dismiss / remove a task. Omit to hide the per-row dismiss action. */
+    onDismissTask?: (item: TasksPanelItem) => void;
+    /** Fires when the header "Add" affordance is activated. Omit to hide it. */
+    onAddTask?: () => void;
+    /**
+     * Read-only mode — hides every write affordance (toggle / edit / dismiss /
+     * add). Mirrors the platform gating writes behind `practice_task_edit`.
+     */
+    readOnly?: boolean;
+    /**
+     * Per-row trailing action toolbar, forwarded to each TaskCard's `actions`
+     * slot. Overrides the default toggle / edit / dismiss buttons (the type Badge
+     * is always prepended by the panel). Ignored when `readOnly`.
+     */
+    renderItemActions?: (item: TasksPanelItem) => ReactNode;
+    /** Controlled scope segment. */
+    scope?: TasksPanelScope;
+    /** Uncontrolled initial scope. Default `'patient'` when both scopes are available, else the only one. */
+    defaultScope?: TasksPanelScope;
+    /** Fires when the user switches scope — the host re-feeds `items`. */
+    onScopeChange?: (next: TasksPanelScope) => void;
+    /** Which scopes the segment offers. Omit ⇒ no scope segment (single-scope panel). */
+    availableScopes?: TasksPanelScope[];
+    /** Load the next page — fired when the bottom edge is reached and via the footer button. */
+    onLoadMore?: () => void;
+    /** Whether more tasks exist. Defaults to `true` when `onLoadMore` is set. */
+    hasMore?: boolean;
+    /** Show the bottom loading row while the next page is fetched. */
+    loadingMore?: boolean;
+    /** Full-panel initial loading state (skeleton rows in the body). */
+    loading?: boolean;
+    /** Error surface — `true` for the default error EmptyState, or a custom node. */
+    error?: boolean | ReactNode;
+    /** Show the filter header (status segment + type / assignee selects + overdue toggle). Default `true`. */
+    showFilters?: boolean;
+    /** Controlled status segment. */
+    statusFilter?: TasksPanelStatusFilter;
+    /** Uncontrolled initial status segment. Default `'todo'` (the platform default). */
+    defaultStatusFilter?: TasksPanelStatusFilter;
+    onStatusFilterChange?: (next: TasksPanelStatusFilter) => void;
+    /** Task types for the type filter. Omit ⇒ no type filter. */
+    typeOptions?: FilterOption[];
+    /** Controlled type filter (`null`/empty ⇒ all). */
+    typeFilter?: string | null;
+    onTypeFilterChange?: (next: string | null) => void;
+    /** Assignees for the assignee filter. Pass an explicit Unassigned option if wanted. Omit ⇒ no assignee filter. */
+    assigneeOptions?: FilterOption[];
+    /** Controlled assignee filter (`null`/empty ⇒ anyone). */
+    assigneeFilter?: string | null;
+    onAssigneeFilterChange?: (next: string | null) => void;
+    /** Controlled overdue-only toggle. */
+    overdueOnly?: boolean;
+    /** Uncontrolled initial overdue-only state. Default `false`. */
+    defaultOverdueOnly?: boolean;
+    onOverdueOnlyChange?: (next: boolean) => void;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /** CTA wired into the first-use empty state (e.g. Create task). */
+    emptyAction?: {
+        label: string;
+        onClick: () => void;
+    };
+    /** Accessible name for the panel region (defaults to `title`). */
+    'aria-label'?: string;
+}
+declare const rootVariants: (props?: ({
+    size?: "sm" | "md" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const TasksPanel: import("react").ForwardRefExoticComponent<TasksPanelProps & import("react").RefAttributes<HTMLElement>>;
+/** Re-export of the size variant union for downstream typing. */
+export type TasksPanelSize = NonNullable<VariantProps<typeof rootVariants>['size']>;
+export {};
+//# sourceMappingURL=tasks-panel.d.ts.map

package/dist/components/token-insert-menu/index.d.ts

@@ -0,0 +1,4 @@
+export { TokenInsertMenu } from './token-insert-menu';
+export type { TokenInsertMenuProps, TokenInsertMenuToken, TokenInsertMenuHandle, } from './token-insert-menu';
+export { tokenInsertMenuAgent } from './token-insert-menu.agent';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/token-insert-menu/index.js

@@ -0,0 +1,6 @@
+import { T as t, t as o } from "../../_chunks/token-insert-menu-CFQqTe_n.js";
+export {
+  t as TokenInsertMenu,
+  o as tokenInsertMenuAgent
+};
+//# sourceMappingURL=index.js.map

package/dist/components/token-insert-menu/token-insert-menu.agent.d.ts

@@ -0,0 +1,4 @@
+import type { AgentAdapter } from '../../agent/types';
+import type { TokenInsertMenuHandle } from './token-insert-menu';
+export declare const tokenInsertMenuAgent: AgentAdapter<TokenInsertMenuHandle>;
+//# sourceMappingURL=token-insert-menu.agent.d.ts.map

package/dist/components/token-insert-menu/token-insert-menu.d.ts

@@ -0,0 +1,33 @@
+/** One selectable merge-token. */
+export interface TokenInsertMenuToken {
+    /** Raw token text inserted verbatim (e.g. `"{{patient.name}}"`). */
+    value: string;
+    /** Human-readable label shown in the menu. Already localised by the consumer. */
+    label: string;
+    /** Optional section heading — when ANY token has one, the menu renders grouped. */
+    group?: string;
+}
+/** Agent-readiness curated handle for TokenInsertMenu. */
+export interface TokenInsertMenuHandle {
+    isOpen: () => boolean;
+    open: () => void;
+    close: () => void;
+    /** Emit a token to the consumer (mirrors a user selecting it). */
+    insert: (token: string) => void;
+}
+export interface TokenInsertMenuProps {
+    /** The merge-tokens to offer. `value` is inserted; `label` is shown. */
+    tokens: TokenInsertMenuToken[];
+    /** Called with the chosen token's raw `value`. The consumer inserts it at
+     *  the caret of their target field — this component never owns the field. */
+    onInsert: (token: string) => void;
+    /** The trigger button's visible text (already localised by the consumer). */
+    triggerLabel: string;
+    disabled?: boolean;
+    /** Opaque instance id — surfaced as `data-component-id` + agent instance id. */
+    id?: string;
+    /** Extra classes for the trigger button. */
+    className?: string;
+}
+export declare const TokenInsertMenu: import("react").ForwardRefExoticComponent<TokenInsertMenuProps & import("react").RefAttributes<HTMLButtonElement>>;
+//# sourceMappingURL=token-insert-menu.d.ts.map

package/dist/components/tool-rail/index.d.ts

@@ -0,0 +1,4 @@
+export { ToolRail } from './tool-rail';
+export type { ToolRailProps, ToolRailHandle, ToolRailTool } from './tool-rail';
+export { toolRailAgent } from './tool-rail.agent';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/tool-rail/index.js

@@ -0,0 +1,6 @@
+import { T as l, t } from "../../_chunks/tool-rail-BZx0-yIr.js";
+export {
+  l as ToolRail,
+  t as toolRailAgent
+};
+//# sourceMappingURL=index.js.map

package/dist/components/tool-rail/tool-rail.agent.d.ts

@@ -0,0 +1,4 @@
+import type { AgentAdapter } from '../../agent/types';
+import type { ToolRailHandle } from './tool-rail';
+export declare const toolRailAgent: AgentAdapter<ToolRailHandle>;
+//# sourceMappingURL=tool-rail.agent.d.ts.map

package/dist/components/tool-rail/tool-rail.d.ts

@@ -0,0 +1,160 @@
+import { type ReactNode } from 'react';
+import { type VariantProps } from 'class-variance-authority';
+import type { AgentAdapter } from '../../agent/types';
+export interface ToolRailTool {
+    /** Stable tool id — used in `data-active`, the imperative handle, and
+     *  to label the open panel region. */
+    id: string;
+    /** Accessible name for the strip icon + tooltip, and the open panel's
+     *  region label. Never rendered as visible body text. */
+    label: string;
+    /** lucide-react glyph (rendered `aria-hidden` inside the IconButton). */
+    icon: ReactNode;
+    /** Panel body for this tool. Rendered inline-start of the strip when
+     *  `side='end'` (mirrored for `'start'`). The consumer composes it. */
+    panel: ReactNode;
+    /**
+     * Optional non-scrolling header for this tool's panel. Rendered pinned at
+     * the top of the open panel — above the scroll region — so a tool's title /
+     * filters stay visible as the body scrolls. This is the rail-level home for
+     * a sticky tool header; every tool gets it for free.
+     */
+    header?: ReactNode;
+    /**
+     * When true the panel body is NOT wrapped in the rail's `ScrollArea` — the
+     * tool fills the (height-bounded) panel and owns its own scroll/layout.
+     * Use for self-scrolling tools (e.g. `AppointmentTimeline`, whose infinite
+     * scroll + today-anchoring + edge fades require it to be the scroll
+     * container). Default `false` (the rail scrolls the body).
+     */
+    fill?: boolean;
+    /** Optional unseen / notification count shown on the strip icon. */
+    badgeCount?: number;
+    /** When true the icon is non-interactive and skipped by roving focus. */
+    disabled?: boolean;
+    /**
+     * Scope tier (drives the two-group divider). The two scope values render in
+     * array order with a divider at the boundary between them — order the array
+     * so the groups stay contiguous. A divider only appears when BOTH groups are
+     * present; omit `scope` on every tool for an ungrouped strip (legacy). The
+     * rail attaches no meaning beyond grouping — the host decides which value
+     * leads (e.g. the Control Room pins favourites first).
+     */
+    scope?: 'global' | 'contextual';
+    /**
+     * When true this icon joins the drag-and-drop / `Alt`+Arrow reorder run.
+     * The host supplies `onReorder` and owns the resulting order. Moves are
+     * confined to the contiguous run of `reorderable` tools — so if EVERY tool
+     * is `reorderable` the run is the whole strip and a tool can be dragged
+     * across the scope divider; the host's `onReorder` decides what crossing it
+     * means (e.g. the Control Room reads it as pin / unpin). Reordering never
+     * changes focus roving — focus follows the moved tool to its new slot.
+     */
+    reorderable?: boolean;
+}
+/**
+ * Curated imperative handle for ToolRail. Exposed as the forwardRef
+ * target so a future agent / MCP UI bridge can drive the rail without
+ * touching the DOM. See `tool-rail.agent.ts`.
+ *
+ * State surfaced here is strictly identifiers + counts — never any
+ * tool's panel content (which may carry PHI).
+ */
+export interface ToolRailHandle {
+    /** Currently-active tool id, or null when collapsed to strip-only. */
+    getActiveToolId: () => string | null;
+    /** Activate a tool by id (opens its panel), or null to collapse. */
+    setActiveTool: (id: string | null) => void;
+    /** Activate a tool by id (opens its panel). */
+    open: (id: string) => void;
+    /** Collapse to strip-only (no active tool). */
+    close: () => void;
+}
+declare const railVariants: (props?: ({
+    side?: "end" | "start" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ToolRailProps extends VariantProps<typeof railVariants> {
+    /** Stable instance id, surfaced on the root as `data-component-id`. */
+    id?: string;
+    /** The tools shown as icons on the strip. */
+    tools: ToolRailTool[];
+    /** Controlled active tool id (null = collapsed / strip-only). */
+    activeToolId?: string | null;
+    /** Uncontrolled initial active tool id (default null). */
+    defaultActiveToolId?: string | null;
+    /** Fires whenever the active tool changes (incl. → null on collapse). */
+    onActiveToolChange?: (id: string | null) => void;
+    /** Which edge the rail docks to. Default `'end'` (inline-end). */
+    side?: 'start' | 'end';
+    /** Accessible label for the toolbar strip. */
+    railLabel?: string;
+    /**
+     * Opt-in resize affordance for the open tool panel. Renders a
+     * `role="separator"` drag handle on the panel's inner edge (the edge
+     * facing the main content). The committed width is written to
+     * `--tool-rail-panel-inline-size` on the panel element (288–640px);
+     * Enter / double-click resets to the token-driven default. Default `false`.
+     */
+    resizablePanel?: boolean;
+    /**
+     * Fires when the user reorders the `reorderable` run (drag-drop or
+     * `Alt`+Arrow). `from` / `to` are indices into `tools`; the host applies the
+     * move to the array it passes back. Reordering is enabled when this callback
+     * is supplied AND at least one tool is `reorderable`. When the whole strip is
+     * reorderable, `to` may land in the other scope group — the host interprets
+     * the crossing (and may treat it as a no-op, e.g. reordering within a
+     * host-ordered group).
+     */
+    onReorder?: (from: number, to: number) => void;
+    /**
+     * Optional override for the polite live-region message announced after a
+     * reorder. Lets the host phrase membership-aware moves (e.g. "Pinned X to
+     * favourites") instead of the generic "moved to position N". Return an empty
+     * string to stay silent (e.g. for a move the host treats as a no-op). When
+     * omitted, the rail announces the generic run-relative position.
+     */
+    formatReorderAnnouncement?: (args: {
+        tool: ToolRailTool;
+        from: number;
+        to: number;
+    }) => string;
+    /**
+     * Optional per-icon overlay control, rendered as a sibling of each strip
+     * IconButton (the same positioned box the notification badge uses). Use for
+     * a small affordance such as a pin toggle — the rail attaches no meaning to
+     * what it renders. Receives the tool and its index / active state.
+     */
+    renderToolAffordance?: (tool: ToolRailTool, context: {
+        index: number;
+        isActive: boolean;
+        isRovingTarget: boolean;
+    }) => ReactNode;
+    /**
+     * Optional non-scrolling header rendered at the top of the OPEN tool panel,
+     * above its scroll region. Host-owned content (e.g. a pin / unpin control) —
+     * the rail attaches no meaning. Receives the active tool.
+     */
+    renderPanelHeader?: (tool: ToolRailTool, context: {
+        isActive: boolean;
+    }) => ReactNode;
+    /**
+     * Identity override for the root's `data-component` attribute. Defaults to
+     * `'tool-rail'`. A product wrapper (e.g. ControlRoomRail) passes its own
+     * kebab id so the DOM / cascade boundary — and an agent's `domHooks.root` —
+     * can tell its surface apart from a bare ToolRail, without the engine ever
+     * importing the wrapper.
+     */
+    dataComponent?: string;
+    /**
+     * Agent adapter registered for this rail instance. Defaults to
+     * `toolRailAgent`. A wrapper passes its own adapter (matching
+     * `dataComponent`) so the rail registers under the wrapper's identity. The
+     * instance id is sourced from the `id` prop (also stamped as
+     * `data-component-id`).
+     */
+    agentAdapter?: AgentAdapter<ToolRailHandle>;
+    className?: string;
+}
+export declare const ToolRail: import("react").ForwardRefExoticComponent<ToolRailProps & import("react").RefAttributes<ToolRailHandle>>;
+export {};
+//# sourceMappingURL=tool-rail.d.ts.map

package/dist/components/tooth-scheme/index.d.ts

@@ -1,5 +1,5 @@
 export * from './tooth-scheme';
-export { FDI_TO_META, FDI_TO_UNIVERSAL, FDI_TO_PALMER, CONDITION_COLORS, CONDITION_TOKENS, CONDITION_SIDE_SYMBOL, CONDITION_PLAN_FOLDER, SURFACE_ASSET_NAME, toothImageUrl, conditionSymbolUrl, surfaceSymbolUrl, zonesForTooth, zoneSurface, zonePath, chartFromConditions, emptyChart, labelFor, layoutTeeth, } from './tooth-data';
-export type { Anatomy, Arch, Quadrant, Side, Surface, SurfaceZone, Projection, SideSymbolSpec, ToothMeta, PositionedTooth, } from './tooth-data';
+export { FDI_TO_META, FDI_TO_UNIVERSAL, FDI_TO_PALMER, CONDITION_COLORS, CONDITION_TOKENS, CONDITION_SIDE_SYMBOL, CONDITION_PLAN_FOLDER, SURFACE_ASSET_NAME, toothImageUrl, conditionSymbolUrl, surfaceSymbolUrl, zonesForTooth, zoneSurface, zonePath, chartFromConditions, emptyChart, labelFor, layoutTeeth, layoutSpecials, specialsForRow, specialIconUrl, generalElement, isSpecialElement, SPECIAL_ELEMENTS, SPECIAL_BY_ID, } from './tooth-data';
+export type { Anatomy, Arch, Quadrant, Side, Surface, SurfaceZone, Projection, Radiograph, RadiographKind, SideSymbolSpec, SpecialElement, SpecialElementKind, PositionedSpecial, ToothMeta, PositionedTooth, } from './tooth-data';
 export { toothSchemeAgent } from './tooth-scheme.agent';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/tooth-scheme/index.js

@@ -1,27 +1,34 @@
-import { C as o, a as t, b as e, c as T, F as O, d as _, e as E, P as I, f as S, S as r, T as N, g as h, h as m, i as n, l as A, j as l, s as C, t as D, k as F, r as c, z as R, m as i, n as L } from "../../_chunks/tooth-scheme-yBr53cvv.js";
+import { C as o, a as e, b as t, c as E, F as S, d as T, e as I, P as _, f as l, S as r, g as O, h as N, T as n, i as c, j as h, k as m, l as A, m as i, n as C, o as D, p as F, s as L, q as R, r as P, t as p, u as M, v as U, z as u, w as y, x as b } from "../../_chunks/tooth-scheme-DJZtzfeY.js";
 export {
   o as CONDITION_COLORS,
-  t as CONDITION_PLAN_FOLDER,
-  e as CONDITION_SIDE_SYMBOL,
-  T as CONDITION_TOKENS,
-  O as FDI_TO_META,
-  _ as FDI_TO_PALMER,
-  E as FDI_TO_UNIVERSAL,
-  I as PERMANENT_TEETH,
-  S as PRIMARY_TEETH,
-  r as SURFACE_ASSET_NAME,
-  N as ToothScheme,
-  h as chartFromConditions,
-  m as conditionSymbolUrl,
-  n as emptyChart,
-  A as labelFor,
-  l as layoutTeeth,
-  C as surfaceSymbolUrl,
-  D as toothImageUrl,
-  F as toothSchemeAgent,
-  c as toothSchemeVariants,
-  R as zonePath,
-  i as zoneSurface,
-  L as zonesForTooth
+  e as CONDITION_PLAN_FOLDER,
+  t as CONDITION_SIDE_SYMBOL,
+  E as CONDITION_TOKENS,
+  S as FDI_TO_META,
+  T as FDI_TO_PALMER,
+  I as FDI_TO_UNIVERSAL,
+  _ as PERMANENT_TEETH,
+  l as PRIMARY_TEETH,
+  r as SPECIAL_BY_ID,
+  O as SPECIAL_ELEMENTS,
+  N as SURFACE_ASSET_NAME,
+  n as ToothScheme,
+  c as chartFromConditions,
+  h as conditionSymbolUrl,
+  m as emptyChart,
+  A as generalElement,
+  i as isSpecialElement,
+  C as labelFor,
+  D as layoutSpecials,
+  F as layoutTeeth,
+  L as specialIconUrl,
+  R as specialsForRow,
+  P as surfaceSymbolUrl,
+  p as toothImageUrl,
+  M as toothSchemeAgent,
+  U as toothSchemeVariants,
+  u as zonePath,
+  y as zoneSurface,
+  b as zonesForTooth
 };
 //# sourceMappingURL=index.js.map