Headless core

type ActionBarAutohide = "always" | "not-last" | "never";

type ActionBarFeedback = "positive" | "negative";

declare function applyTransaction<T>(cache: GridRowProjectionCache<T>, transaction: {
  readonly add?: readonly {
    readonly row: T;
    readonly index?: number;
  }[];
  readonly update?: readonly T[];
  readonly remove?: readonly string[];
}, model: GridRowProjectionModel<T>): GridRowProjection<T>;

export declare const assistantActionBarAnatomy: {
  readonly scope: "assistant-action-bar";
  readonly parts: readonly ["root", "copy", "reload", "edit", "speak", "stop-speaking", "feedback-positive", "feedback-negative", "export-markdown"];
};

interface AssistantActionBarApi {
  rootProps(): PartProps;
  copyProps(): PartProps;
  reloadProps(): PartProps;
  editProps(): PartProps;
  speakProps(): PartProps;
  stopSpeakingProps(): PartProps;
  feedbackPositiveProps(): PartProps;
  feedbackNegativeProps(): PartProps;
  exportMarkdownProps(): PartProps;
  getVersion(): number;
  subscribe(listener: () => void): () => void;
  destroy(): void;
}

interface AssistantActionBarClientLike {
  readonly thread?: {
    readonly getState: () => Record<string, unknown>;
  };
  readonly message?: {
    readonly getState: () => Record<string, unknown>;
  };
  readonly capabilities?: Record<string, boolean>;
}

interface AssistantActionBarConnectOptions {
  readonly messageId?: string;
  readonly message?: ExportableMessage;
  readonly copyText?: string;
  readonly hideWhenRunning?: boolean;
  readonly autohide?: ActionBarAutohide;
  readonly autohideFloat?: boolean;
  readonly isLast?: boolean;
  readonly copiedDuration?: number;
  readonly clipboard?: {
    readonly writeText: (text: string) => void | Promise<void>;
  };
  readonly onFeedback?: (feedback: ActionBarFeedback) => void;
  readonly onExport?: (markdown: string) => void;
  readonly onReload?: () => void;
  readonly onEdit?: () => void;
  readonly onSpeak?: () => void;
  readonly onStopSpeaking?: () => void;
}

interface AssistantActionBarMount {
  readonly connector: AssistantActionBarApi;
  readonly root: HTMLElement;
  destroy(): void;
}

type AssistantActionBarPart = (typeof parts)[number];

export declare const assistantAttachmentAnatomy: {
  readonly scope: "assistant-attachment";
  readonly parts: readonly ["root", "thumb", "name", "remove"];
};

interface AssistantAttachmentApi {
  rootProps(): PartProps;
  thumbProps(): PartProps;
  nameProps(): PartProps;
  removeProps(): PartProps;
}

interface AssistantAttachmentConnectOptions {
  readonly attachment: AssistantAttachmentLike;
  readonly inMessage?: boolean;
  readonly onRemove?: () => void;
}

interface AssistantAttachmentLike {
  readonly id: string;
  readonly type?: string;
  readonly name: string;
  readonly contentType?: string;
  readonly status?: {
    readonly type?: string;
    readonly reason?: string;
    readonly progress?: number;
  };
  readonly content?: readonly unknown[];
  readonly file?: unknown;
}

type AssistantAttachmentPart = (typeof parts)[number];

export declare const assistantBranchPickerAnatomy: {
  readonly scope: "assistant-branch-picker";
  readonly parts: readonly ["root", "previous", "next", "number", "count"];
};

interface AssistantBranchPickerApi {
  rootProps(): PartProps;
  previousProps(): PartProps;
  nextProps(): PartProps;
  numberProps(): PartProps;
  countProps(): PartProps;
  readonly canPrevious: boolean;
  readonly canNext: boolean;
}

interface AssistantBranchPickerConnectOptions {
  readonly branches: readonly string[];
  readonly currentIndex: number;
  readonly isRunning?: boolean;
  readonly switchBranchDuringRun?: boolean;
  readonly onSwitch?: (branchId: string) => void;
}

type AssistantBranchPickerPart = (typeof assistantBranchPickerAnatomy.parts)[number];

export declare const assistantChainOfThoughtAnatomy: {
  readonly scope: "assistant-chain-of-thought";
  readonly parts: readonly ["root", "accordion-trigger", "parts"];
};

