@assistant-ui/react 0.15.19 → 0.15.21

package/dist/primitives/composer/trigger/TriggerPopoverRootContext.d.ts

@@ -3,14 +3,14 @@ import { TriggerBehavior } from "./triggerSelectionResource.js";
 import { TriggerPopoverResourceOutput } from "./TriggerPopoverResource.js";
 import { FC, ReactNode } from "react";
 //#region src/primitives/composer/trigger/TriggerPopoverRootContext.d.ts
-type RegisteredTrigger = {
+export type RegisteredTrigger = {
   readonly char: string;
   readonly matcher?: TriggerMatcher | undefined;
   /** Behavior contributed by a child `TriggerPopover.Directive` / `.Action`. */
   readonly behavior?: TriggerBehavior;
   readonly resource: TriggerPopoverResourceOutput;
 };
-type TriggerPopoverLifecycleListener = {
+export type TriggerPopoverLifecycleListener = {
   added(trigger: RegisteredTrigger): void;
   removed(char: string): void;
 };
@@ -19,11 +19,11 @@ type TriggerPopoverLifecycleListener = {
  * focused element (typically the composer textarea) so it can advertise the
  * combobox relationship per the WAI-ARIA editable combobox pattern.
  */
-type TriggerPopoverActiveAria = {
+export type TriggerPopoverActiveAria = {
   popoverId: string;
   highlightedItemId: string | undefined;
 };
-type TriggerPopoverRootContextValue = {
+export type TriggerPopoverRootContextValue = {
   register(trigger: RegisteredTrigger): () => void;
   getTriggers(): ReadonlyMap<string, RegisteredTrigger>;
   subscribe(listener: () => void): () => void;
@@ -42,27 +42,27 @@ type TriggerPopoverRootContextValue = {
 type TriggerPopoverAriaPublish = {
   setActiveAria(char: string, aria: TriggerPopoverActiveAria | null): void;
 };
-declare const useTriggerPopoverRootContext: () => TriggerPopoverRootContextValue;
-declare const useTriggerPopoverRootContextOptional: () => TriggerPopoverRootContextValue | null;
+export declare const useTriggerPopoverRootContext: () => TriggerPopoverRootContextValue;
+export declare const useTriggerPopoverRootContextOptional: () => TriggerPopoverRootContextValue | null;
 /**
  * Internal hook used by `TriggerPopover` children to publish their open and
  * highlight state. Not exported from the trigger module.
  */
-declare const useTriggerPopoverAriaPublish: () => TriggerPopoverAriaPublish;
+export declare const useTriggerPopoverAriaPublish: () => TriggerPopoverAriaPublish;
 /**
  * Live map of registered triggers, re-rendering on change. Prefer
  * `subscribeLifecycle` for incremental add/remove handling.
  */
-declare const useTriggerPopoverTriggers: () => ReadonlyMap<string, RegisteredTrigger>;
+export declare const useTriggerPopoverTriggers: () => ReadonlyMap<string, RegisteredTrigger>;
 /** Like `useTriggerPopoverTriggers` but returns an empty map outside a root. */
-declare const useTriggerPopoverTriggersOptional: () => ReadonlyMap<string, RegisteredTrigger>;
+export declare const useTriggerPopoverTriggersOptional: () => ReadonlyMap<string, RegisteredTrigger>;
 /**
  * Returns the ARIA descriptor of the currently open trigger popover, or
  * `null` if none is open or the consumer is rendered outside a
  * `TriggerPopoverRoot`.
  */
-declare const useTriggerPopoverActiveAriaOptional: () => TriggerPopoverActiveAria | null;
-declare namespace ComposerPrimitiveTriggerPopoverRoot {
+export declare const useTriggerPopoverActiveAriaOptional: () => TriggerPopoverActiveAria | null;
+export declare namespace ComposerPrimitiveTriggerPopoverRoot {
   type Props = {
     children: ReactNode;
   };
@@ -91,7 +91,6 @@ declare namespace ComposerPrimitiveTriggerPopoverRoot {
  * </ComposerPrimitive.Unstable_TriggerPopoverRoot>
  * ```
  */
-declare const ComposerPrimitiveTriggerPopoverRoot: FC<ComposerPrimitiveTriggerPopoverRoot.Props>;
+export declare const ComposerPrimitiveTriggerPopoverRoot: FC<ComposerPrimitiveTriggerPopoverRoot.Props>;
 //#endregion
-export { ComposerPrimitiveTriggerPopoverRoot, RegisteredTrigger, TriggerPopoverActiveAria, TriggerPopoverLifecycleListener, TriggerPopoverRootContextValue, useTriggerPopoverActiveAriaOptional, useTriggerPopoverAriaPublish, useTriggerPopoverRootContext, useTriggerPopoverRootContextOptional, useTriggerPopoverTriggers, useTriggerPopoverTriggersOptional };
 //# sourceMappingURL=TriggerPopoverRootContext.d.ts.map

package/dist/primitives/composer/trigger/TriggerPopoverRootContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TriggerPopoverRootContext.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/TriggerPopoverRootContext.tsx"],"mappings":";;;;;KAoBY;WACD;WACA,UAAU;;WAEV,WAAW;WACX,UAAU;;KAGT;EACV,MAAM,SAAS;EACf,QAAQ;;;;;;;KAQE;EACV;EACA;;KAGU;EACV,SAAS,SAAS;EAClB,eAAe,oBAAoB;EACnC,UAAU;;EAEV,mBAAmB,UAAU;;EAE7B,iBAAiB;;EAEjB,cAAc;;;;;;;KAQX;EACH,cAAc,cAAc,MAAM;;cASvB,oCAA4B;cAS5B,4CAAoC;;;;;cAOpC,oCAAmC;;;;;cAanC,iCAAyB,oBAAA;;cAUzB,yCAAiC,oBAAA;;;;;;cAgBjC,2CACP;kBASW;OACH;IACV,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgLD,qCAAqC,GAChD,oCAAoC"}
+{"version":3,"file":"TriggerPopoverRootContext.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/TriggerPopoverRootContext.tsx"],"mappings":";;;;;YAoBY;WACD;WACA,UAAU;;WAEV,WAAW;WACX,UAAU;;YAGT;EACV,MAAM,SAAS;EACf,QAAQ;;;;;;;YAQE;EACV;EACA;;YAGU;EACV,SAAS,SAAS;EAClB,eAAe,oBAAoB;EACnC,UAAU;;EAEV,mBAAmB,UAAU;;EAE7B,iBAAiB;;EAEjB,cAAc;;;;;;;KAQX;EACH,cAAc,cAAc,MAAM;;qBASvB,oCAA4B;qBAS5B,4CAAoC;;;;;qBAOpC,oCAAmC;;;;;qBAanC,iCAAyB,oBAAA;;qBAUzB,yCAAiC,oBAAA;;;;;;qBAgBjC,2CACP;yBASW;OACH;IACV,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgLD,qCAAqC,GAChD,oCAAoC"}

package/dist/primitives/composer/trigger/detectTrigger.d.ts

@@ -1,5 +1,5 @@
 //#region src/primitives/composer/trigger/detectTrigger.d.ts
-type TriggerMatch = {
+export type TriggerMatch = {
   readonly query: string;
   readonly offset: number;
   readonly endOffset: number;
@@ -14,8 +14,7 @@ type TriggerMatch = {
  * Return null when the caret is at or before the trigger. Escape moves the
  * caret to `offset` so a match there would reopen the popover.
  */
-type TriggerMatcher = (text: string, triggerChar: string, cursorPosition: number) => TriggerMatch | null;
-declare function resolveTriggerMatch(text: string, triggerChar: string, cursorPosition: number, match: TriggerMatch | null): TriggerMatch | null;
+export type TriggerMatcher = (text: string, triggerChar: string, cursorPosition: number) => TriggerMatch | null;
+export declare function resolveTriggerMatch(text: string, triggerChar: string, cursorPosition: number, match: TriggerMatch | null): TriggerMatch | null;
 //#endregion
-export { TriggerMatch, TriggerMatcher, resolveTriggerMatch };
 //# sourceMappingURL=detectTrigger.d.ts.map

package/dist/primitives/composer/trigger/detectTrigger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detectTrigger.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/detectTrigger.ts"],"mappings":";KAEY;WACD;WACA;WACA;;;;;;;;;;;;KAaC,kBACV,cACA,qBACA,2BACG;iBAEW,oBACd,cACA,qBACA,wBACA,OAAO,sBACN"}
+{"version":3,"file":"detectTrigger.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/detectTrigger.ts"],"mappings":";YAEY;WACD;WACA;WACA;;;;;;;;;;;;YAaC,kBACV,cACA,qBACA,2BACG;wBAEW,oBACd,cACA,qBACA,wBACA,OAAO,sBACN"}

package/dist/primitives/composer/trigger/index.d.ts

@@ -8,7 +8,7 @@ import { ComposerPrimitiveTriggerPopoverBack } from "./TriggerPopoverBack.js";
 import { ComposerPrimitiveTriggerPopoverAction } from "./TriggerPopoverAction.js";
 import { ComposerPrimitiveTriggerPopoverDirective } from "./TriggerPopoverDirective.js";
 //#region src/primitives/composer/trigger/index.d.ts
-declare const ComposerPrimitiveTriggerPopover: import("react").ForwardRefExoticComponent<Omit<Omit<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+export declare const ComposerPrimitiveTriggerPopover: import("react").ForwardRefExoticComponent<Omit<Omit<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
   asChild?: boolean;
 }, "ref"> & {
   render?: import("react").ReactElement | undefined;
@@ -22,5 +22,5 @@ declare const ComposerPrimitiveTriggerPopover: import("react").ForwardRefExoticC
   Action: import("react").FC<ComposerPrimitiveTriggerPopoverAction.Props>;
 };
 //#endregion
-export { ComposerPrimitiveTriggerPopover, ComposerPrimitiveTriggerPopoverBack, ComposerPrimitiveTriggerPopoverCategories, ComposerPrimitiveTriggerPopoverCategoryItem, ComposerPrimitiveTriggerPopoverItem, ComposerPrimitiveTriggerPopoverItems, ComposerPrimitiveTriggerPopoverRoot, type RegisteredTrigger, type TriggerBehavior, type TriggerMatch, type TriggerMatcher, type TriggerPopoverRootContextValue, useTriggerPopoverRootContext, useTriggerPopoverRootContextOptional, useTriggerPopoverScopeContext, useTriggerPopoverScopeContextOptional, useTriggerPopoverTriggers, useTriggerPopoverTriggersOptional };
+export { ComposerPrimitiveTriggerPopoverBack, ComposerPrimitiveTriggerPopoverCategories, ComposerPrimitiveTriggerPopoverCategoryItem, ComposerPrimitiveTriggerPopoverItem, ComposerPrimitiveTriggerPopoverItems, ComposerPrimitiveTriggerPopoverRoot, type RegisteredTrigger, type TriggerBehavior, type TriggerMatch, type TriggerMatcher, type TriggerPopoverRootContextValue, useTriggerPopoverRootContext, useTriggerPopoverRootContextOptional, useTriggerPopoverScopeContext, useTriggerPopoverScopeContextOptional, useTriggerPopoverTriggers, useTriggerPopoverTriggersOptional };
 //# sourceMappingURL=index.d.ts.map

package/dist/primitives/composer/trigger/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/index.ts"],"mappings":";;;;;;;;;;cA6Ba,iDAA+B,0BAAA,KAAA,KAAA,qBAAA,gBAAA,kCAAA,eAAA;;;;;;qBAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/index.ts"],"mappings":";;;;;;;;;;qBA6Ba,iDAA+B,0BAAA,KAAA,KAAA,qBAAA,gBAAA,kCAAA,eAAA;;;;;;qBAAA"}

package/dist/primitives/composer/trigger/matchesTriggerItemQuery.d.ts

@@ -1,6 +1,5 @@
 import { Unstable_TriggerItem } from "@assistant-ui/core";
 //#region src/primitives/composer/trigger/matchesTriggerItemQuery.d.ts
-declare function matchesTriggerItemQuery(item: Unstable_TriggerItem, lowerQuery: string): boolean;
+export declare function matchesTriggerItemQuery(item: Unstable_TriggerItem, lowerQuery: string): boolean;
 //#endregion
-export { matchesTriggerItemQuery };
 //# sourceMappingURL=matchesTriggerItemQuery.d.ts.map

package/dist/primitives/composer/trigger/matchesTriggerItemQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matchesTriggerItemQuery.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/matchesTriggerItemQuery.ts"],"mappings":";;iBAEgB,wBACd,MAAM,sBACN"}
+{"version":3,"file":"matchesTriggerItemQuery.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/matchesTriggerItemQuery.ts"],"mappings":";;wBAEgB,wBACd,MAAM,sBACN"}

package/dist/primitives/composer/trigger/triggerDetectionResource.d.ts

@@ -1,8 +1,8 @@
 import { TriggerMatch, TriggerMatcher } from "./detectTrigger.js";
 //#region src/primitives/composer/trigger/triggerDetectionResource.d.ts
 /** Detected trigger position within the composer text. */
-type DetectedTrigger = TriggerMatch;
-type TriggerDetectionResourceOutput = {
+export type DetectedTrigger = TriggerMatch;
+export type TriggerDetectionResourceOutput = {
   /** Detected trigger (or `null` when inactive). */
   readonly trigger: DetectedTrigger | null;
   /** Current query string (empty when no trigger active). */
@@ -10,11 +10,10 @@ type TriggerDetectionResourceOutput = {
   /** Update the tracked cursor position (wired to composer input). */
   setCursorPosition(pos: number): void;
 };
-declare const TriggerDetectionResource: import("@assistant-ui/tap").Resource<TriggerDetectionResourceOutput, [{
+export declare const TriggerDetectionResource: import("@assistant-ui/tap").Resource<TriggerDetectionResourceOutput, [{
   text: string;
   triggerChar: string;
   matcher?: TriggerMatcher | undefined;
 }]>;
 //#endregion
-export { DetectedTrigger, TriggerDetectionResource, TriggerDetectionResourceOutput };
 //# sourceMappingURL=triggerDetectionResource.d.ts.map

package/dist/primitives/composer/trigger/triggerDetectionResource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triggerDetectionResource.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/triggerDetectionResource.ts"],"mappings":";;;KASY,kBAAkB;KAElB;;WAED,SAAS;;WAET;;EAET,kBAAkB;;cA6BP,sDAAwB,SAAA;EApB7B;EACO;EACH,UAAA"}
+{"version":3,"file":"triggerDetectionResource.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/triggerDetectionResource.ts"],"mappings":";;;YASY,kBAAkB;YAElB;;WAED,SAAS;;WAET;;EAET,kBAAkB;;qBA6BP,sDAAwB,SAAA;EApB7B;EACO;EACH,UAAA"}

package/dist/primitives/composer/trigger/triggerKeyboardResource.d.ts

@@ -1,12 +1,12 @@
 import { Unstable_TriggerCategory, Unstable_TriggerItem } from "@assistant-ui/core";
 //#region src/primitives/composer/trigger/triggerKeyboardResource.d.ts
 /** Key event shape accepted by the keyboard handler. */
-type TriggerPopoverKeyEvent = {
+export type TriggerPopoverKeyEvent = {
   readonly key: string;
   readonly shiftKey: boolean;
   preventDefault(): void;
 };
-type TriggerKeyboardResourceOutput = {
+export type TriggerKeyboardResourceOutput = {
   /** Index of the currently highlighted entry within the navigable list. */
   readonly highlightedIndex: number;
   /** ID of the currently highlighted item (for `aria-activedescendant`). */
@@ -16,7 +16,7 @@ type TriggerKeyboardResourceOutput = {
   /** Handle a key event; returns `true` if it was consumed. */
   handleKeyDown(e: TriggerPopoverKeyEvent): boolean;
 };
-declare const TriggerKeyboardResource: import("@assistant-ui/tap").Resource<TriggerKeyboardResourceOutput, [{
+export declare const TriggerKeyboardResource: import("@assistant-ui/tap").Resource<TriggerKeyboardResourceOutput, [{
   navigableList: readonly (Unstable_TriggerCategory | Unstable_TriggerItem)[];
   isSearchMode: boolean;
   activeCategoryId: string | null;
@@ -29,5 +29,4 @@ declare const TriggerKeyboardResource: import("@assistant-ui/tap").Resource<Trig
   close: () => void;
 }]>;
 //#endregion
-export { TriggerKeyboardResource, TriggerKeyboardResourceOutput, TriggerPopoverKeyEvent };
 //# sourceMappingURL=triggerKeyboardResource.d.ts.map

package/dist/primitives/composer/trigger/triggerKeyboardResource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triggerKeyboardResource.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/triggerKeyboardResource.ts"],"mappings":";;;KAeY;WACD;WACA;EACT;;KAGU;;WAED;;WAEA;;EAET,eAAe;;EAEf,cAAc,GAAG;;cAwHN,qDAAuB,SAAA;EArGnB,yBAAU,2BAA2B;EACtC;EACI;EACX;EACI;EACL;EACM,aAAC,MAAM;EACH,iBAAC;EACT;EACD"}
+{"version":3,"file":"triggerKeyboardResource.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/triggerKeyboardResource.ts"],"mappings":";;;YAeY;WACD;WACA;EACT;;YAGU;;WAED;;WAEA;;EAET,eAAe;;EAEf,cAAc,GAAG;;qBAwHN,qDAAuB,SAAA;EArGnB,yBAAU,2BAA2B;EACtC;EACI;EACX;EACI;EACL;EACM,aAAC,MAAM;EACH,iBAAC;EACT;EACD"}

package/dist/primitives/composer/trigger/triggerNavigationResource.d.ts

@@ -1,6 +1,6 @@
 import { Unstable_TriggerAdapter, Unstable_TriggerCategory, Unstable_TriggerItem } from "@assistant-ui/core";
 //#region src/primitives/composer/trigger/triggerNavigationResource.d.ts
-type TriggerNavigationResourceOutput = {
+export type TriggerNavigationResourceOutput = {
   /** Filtered categories visible in the list (empty in search mode). */
   readonly categories: readonly Unstable_TriggerCategory[];
   /** Filtered items visible in the list. */
@@ -16,11 +16,10 @@ type TriggerNavigationResourceOutput = {
   /** Return to the top-level category list. */
   goBack(): void;
 };
-declare const TriggerNavigationResource: import("@assistant-ui/tap").Resource<TriggerNavigationResourceOutput, [{
+export declare const TriggerNavigationResource: import("@assistant-ui/tap").Resource<TriggerNavigationResourceOutput, [{
   adapter: Unstable_TriggerAdapter | undefined;
   query: string;
   open: boolean;
 }]>;
 //#endregion
-export { TriggerNavigationResource, TriggerNavigationResourceOutput };
 //# sourceMappingURL=triggerNavigationResource.d.ts.map

package/dist/primitives/composer/trigger/triggerNavigationResource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triggerNavigationResource.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/triggerNavigationResource.ts"],"mappings":";;KASY;;WAED,qBAAqB;;WAErB,gBAAgB;;WAEhB;;WAEA;;WAEA,yBACL,2BACA;;EAGJ,eAAe;;EAEf;;cAsGW,uDAAyB,SAAA;EA1F3B,SAAA;EACF;EACD"}
+{"version":3,"file":"triggerNavigationResource.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/triggerNavigationResource.ts"],"mappings":";;YASY;;WAED,qBAAqB;;WAErB,gBAAgB;;WAEhB;;WAEA;;WAEA,yBACL,2BACA;;EAGJ,eAAe;;EAEf;;qBAsGW,uDAAyB,SAAA;EA1F3B,SAAA;EACF;EACD"}

package/dist/primitives/composer/trigger/triggerSelectionResource.d.ts

@@ -3,8 +3,8 @@ import { AssistantClient } from "@assistant-ui/store";
 import { Unstable_DirectiveFormatter, Unstable_TriggerItem } from "@assistant-ui/core";
 //#region src/primitives/composer/trigger/triggerSelectionResource.d.ts
 /** External override for selection (used by Lexical's DirectivePlugin). */
-type SelectItemOverride = (item: Unstable_TriggerItem) => boolean;
-type TriggerBehavior = {
+export type SelectItemOverride = (item: Unstable_TriggerItem) => boolean;
+export type TriggerBehavior = {
   readonly kind: "directive";
   readonly formatter: Unstable_DirectiveFormatter;
   readonly onInserted?: (item: Unstable_TriggerItem) => void;
@@ -14,7 +14,7 @@ type TriggerBehavior = {
   readonly onExecute: (item: Unstable_TriggerItem) => void;
   readonly removeOnExecute?: boolean;
 };
-type TriggerSelectionResourceOutput = {
+export type TriggerSelectionResourceOutput = {
   /** Select an item — runs override (if any) then applies behavior. */
   selectItem(item: Unstable_TriggerItem): void;
   /** Close the popover (moves cursor before trigger to deactivate detection). */
@@ -22,7 +22,7 @@ type TriggerSelectionResourceOutput = {
   /** Register a Lexical-style selection override. Returns unregister fn. */
   registerSelectItemOverride(fn: SelectItemOverride): () => void;
 };
-declare const TriggerSelectionResource: import("@assistant-ui/tap").Resource<TriggerSelectionResourceOutput, [{
+export declare const TriggerSelectionResource: import("@assistant-ui/tap").Resource<TriggerSelectionResourceOutput, [{
   behavior: TriggerBehavior | undefined;
   trigger: DetectedTrigger | null;
   aui: AssistantClient;
@@ -32,5 +32,4 @@ declare const TriggerSelectionResource: import("@assistant-ui/tap").Resource<Tri
   onSelected: () => void;
 }]>;
 //#endregion
-export { SelectItemOverride, TriggerBehavior, TriggerSelectionResource, TriggerSelectionResourceOutput };
 //# sourceMappingURL=triggerSelectionResource.d.ts.map

package/dist/primitives/composer/trigger/triggerSelectionResource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triggerSelectionResource.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/triggerSelectionResource.ts"],"mappings":";;;;;KAUY,sBAAsB,MAAM;KAE5B;WAEG;WACA,WAAW;WACX,cAAc,MAAM;;WAGpB;WACA,WAAW;WACX,YAAY,MAAM;WAClB;;KAGH;;EAEV,WAAW,MAAM;;EAEjB;;EAEA,2BAA2B,IAAI;;cAwFpB,sDAAwB,SAAA;EA7EzB,UAAA;EACD,SAAA;EACJ,KAAA;EACQ;EACM,oBAAC;;EAER"}
+{"version":3,"file":"triggerSelectionResource.d.ts","names":[],"sources":["../../../../src/primitives/composer/trigger/triggerSelectionResource.ts"],"mappings":";;;;;YAUY,sBAAsB,MAAM;YAE5B;WAEG;WACA,WAAW;WACX,cAAc,MAAM;;WAGpB;WACA,WAAW;WACX,YAAY,MAAM;WAClB;;YAGH;;EAEV,WAAW,MAAM;;EAEjB;;EAEA,2BAA2B,IAAI;;qBAwFpB,sDAAwB,SAAA;EA7EzB,UAAA;EACD,SAAA;EACJ,KAAA;EACQ;EACM,oBAAC;;EAER"}

package/dist/primitives/composer/useComposerInputState.d.ts

@@ -1,13 +1,12 @@
 //#region src/primitives/composer/useComposerInputState.d.ts
-type TriggerPopoverAriaProps = {
+export type TriggerPopoverAriaProps = {
   "aria-controls"?: string;
   "aria-expanded"?: true;
   "aria-haspopup"?: "listbox";
   "aria-activedescendant"?: string | undefined;
 };
-declare function useComposerInputValue(): string;
-declare function useComposerInputDisabled(disabled?: boolean | undefined): boolean;
-declare function useTriggerPopoverAriaProps(): TriggerPopoverAriaProps;
+export declare function useComposerInputValue(): string;
+export declare function useComposerInputDisabled(disabled?: boolean | undefined): boolean;
+export declare function useTriggerPopoverAriaProps(): TriggerPopoverAriaProps;
 //#endregion
-export { TriggerPopoverAriaProps, useComposerInputDisabled, useComposerInputValue, useTriggerPopoverAriaProps };
 //# sourceMappingURL=useComposerInputState.d.ts.map

package/dist/primitives/composer/useComposerInputState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useComposerInputState.d.ts","names":[],"sources":["../../../src/primitives/composer/useComposerInputState.ts"],"mappings":";KAKY;EACV;EACA;EACA;EACA;;iBAGc;iBAIA,yBAAyB;iBAOzB,8BAA8B"}
+{"version":3,"file":"useComposerInputState.d.ts","names":[],"sources":["../../../src/primitives/composer/useComposerInputState.ts"],"mappings":";YAKY;EACV;EACA;EACA;EACA;;wBAGc;wBAIA,yBAAyB;wBAOzB,8BAA8B"}

package/dist/primitives/dropdownMenuRenderPrimitives.d.ts

@@ -1,17 +1,16 @@
 import { DropdownMenu } from "radix-ui";
 //#region src/primitives/dropdownMenuRenderPrimitives.d.ts
-declare const DropdownMenuRenderTrigger: import("react").ForwardRefExoticComponent<Omit<DropdownMenu.DropdownMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & {
+export declare const DropdownMenuRenderTrigger: import("react").ForwardRefExoticComponent<Omit<DropdownMenu.DropdownMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLButtonElement>>;
-declare const DropdownMenuRenderContent: import("react").ForwardRefExoticComponent<Omit<DropdownMenu.DropdownMenuContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+export declare const DropdownMenuRenderContent: import("react").ForwardRefExoticComponent<Omit<DropdownMenu.DropdownMenuContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuRenderItem: import("react").ForwardRefExoticComponent<Omit<DropdownMenu.DropdownMenuItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+export declare const DropdownMenuRenderItem: import("react").ForwardRefExoticComponent<Omit<DropdownMenu.DropdownMenuItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuRenderSeparator: import("react").ForwardRefExoticComponent<Omit<DropdownMenu.DropdownMenuSeparatorProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+export declare const DropdownMenuRenderSeparator: import("react").ForwardRefExoticComponent<Omit<DropdownMenu.DropdownMenuSeparatorProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLDivElement>>;
 //#endregion
-export { DropdownMenuRenderContent, DropdownMenuRenderItem, DropdownMenuRenderSeparator, DropdownMenuRenderTrigger };
 //# sourceMappingURL=dropdownMenuRenderPrimitives.d.ts.map

package/dist/primitives/dropdownMenuRenderPrimitives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dropdownMenuRenderPrimitives.d.ts","names":[],"sources":["../../src/primitives/dropdownMenuRenderPrimitives.ts"],"mappings":";;cAGa,2CAAyB,0BAAA,KAAA,aAAA,2CAAA,cAAA;;oBAErC,cAAA;cACY,2CAAyB,0BAAA,KAAA,aAAA,2CAAA,cAAA;;oBAErC,cAAA;cACY,wCAAsB,0BAAA,KAAA,aAAA,wCAAA,cAAA;;oBAElC,cAAA;cACY,6CAA2B,0BAAA,KAAA,aAAA,6CAAA,cAAA;;oBAEvC,cAAA"}
+{"version":3,"file":"dropdownMenuRenderPrimitives.d.ts","names":[],"sources":["../../src/primitives/dropdownMenuRenderPrimitives.ts"],"mappings":";;qBAGa,2CAAyB,0BAAA,KAAA,aAAA,2CAAA,cAAA;;oBAErC,cAAA;qBACY,2CAAyB,0BAAA,KAAA,aAAA,2CAAA,cAAA;;oBAErC,cAAA;qBACY,wCAAsB,0BAAA,KAAA,aAAA,wCAAA,cAAA;;oBAElC,cAAA;qBACY,6CAA2B,0BAAA,KAAA,aAAA,6CAAA,cAAA;;oBAEvC,cAAA"}

package/dist/primitives/error/ErrorMessage.d.ts

@@ -1,15 +1,14 @@
 import { Primitive } from "../../utils/Primitive.js";
 import { ComponentPropsWithoutRef, ComponentRef } from "react";
 //#region src/primitives/error/ErrorMessage.d.ts
-declare namespace ErrorPrimitiveMessage {
+export declare namespace ErrorPrimitiveMessage {
   type Element = ComponentRef<typeof Primitive.span>;
   type Props = ComponentPropsWithoutRef<typeof Primitive.span>;
 }
-declare const ErrorPrimitiveMessage: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement> & {
+export declare const ErrorPrimitiveMessage: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement> & {
   asChild?: boolean;
 }, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
 //#endregion
-export { ErrorPrimitiveMessage };
 //# sourceMappingURL=ErrorMessage.d.ts.map

package/dist/primitives/error/ErrorMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ErrorMessage.d.ts","names":[],"sources":["../../../src/primitives/error/ErrorMessage.tsx"],"mappings":";;;kBAUiB;OACH,UAAU,oBAAoB,UAAU;OACxC,QAAQ,gCAAgC,UAAU;;cAGnD,uCAAqB,0BAAA,KAAA,qBAAA,gBAAA,mCAAA,eAAA;;;;oBAahC,cAAA,2CAAA,cAAA"}
+{"version":3,"file":"ErrorMessage.d.ts","names":[],"sources":["../../../src/primitives/error/ErrorMessage.tsx"],"mappings":";;;yBAUiB;OACH,UAAU,oBAAoB,UAAU;OACxC,QAAQ,gCAAgC,UAAU;;qBAGnD,uCAAqB,0BAAA,KAAA,qBAAA,gBAAA,mCAAA,eAAA;;;;oBAahC,cAAA,2CAAA,cAAA"}

package/dist/primitives/error/ErrorRoot.d.ts

@@ -1,15 +1,14 @@
 import { Primitive } from "../../utils/Primitive.js";
 import { ComponentPropsWithoutRef, ComponentRef } from "react";
 //#region src/primitives/error/ErrorRoot.d.ts
-declare namespace ErrorPrimitiveRoot {
+export declare namespace ErrorPrimitiveRoot {
   type Element = ComponentRef<typeof Primitive.div>;
   type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
 }
-declare const ErrorPrimitiveRoot: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+export declare const ErrorPrimitiveRoot: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
   asChild?: boolean;
 }, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
 //#endregion
-export { ErrorPrimitiveRoot };
 //# sourceMappingURL=ErrorRoot.d.ts.map

package/dist/primitives/error/ErrorRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ErrorRoot.d.ts","names":[],"sources":["../../../src/primitives/error/ErrorRoot.tsx"],"mappings":";;;kBASiB;OACH,UAAU,oBAAoB,UAAU;OACxC,QAAQ,gCAAgC,UAAU;;cAGnD,oCAAkB,0BAAA,KAAA,qBAAA,gBAAA,kCAAA,eAAA;;;;oBAK7B,cAAA,0CAAA,cAAA"}
+{"version":3,"file":"ErrorRoot.d.ts","names":[],"sources":["../../../src/primitives/error/ErrorRoot.tsx"],"mappings":";;;yBASiB;OACH,UAAU,oBAAoB,UAAU;OACxC,QAAQ,gCAAgC,UAAU;;qBAGnD,oCAAkB,0BAAA,KAAA,qBAAA,gBAAA,kCAAA,eAAA;;;;oBAK7B,cAAA,0CAAA,cAAA"}

package/dist/primitives/message/MessageError.d.ts

@@ -1,6 +1,5 @@
 import { FC, PropsWithChildren } from "react";
 //#region src/primitives/message/MessageError.d.ts
-declare const MessagePrimitiveError: FC<PropsWithChildren>;
+export declare const MessagePrimitiveError: FC<PropsWithChildren>;
 //#endregion
-export { MessagePrimitiveError };
 //# sourceMappingURL=MessageError.d.ts.map

package/dist/primitives/message/MessageError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageError.d.ts","names":[],"sources":["../../../src/primitives/message/MessageError.ts"],"mappings":";;cAKa,uBAAuB,GAAG"}
+{"version":3,"file":"MessageError.d.ts","names":[],"sources":["../../../src/primitives/message/MessageError.ts"],"mappings":";;qBAKa,uBAAuB,GAAG"}

package/dist/primitives/message/MessageIf.d.ts

@@ -15,13 +15,12 @@ type MessageIfFilters = {
   submittedFeedback: "positive" | "negative" | null | undefined;
 };
 type UseMessageIfProps = RequireAtLeastOne<MessageIfFilters>;
-declare namespace MessagePrimitiveIf {
+export declare namespace MessagePrimitiveIf {
   type Props = PropsWithChildren<UseMessageIfProps>;
 }
 /**
  * @deprecated Use `<AuiIf condition={(s) => s.message...} />` instead.
  */
-declare const MessagePrimitiveIf: FC<MessagePrimitiveIf.Props>;
+export declare const MessagePrimitiveIf: FC<MessagePrimitiveIf.Props>;
 //#endregion
-export { MessagePrimitiveIf };
 //# sourceMappingURL=MessageIf.d.ts.map

package/dist/primitives/message/MessageIf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageIf.d.ts","names":[],"sources":["../../../src/primitives/message/MessageIf.ts"],"mappings":";;;KAMK;EACH;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAEG,oBAAoB,kBAAkB;kBAwD1B;OACH,QAAQ,kBAAkB;;;;;cAM3B,oBAAoB,GAAG,mBAAmB"}
+{"version":3,"file":"MessageIf.d.ts","names":[],"sources":["../../../src/primitives/message/MessageIf.ts"],"mappings":";;;KAMK;EACH;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAEG,oBAAoB,kBAAkB;yBAwD1B;OACH,QAAQ,kBAAkB;;;;;qBAM3B,oBAAoB,GAAG,mBAAmB"}

package/dist/primitives/message/MessageParts.d.ts

@@ -1,13 +1,13 @@
 import { MessagePartComponent as MessagePartComponentBase, MessagePrimitivePartByIndex as MessagePrimitivePartByIndexBase, MessagePrimitiveParts as MessagePrimitiveParts$1 } from "@assistant-ui/core/react";
 import { FC } from "react";
 //#region src/primitives/message/MessageParts.d.ts
-declare namespace MessagePrimitiveParts {
+export declare namespace MessagePrimitiveParts {
   type Props = MessagePrimitiveParts$1.Props;
 }
 /**
  * Renders the parts of a message with web-specific default components.
  */
-declare const MessagePrimitiveParts: FC<MessagePrimitiveParts.Props>;
+export declare const MessagePrimitiveParts: FC<MessagePrimitiveParts.Props>;
 //#endregion
-export { MessagePartComponentBase as MessagePartComponent, MessagePrimitivePartByIndexBase as MessagePrimitivePartByIndex, MessagePrimitiveParts };
+export { MessagePartComponentBase as MessagePartComponent, MessagePrimitivePartByIndexBase as MessagePrimitivePartByIndex };
 //# sourceMappingURL=MessageParts.d.ts.map

package/dist/primitives/message/MessageParts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageParts.d.ts","names":[],"sources":["../../../src/primitives/message/MessageParts.tsx"],"mappings":";;;kBA0BiB;OACH,QAAQ,wBAA0B;;;;;cAMnC,uBAAuB,GAAG,sBAAsB"}
+{"version":3,"file":"MessageParts.d.ts","names":[],"sources":["../../../src/primitives/message/MessageParts.tsx"],"mappings":";;;yBA0BiB;OACH,QAAQ,wBAA0B;;;;;qBAMnC,uBAAuB,GAAG,sBAAsB"}

package/dist/primitives/message/MessagePartsGrouped.d.ts

@@ -5,8 +5,8 @@ type MessagePartGroup = {
   groupKey: string | undefined;
   indices: number[];
 };
-type GroupingFunction = (parts: readonly any[]) => MessagePartGroup[];
-declare namespace MessagePrimitiveUnstable_PartsGrouped {
+export type GroupingFunction = (parts: readonly any[]) => MessagePartGroup[];
+export declare namespace MessagePrimitiveUnstable_PartsGrouped {
   type Props = {
     /**
      * Function that takes an array of message parts and returns an array of groups.
@@ -168,14 +168,13 @@ declare namespace MessagePrimitiveUnstable_PartsGrouped {
  * />
  * ```
  */
-declare const MessagePrimitiveUnstable_PartsGrouped: FC<MessagePrimitiveUnstable_PartsGrouped.Props>;
+export declare const MessagePrimitiveUnstable_PartsGrouped: FC<MessagePrimitiveUnstable_PartsGrouped.Props>;
 /**
  * Renders the parts of a message grouped by their parent ID.
  * This is a convenience wrapper around Unstable_PartsGrouped with parent ID grouping.
  *
  * @deprecated Use MessagePrimitive.Unstable_PartsGrouped instead for more flexibility
  */
-declare const MessagePrimitiveUnstable_PartsGroupedByParentId: FC<Omit<MessagePrimitiveUnstable_PartsGrouped.Props, "groupingFunction">>;
+export declare const MessagePrimitiveUnstable_PartsGroupedByParentId: FC<Omit<MessagePrimitiveUnstable_PartsGrouped.Props, "groupingFunction">>;
 //#endregion
-export { GroupingFunction, MessagePrimitiveUnstable_PartsGrouped, MessagePrimitiveUnstable_PartsGroupedByParentId };
 //# sourceMappingURL=MessagePartsGrouped.d.ts.map

package/dist/primitives/message/MessagePartsGrouped.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessagePartsGrouped.d.ts","names":[],"sources":["../../../src/primitives/message/MessagePartsGrouped.tsx"],"mappings":";;;KA8BK;EACH;EACA;;KAGU,oBAAoB,0BAA0B;kBAmDzC;OACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4CV,kBAAkB;;;;;;;IAQlB;;MAGM,QAAQ;;MAER,OAAO;;MAEP,YAAY;;MAEZ,SAAS;;MAET,QAAQ;;MAER,OAAO;;;;;;;MAOP,iBAAiB;;MAEjB;;QAGM,UACI,eAAe;;QAGnB,WAAW;;;MAIjB;;QAGM,UACI,eAAe;;QAGnB,WAAW,cAAc;;;QAIzB,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqC9B,QAAQ,cACN;QACE;QACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqOD,uCAAuC,GAClD,sCAAsC;;;;;;;cA2C3B,iDAAiD,GAC5D,KAAK,sCAAsC"}
+{"version":3,"file":"MessagePartsGrouped.d.ts","names":[],"sources":["../../../src/primitives/message/MessagePartsGrouped.tsx"],"mappings":";;;KA8BK;EACH;EACA;;YAGU,oBAAoB,0BAA0B;yBAmDzC;OACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4CV,kBAAkB;;;;;;;IAQlB;;MAGM,QAAQ;;MAER,OAAO;;MAEP,YAAY;;MAEZ,SAAS;;MAET,QAAQ;;MAER,OAAO;;;;;;;MAOP,iBAAiB;;MAEjB;;QAGM,UACI,eAAe;;QAGnB,WAAW;;;MAIjB;;QAGM,UACI,eAAe;;QAGnB,WAAW,cAAc;;;QAIzB,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqC9B,QAAQ,cACN;QACE;QACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqOD,uCAAuC,GAClD,sCAAsC;;;;;;;qBA2C3B,iDAAiD,GAC5D,KAAK,sCAAsC"}

package/dist/primitives/message/MessageRoot.d.ts

@@ -1,7 +1,7 @@
 import { Primitive } from "../../utils/Primitive.js";
 import { ComponentPropsWithoutRef, ComponentRef } from "react";
 //#region src/primitives/message/MessageRoot.d.ts
-declare namespace MessagePrimitiveRoot {
+export declare namespace MessagePrimitiveRoot {
   type Element = ComponentRef<typeof Primitive.div>;
   type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
 }
@@ -28,11 +28,10 @@ declare namespace MessagePrimitiveRoot {
  * </MessagePrimitive.Root>
  * ```
  */
-declare const MessagePrimitiveRoot: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+export declare const MessagePrimitiveRoot: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
   asChild?: boolean;
 }, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
 //#endregion
-export { MessagePrimitiveRoot };
 //# sourceMappingURL=MessageRoot.d.ts.map

package/dist/primitives/message/MessageRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageRoot.d.ts","names":[],"sources":["../../../src/primitives/message/MessageRoot.tsx"],"mappings":";;;kBAuHiB;OACH,UAAU,oBAAoB,UAAU;OACxC,QAAQ,gCAAgC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;cA8EnD,sCAAoB,0BAAA,KAAA,qBAAA,gBAAA,kCAAA,eAAA;;;;oBAkB/B,cAAA,0CAAA,cAAA"}
+{"version":3,"file":"MessageRoot.d.ts","names":[],"sources":["../../../src/primitives/message/MessageRoot.tsx"],"mappings":";;;yBAuHiB;OACH,UAAU,oBAAoB,UAAU;OACxC,QAAQ,gCAAgC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;qBA8EnD,sCAAoB,0BAAA,KAAA,qBAAA,gBAAA,kCAAA,eAAA;;;;oBAkB/B,cAAA,0CAAA,cAAA"}

package/dist/primitives/messagePart/MessagePartImage.d.ts

@@ -1,7 +1,7 @@
 import { Primitive } from "../../utils/Primitive.js";
 import { ComponentPropsWithoutRef, ComponentRef } from "react";
 //#region src/primitives/messagePart/MessagePartImage.d.ts
-declare namespace MessagePartPrimitiveImage {
+export declare namespace MessagePartPrimitiveImage {
   type Element = ComponentRef<typeof Primitive.img>;
   /**
    * Props for the MessagePartPrimitive.Image component.
@@ -24,11 +24,10 @@ declare namespace MessagePartPrimitiveImage {
  * />
  * ```
  */
-declare const MessagePartPrimitiveImage: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").ClassAttributes<HTMLImageElement> & import("react").ImgHTMLAttributes<HTMLImageElement> & {
+export declare const MessagePartPrimitiveImage: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").ClassAttributes<HTMLImageElement> & import("react").ImgHTMLAttributes<HTMLImageElement> & {
   asChild?: boolean;
 }, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLImageElement>, "ref"> & import("react").RefAttributes<HTMLImageElement>>;
 //#endregion
-export { MessagePartPrimitiveImage };
 //# sourceMappingURL=MessagePartImage.d.ts.map

package/dist/primitives/messagePart/MessagePartImage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessagePartImage.d.ts","names":[],"sources":["../../../src/primitives/messagePart/MessagePartImage.tsx"],"mappings":";;;kBAUiB;OACH,UAAU,oBAAoB,UAAU;;;;;OAKxC,QAAQ,gCAAgC,UAAU;;;;;;;;;;;;;;;;;cAkBnD,2CAAyB,0BAAA,KAAA,qBAAA,gBAAA,oCAAA,kBAAA;;;;oBAMpC,cAAA,4CAAA,cAAA"}
+{"version":3,"file":"MessagePartImage.d.ts","names":[],"sources":["../../../src/primitives/messagePart/MessagePartImage.tsx"],"mappings":";;;yBAUiB;OACH,UAAU,oBAAoB,UAAU;;;;;OAKxC,QAAQ,gCAAgC,UAAU;;;;;;;;;;;;;;;;;qBAkBnD,2CAAyB,0BAAA,KAAA,qBAAA,gBAAA,oCAAA,kBAAA;;;;oBAMpC,cAAA,4CAAA,cAAA"}

package/dist/primitives/messagePart/MessagePartText.d.ts

@@ -2,7 +2,7 @@ import { Primitive } from "../../utils/Primitive.js";
 import { SmoothOptions } from "../../utils/smooth/useSmooth.js";
 import { ComponentPropsWithoutRef, ComponentRef, ElementType } from "react";
 //#region src/primitives/messagePart/MessagePartText.d.ts
-declare namespace MessagePartPrimitiveText {
+export declare namespace MessagePartPrimitiveText {
   type Element = ComponentRef<typeof Primitive.span>;
   type Props = Omit<ComponentPropsWithoutRef<typeof Primitive.span>, "children" | "asChild"> & {
     /**
@@ -37,11 +37,11 @@ declare namespace MessagePartPrimitiveText {
  * />
  * ```
  */
-declare const MessagePartPrimitiveText: import("react").ForwardRefExoticComponent<Omit<Omit<Omit<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement> & {
+export declare const MessagePartPrimitiveText: import("react").ForwardRefExoticComponent<Omit<Omit<Omit<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement> & {
   asChild?: boolean;
 }, "ref"> & {
   render?: import("react").ReactElement | undefined;
-} & import("react").RefAttributes<HTMLSpanElement>, "ref">, "asChild" | "children"> & {
+} & import("react").RefAttributes<HTMLSpanElement>, "ref">, "children" | "asChild"> & {
   /**
    * Whether to enable smooth text streaming animation.
    * When enabled, text appears with a typing effect as it streams in.
@@ -58,5 +58,4 @@ declare const MessagePartPrimitiveText: import("react").ForwardRefExoticComponen
   component?: ElementType;
 } & import("react").RefAttributes<HTMLSpanElement>>;
 //#endregion
-export { MessagePartPrimitiveText };
 //# sourceMappingURL=MessagePartText.d.ts.map

package/dist/primitives/messagePart/MessagePartText.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessagePartText.d.ts","names":[],"sources":["../../../src/primitives/messagePart/MessagePartText.tsx"],"mappings":";;;;kBAaiB;OACH,UAAU,oBAAoB,UAAU;OACxC,QAAQ,KAClB,gCAAgC,UAAU;;;;;;;;IAU1C,mBAAmB;;;;;;IAMnB,YAAY;;;;;;;;;;;;;;;;;;;cAoBH,0CAAwB,0BAAA,KAAA,KAAA,qBAAA,gBAAA,mCAAA,eAAA;;;;;;;;;;;;EA1BxB,mBAAU;;;;;;EAMP,YAAA;oBA0Cf,cAAA"}
+{"version":3,"file":"MessagePartText.d.ts","names":[],"sources":["../../../src/primitives/messagePart/MessagePartText.tsx"],"mappings":";;;;yBAaiB;OACH,UAAU,oBAAoB,UAAU;OACxC,QAAQ,KAClB,gCAAgC,UAAU;;;;;;;;IAU1C,mBAAmB;;;;;;IAMnB,YAAY;;;;;;;;;;;;;;;;;;;qBAoBH,0CAAwB,0BAAA,KAAA,KAAA,qBAAA,gBAAA,mCAAA,eAAA;;;;;;;;;;;;EA1BxB,mBAAU;;;;;;EAMP,YAAA;oBA0Cf,cAAA"}

package/dist/primitives/messagePart/useMessagePartData.d.ts

@@ -17,7 +17,6 @@ import { DataMessagePart } from "@assistant-ui/core";
  *
  * See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
  */
-declare const useMessagePartData: <T = any>(name?: string) => DataMessagePart<T> | null;
+export declare const useMessagePartData: <T = any>(name?: string) => DataMessagePart<T> | null;
 //#endregion
-export { useMessagePartData };
 //# sourceMappingURL=useMessagePartData.d.ts.map

package/dist/primitives/messagePart/useMessagePartData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMessagePartData.d.ts","names":[],"sources":["../../../src/primitives/messagePart/useMessagePartData.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAsBa,qBAAsB,SAAS,kBAAa,gBAAA"}
+{"version":3,"file":"useMessagePartData.d.ts","names":[],"sources":["../../../src/primitives/messagePart/useMessagePartData.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAsBa,qBAAsB,SAAS,kBAAa,gBAAA"}

package/dist/primitives/messagePart/useMessagePartFile.d.ts

@@ -16,9 +16,8 @@ import { FileMessagePart, MessagePartStatus } from "@assistant-ui/core";
  *
  * See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
  */
-declare const useMessagePartFile: () => FileMessagePart & {
+export declare const useMessagePartFile: () => FileMessagePart & {
   readonly status: MessagePartStatus | import("@assistant-ui/core").ToolCallMessagePartStatus;
 };
 //#endregion
-export { useMessagePartFile };
 //# sourceMappingURL=useMessagePartFile.d.ts.map

package/dist/primitives/messagePart/useMessagePartFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMessagePartFile.d.ts","names":[],"sources":["../../../src/primitives/messagePart/useMessagePartFile.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAkCa,0BAAkB;mBAAA"}
+{"version":3,"file":"useMessagePartFile.d.ts","names":[],"sources":["../../../src/primitives/messagePart/useMessagePartFile.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAkCa,0BAAkB;mBAAA"}