@assistant-ui/react 0.5.74 → 0.5.75

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.
package/dist/index.d.mts CHANGED
@@ -1,7 +1,7 @@
1
1
  import { A as Attachment, P as PendingAttachment, T as ThreadMessage, C as CoreMessage, a as AppendMessage, M as ModelConfig, b as ModelConfigProvider, c as ThreadAssistantContentPart, d as MessageStatus, e as ThreadStep, f as PendingAttachmentStatus, g as CompleteAttachment, h as CompleteAttachmentStatus, i as Tool, j as TextContentPart, I as ImageContentPart, k as ToolCallContentPart, l as CoreToolCallContentPart, U as UIContentPart, m as CreateEdgeRuntimeAPIOptions, n as ThreadUserContentPart, o as ContentPartStatus, p as ToolCallContentPartStatus } from './edge-rTP-G718.mjs';
2
2
  export { q as AttachmentStatus, v as CoreAssistantContentPart, y as CoreAssistantMessage, w as CoreSystemMessage, u as CoreUserContentPart, x as CoreUserMessage, E as EdgeRuntimeRequestOptions, s as ThreadAssistantMessage, r as ThreadSystemMessage, t as ThreadUserMessage } from './edge-rTP-G718.mjs';
3
3
  import * as react from 'react';
4
- import { ComponentType, PropsWithChildren, FC, ComponentPropsWithoutRef, ElementType, ReactNode } from 'react';
4
+ import { ComponentType, PropsWithChildren, FC, ElementRef, ComponentPropsWithoutRef, ElementType, ReactNode } from 'react';
5
5
  import { StoreApi, UseBoundStore } from 'zustand';
6
6
  import { Primitive } from '@radix-ui/react-primitive';
7
7
  import * as PopoverPrimitive from '@radix-ui/react-popover';
@@ -49,7 +49,7 @@ declare namespace SpeechSynthesisAdapter {
49
49
  type Utterance = {
50
50
  status: Status;
51
51
  cancel: () => void;
52
- onEnd: (callback: () => void) => Unsubscribe;
52
+ subscribe: (callback: () => void) => Unsubscribe;
53
53
  };
54
54
  }