interface AssistantChainOfThoughtApi {
  rootProps(): PartProps;
  triggerProps(): PartProps;
  partsProps(): PartProps;
  readonly open: boolean;
}

type AssistantChainOfThoughtPart = (typeof assistantChainOfThoughtAnatomy.parts)[number];

export declare const assistantComposerAnatomy: {
  readonly scope: "assistant-composer";
  readonly parts: readonly ["root", "input", "send", "cancel", "add-attachment", "add-attachment-input", "attachments", "attachment", "attachment-dropzone", "dictate", "stop-dictation", "dictation-transcript", "quote", "quote-text", "quote-dismiss", "queue", "trigger-popover-root", "trigger-popover", "trigger-popover-categories", "trigger-popover-category-item", "trigger-popover-items", "trigger-popover-item", "trigger-popover-back"];
};

interface AssistantComposerApi {
  rootProps(): PartProps;
  inputProps(options?: AssistantComposerInputOptions): PartProps;
  sendProps(): PartProps;
  cancelProps(): PartProps;
  addAttachmentProps(): PartProps;
  addAttachmentInputProps(): PartProps;
  attachmentsProps(): PartProps;
  attachmentDropzoneProps(): PartProps;
  dictateProps(): PartProps;
  stopDictationProps(): PartProps;
  dictationTranscriptProps(): PartProps;
  quoteProps(): PartProps;
  quoteTextProps(): PartProps;
  quoteDismissProps(): PartProps;
  queueProps(): PartProps;
  triggerPopoverRootProps(): PartProps;
  triggerPopoverProps(): PartProps;
  triggerPopoverCategoriesProps(): PartProps;
  triggerPopoverCategoryItemProps(category: string): PartProps;
  triggerPopoverItemsProps(): PartProps;
  triggerPopoverItemProps(item: TriggerPopoverItem): PartProps;
  triggerPopoverBackProps(): PartProps;
  selectTriggerPopover(item: TriggerPopoverItem): void;
  selectTriggerPopoverCategory(category: string): boolean;
  removeAttachment(id: string): void;
  subscribe(listener: () => void): () => void;
  readonly text: string;
  readonly canSend: boolean;
  readonly canCancel: boolean;
  readonly isEditing: boolean;
  readonly isSubmitting: boolean;
  readonly canDictate: boolean;
  readonly isDictating: boolean;
  readonly canAttach: boolean;
  readonly attachments: readonly AssistantComposerAttachmentLike[];
  readonly queueItems: readonly unknown[];
  readonly triggerPopoverOpen: boolean;
}

interface AssistantComposerAttachmentLike {
  readonly id: string;
  readonly type?: string;
  readonly name: string;
  readonly contentType?: string;
  readonly status?: {
    readonly type?: string;
    readonly reason?: string;
    readonly progress?: number;
  };
  readonly content?: readonly unknown[];
  readonly file?: unknown;
}

interface AssistantComposerClientLike {
  readonly composer?: AssistantComposerScopeLike;
  readonly capabilities?: Record<string, boolean>;
}

interface AssistantComposerConnectOptions {
  readonly compact?: boolean;
  readonly submitMode?: ComposerSubmitMode;
  readonly cancelOnEscape?: boolean;
  readonly addAttachmentOnPaste?: boolean;
  readonly steerHotkey?: "shiftEnter" | "altEnter" | "ctrlEnter";
  readonly unstableInsertNewlineOnTouchEnter?: boolean;
  readonly inputLabel?: string;
  readonly attachmentAccept?: string;
  readonly attachmentMultiple?: boolean;
  readonly getDragging?: () => boolean;
  readonly onDraggingChange?: (dragging: boolean) => void;
  readonly onAddAttachment?: (files: readonly File[]) => void;
  readonly onRequestAttachment?: () => void;
  readonly onDictate?: () => void;
  readonly onStopDictation?: () => void;
  readonly onQuoteDismiss?: () => void;
  readonly onSubmit?: (event?: unknown) => void;
  readonly triggerPopover?: TriggerPopoverRegistry;
  readonly inputHistory?: InputHistory;
  readonly onCompositionStart?: () => void;
  readonly onCompositionEnd?: () => void;
}

type AssistantComposerInputOptions = Pick<AssistantComposerConnectOptions, "submitMode" | "cancelOnEscape" | "addAttachmentOnPaste" | "steerHotkey" | "unstableInsertNewlineOnTouchEnter" | "inputLabel">;

interface AssistantComposerMount {
  readonly connector: AssistantComposerApi;
  readonly root: HTMLFormElement;
  destroy(): void;
}

type AssistantComposerPart = (typeof parts)[number];

type AssistantDataUIRegistration<T = unknown> = {
  readonly name: string;
  readonly render: T;
};

export declare const assistantErrorAnatomy: {
  readonly scope: "assistant-error";
  readonly parts: readonly ["root", "message"];
};

interface AssistantErrorApi {
  rootProps(): PartProps;
  messageProps(): PartProps;
  readonly visible: boolean;
  readonly message: string;
}

interface AssistantErrorConnectOptions {
  readonly status?: AssistantErrorStatus;
}

type AssistantErrorPart = (typeof assistantErrorAnatomy.parts)[number];

type AssistantErrorStatus = {
  readonly type: string;
  readonly reason?: string;
  readonly error?: unknown;
};

type AssistantMcpAddFormController = {
  readonly getState: () => AssistantMcpAddFormState;
  readonly subscribe: (listener: () => void) => () => void;
  readonly rootProps: () => Readonly<Record<string, unknown>>;
  readonly inputProps: (name: string) => Readonly<Record<string, unknown>>;
  readonly submitProps: () => Readonly<Record<string, unknown>>;
  readonly setValue: (name: string, value: unknown) => void;
  readonly submit: (values?: Readonly<Record<string, unknown>>) => Promise<void>;
  readonly reset: () => void;
  readonly dispose: () => void;
};

type AssistantMcpAddFormStatus = "idle" | "submitting" | "submitted" | "error";

type AssistantMcpElicitationController = {
  readonly getState: () => AssistantMcpElicitationState;
  readonly subscribe: (listener: () => void) => () => void;
  readonly rootProps: () => Readonly<Record<string, unknown>>;
  readonly formProps: () => Readonly<Record<string, unknown>>;
  readonly submitProps: () => Readonly<Record<string, unknown>>;
  readonly cancelProps: () => Readonly<Record<string, unknown>>;
  readonly submit: (response: unknown) => Promise<void>;
  readonly cancel: () => void;
  readonly dispose: () => void;
};

type AssistantMcpElicitationStatus = "pending" | "submitted" | "cancelled";

type AssistantMcpManagerController = {
  readonly getState: () => AssistantMcpManagerState;
  readonly subscribe: (listener: () => void) => () => void;
  readonly rootProps: () => Readonly<Record<string, unknown>>;
  readonly connectorsProps: () => Readonly<Record<string, unknown>>;
  readonly customServersProps: () => Readonly<Record<string, unknown>>;
  readonly addCustomTriggerProps: () => Readonly<Record<string, unknown>>;
  readonly connect: (serverId: string) => Promise<void>;
  readonly disconnect: (serverId: string) => Promise<void>;
  readonly dispose: () => void;
};

type AssistantMcpManagerLike = {
  readonly listServers: () => readonly AssistantMcpServerState[];
  readonly getServer: (serverId: string) => AssistantMcpServerState | undefined;
  readonly connect: (serverId: string) => Promise<void>;
  readonly disconnect: (serverId: string) => Promise<void>;
  readonly subscribe: (listener: () => void) => () => void;
};

type AssistantMcpServerController = {
  readonly getState: () => AssistantMcpServerState;
  readonly subscribe: (listener: () => void) => () => void;
  readonly rootProps: () => Readonly<Record<string, unknown>>;
  readonly iconProps: () => Readonly<Record<string, unknown>>;
  readonly nameProps: () => Readonly<Record<string, unknown>>;
  readonly statusProps: () => Readonly<Record<string, unknown>>;
  readonly connectButtonProps: () => Readonly<Record<string, unknown>>;
  readonly disconnectButtonProps: () => Readonly<Record<string, unknown>>;
  readonly removeButtonProps: () => Readonly<Record<string, unknown>>;
  readonly connect: () => Promise<void>;
  readonly disconnect: () => Promise<void>;
  readonly dispose: () => void;
};

export declare const assistantModalAnatomy: {
  readonly scope: "assistant-modal";
  readonly parts: readonly ["root", "trigger", "anchor", "content", "title", "description", "close"];
};

interface AssistantModalApi {
  rootProps(): PartProps;
  triggerProps(): PartProps;
  anchorProps(): PartProps;
  contentProps(): PartProps;
  titleProps(): PartProps;
  descriptionProps(): PartProps;
  closeProps(): PartProps;
  readonly open: boolean;
}