55
55
  type SpeechSynthesisAdapter = {
@@ -110,6 +110,10 @@ type SubmitFeedbackOptions = {
110
110
  type ThreadSuggestion = {
111
111
  prompt: string;
112
112
  };
113
+ type SpeechState = Readonly<{
114
+ messageId: string;
115
+ status: SpeechSynthesisAdapter.Status;
116
+ }>;
113
117
  type ThreadRuntimeCore = Readonly<{
114
118
  getBranches: (messageId: string) => readonly string[];
115
119
  switchToBranch: (branchId: string) => void;
@@ -117,12 +121,14 @@ type ThreadRuntimeCore = Readonly<{
117
121
  startRun: (parentId: string | null) => void;
118
122
  cancelRun: () => void;
119
123
  addToolResult: (options: AddToolResultOptions) => void;
120
- speak: (messageId: string) => SpeechSynthesisAdapter.Utterance;
124
+ speak: (messageId: string) => void;
125
+ stopSpeaking: () => void;
121
126
  submitFeedback: (feedback: SubmitFeedbackOptions) => void;
122
127
  getModelConfig: () => ModelConfig;
123
128
  composer: ThreadComposerRuntimeCore;
124
129
  getEditComposer: (messageId: string) => ComposerRuntimeCore | undefined;
125
130
  beginEdit: (messageId: string) => void;
131
+ speech: SpeechState | null;
126
132
  capabilities: Readonly<RuntimeCapabilities>;
127
133
  threadId: string;
128
134
  isDisabled: boolean;
@@ -350,8 +356,10 @@ declare class LocalThreadRuntimeCore implements ThreadRuntimeCore {
350
356
  private notifySubscribers;
351
357
  subscribe(callback: () => void): Unsubscribe;
352
358
  addToolResult({ messageId, toolCallId, result, }: AddToolResultOptions): void;
353
- private _utterance;
354
- speak(messageId: string): SpeechSynthesisAdapter.Utterance;
359
+ private _stopSpeaking;
360
+ speech: SpeechState | null;
361
+ speak(messageId: string): void;
362
+ stopSpeaking(): void;
355
363
  submitFeedback({ messageId, type }: SubmitFeedbackOptions): void;
356
364
  export(): ExportedMessageRepository;
357
365
  import(data: ExportedMessageRepository): void;
@@ -445,6 +453,9 @@ declare function streamPartEncoderStream<T extends Record<string, unknown>>(): P
445
453
  declare namespace StreamUtils {
446
454
  export type { StreamPart };
447
455
  }
456
+ /**
457
+ * @deprecated `streamUtils` will be replaced with `assistant-stream` once it is ready.
458
+ */
448
459
  declare const streamUtils: {
449
460
  streamPartEncoderStream: typeof streamPartEncoderStream;
450
461
  streamPartDecoderStream: typeof streamPartDecoderStream;
@@ -493,10 +504,14 @@ type ExternalStoreAdapterBase<T> = {
493
504
  onAddToolResult?: ((options: AddToolResultOptions) => Promise<void> | void) | undefined;
494
505
  onSwitchToThread?: ((threadId: string) => Promise<void> | void) | undefined;
495
506
  onSwitchToNewThread?: (() => Promise<void> | void) | undefined;
507
+ /**
508
+ * @deprecated Provide a speech adapter to `ExternalStoreAdapter.adapters.speech` instead. This will be removed in 0.6.
509
+ */
496
510
  onSpeak?: ((message: ThreadMessage) => SpeechSynthesisAdapter.Utterance) | undefined;
497
511
  convertMessage?: ExternalStoreMessageConverter<T> | undefined;
498
512
  adapters?: {
499
513
  attachments?: AttachmentAdapter | undefined;
514
+ speech?: SpeechSynthesisAdapter | undefined;
500
515
  feedback?: FeedbackAdapter | undefined;
501
516
  };
502
517
  unstable_capabilities?: {
@@ -822,13 +837,15 @@ type MessageState = ThreadMessage & {
822
837
  branches: readonly string[];
823
838
  branchNumber: number;
824
839
  branchCount: number;
840
+ speech: SpeechState | null;
825
841
  };
826
842
  type MessageStateBinding = SubscribableWithState<MessageState>;
827
843
  type MessageRuntime = {
828
844
  composer: EditComposerRuntime;
829
845
  getState(): MessageState;
830
846
  reload(): void;
831
- speak(): SpeechSynthesisAdapter.Utterance;
847
+ speak(): void;
848
+ stopSpeaking(): void;
832
849
  submitFeedback({ type }: {
833
850
  type: "positive" | "negative";
834
851
  }): void;
@@ -849,7 +866,8 @@ declare class MessageRuntimeImpl implements MessageRuntime {
849
866
  composer: EditComposerRuntimeImpl;
850
867
  getState(): MessageState;
851
868
  reload(): void;
852
- speak(): SpeechSynthesisAdapter.Utterance;
869
+ speak(): void;
870
+ stopSpeaking(): void;
853
871
  submitFeedback({ type }: {
854
872
  type: "positive" | "negative";
855
873
  }): void;
@@ -877,6 +895,7 @@ type ThreadState = Readonly<{
877
895
  messages: readonly ThreadMessage[];
878
896
  suggestions: readonly ThreadSuggestion[];
879
897
  extras: unknown;
898
+ speech: SpeechState | null;
880
899
  }>;
881
900
  type ThreadRuntime = {
882
901
  composer: ThreadComposerRuntime;
@@ -893,6 +912,7 @@ type ThreadRuntime = {
893
912
  export(): ExportedMessageRepository;
894
913
  import(repository: ExportedMessageRepository): void;
895
914
  getMesssageByIndex(idx: number): MessageRuntime;
915
+ stopSpeaking: () => void;
896
916
  /**
897
917
  * @deprecated Use `getState().capabilities` instead. This will be removed in 0.6.0.
898
918
  */
@@ -917,6 +937,10 @@ type ThreadRuntime = {
917
937
  * @deprecated Use `getState().followupSuggestions` instead. This will be removed in 0.6.0.
918
938
  */
919
939
  suggestions: readonly ThreadSuggestion[];
940
+ /**
941
+ * @deprecated Use `getState().speechState` instead. This will be removed in 0.6.0.
942
+ */
943
+ speech: SpeechState | null;
920
944
  /**
921
945
  * @deprecated Use `getState().extras` instead. This will be removed in 0.6.0.
922
946
  */
@@ -936,7 +960,7 @@ type ThreadRuntime = {
936
960
  /**
937
961
  * @deprecated Use `getMesssageById(id).speak()` instead. This will be removed in 0.6.0.
938
962
  */
939
- speak: (messageId: string) => SpeechSynthesisAdapter.Utterance;
963
+ speak: (messageId: string) => void;
940
964
  /**
941
965
  * @deprecated Use `getMesssageById(id).submitFeedback({ type })` instead. This will be removed in 0.6.0.
942
966
  */
@@ -988,6 +1012,13 @@ declare class ThreadRuntimeImpl implements ThreadRuntimeCore, ThreadRuntime {
988
1012
  * @deprecated Use `getState().messages` instead. This will be removed in 0.6.0.
989
1013
  */
990
1014
  get messages(): readonly ThreadMessage[];
1015
+ /**
1016
+ * @deprecated Use `getState().speechState` instead. This will be removed in 0.6.0.
1017
+ */
1018
+ get speech(): Readonly<{
1019
+ messageId: string;
1020
+ status: SpeechSynthesisAdapter.Status;
1021
+ }> | null;
991
1022
  unstable_getCore(): Readonly<{
992
1023
  getBranches: (messageId: string) => readonly string[];
993
1024
  switchToBranch: (branchId: string) => void;
@@ -995,12 +1026,14 @@ declare class ThreadRuntimeImpl implements ThreadRuntimeCore, ThreadRuntime {
995
1026
  startRun: (parentId: string | null) => void;
996
1027
  cancelRun: () => void;
997
1028
  addToolResult: (options: AddToolResultOptions) => void;
998
- speak: (messageId: string) => SpeechSynthesisAdapter.Utterance;
1029
+ speak: (messageId: string) => void;
1030
+ stopSpeaking: () => void;
999
1031
  submitFeedback: (feedback: SubmitFeedbackOptions) => void;
1000
1032
  getModelConfig: () => ModelConfig;
1001
1033
  composer: ThreadComposerRuntimeCore;
1002
1034
  getEditComposer: (messageId: string) => ComposerRuntimeCore | undefined;
1003
1035
  beginEdit: (messageId: string) => void;
1036
+ speech: SpeechState | null;
1004
1037
  capabilities: Readonly<RuntimeCapabilities>;
1005
1038
  threadId: string;
1006
1039
  isDisabled: boolean;
@@ -1022,6 +1055,7 @@ declare class ThreadRuntimeImpl implements ThreadRuntimeCore, ThreadRuntime {
1022
1055
  messages: readonly ThreadMessage[];
1023
1056
  suggestions: readonly ThreadSuggestion[];
1024
1057
  extras: unknown;
1058
+ speech: SpeechState | null;
1025
1059
  }>;
1026
1060
  append(message: CreateAppendMessage): void;
1027
1061
  subscribe(callback: () => void): Unsubscribe;
@@ -1040,7 +1074,14 @@ declare class ThreadRuntimeImpl implements ThreadRuntimeCore, ThreadRuntime {
1040
1074
  * @deprecated Use `getMesssageById(id).switchToBranch({ options })` instead. This will be removed in 0.6.0.
1041
1075
  */
1042
1076
  switchToBranch(branchId: string): void;
1043
- speak(messageId: string): SpeechSynthesisAdapter.Utterance;
1077
+ /**
1078
+ * @deprecated Use `getMesssageById(id).speak()` instead. This will be removed in 0.6.0.
1079
+ */
1080
+ speak(messageId: string): void;
1081
+ stopSpeaking(): void;
1082
+ /**
1083
+ * @deprecated Use `getMesssageById(id).submitFeedback({ type })` instead. This will be removed in 0.6.0.
1084
+ */
1044
1085
  submitFeedback(options: SubmitFeedbackOptions): void;
1045
1086
  /**
1046
1087
  * @deprecated Use `getMesssageById(id).getMessageByIndex(idx).composer` instead. This will be removed in 0.6.0.
@@ -1147,12 +1188,6 @@ type MessageUtilsState = Readonly<{
1147
1188
  setIsCopied: (value: boolean) => void;
1148
1189
  isHovering: boolean;
1149
1190
  setIsHovering: (value: boolean) => void;
1150
- /** @deprecated This will be moved to `useMessage().isSpeaking` instead. This will be removed in 0.6.0. */
1151
- isSpeaking: boolean;
1152
- /** @deprecated This will be moved to `useMessageRuntime().stopSpeaking()` instead. This will be removed in 0.6.0. */
1153
- stopSpeaking: () => void;
1154
- /** @deprecated This will be moved to `useMessageRuntime().speak()` instead. This will be removed in 0.6.0. */
1155
- addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
1156
1191
  /** @deprecated This will be moved to `useMessage().submittedFeedback`. This will be removed in 0.6.0. */
1157
1192
  submittedFeedback: "positive" | "negative" | null;
1158
1193
  /** @deprecated This will be moved to `useMessageRuntime().submitFeedback()` instead. This will be removed in 0.6.0. */
@@ -1332,6 +1367,10 @@ declare const useThread: {
1332
1367
  messages: readonly ThreadMessage[];
1333
1368
  suggestions: readonly ThreadSuggestion[];
1334
1369
  extras: unknown;
1370
+ speech: Readonly<{
1371
+ messageId: string;
1372
+ status: SpeechSynthesisAdapter.Status;
1373
+ }> | null;
1335
1374
  }>;
1336
1375
  <TSelected>(selector: (state: Readonly<{
1337
1376
  threadId: string;
@@ -1350,6 +1389,10 @@ declare const useThread: {
1350
1389
  messages: readonly ThreadMessage[];
1351
1390
  suggestions: readonly ThreadSuggestion[];
1352
1391
  extras: unknown;
1392
+ speech: Readonly<{
1393
+ messageId: string;
1394
+ status: SpeechSynthesisAdapter.Status;
1395
+ }> | null;
1353
1396
  }>) => TSelected): TSelected;
1354
1397
  (options: {
1355
1398
  optional: true;
@@ -1370,6 +1413,10 @@ declare const useThread: {
1370
1413
  messages: readonly ThreadMessage[];
1371
1414
  suggestions: readonly ThreadSuggestion[];
1372
1415
  extras: unknown;
1416
+ speech: Readonly<{
1417
+ messageId: string;
1418
+ status: SpeechSynthesisAdapter.Status;
1419
+ }> | null;
1373
1420
  }> | null;
1374
1421
  <TSelected>(options: {
1375
1422
  optional: true;
@@ -1390,6 +1437,10 @@ declare const useThread: {
1390
1437
  messages: readonly ThreadMessage[];
1391
1438
  suggestions: readonly ThreadSuggestion[];
1392
1439
  extras: unknown;
1440
+ speech: Readonly<{
1441
+ messageId: string;
1442
+ status: SpeechSynthesisAdapter.Status;
1443
+ }> | null;
1393
1444
  }>) => TSelected;
1394
1445
  }): TSelected | null;
1395
1446
  };
@@ -1411,6 +1462,10 @@ declare const useThreadStore: {
1411
1462
  messages: readonly ThreadMessage[];
1412
1463
  suggestions: readonly ThreadSuggestion[];
1413
1464
  extras: unknown;
1465
+ speech: Readonly<{
1466
+ messageId: string;
1467
+ status: SpeechSynthesisAdapter.Status;
1468
+ }> | null;
1414
1469
  }>>;
1415
1470
  (options: {
1416
1471
  optional: true;
@@ -1431,6 +1486,10 @@ declare const useThreadStore: {
1431
1486
  messages: readonly ThreadMessage[];
1432
1487
  suggestions: readonly ThreadSuggestion[];
1433
1488
  extras: unknown;
1489
+ speech: Readonly<{
1490
+ messageId: string;
1491
+ status: SpeechSynthesisAdapter.Status;
1492
+ }> | null;
1434
1493
  }>> | null;
1435
1494
  };
1436
1495
  /**
@@ -1558,9 +1617,6 @@ declare const useMessageUtils: {
1558
1617
  setIsCopied: (value: boolean) => void;
1559
1618
  isHovering: boolean;
1560
1619
  setIsHovering: (value: boolean) => void;
1561
- isSpeaking: boolean;
1562
- stopSpeaking: () => void;
1563
- addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
1564
1620
  submittedFeedback: "positive" | "negative" | null;
1565
1621
  setSubmittedFeedback: (feedback: "positive" | "negative" | null) => void;
1566
1622
  }>;
@@ -1569,9 +1625,6 @@ declare const useMessageUtils: {
1569
1625
  setIsCopied: (value: boolean) => void;
1570
1626
  isHovering: boolean;
1571
1627
  setIsHovering: (value: boolean) => void;
1572
- isSpeaking: boolean;
1573
- stopSpeaking: () => void;
1574
- addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
1575
1628
  submittedFeedback: "positive" | "negative" | null;
1576
1629
  setSubmittedFeedback: (feedback: "positive" | "negative" | null) => void;
1577
1630
  }>) => TSelected): TSelected;
@@ -1582,9 +1635,6 @@ declare const useMessageUtils: {
1582
1635
  setIsCopied: (value: boolean) => void;
1583
1636
  isHovering: boolean;
1584
1637
  setIsHovering: (value: boolean) => void;
1585
- isSpeaking: boolean;
1586
- stopSpeaking: () => void;
1587
- addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
1588
1638
  submittedFeedback: "positive" | "negative" | null;
1589
1639
  setSubmittedFeedback: (feedback: "positive" | "negative" | null) => void;
1590
1640
  }> | null;
@@ -1595,9 +1645,6 @@ declare const useMessageUtils: {
1595
1645
  setIsCopied: (value: boolean) => void;
1596
1646
  isHovering: boolean;
1597
1647
  setIsHovering: (value: boolean) => void;
1598
- isSpeaking: boolean;
1599
- stopSpeaking: () => void;
1600
- addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
1601
1648
  submittedFeedback: "positive" | "negative" | null;
1602
1649
  setSubmittedFeedback: (feedback: "positive" | "negative" | null) => void;
1603
1650
  }>) => TSelected;
@@ -1609,9 +1656,6 @@ declare const useMessageUtilsStore: {
1609
1656
  setIsCopied: (value: boolean) => void;
1610
1657
  isHovering: boolean;
1611
1658
  setIsHovering: (value: boolean) => void;
1612
- isSpeaking: boolean;
1613
- stopSpeaking: () => void;
1614
- addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
1615
1659
  submittedFeedback: "positive" | "negative" | null;
1616
1660
  setSubmittedFeedback: (feedback: "positive" | "negative" | null) => void;
1617
1661
  }>>;
@@ -1622,9 +1666,6 @@ declare const useMessageUtilsStore: {
1622
1666
  setIsCopied: (value: boolean) => void;
1623
1667
  isHovering: boolean;
1624
1668
  setIsHovering: (value: boolean) => void;
1625
- isSpeaking: boolean;
1626
- stopSpeaking: () => void;
1627
- addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
1628
1669
  submittedFeedback: "positive" | "negative" | null;
1629
1670
  setSubmittedFeedback: (feedback: "positive" | "negative" | null) => void;
1630
1671
  }>> | null;
@@ -1712,6 +1753,9 @@ declare function useComposerRuntime(options?: {
1712
1753
  optional?: boolean | undefined;
1713
1754
  }): ComposerRuntime | null;
1714
1755
 
1756
+ /**
1757
+ * @deprecated Use `useThreadRuntime().append()` instead. This will be removed in 0.6.
1758
+ */
1715
1759
  declare const useAppendMessage: () => (message: CreateAppendMessage) => void;
1716
1760
 
1717
1761
  /**
@@ -1844,8 +1888,15 @@ type UseActionBarFloatStatusProps = {
1844
1888
  autohideFloat?: "always" | "single-branch" | "never" | undefined;
1845
1889
  };
1846
1890
 
1847
- type PrimitiveDivProps$6 = ComponentPropsWithoutRef<typeof Primitive.div>;
1848
- type ActionBarPrimitiveRootProps = PrimitiveDivProps$6 & UseActionBarFloatStatusProps;
1891
+ type PrimitiveDivProps$2 = ComponentPropsWithoutRef<typeof Primitive.div>;
1892
+ /**
1893
+ * @deprecated Use `ActionBarPrimitive.Root.Props` instead. This will be removed in 0.6.
1894
+ */
1895
+ type ActionBarPrimitiveRootProps = ActionBarPrimitiveRoot.Props;
1896
+ declare namespace ActionBarPrimitiveRoot {
1897
+ type Element = ElementRef<typeof Primitive.div>;
1898
+ type Props = PrimitiveDivProps$2 & UseActionBarFloatStatusProps;
1899
+ }
1849
1900
  declare const ActionBarPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
1850
1901
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
1851
1902
  } & {
@@ -1854,82 +1905,157 @@ declare const ActionBarPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<
1854
1905
 
1855
1906
  type PrimitiveButtonProps = ComponentPropsWithoutRef<typeof Primitive.button>;
1856
1907
  type ActionButtonProps<THook> = PrimitiveButtonProps & (THook extends (props: infer TProps) => unknown ? TProps : never);
1908
+ type ActionButtonElement = ElementRef<typeof Primitive.button>;
1857
1909
 
1858
- type ActionBarPrimitiveCopyProps = ActionButtonProps<typeof useActionBarCopy>;
1859
- declare const ActionBarPrimitiveCopy: react.ForwardRefExoticComponent<Partial<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1910
+ /**
1911
+ * @deprecated Use `ActionBarPrimitive.Copy.Props` instead. This will be removed in 0.6.
1912
+ */
1913
+ type ActionBarPrimitiveCopyProps = ActionBarPrimitiveCopy.Props;
1914
+ declare namespace ActionBarPrimitiveCopy {
1915
+ type Element = HTMLButtonElement;
1916
+ type Props = ActionButtonProps<typeof useActionBarCopy>;
1917
+ }
1918
+ declare const ActionBarPrimitiveCopy: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1860
1919
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1861
1920
  } & {
1862
1921
  asChild?: boolean;
1863
- }, "ref"> & UseActionBarCopyProps> & react.RefAttributes<HTMLButtonElement>>;
1922
+ }, "ref"> & UseActionBarCopyProps & react.RefAttributes<HTMLButtonElement>>;
1864
1923
 
1865
- type ActionBarPrimitiveReloadProps = ActionButtonProps<typeof useActionBarReload>;
1924
+ /**
1925
+ * @deprecated Use `ActionBarPrimitive.Reload.Props` instead. This will be removed in 0.6.
1926
+ */
1927
+ type ActionBarPrimitiveReloadProps = ActionBarPrimitiveReload.Props;
1928
+ declare namespace ActionBarPrimitiveReload {
1929
+ type Element = ActionButtonElement;
1930
+ type Props = ActionButtonProps<typeof useActionBarReload>;
1931
+ }
1866
1932
  declare const ActionBarPrimitiveReload: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1867
1933
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1868
1934
  } & {
1869
1935
  asChild?: boolean;
1870
1936
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1871
1937
 
1872
- type ActionBarPrimitiveEditProps = ActionButtonProps<typeof useActionBarEdit>;
1938
+ /**
1939
+ * @deprecated Use `ActionBarPrimitive.Edit.Props` instead. This will be removed in 0.6.
1940
+ */
1941
+ type ActionBarPrimitiveEditProps = ActionBarPrimitiveEdit.Props;
1942
+ declare namespace ActionBarPrimitiveEdit {
1943
+ type Element = ActionButtonElement;
1944
+ type Props = ActionButtonProps<typeof useActionBarEdit>;
1945
+ }
1873
1946
  declare const ActionBarPrimitiveEdit: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1874
1947
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1875
1948
  } & {
1876
1949
  asChild?: boolean;
1877
1950
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1878
1951
 
1879
- type ActionBarPrimitiveSpeakProps = ActionButtonProps<typeof useActionBarSpeak>;
1952
+ /**
1953
+ * @deprecated Use `ActionBarPrimitive.Speak.Props` instead. This will be removed in 0.6.
1954
+ */
1955
+ type ActionBarPrimitiveSpeakProps = ActionBarPrimitiveSpeak.Props;
1956
+ declare namespace ActionBarPrimitiveSpeak {
1957
+ type Element = ActionButtonElement;
1958
+ type Props = ActionButtonProps<typeof useActionBarSpeak>;
1959
+ }
1880
1960
  declare const ActionBarPrimitiveSpeak: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1881
1961
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1882
1962
  } & {
1883
1963
  asChild?: boolean;
1884
1964
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1885
1965
 
1886
- type ActionBarPrimitiveStopSpeakingProps = ActionButtonProps<typeof useActionBarStopSpeaking>;
1887
- declare const ActionBarPrimitiveStopSpeaking: react.ForwardRefExoticComponent<Partial<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1966
+ /**
1967
+ * @deprecated Use `ActionBarPrimitive.StopSpeaking.Props` instead. This will be removed in 0.6.
1968
+ */
1969
+ type ActionBarPrimitiveStopSpeakingProps = ActionBarPrimitiveStopSpeaking.Props;
1970
+ declare namespace ActionBarPrimitiveStopSpeaking {
1971
+ type Element = HTMLButtonElement;
1972
+ type Props = ActionButtonProps<typeof useActionBarStopSpeaking>;
1973
+ }
1974
+ declare const ActionBarPrimitiveStopSpeaking: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1888
1975
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1889
1976
  } & {
1890
1977
  asChild?: boolean;
1891
- }, "ref">> & react.RefAttributes<HTMLButtonElement>>;
1978
+ }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1892
1979
 
1893
- type ActionBarPrimitiveFeedbackPositiveProps = ActionButtonProps<typeof useActionBarFeedbackPositive>;
1894
- declare const ActionBarPrimitiveFeedbackPositive: react.ForwardRefExoticComponent<Partial<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1980
+ /**
1981
+ * @deprecated Use `ActionBarPrimitive.FeedbackPositive.Props` instead. This will be removed in 0.6.
1982
+ */
1983
+ type ActionBarPrimitiveFeedbackPositiveProps = ActionBarPrimitiveFeedbackPositive.Props;
1984
+ declare namespace ActionBarPrimitiveFeedbackPositive {
1985
+ type Element = HTMLButtonElement;
1986
+ type Props = ActionButtonProps<typeof useActionBarFeedbackPositive>;
1987
+ }
1988
+ declare const ActionBarPrimitiveFeedbackPositive: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1895
1989
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1896
1990
  } & {
1897
1991
  asChild?: boolean;
1898
- }, "ref">> & react.RefAttributes<HTMLButtonElement>>;
1992
+ }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1899
1993
 
1900
- type ActionBarPrimitiveFeedbackNegativeProps = ActionButtonProps<typeof useActionBarFeedbackNegative>;
1901
- declare const ActionBarPrimitiveFeedbackNegative: react.ForwardRefExoticComponent<Partial<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1994
+ /**
1995
+ * @deprecated Use `ActionBarPrimitive.FeedbackNegative.Props` instead. This will be removed in 0.6.
1996
+ */
1997
+ type ActionBarPrimitiveFeedbackNegativeProps = ActionBarPrimitiveFeedbackNegative.Props;
1998
+ declare namespace ActionBarPrimitiveFeedbackNegative {
1999
+ type Element = HTMLButtonElement;
2000
+ type Props = ActionButtonProps<typeof useActionBarFeedbackNegative>;
2001
+ }
2002
+ declare const ActionBarPrimitiveFeedbackNegative: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1902
2003
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1903
2004
  } & {
1904
2005
  asChild?: boolean;
1905
- }, "ref">> & react.RefAttributes<HTMLButtonElement>>;
2006
+ }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1906
2007
 
1907
2008
  declare namespace index$7 {
1908
2009
  export { ActionBarPrimitiveCopy as Copy, ActionBarPrimitiveEdit as Edit, ActionBarPrimitiveFeedbackNegative as FeedbackNegative, ActionBarPrimitiveFeedbackPositive as FeedbackPositive, ActionBarPrimitiveReload as Reload, ActionBarPrimitiveRoot as Root, ActionBarPrimitiveSpeak as Speak, ActionBarPrimitiveStopSpeaking as StopSpeaking };
1909
2010
  }
1910
2011
 
2012
+ /**
2013
+ * @deprecated Use `AssistantModalPrimitive.Root.Props` instead. This will be removed in 0.6.
2014
+ */
1911
2015
  type AssistantModalPrimitiveRootProps = PopoverPrimitive.PopoverProps;
1912
- declare const AssistantModalPrimitiveRoot: FC<AssistantModalPrimitiveRootProps>;
2016
+ declare namespace AssistantModalPrimitiveRoot {
2017
+ type Props = PopoverPrimitive.PopoverProps;
2018
+ }
2019
+ declare const AssistantModalPrimitiveRoot: FC<AssistantModalPrimitiveRoot.Props>;
1913
2020
 
1914
- type AssistantModalPrimitiveTriggerProps = ComponentPropsWithoutRef<typeof PopoverPrimitive.Trigger>;
2021
+ /**
2022
+ * @deprecated Use `AssistantModalPrimitive.Trigger.Props` instead. This will be removed in 0.6.
2023
+ */
2024
+ type AssistantModalPrimitiveTriggerProps = AssistantModalPrimitiveTrigger.Props;
2025
+ declare namespace AssistantModalPrimitiveTrigger {
2026
+ type Element = ElementRef<typeof PopoverPrimitive.Trigger>;
2027
+ type Props = ComponentPropsWithoutRef<typeof PopoverPrimitive.Trigger>;
2028
+ }
1915
2029
  declare const AssistantModalPrimitiveTrigger: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1916
2030
 
1917
- type AssistantModalPrimitiveContentProps = ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> & {
1918
- dissmissOnInteractOutside?: boolean | undefined;
1919
- };
2031
+ /**
2032
+ * @deprecated Use `AssistantModalPrimitive.Content.Props` instead. This will be removed in 0.6.
2033
+ */
2034
+ type AssistantModalPrimitiveContentProps = AssistantModalPrimitiveContent.Props;
2035
+ declare namespace AssistantModalPrimitiveContent {
2036
+ type Element = ElementRef<typeof PopoverPrimitive.Content>;
2037
+ type Props = ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> & {
2038
+ dissmissOnInteractOutside?: boolean | undefined;
2039
+ };
2040
+ }
1920
2041
  declare const AssistantModalPrimitiveContent: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
1921
2042
  dissmissOnInteractOutside?: boolean | undefined;
1922
2043
  } & react.RefAttributes<HTMLDivElement>>;
1923
2044
 
2045
+ declare namespace AssistantModalPrimitiveAnchor {
2046
+ type Element = ElementRef<typeof PopoverPrimitive.Anchor>;
2047
+ type Props = ComponentPropsWithoutRef<typeof PopoverPrimitive.Anchor>;
2048
+ }
1924
2049
  declare const AssistantModalPrimitiveAnchor: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverAnchorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
1925
2050
 
1926
2051
  declare namespace index$6 {
1927
2052
  export { AssistantModalPrimitiveAnchor as Anchor, AssistantModalPrimitiveContent as Content, AssistantModalPrimitiveRoot as Root, AssistantModalPrimitiveTrigger as Trigger };
1928
2053
  }
1929
2054
 
1930
- type PrimitiveDivProps$5 = ComponentPropsWithoutRef<typeof Primitive.div>;
2055
+ type PrimitiveDivProps$1 = ComponentPropsWithoutRef<typeof Primitive.div>;
1931
2056
  declare namespace AttachmentPrimitiveRoot {
1932
- type Props = PrimitiveDivProps$5;
2057
+ type Element = ElementRef<typeof Primitive.div>;
2058
+ type Props = PrimitiveDivProps$1;
1933
2059
  }
1934
2060
  declare const AttachmentPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
1935
2061
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
@@ -1937,9 +2063,10 @@ declare const AttachmentPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit
1937
2063
  asChild?: boolean;
1938
2064
  }, "ref"> & react.RefAttributes<HTMLDivElement>>;
1939
2065
 
1940
- type PrimitiveDivProps$4 = ComponentPropsWithoutRef<typeof Primitive.div>;
2066
+ type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
1941
2067
  declare namespace AttachmentPrimitiveThumb {
1942
- type Props = PrimitiveDivProps$4;
2068
+ type Element = ElementRef<typeof Primitive.div>;
2069
+ type Props = PrimitiveDivProps;
1943
2070
  }
1944
2071
  declare const AttachmentPrimitiveThumb: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
1945
2072
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
@@ -1955,6 +2082,7 @@ declare const AttachmentPrimitiveName: FC<AttachmentPrimitiveName.Props>;
1955
2082
  declare const useAttachmentRemove: () => () => void;
1956
2083
 
1957
2084
  declare namespace AttachmentPrimitiveRemove {
2085
+ type Element = ActionButtonElement;
1958
2086
  type Props = ActionButtonProps<typeof useAttachmentRemove>;
1959
2087
  }
1960
2088
  declare const AttachmentPrimitiveRemove: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
@@ -1967,30 +2095,62 @@ declare namespace index$5 {
1967
2095
  export { AttachmentPrimitiveName as Name, AttachmentPrimitiveRemove as Remove, AttachmentPrimitiveRoot as Root, AttachmentPrimitiveThumb as unstable_Thumb };
1968
2096
  }
1969
2097
 
1970
- type BranchPickerPrimitiveNextProps = ActionButtonProps<typeof useBranchPickerNext>;
2098
+ /**
2099
+ * @deprecated Use `BranchPickerPrimitive.Next.Props` instead. This will be removed in 0.6.
2100
+ */
2101
+ type BranchPickerPrimitiveNextProps = BranchPickerPrimitiveNext.Props;
2102
+ declare namespace BranchPickerPrimitiveNext {
2103
+ type Element = ActionButtonElement;
2104
+ type Props = ActionButtonProps<typeof useBranchPickerNext>;
2105
+ }
1971
2106
  declare const BranchPickerPrimitiveNext: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1972
2107
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1973
2108
  } & {
1974
2109
  asChild?: boolean;
1975
2110
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1976
2111
 
1977
- type BranchPickerPrimitivePreviousProps = ActionButtonProps<typeof useBranchPickerPrevious>;
1978
- declare const BranchPickerPrevious: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
2112
+ /**
2113
+ * @deprecated Use `BranchPickerPrimitive.Previous.Props` instead. This will be removed in 0.6.
2114
+ */
2115
+ type BranchPickerPrimitivePreviousProps = BranchPickerPrimitivePrevious.Props;
2116
+ declare namespace BranchPickerPrimitivePrevious {
2117
+ type Element = ActionButtonElement;
2118
+ type Props = ActionButtonProps<typeof useBranchPickerPrevious>;
2119
+ }
2120
+ declare const BranchPickerPrimitivePrevious: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
1979
2121
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
1980
2122
  } & {
1981
2123
  asChild?: boolean;
1982
2124
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
1983
2125
 
1984
- type BranchPickerPrimitiveCountProps = Record<string, never>;
1985
- declare const BranchPickerPrimitiveCount: FC<BranchPickerPrimitiveCountProps>;
2126
+ /**
2127
+ * @deprecated Use `BranchPickerPrimitive.Count.Props` instead. This will be removed in 0.6.
2128
+ */
2129
+ type BranchPickerPrimitiveCountProps = BranchPickerPrimitiveCount.Props;
2130
+ declare namespace BranchPickerPrimitiveCount {
2131
+ type Props = Record<string, never>;
2132
+ }
2133
+ declare const BranchPickerPrimitiveCount: FC<BranchPickerPrimitiveCount.Props>;
1986
2134
 
1987
- type BranchPickerPrimitiveNumberProps = Record<string, never>;
1988
- declare const BranchPickerPrimitiveNumber: FC<BranchPickerPrimitiveNumberProps>;
2135
+ /**
2136
+ * @deprecated Use `BranchPickerPrimitive.Number.Props` instead. This will be removed in 0.6.
2137
+ */
2138
+ type BranchPickerPrimitiveNumberProps = BranchPickerPrimitiveNumber.Props;
2139
+ declare namespace BranchPickerPrimitiveNumber {
2140
+ type Props = Record<string, never>;
2141
+ }
2142
+ declare const BranchPickerPrimitiveNumber: FC<BranchPickerPrimitiveNumber.Props>;
1989
2143
 
1990
- type PrimitiveDivProps$3 = ComponentPropsWithoutRef<typeof Primitive.div>;
1991
- type BranchPickerPrimitiveRootProps = PrimitiveDivProps$3 & {
1992
- hideWhenSingleBranch?: boolean | undefined;
1993
- };
2144
+ /**
2145
+ * @deprecated Use `BranchPickerPrimitive.Root.Props` instead. This will be removed in 0.6.
2146
+ */
2147
+ type BranchPickerPrimitiveRootProps = BranchPickerPrimitiveRoot.Props;
2148
+ declare namespace BranchPickerPrimitiveRoot {
2149
+ type Element = ElementRef<typeof Primitive.div>;
2150
+ type Props = ComponentPropsWithoutRef<typeof Primitive.div> & {
2151
+ hideWhenSingleBranch?: boolean | undefined;
2152
+ };
2153
+ }
1994
2154
  declare const BranchPickerPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
1995
2155
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
1996
2156
  } & {
@@ -2000,70 +2160,112 @@ declare const BranchPickerPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Om
2000
2160
  } & react.RefAttributes<HTMLDivElement>>;
2001
2161
 
2002
2162
  declare namespace index$4 {
2003
- export { BranchPickerPrimitiveCount as Count, BranchPickerPrimitiveNext as Next, BranchPickerPrimitiveNumber as Number, BranchPickerPrevious as Previous, BranchPickerPrimitiveRoot as Root };
2163
+ export { BranchPickerPrimitiveCount as Count, BranchPickerPrimitiveNext as Next, BranchPickerPrimitiveNumber as Number, BranchPickerPrimitivePrevious as Previous, BranchPickerPrimitiveRoot as Root };
2004
2164
  }
2005
2165
 
2006
- type PrimitiveFormProps = ComponentPropsWithoutRef<typeof Primitive.form>;
2007
- type ComposerPrimitiveRootProps = PrimitiveFormProps;
2166
+ type ComposerPrimitiveRootProps = ComposerPrimitiveRoot.Props;
2167
+ declare namespace ComposerPrimitiveRoot {
2168
+ type Element = ElementRef<typeof Primitive.form>;
2169
+ type Props = ComponentPropsWithoutRef<typeof Primitive.form>;
2170
+ }
2008
2171
  declare const ComposerPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
2009
2172
  ref?: ((instance: HTMLFormElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLFormElement> | null | undefined;
2010
2173
  } & {
2011
2174
  asChild?: boolean;
2012
2175
  }, "ref"> & react.RefAttributes<HTMLFormElement>>;
2013
2176
 
2014
- type ComposerPrimitiveInputProps = TextareaAutosizeProps & {
2015
- asChild?: boolean | undefined;
2016
- submitOnEnter?: boolean | undefined;
2017
- cancelOnEscape?: boolean | undefined;
2018
- };
2177
+ /**
2178
+ * @deprecated Use `ComposerPrimitive.Input.Props` instead. This will be removed in 0.6.
2179
+ */
2180
+ type ComposerPrimitiveInputProps = ComposerPrimitiveInput.Props;
2181
+ declare namespace ComposerPrimitiveInput {
2182
+ type Element = HTMLTextAreaElement;
2183
+ type Props = TextareaAutosizeProps & {
2184
+ asChild?: boolean | undefined;
2185
+ submitOnEnter?: boolean | undefined;
2186
+ cancelOnEscape?: boolean | undefined;
2187
+ };
2188
+ }
2019
2189
  declare const ComposerPrimitiveInput: react.ForwardRefExoticComponent<TextareaAutosizeProps & {
2020
2190
  asChild?: boolean | undefined;
2021
2191
  submitOnEnter?: boolean | undefined;
2022
2192
  cancelOnEscape?: boolean | undefined;
2023
2193
  } & react.RefAttributes<HTMLTextAreaElement>>;
2024
2194
 
2025
- type ComposerPrimitiveSendProps = ActionButtonProps<typeof useComposerSend>;
2195
+ /**
2196
+ * @deprecated Use `ComposerPrimitive.Send.Props` instead. This will be removed in 0.6.
2197
+ */
2198
+ type ComposerPrimitiveSendProps = ComposerPrimitiveSend.Props;
2199
+ declare namespace ComposerPrimitiveSend {
2200
+ type Element = ActionButtonElement;
2201
+ type Props = ActionButtonProps<typeof useComposerSend>;
2202
+ }
2026
2203
  declare const ComposerPrimitiveSend: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
2027
2204
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
2028
2205
  } & {
2029
2206
  asChild?: boolean;
2030
2207
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
2031
2208
 
2032
- type ComposerPrimitiveCancelProps = ActionButtonProps<typeof useComposerCancel>;
2209
+ /**
2210
+ * @deprecated Use `ComposerPrimitive.Cancel.Props` instead. This will be removed in 0.6.
2211
+ */
2212
+ type ComposerPrimitiveCancelProps = ComposerPrimitiveCancel.Props;
2213
+ declare namespace ComposerPrimitiveCancel {
2214
+ type Element = ActionButtonElement;
2215
+ type Props = ActionButtonProps<typeof useComposerCancel>;
2216
+ }
2033
2217
  declare const ComposerPrimitiveCancel: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
2034
2218
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
2035
2219
  } & {
2036
2220
  asChild?: boolean;
2037
2221
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
2038
2222
 
2223
+ declare namespace ComposerPrimitiveAddAttachment {
2224
+ type Element = ActionButtonElement;
2225
+ type Props = ActionButtonProps<typeof useComposerAddAttachment>;
2226
+ }
2039
2227
  declare const ComposerPrimitiveAddAttachment: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
2040
2228
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
2041
2229
  } & {
2042
2230
  asChild?: boolean;
2043
2231
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
2044
2232
 
2045
- type ComposerPrimitiveAttachmentsProps = {
2046
- components: {
2047
- Image?: ComponentType | undefined;
2048
- Document?: ComponentType | undefined;
2049
- File?: ComponentType | undefined;
2050
- Attachment?: ComponentType | undefined;
2051
- } | undefined;
2052
- };
2053
- declare const ComposerPrimitiveAttachments: FC<ComposerPrimitiveAttachmentsProps>;
2233
+ declare namespace ComposerPrimitiveAttachments {
2234
+ type Props = {
2235
+ components: {
2236
+ Image?: ComponentType | undefined;
2237
+ Document?: ComponentType | undefined;
2238
+ File?: ComponentType | undefined;
2239
+ Attachment?: ComponentType | undefined;
2240
+ } | undefined;
2241
+ };
2242
+ }
2243
+ declare const ComposerPrimitiveAttachments: FC<ComposerPrimitiveAttachments.Props>;
2054
2244
 
2055
- type ComposerPrimitiveIfProps = PropsWithChildren<UseComposerIfProps>;
2056
- declare const ComposerPrimitiveIf: FC<ComposerPrimitiveIfProps>;
2245
+ /**
2246
+ * @deprecated Use `ComposerPrimitive.If.Props` instead. This will be removed in 0.6.
2247
+ */
2248
+ type ComposerPrimitiveIfProps = ComposerPrimitiveIf.Props;
2249
+ declare namespace ComposerPrimitiveIf {
2250
+ type Props = PropsWithChildren<UseComposerIfProps>;
2251
+ }
2252
+ declare const ComposerPrimitiveIf: FC<ComposerPrimitiveIf.Props>;
2057
2253
 
2058
2254
  declare namespace index$3 {
2059
2255
  export { ComposerPrimitiveAddAttachment as AddAttachment, ComposerPrimitiveAttachments as Attachments, ComposerPrimitiveCancel as Cancel, ComposerPrimitiveIf as If, ComposerPrimitiveInput as Input, ComposerPrimitiveRoot as Root, ComposerPrimitiveSend as Send };
2060
2256
  }
2061
2257
 
2062
- type PrimitiveSpanProps$1 = ComponentPropsWithoutRef<typeof Primitive.span>;
2063
- type ContentPartPrimitiveTextProps = Omit<PrimitiveSpanProps$1, "children" | "asChild"> & {
2064
- smooth?: boolean;
2065
- component?: ElementType;
2066
- };
2258
+ /**
2259
+ * @deprecated Use `ContentPartPrimitive.Text.Props` instead. This will be removed in 0.6.
2260
+ */
2261
+ type ContentPartPrimitiveTextProps = ContentPartPrimitiveText.Props;
2262
+ declare namespace ContentPartPrimitiveText {
2263
+ type Element = ElementRef<typeof Primitive.span>;
2264
+ type Props = Omit<ComponentPropsWithoutRef<typeof Primitive.span>, "children" | "asChild"> & {
2265
+ smooth?: boolean;
2266
+ component?: ElementType;
2267
+ };
2268
+ }
2067
2269
  declare const ContentPartPrimitiveText: react.ForwardRefExoticComponent<Omit<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
2068
2270
  ref?: ((instance: HTMLSpanElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLSpanElement> | null | undefined;
2069
2271
  } & {
@@ -2073,129 +2275,212 @@ declare const ContentPartPrimitiveText: react.ForwardRefExoticComponent<Omit<Omi
2073
2275
  component?: ElementType;
2074
2276
  } & react.RefAttributes<HTMLSpanElement>>;
2075
2277
 
2076
- type PrimitiveImageProps = ComponentPropsWithoutRef<typeof Primitive.img>;
2077
- type ContentPartPrimitiveImageProps = PrimitiveImageProps;
2278
+ /**
2279
+ * @deprecated Use `ContentPartPrimitive.Image.Props` instead. This will be removed in 0.6.
2280
+ */
2281
+ type ContentPartPrimitiveImageProps = ContentPartPrimitiveImage.Props;
2282
+ declare namespace ContentPartPrimitiveImage {
2283
+ type Element = ElementRef<typeof Primitive.img>;
2284
+ type Props = ComponentPropsWithoutRef<typeof Primitive.img>;
2285
+ }
2078
2286
  declare const ContentPartPrimitiveImage: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "ref"> & {
2079
2287
  ref?: ((instance: HTMLImageElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLImageElement> | null | undefined;
2080
2288
  } & {
2081
2289
  asChild?: boolean;
2082
2290
  }, "ref"> & react.RefAttributes<HTMLImageElement>>;
2083
2291
 
2084
- type ContentPartPrimitiveDisplayProps = Record<string, never>;
2085
- declare const ContentPartPrimitiveDisplay: FC;
2292
+ /**
2293
+ * @deprecated Use `ContentPartPrimitive.Display.Props` instead. This will be removed in 0.6.
2294
+ */
2295
+ type ContentPartPrimitiveDisplayProps = ContentPartPrimitiveDisplay.Props;
2296
+ declare namespace ContentPartPrimitiveDisplay {
2297
+ type Props = Record<string, never>;
2298
+ }
2299
+ declare const ContentPartPrimitiveDisplay: FC<ContentPartPrimitiveDisplay.Props>;
2086
2300
 
2087
- type ContentPartPrimitiveInProgressProps = PropsWithChildren;
2088
- declare const ContentPartPrimitiveInProgress: FC<ContentPartPrimitiveInProgressProps>;
2301
+ /**
2302
+ * @deprecated Use `ContentPartPrimitive.InProgress.Props` instead. This will be removed in 0.6.
2303
+ */
2304
+ type ContentPartPrimitiveInProgressProps = ContentPartPrimitiveInProgress.Props;
2305
+ declare namespace ContentPartPrimitiveInProgress {
2306
+ type Props = PropsWithChildren;
2307
+ }
2308
+ declare const ContentPartPrimitiveInProgress: FC<ContentPartPrimitiveInProgress.Props>;
2089
2309
 
2090
2310
  declare namespace index$2 {
2091
2311
  export { ContentPartPrimitiveDisplay as Display, ContentPartPrimitiveImage as Image, ContentPartPrimitiveInProgress as InProgress, ContentPartPrimitiveText as Text };
2092
2312
  }
2093
2313
 
2094
- type PrimitiveDivProps$2 = ComponentPropsWithoutRef<typeof Primitive.div>;
2095
- type MessagePrimitiveRootProps = PrimitiveDivProps$2;
2314
+ /**
2315
+ * @deprecated Use `MessagePrimitive.Root.Props` instead. This will be removed in 0.6.
2316
+ */
2317
+ type MessagePrimitiveRootProps = MessagePrimitiveRoot.Props;
2318
+ declare namespace MessagePrimitiveRoot {
2319
+ type Element = ElementRef<typeof Primitive.div>;
2320
+ type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
2321
+ }
2096
2322
  declare const MessagePrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
2097
2323
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
2098
2324
  } & {
2099
2325
  asChild?: boolean;
2100
2326
  }, "ref"> & react.RefAttributes<HTMLDivElement>>;
2101
2327
 
2102
- type MessagePrimitiveIfProps = PropsWithChildren<UseMessageIfProps>;
2103
- declare const MessagePrimitiveIf: FC<MessagePrimitiveIfProps>;
2328
+ /**
2329
+ * @deprecated Use `MessagePrimitive.If.Props` instead. This will be removed in 0.6.
2330
+ */
2331
+ type MessagePrimitiveIfProps = MessagePrimitiveIf.Props;
2332
+ declare namespace MessagePrimitiveIf {
2333
+ type Props = PropsWithChildren<UseMessageIfProps>;
2334
+ }
2335
+ declare const MessagePrimitiveIf: FC<MessagePrimitiveIf.Props>;
2104
2336
 
2105
- type MessagePrimitiveContentProps = {
2106
- components?: {
2107
- Empty?: EmptyContentPartComponent | undefined;
2108
- Text?: TextContentPartComponent | undefined;
2109
- Image?: ImageContentPartComponent | undefined;
2110
- UI?: UIContentPartComponent | undefined;
2111
- tools?: {
2112
- by_name?: Record<string, ToolCallContentPartComponent | undefined> | undefined;
2113
- Fallback?: ComponentType<ToolCallContentPartProps> | undefined;
2337
+ /**
2338
+ * @deprecated Use `MessagePrimitive.Content.Props` instead. This will be removed in 0.6.
2339
+ */
2340
+ type MessagePrimitiveContentProps = MessagePrimitiveContent.Props;
2341
+ declare namespace MessagePrimitiveContent {
2342
+ type Props = {
2343
+ components?: {
2344
+ Empty?: EmptyContentPartComponent | undefined;
2345
+ Text?: TextContentPartComponent | undefined;
2346
+ Image?: ImageContentPartComponent | undefined;
2347
+ UI?: UIContentPartComponent | undefined;
2348
+ tools?: {
2349
+ by_name?: Record<string, ToolCallContentPartComponent | undefined> | undefined;
2350
+ Fallback?: ComponentType<ToolCallContentPartProps> | undefined;
2351
+ } | undefined;
2114
2352
  } | undefined;
2115
- } | undefined;
2116
- };
2117
- declare const MessagePrimitiveContent: FC<MessagePrimitiveContentProps>;
2353
+ };
2354
+ }
2355
+ declare const MessagePrimitiveContent: FC<MessagePrimitiveContent.Props>;
2118
2356
 
2119
2357
  type PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.span>;
2358
+ /**
2359
+ * @deprecated Define a custom Text renderer via ContentPartPrimitiveInProgress instead. This will be removed in 0.6.
2360
+ */
2120
2361
  type MessagePrimitiveInProgressProps = PrimitiveSpanProps;
2121
2362
  /**
2122
2363
  * @deprecated Define a custom Text renderer via ContentPartPrimitiveInProgress instead. This will be removed in 0.6.
2123
2364
  */
2124
2365
  declare const MessagePrimitiveInProgress: FC<MessagePrimitiveInProgressProps>;
2125
2366
 
2126
- type MessagePrimitiveAttachmentsProps = {
2127
- components: {
2128
- Image?: ComponentType | undefined;
2129
- Document?: ComponentType | undefined;
2130
- File?: ComponentType | undefined;
2131
- Attachment?: ComponentType | undefined;
2132
- } | undefined;
2133
- };
2134
- declare const MessagePrimitiveAttachments: FC<MessagePrimitiveAttachmentsProps>;
2367
+ declare namespace MessagePrimitiveAttachments {
2368
+ type Props = {
2369
+ components: {
2370
+ Image?: ComponentType | undefined;
2371
+ Document?: ComponentType | undefined;
2372
+ File?: ComponentType | undefined;
2373
+ Attachment?: ComponentType | undefined;
2374
+ } | undefined;
2375
+ };
2376
+ }
2377
+ declare const MessagePrimitiveAttachments: FC<MessagePrimitiveAttachments.Props>;
2135
2378
 
2136
2379
  declare namespace index$1 {
2137
2380
  export { MessagePrimitiveAttachments as Attachments, MessagePrimitiveContent as Content, MessagePrimitiveIf as If, MessagePrimitiveInProgress as InProgress, MessagePrimitiveRoot as Root };
2138
2381
  }
2139
2382
 
2140
- type PrimitiveDivProps$1 = ComponentPropsWithoutRef<typeof Primitive.div>;
2141
- type ThreadPrimitiveRootProps = PrimitiveDivProps$1;
2383
+ /**
2384
+ * @deprecated Use `ThreadPrimitive.Root.Props` instead. This will be removed in 0.6.
2385
+ */
2386
+ type ThreadPrimitiveRootProps = ThreadPrimitiveRoot.Props;
2387
+ declare namespace ThreadPrimitiveRoot {
2388
+ type Element = ElementRef<typeof Primitive.div>;
2389
+ type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
2390
+ }
2142
2391
  declare const ThreadPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
2143
2392
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
2144
2393
  } & {
2145
2394
  asChild?: boolean;
2146
2395
  }, "ref"> & react.RefAttributes<HTMLDivElement>>;
2147
2396
 
2148
- type ThreadPrimitiveEmptyProps = {
2149
- children: ReactNode;
2150
- };
2151
- declare const ThreadPrimitiveEmpty: FC<ThreadPrimitiveEmptyProps>;
2397
+ /**
2398
+ * @deprecated Use `ThreadPrimitive.Empty.Props` instead. This will be removed in 0.6.
2399
+ */
2400
+ type ThreadPrimitiveEmptyProps = ThreadPrimitiveEmpty.Props;
2401
+ declare namespace ThreadPrimitiveEmpty {
2402
+ type Props = PropsWithChildren;
2403
+ }
2404
+ declare const ThreadPrimitiveEmpty: FC<ThreadPrimitiveEmpty.Props>;
2152
2405
 
2153
- type ThreadPrimitiveIfProps = PropsWithChildren<UseThreadIfProps>;
2154
- declare const ThreadPrimitiveIf: FC<ThreadPrimitiveIfProps>;
2406
+ /**
2407
+ * @deprecated Use `ThreadPrimitive.If.Props` instead. This will be removed in 0.6.
2408
+ */
2409
+ type ThreadPrimitiveIfProps = ThreadPrimitiveIf.Props;
2410
+ declare namespace ThreadPrimitiveIf {
2411
+ type Props = PropsWithChildren<UseThreadIfProps>;
2412
+ }
2413
+ declare const ThreadPrimitiveIf: FC<ThreadPrimitiveIf.Props>;
2155
2414
 
2156
2415
  type UseThreadViewportAutoScrollProps = {
2157
2416
  autoScroll?: boolean | undefined;
2158
2417
  };
2159
2418
 
2160
- type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
2161
- type ThreadPrimitiveViewportProps = PrimitiveDivProps & UseThreadViewportAutoScrollProps;
2419
+ /**
2420
+ * @deprecated Use `ThreadPrimitive.Viewport.Props` instead. This will be removed in 0.6.
2421
+ */
2422
+ type ThreadPrimitiveViewportProps = ThreadPrimitiveViewport.Props;
2423
+ declare namespace ThreadPrimitiveViewport {
2424
+ type Element = ElementRef<typeof Primitive.div>;
2425
+ type Props = ComponentPropsWithoutRef<typeof Primitive.div> & UseThreadViewportAutoScrollProps;
2426
+ }
2162
2427
  declare const ThreadPrimitiveViewport: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
2163
2428
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
2164
2429
  } & {
2165
2430
  asChild?: boolean;
2166
2431
  }, "ref"> & UseThreadViewportAutoScrollProps & react.RefAttributes<HTMLDivElement>>;
2167
2432
 
2168
- type ThreadPrimitiveMessagesProps = {
2169
- components: {
2170
- Message: ComponentType;
2171
- EditComposer?: ComponentType | undefined;
2172
- UserEditComposer?: ComponentType | undefined;
2173
- AssistantEditComposer?: ComponentType | undefined;
2174
- SystemEditComposer?: ComponentType | undefined;
2175
- UserMessage?: ComponentType | undefined;
2176
- AssistantMessage?: ComponentType | undefined;
2177
- SystemMessage?: ComponentType | undefined;
2178
- } | {
2179
- Message?: ComponentType | undefined;
2180
- EditComposer?: ComponentType | undefined;
2181
- UserEditComposer?: ComponentType | undefined;
2182
- AssistantEditComposer?: ComponentType | undefined;
2183
- SystemEditComposer?: ComponentType | undefined;
2184
- UserMessage: ComponentType;
2185
- AssistantMessage: ComponentType;
2186
- SystemMessage?: ComponentType | undefined;
2433
+ /**
2434
+ * @deprecated Use `ThreadPrimitive.Messages.Props` instead. This will be removed in 0.6.
2435
+ */
2436
+ type ThreadPrimitiveMessagesProps = ThreadPrimitiveMessages.Props;
2437
+ declare namespace ThreadPrimitiveMessages {
2438
+ type Props = {
2439
+ components: {
2440
+ Message: ComponentType;
2441
+ EditComposer?: ComponentType | undefined;
2442
+ UserEditComposer?: ComponentType | undefined;
2443
+ AssistantEditComposer?: ComponentType | undefined;
2444
+ SystemEditComposer?: ComponentType | undefined;
2445
+ UserMessage?: ComponentType | undefined;
2446
+ AssistantMessage?: ComponentType | undefined;
2447
+ SystemMessage?: ComponentType | undefined;
2448
+ } | {
2449
+ Message?: ComponentType | undefined;
2450
+ EditComposer?: ComponentType | undefined;
2451
+ UserEditComposer?: ComponentType | undefined;
2452
+ AssistantEditComposer?: ComponentType | undefined;
2453
+ SystemEditComposer?: ComponentType | undefined;
2454
+ UserMessage: ComponentType;
2455
+ AssistantMessage: ComponentType;
2456
+ SystemMessage?: ComponentType | undefined;
2457
+ };
2187
2458
  };
2188
- };
2189
- declare const ThreadPrimitiveMessages: react.NamedExoticComponent<ThreadPrimitiveMessagesProps>;
2459
+ }
2460
+ declare const ThreadPrimitiveMessages: react.NamedExoticComponent<ThreadPrimitiveMessages.Props>;
2190
2461
 
2191
- type ThreadPrimitiveScrollToBottomProps = ActionButtonProps<typeof useThreadScrollToBottom>;
2462
+ /**
2463
+ * @deprecated Use `ThreadPrimitive.ScrollToBottom.Props` instead. This will be removed in 0.6.
2464
+ */
2465
+ type ThreadPrimitiveScrollToBottomProps = ThreadPrimitiveScrollToBottom.Props;
2466
+ declare namespace ThreadPrimitiveScrollToBottom {
2467
+ type Element = ActionButtonElement;
2468
+ type Props = ActionButtonProps<typeof useThreadScrollToBottom>;
2469
+ }
2192
2470
  declare const ThreadPrimitiveScrollToBottom: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
2193
2471
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
2194
2472
  } & {
2195
2473
  asChild?: boolean;
2196
2474
  }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
2197
2475
 
2198
- type ThreadPrimitiveSuggestionProps = ActionButtonProps<typeof useThreadSuggestion>;
2476
+ /**
2477
+ * @deprecated Use `ThreadPrimitive.Suggestion.Props` instead. This will be removed in 0.6.
2478
+ */
2479
+ type ThreadPrimitiveSuggestionProps = ThreadPrimitiveSuggestion.Props;
2480
+ declare namespace ThreadPrimitiveSuggestion {
2481
+ type Element = ActionButtonElement;
2482
+ type Props = ActionButtonProps<typeof useThreadSuggestion>;
2483
+ }
2199
2484
  declare const ThreadPrimitiveSuggestion: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
2200
2485
  ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
2201
2486
  } & {
@@ -2377,7 +2662,9 @@ declare const exports$c: {
2377
2662
  asChild?: boolean;
2378
2663
  }, "ref"> & UseActionBarFloatStatusProps & react.RefAttributes<HTMLDivElement>, "ref">> & react.RefAttributes<HTMLDivElement>>;
2379
2664
  Reload: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2380
- Copy: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2665
+ Copy: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & {
2666
+ copiedDuration?: number | undefined;
2667
+ } & react.RefAttributes<HTMLButtonElement>>;
2381
2668
  Speak: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2382
2669
  StopSpeaking: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2383
2670
  SpeechControl: FC;
@@ -2387,7 +2674,15 @@ declare const exports$c: {
2387
2674
  declare const _default$b: typeof AssistantActionBar & typeof exports$c;
2388
2675
 
2389
2676
  declare const AssistantMessage: FC;
2390
- type AssistantMessageContentProps = MessagePrimitiveContentProps & ComponentPropsWithoutRef<"div">;
2677
+ /**
2678
+ * @deprecated Use `AssistantMessage.Content.Props` instead. This will be removed in 0.6.
2679
+ */
2680
+ type AssistantMessageContentProps = AssistantMessageContent.Props;
2681
+ declare namespace AssistantMessageContent {
2682
+ type Element = HTMLDivElement;
2683
+ type Props = MessagePrimitiveContent.Props & ComponentPropsWithoutRef<"div">;
2684
+ }
2685
+ declare const AssistantMessageContent: react.ForwardRefExoticComponent<MessagePrimitiveContent.Props & Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2391
2686
  declare const exports$b: {
2392
2687
  Root: react.ForwardRefExoticComponent<Partial<Omit<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
2393
2688
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
@@ -2395,25 +2690,24 @@ declare const exports$b: {
2395
2690
  asChild?: boolean;
2396
2691
  }, "ref"> & react.RefAttributes<HTMLDivElement>, "ref">> & react.RefAttributes<HTMLDivElement>>;
2397
2692
  Avatar: FC;
2398
- Content: react.ForwardRefExoticComponent<MessagePrimitiveContentProps & Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2693
+ Content: react.ForwardRefExoticComponent<MessagePrimitiveContent.Props & Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2399
2694
  };
2400
2695
  declare const _default$a: typeof AssistantMessage & typeof exports$b;
2401
2696
 
2402
2697
  declare const AssistantModal: FC<ThreadConfig>;
2403
- type AssistantModalButtonProps = TooltipIconButtonProps & {
2404
- "data-state"?: "open" | "closed";
2405
- };
2698
+ declare namespace AssistantModalRoot {
2699
+ type Props = AssistantModalPrimitiveRoot.Props & ThreadConfigProviderProps;
2700
+ }
2701
+ declare const AssistantModalRoot: FC<AssistantModalRoot.Props>;
2406
2702
  declare const exports$a: {
2407
- Root: FC<PopoverPrimitive.PopoverProps & {
2408
- config?: ThreadConfig | undefined;
2409
- } & {
2410
- children?: react.ReactNode | undefined;
2411
- }>;
2703
+ Root: FC<AssistantModalRoot.Props>;
2412
2704
  Trigger: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2413
2705
  Content: react.ForwardRefExoticComponent<Partial<Omit<Omit<PopoverPrimitive.PopoverContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
2414
2706
  dissmissOnInteractOutside?: boolean | undefined;
2415
2707
  } & react.RefAttributes<HTMLDivElement>, "ref">> & react.RefAttributes<HTMLDivElement>>;
2416
- Button: react.ForwardRefExoticComponent<Partial<AssistantModalButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2708
+ Button: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & {
2709
+ "data-state"?: "open" | "closed";
2710
+ } & react.RefAttributes<HTMLButtonElement>>;
2417
2711
  Anchor: react.ForwardRefExoticComponent<Partial<Omit<Omit<PopoverPrimitive.PopoverAnchorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>, "ref">> & react.RefAttributes<HTMLDivElement>>;
2418
2712
  };
2419
2713
  declare const _default$9: typeof AssistantModal & typeof exports$a;
@@ -2438,7 +2732,19 @@ declare const ComposerInputStyled: react.ForwardRefExoticComponent<Partial<Omit<
2438
2732
  submitOnEnter?: boolean | undefined;
2439
2733
  cancelOnEscape?: boolean | undefined;
2440
2734
  } & react.RefAttributes<HTMLTextAreaElement>, "ref">> & react.RefAttributes<HTMLTextAreaElement>>;
2441
- type ComposerInputProps = ComponentPropsWithoutRef<typeof ComposerInputStyled>;
2735
+ /**
2736
+ * @deprecated Use `ComposerInput.Props` instead. This will be removed in 0.6.
2737
+ */
2738
+ type ComposerInputProps = ComposerInput.Props;
2739
+ declare namespace ComposerInput {
2740
+ type Element = HTMLTextAreaElement;
2741
+ type Props = ComponentPropsWithoutRef<typeof ComposerInputStyled>;
2742
+ }
2743
+ declare const ComposerInput: react.ForwardRefExoticComponent<Omit<Partial<Omit<react_textarea_autosize.TextareaAutosizeProps & {
2744
+ asChild?: boolean | undefined;
2745
+ submitOnEnter?: boolean | undefined;
2746
+ cancelOnEscape?: boolean | undefined;
2747
+ } & react.RefAttributes<HTMLTextAreaElement>, "ref">> & react.RefAttributes<HTMLTextAreaElement>, "ref"> & react.RefAttributes<HTMLTextAreaElement>>;
2442
2748
  declare const exports$8: {
2443
2749
  Root: react.ForwardRefExoticComponent<Partial<Omit<Omit<Omit<react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
2444
2750
  ref?: ((instance: HTMLFormElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLFormElement> | null | undefined;
@@ -2454,7 +2760,7 @@ declare const exports$8: {
2454
2760
  Send: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2455
2761
  Cancel: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2456
2762
  AddAttachment: react.ForwardRefExoticComponent<Partial<TooltipIconButtonProps> & react.RefAttributes<HTMLButtonElement>>;
2457
- Attachments: FC<Partial<ComposerPrimitiveAttachmentsProps>>;
2763
+ Attachments: FC<Partial<ComposerPrimitiveAttachments.Props>>;
2458
2764
  };
2459
2765
  declare const _default$7: typeof Composer & typeof exports$8;
2460
2766
 
@@ -2488,7 +2794,23 @@ declare const exports$6: {
2488
2794
  declare const _default$5: typeof EditComposer & typeof exports$6;
2489
2795
 
2490
2796
  declare const Thread: FC<ThreadConfig>;
2491
- type ThreadRootProps = ThreadPrimitiveRootProps & ThreadConfigProviderProps;
2797
+ /**
2798
+ * @deprecated Use `Thread.Root.Props` instead. This will be removed in 0.6.
2799
+ */
2800
+ type ThreadRootProps = ThreadRoot.Props;
2801
+ declare namespace ThreadRoot {
2802
+ type Element = HTMLDivElement;
2803
+ type Props = ThreadPrimitiveRoot.Props & ThreadConfigProviderProps;
2804
+ }
2805
+ declare const ThreadRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
2806
+ ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
2807
+ } & {
2808
+ asChild?: boolean;
2809
+ }, "ref"> & {
2810
+ config?: ThreadConfig | undefined;
2811
+ } & {
2812
+ children?: react.ReactNode | undefined;
2813
+ } & react.RefAttributes<HTMLDivElement>>;
2492
2814
  declare const exports$5: {
2493
2815
  Root: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
2494
2816
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
@@ -2520,15 +2842,23 @@ declare const exports$5: {
2520
2842
  declare const _default$4: typeof Thread & typeof exports$5;
2521
2843
 
2522
2844
  declare const UserMessage: FC;
2523
- type UserMessageContentProps = MessagePrimitiveContentProps & ComponentPropsWithoutRef<"div">;
2845
+ /**
2846
+ * @deprecated Use `UserMessage.Content.Props` instead. This will be removed in 0.6.
2847
+ */
2848
+ type UserMessageContentProps = UserMessageContent.Props;
2849
+ declare namespace UserMessageContent {
2850
+ type Element = HTMLDivElement;
2851
+ type Props = MessagePrimitiveContent.Props & ComponentPropsWithoutRef<"div">;
2852
+ }
2853
+ declare const UserMessageContent: react.ForwardRefExoticComponent<MessagePrimitiveContent.Props & Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2524
2854
  declare const exports$4: {
2525
2855
  Root: react.ForwardRefExoticComponent<Partial<Omit<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
2526
2856
  ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
2527
2857
  } & {
2528
2858
  asChild?: boolean;
2529
2859
  }, "ref"> & react.RefAttributes<HTMLDivElement>, "ref">> & react.RefAttributes<HTMLDivElement>>;
2530
- Content: react.ForwardRefExoticComponent<MessagePrimitiveContentProps & Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2531
- Attachments: FC<Partial<MessagePrimitiveAttachmentsProps>>;
2860
+ Content: react.ForwardRefExoticComponent<MessagePrimitiveContent.Props & Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2861
+ Attachments: FC<Partial<MessagePrimitiveAttachments.Props>>;
2532
2862
  };
2533
2863
  declare const _default$3: typeof UserMessage & typeof exports$4;
2534
2864
 
@@ -2555,9 +2885,19 @@ declare const _default$1: typeof UserMessageAttachment & typeof exports$2;
2555
2885
 
2556
2886
  declare const ThreadWelcome: FC;
2557
2887
  declare const ThreadWelcomeMessageStyled: react.ForwardRefExoticComponent<Partial<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">> & react.RefAttributes<HTMLParagraphElement>>;
2558
- type ThreadWelcomeMessageProps = Omit<ComponentPropsWithoutRef<typeof ThreadWelcomeMessageStyled>, "children"> & {
2888
+ /**
2889
+ * @deprecated Use `ThreadWelcome.Message.Props` instead. This will be removed in 0.6.
2890
+ */
2891
+ type ThreadWelcomeMessageProps = ThreadWelcomeMessage.Props;
2892
+ declare namespace ThreadWelcomeMessage {
2893
+ type Element = HTMLParagraphElement;
2894
+ type Props = Omit<ComponentPropsWithoutRef<typeof ThreadWelcomeMessageStyled>, "children"> & {
2895
+ message?: string | undefined;
2896
+ };
2897
+ }
2898
+ declare const ThreadWelcomeMessage: react.ForwardRefExoticComponent<Omit<Omit<Partial<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">> & react.RefAttributes<HTMLParagraphElement>, "ref">, "children"> & {
2559
2899
  message?: string | undefined;
2560
- };
2900
+ } & react.RefAttributes<HTMLParagraphElement>>;
2561
2901
  type ThreadWelcomeSuggestionProps = {
2562
2902
  suggestion: SuggestionConfig;
2563
2903
  };