import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode, FC, ComponentType, Dispatch } from 'react';
import { AttachmentAdapter } from '@assistant-ui/react';

interface ComposerProps {
    /** Placeholder shown in the textarea. Default: "Send a message..." */
    placeholder?: string;
    /**
     * Show the file-attach button and dropzone. Default: follow the runtime
     * (`attachments` on `TimbalChat`). Pass `false` to hide even when uploads
     * are enabled; pass `true` to show only when an attachment adapter is active.
     */
    showAttachments?: boolean;
    /** Extra content rendered inside the toolbar, left of the send button. */
    toolbar?: ReactNode;
    /** Tooltip shown on the send button. Default: "Send message". */
    sendTooltip?: string;
    /** Disable autofocus on mount. Default: false. */
    noAutoFocus?: boolean;
    /** Extra className applied to the outer composer wrapper. */
    className?: string;
}
/**
 * Default chat composer — auto-resizing textarea with Enter-to-send,
 * Shift+Enter for newline, attach pill on the left, and a circular send /
 * cancel button on the right. Wraps `ComposerPrimitive` so consumers can
 * override individual slots without losing the Studio chrome.
 */
declare const Composer: FC<ComposerProps>;

interface ThreadSuggestion {
    /** Title shown on the row. Also sent verbatim as the user message. */
    title: string;
    /** Optional secondary line. */
    description?: string;
    /** Optional leading icon. */
    icon?: ReactNode;
    /**
     * Override the prompt sent when the row is clicked. Useful when the row
     * label is short ("Weekly recap") but the prompt should be longer.
     */
    prompt?: string;
}
/**
 * Suggestions can be passed as a static array, a thunk that returns an
 * array, or an async function for dynamic / per-user suggestions.
 */
type SuggestionsSource = ThreadSuggestion[] | (() => ThreadSuggestion[] | Promise<ThreadSuggestion[]>);
interface ThreadSuggestionsProps {
    suggestions?: SuggestionsSource;
    className?: string;
}
/**
 * Render suggestions as a stacked column of full-width rows. Each row reads
 * like a list item rather than a chip, matching the Studio playground.
 *
 * On click the row's `prompt` (or `title` if no prompt) is appended as a
 * user message via the thread runtime.
 */
declare const Suggestions: FC<ThreadSuggestionsProps>;
/**
 * Resolve a `SuggestionsSource` to an array. Re-runs when the source
 * identity changes. Sync arrays / sync functions resolve immediately;
 * async functions stream in once the promise settles.
 */
declare function useResolvedSuggestions(source?: SuggestionsSource): ThreadSuggestion[] | undefined;
interface SuggestionsSlotProps {
    suggestions?: SuggestionsSource;
    className?: string;
}
type SuggestionsComponent = ComponentType<SuggestionsSlotProps>;

/** A value that is either a literal or a binding into local state. */
type UiBindable<T> = T | {
    $bind: string;
};
interface UiArtifact {
    type: "ui";
    title?: string;
    /** Initial values for `$bind` references. */
    initialState?: Record<string, unknown>;
    /** Root of the node tree. */
    root: UiNode;
}
interface UiNodeBase {
    id?: string;
    className?: string;
}
interface UiBoxNode extends UiNodeBase {
    kind: "box";
    /** Flex direction. Default: "col". */
    direction?: "row" | "col";
    /** Tailwind spacing units (gap = `gap * 0.25rem`). */
    gap?: number;
    align?: "start" | "center" | "end" | "stretch";
    justify?: "start" | "center" | "end" | "between" | "around";
    wrap?: boolean;
    padding?: number;
    children?: UiNode[];
}
interface UiTextNode extends UiNodeBase {
    kind: "text";
    value: UiBindable<string | number>;
    muted?: boolean;
    size?: "xs" | "sm" | "base" | "lg";
    weight?: "normal" | "medium" | "semibold" | "bold";
}
interface UiHeadingNode extends UiNodeBase {
    kind: "heading";
    value: UiBindable<string>;
    level?: 1 | 2 | 3 | 4;
}
interface UiBadgeNode extends UiNodeBase {
    kind: "badge";
    value: UiBindable<string>;
    tone?: "default" | "primary" | "success" | "warn" | "danger";
}
interface UiButtonNode extends UiNodeBase {
    kind: "button";
    label: UiBindable<string>;
    variant?: "default" | "outline" | "ghost" | "secondary" | "destructive" | "link";
    size?: "sm" | "default" | "lg";
    disabled?: UiBindable<boolean>;
    onClick?: UiAction | UiAction[];
}
/**
 * Two-state toggle. `binding` is a dotted state path; clicking flips the
 * stored boolean. Optional `onChange` fires *after* the state flip.
 */
interface UiToggleNode extends UiNodeBase {
    kind: "toggle";
    label?: UiBindable<string>;
    binding: string;
    onChange?: UiAction | UiAction[];
}
/**
 * Numeric range input. `binding` is a dotted state path; the slider reads and
 * writes the stored number. Optional `onChange` fires after each commit.
 */
interface UiSliderNode extends UiNodeBase {
    kind: "slider";
    binding: string;
    min?: number;
    max?: number;
    step?: number;
    label?: UiBindable<string>;
    /** Show the current value next to the slider. Default: true. */
    showValue?: boolean;
    onChange?: UiAction | UiAction[];
}
interface UiTooltipNode extends UiNodeBase {
    kind: "tooltip";
    content: UiBindable<string>;
    side?: "top" | "bottom" | "left" | "right";
    child: UiNode;
}
/**
 * Wrap any node to make it draggable. Drag is purely visual — release fires
 * `onDragEnd`. If `snapBack` (default) the child returns to its origin.
 */
interface UiDraggableNode extends UiNodeBase {
    kind: "draggable";
    child: UiNode;
    axis?: "x" | "y" | "both";
    snapBack?: boolean;
    onDragEnd?: UiAction | UiAction[];
}
/**
 * Escape hatch: a host-app-registered component. The host registers a
 * renderer by name via `UiCustomNodeRegistryProvider`; props are passed
 * through after binding resolution and children render recursively.
 */
interface UiCustomNode extends UiNodeBase {
    kind: "custom";
    name: string;
    props?: Record<string, unknown>;
    children?: UiNode[];
}
type UiNode = UiBoxNode | UiTextNode | UiHeadingNode | UiBadgeNode | UiButtonNode | UiToggleNode | UiSliderNode | UiTooltipNode | UiDraggableNode | UiCustomNode;
type UiAction = 
/** Append a user message to the active thread. */
{
    kind: "message";
    text: UiBindable<string>;
}
/** Set a path in local state to a (possibly bound) value. */
 | {
    kind: "set";
    path: string;
    value: UiBindable<unknown>;
}
/** Flip a boolean at the given local-state path. */
 | {
    kind: "toggle";
    path: string;
}
/** Bubble a named event to the host app via `UiEventProvider`. */
 | {
    kind: "emit";
    name: string;
    payload?: unknown;
};
declare function isUiBinding(value: unknown): value is {
    $bind: string;
};

/** Per-series presentation config (shadcn `ChartConfig` analog). */
interface ChartSeriesConfig {
    dataKey: string;
    /** Legend / tooltip label. Defaults to `dataKey`. */
    label?: string;
    /** CSS color (token or literal). Defaults to the theme `--chart-N` palette. */
    color?: string;
}
interface ChartArtifact {
    type: "chart";
    /** Chart kind. Cartesian kinds share one SVG engine; pie/donut/radial/radar are radial. */
    chartType?: "bar" | "horizontalBar" | "line" | "area" | "pie" | "donut" | "radial" | "radar";
    /** Optional title rendered above the chart. */
    title?: string;
    /** Optional sub-title / caption rendered under the title. */
    description?: string;
    /** Array of data points. Keys map to series via `dataKey` / `xKey`. */
    data: Array<Record<string, unknown>>;
    /** Field name on each data point used for the X axis / category. */
    xKey?: string;
    /** Field name(s) used for series. Defaults to all keys except `xKey`. */
    dataKey?: string | string[];
    /**
     * Rich per-series config (labels + colors). Takes precedence over `dataKey`.
     * Mirrors shadcn's `ChartConfig`.
     */
    series?: ChartSeriesConfig[];
    /** Stack bar / area series on top of each other. */
    stacked?: boolean;
    /** Line / area interpolation. Default `monotone`. */
    curve?: "monotone" | "linear" | "step";
    /** Draw point markers on line / area series. */
    dots?: boolean;
    /** Tooltip series marker style. Default `dot`. */
    tooltipIndicator?: "dot" | "line" | "dashed";
    /** Show the series legend. */
    legend?: boolean;
    /** Show category / value axis ticks on flush cartesian charts. Default false (tooltips carry labels). */
    showAxes?: boolean;
    /** Per-slice / per-ring colors for pie / donut / radial. */
    colors?: string[];
    /** Optional unit label appended to numeric axis ticks and tooltip values. */
    unit?: string;
}
interface QuestionOption {
    id: string;
    label: string;
    description?: string;
}
/**
 * Question artifact — renders an in-thread choice widget. When the user picks
 * an option, the renderer calls back into the runtime with the selected
 * label as a new user message. Agents should treat the user response as the
 * answer.
 */
interface QuestionArtifact {
    type: "question";
    /** Optional prompt shown above the options. Falls back to the message text. */
    prompt?: string;
    options: QuestionOption[];
    /** Allow selecting more than one option. Default: false. */
    multi?: boolean;
}
/** HTML/CSS/JS rendered in an iframe. See {@link HtmlArtifactView}. */
interface HtmlArtifact {
    type: "html";
    content: string;
    /**
     * When true (default) the HTML renders inside a sandboxed iframe. The
     * sandbox allows scripts, forms, and modals but still isolates the
     * document from the host page. Set to `false` for fully unrestricted
     * inline HTML (scripts, external CDN assets, etc.) — trusted content only.
     */
    sandboxed?: boolean;
    /** Optional title rendered above the iframe. */
    title?: string;
    /** Iframe height in CSS pixels or any valid CSS length. Default: "320px". */
    height?: string;
}
interface JsonArtifact {
    type: "json";
    title?: string;
    data: unknown;
}
interface TableArtifact {
    type: "table";
    title?: string;
    columns?: Array<{
        key: string;
        label?: string;
    }>;
    rows: Array<Record<string, unknown>>;
}

type TimbalArtifact = ChartArtifact | QuestionArtifact | HtmlArtifact | JsonArtifact | TableArtifact | UiArtifact;
type AnyArtifact = TimbalArtifact | {
    type: string;
    [key: string]: unknown;
};
/**
 * Type guard for artifact-shaped objects. Anything with a string `type` field
 * is considered a candidate; specific renderers narrow further.
 */
declare function isArtifact(value: unknown): value is AnyArtifact;

interface ArtifactRendererProps<T extends AnyArtifact = AnyArtifact> {
    artifact: T;
}
type ArtifactRenderer<T extends AnyArtifact = AnyArtifact> = ComponentType<ArtifactRendererProps<T>>;
type ArtifactRegistry = Record<string, ArtifactRenderer<AnyArtifact>>;
declare const defaultArtifactRenderers: ArtifactRegistry;
/**
 * Provide a custom artifact registry to the subtree. Custom renderers are
 * merged on top of the defaults — pass `override: true` to replace.
 */
declare const ArtifactRegistryProvider: FC<{
    renderers?: ArtifactRegistry;
    override?: boolean;
    children: ReactNode;
}>;
declare function useArtifactRegistry(): ArtifactRegistry;
/**
 * Render an artifact using the closest registry. Falls back to the JSON
 * renderer when no entry matches the artifact's `type`.
 */
declare const ArtifactView: FC<{
    artifact: AnyArtifact;
}>;

type UiState = Record<string, unknown>;
type UiStateAction = {
    type: "set";
    path: string;
    value: unknown;
} | {
    type: "toggle";
    path: string;
} | {
    type: "replace";
    state: UiState;
};
declare function uiStateReducer(state: UiState, action: UiStateAction): UiState;
/** Read a dotted path from a state object. Returns undefined when missing. */
declare function getPath(state: UiState, path: string): unknown;
/**
 * Set a dotted path on a state object, returning a new object. Intermediate
 * objects are cloned (or created when missing) so the result is safe to use
 * directly with React state without further copying.
 */
declare function setPath(state: UiState, path: string, value: unknown): UiState;
/** Resolve a UiBindable into its concrete value against the given state. */
declare function resolveBindable<T>(value: UiBindable<T>, state: UiState): T;

declare const UiStateProvider: FC<{
    state: UiState;
    dispatch: Dispatch<UiStateAction>;
    children: ReactNode;
}>;
declare function useUiState(): UiState;
declare function useUiDispatch(): Dispatch<UiStateAction>;
interface UiEventEnvelope {
    name: string;
    payload?: unknown;
}
/**
 * Subscribe the host app to `emit`-kind actions fired from any UiArtifact in
 * the subtree. Wrap your runtime / chat root once.
 */
declare const UiEventProvider: FC<{
    onEvent: (event: UiEventEnvelope) => void;
    children: ReactNode;
}>;
declare function useUiEventEmitter(): ((event: UiEventEnvelope) => void) | null;
interface UiCustomNodeProps {
    /** Already binding-resolved props from the artifact. */
    props: Record<string, unknown>;
    /** Recursively rendered children. */
    children?: ReactNode;
}
type UiCustomNodeRenderer = ComponentType<UiCustomNodeProps>;
/**
 * Register named renderers for `{ kind: "custom", name: "..." }` nodes. Lets
 * host apps extend the palette without forking the package.
 */
declare const UiCustomNodeRegistryProvider: FC<{
    renderers: Record<string, UiCustomNodeRenderer>;
    children: ReactNode;
}>;
declare function useUiCustomNodeRegistry(): Record<string, UiCustomNodeRenderer>;

type ThreadVariant = "default" | "panel";

interface ThreadWelcomeConfig {
    heading?: string;
    subheading?: string;
    /**
     * Optional brand icon rendered above the heading. Pass any ReactNode — the
     * SDK no longer ships a default sparkle icon so apps can drop in their
     * own logo or stay minimal.
     */
    icon?: ReactNode;
}
interface ThreadWelcomeProps {
    config?: ThreadWelcomeConfig;
    suggestions?: SuggestionsSource;
    /**
     * When set, controls whether the default welcome renders `suggestions`.
     * Omitted: shown for `variant="default"`, hidden for `variant="panel"`.
     */
    showWelcomeSuggestions?: boolean;
    /**
     * The resolved `Suggestions` component (default or user-overridden via
     * `components.Suggestions`). Custom Welcome implementations should render
     * this and pass their `suggestions` source through.
     */
    Suggestions?: SuggestionsComponent;
}
interface ThreadComponents {
    /** Replace the user message bubble. Access content via `MessagePrimitive.Parts`. */
    UserMessage?: ComponentType;
    /** Replace the assistant message bubble. Access content via `MessagePrimitive.Parts`. */
    AssistantMessage?: ComponentType;
    /** Replace the inline edit composer. */
    EditComposer?: ComponentType;
    /** Replace the composer (input bar). Receives all `ComposerProps` from the parent. */
    Composer?: ComponentType<ComposerProps>;
    /** Replace the welcome / empty state. Renders only while the thread is empty. */
    Welcome?: ComponentType<ThreadWelcomeProps>;
    /** Replace the suggestion list (rendered inside Welcome). */
    Suggestions?: SuggestionsComponent;
    /** Replace the scroll-to-bottom button. */
    ScrollToBottom?: ComponentType;
}
interface ThreadArtifactsConfig {
    /** Custom artifact renderers, merged on top of the built-in defaults. */
    renderers?: ArtifactRegistry;
    /** Replace the built-in renderers entirely instead of merging. */
    override?: boolean;
}

interface ThreadProps {
    className?: string;
    /**
     * `panel` — side column / narrow copilot: full width, compact welcome, tighter padding.
     * `default` — centered chat page.
     */
    variant?: ThreadVariant;
    /** Max width of the message column. Default: `44rem` or `100%` when `variant="panel"`. */
    maxWidth?: string;
    /** Welcome screen text + optional brand icon. */
    welcome?: ThreadWelcomeConfig;
    /**
     * Welcome-screen suggestion rows. Accepts a static array, a thunk, or an
     * async function for per-user suggestions.
     */
    suggestions?: SuggestionsSource;
    /**
     * Show suggestion rows on the built-in welcome when `suggestions` is set.
     * Default: `true` for `variant="default"`, `false` for `variant="panel"`.
     */
    showWelcomeSuggestions?: boolean;
    /** Composer input placeholder. Default: "Send a message...". */
    composerPlaceholder?: string;
    /** Override individual UI slots while keeping the rest as defaults. */
    components?: ThreadComponents;
    /**
     * Configure how rich tool/artifact results render. Pass `renderers` to add
     * support for custom artifact `type` values. Built-in types (`chart`,
     * `question`, `html`, `json`, `table`, `ui`) are always available unless
     * `override: true` is set.
     */
    artifacts?: ThreadArtifactsConfig;
    /**
     * Called when a `ui` artifact fires an `{ kind: "emit" }` action. Use this
     * to react to slider commits, drag gestures, or other host-side logic
     * beyond the built-in `message` action (which already appends a user
     * message).
     */
    onArtifactEvent?: (event: UiEventEnvelope) => void;
    /**
     * Auto-scroll the conversation to the bottom as new content streams in.
     * Default: `true`. Set `false` to never auto-follow the stream (the
     * scroll-to-bottom button still works).
     */
    autoScroll?: boolean;
    /**
     * Scroll to the bottom when a new run starts (you send a message). Default:
     * `true`.
     */
    scrollToBottomOnRunStart?: boolean;
    /**
     * Scroll to the bottom instantly when the thread is first initialized (its
     * history finishes loading). Default: `true`.
     */
    scrollToBottomOnInitialize?: boolean;
    /**
     * Scroll to the bottom instantly when switching to a different thread.
     * Default: `true`.
     */
    scrollToBottomOnThreadSwitch?: boolean;
}
declare const Thread: FC<ThreadProps>;

type UploadFetchFn = (url: string, options?: RequestInit) => Promise<Response>;
interface CreateDefaultAttachmentAdapterOptions {
    /**
     * API base path used to derive the upload URL when {@link uploadUrl} is
     * omitted. Trailing slashes are stripped. Defaults to `""` (relative
     * `/files/upload`).
     */
    baseUrl?: string;
    /**
     * Absolute or relative URL the adapter `POST`s the multipart upload to.
     * Defaults to `${baseUrl}/files/upload`.
     */
    uploadUrl?: string;
    /**
     * Custom fetch used for the upload. Defaults to {@link authFetch}. Do not
     * set `Content-Type` on multipart uploads — the boundary must be automatic.
     */
    fetch?: UploadFetchFn;
    /**
     * MIME / extension `accept` string for the file picker.
     */
    accept?: string;
}
/** @deprecated Use {@link CreateDefaultAttachmentAdapterOptions}. */
type CreateUploadAttachmentAdapterOptions = CreateDefaultAttachmentAdapterOptions;
declare const DEFAULT_UPLOAD_ACCEPT = "image/*,application/pdf,text/*,.md,.json,.csv,.tsv,.xlsx,.docx";
/**
 * Build an `AttachmentAdapter` that uploads each file to a Timbal-style
 * `/files/upload` endpoint and returns a `CompleteAttachment` whose
 * `content[]` references the returned URL.
 */
declare function createDefaultAttachmentAdapter({ baseUrl, uploadUrl, fetch: fetchFn, accept, }?: CreateDefaultAttachmentAdapterOptions): AttachmentAdapter;
/** @deprecated Alias of {@link createDefaultAttachmentAdapter}. */
declare const createUploadAttachmentAdapter: typeof createDefaultAttachmentAdapter;

/** Tweaks for the built-in upload adapter (see {@link createDefaultAttachmentAdapter}). */
type TimbalAttachmentsConfig = {
    uploadUrl?: string;
    accept?: string;
};
/**
 * Enable or customise composer attachments.
 *
 * - `true` — built-in adapter posting to `${baseUrl}/files/upload`
 * - `{ uploadUrl?, accept? }` — same adapter with overrides
 * - `AttachmentAdapter` — fully custom (e.g. presigned S3)
 * - `null` — disable attachments (no `+` button / dropzone wiring)
 * - `undefined` — ON by default (built-in upload adapter). Pass `null` to opt out.
 */
type TimbalAttachmentsProp = boolean | TimbalAttachmentsConfig | AttachmentAdapter | null;
interface ResolveAttachmentAdapterOptions {
    baseUrl?: string;
    fetch?: CreateDefaultAttachmentAdapterOptions["fetch"];
    /** @deprecated Prefer `attachments={{ uploadUrl }}` */
    uploadUrl?: string;
    /** @deprecated Prefer `attachments={{ accept }}` */
    accept?: string;
}
/**
 * Resolve the `AttachmentAdapter` (if any) for {@link TimbalRuntimeProvider}.
 */
declare function resolveAttachmentAdapter(attachments: TimbalAttachmentsProp | undefined, options?: ResolveAttachmentAdapterOptions): AttachmentAdapter | undefined;

interface TextContentPart {
    type: "text";
    text: string;
}
interface ThinkingContentPart {
    type: "thinking";
    text: string;
}
/**
 * A tool invocation. `argsText` accumulates from streaming `tool_use_delta`
 * events; `result` is set once the matching `tool_result` arrives in the
 * `OUTPUT` event.
 *
 * `result` is always a JSON-serializable value (string, number, object, array)
 * — the runtime preserves whatever the agent returns. `resultText` is the
 * text representation of the result blocks from `tool_result.content`, useful
 * as a quick fallback when callers don't want to walk the structured result.
 */
interface ToolCallContentPart {
    type: "tool-call";
    toolCallId: string;
    toolName: string;
    argsText: string;
    result?: unknown;
    resultText?: string;
    status?: "running" | "complete" | "error";
}
type ContentPart = TextContentPart | ThinkingContentPart | ToolCallContentPart;
type MessageRole = "user" | "assistant";
/**
 * A file attached to a user message. We carry a single `dataUrl` field
 * (despite the name, it may be either a `data:<mime>;base64,<bytes>` URL
 * or a real `https://...` URL returned by an upload adapter) and project
 * it both onto the wire (`{type:"file", file: dataUrl}`) and onto the
 * assistant-ui display layer (`ImageMessagePart` / `FileMessagePart`
 * inside `attachments[].content`).
 *
 * Both forms are accepted by Timbal's `FileContent` factory, so the same
 * field works whether the attachment was inlined as base64 or uploaded
 * to object storage.
 */
interface ChatAttachment {
    id: string;
    type: "image" | "document" | "file";
    name?: string;
    contentType?: string;
    /**
     * Either a `data:<mime>;base64,<bytes>` URL (inline) or a remote
     * `https://...` URL produced by an upload-style {@link AttachmentAdapter}.
     */
    dataUrl: string;
}
interface ChatMessage {
    id: string;
    role: MessageRole;
    content: ContentPart[];
    /** Files attached to a user message. Empty/undefined for assistant messages. */
    attachments?: ChatAttachment[];
    /** Run id stamped from the top-level `START` SSE event. */
    runId?: string;
}

type FetchFn = (url: string, options?: RequestInit) => Promise<Response>;
interface UseTimbalStreamOptions {
    workforceId: string;
    baseUrl?: string;
    fetch?: FetchFn;
    /**
     * When true, every parsed SSE event is `console.debug`-ed with a
     * `[timbal]` prefix. Useful for diagnosing tool/artifact rendering issues
     * without screen-sharing. Default: `false`.
     */
    debug?: boolean;
}
interface SendOptions {
    attachments?: ChatAttachment[];
    /** Override the parent run id resolution. Pass `null` to start a new thread. */
    parentId?: string | null;
}
interface TimbalStreamApi {
    messages: ChatMessage[];
    isRunning: boolean;
    send: (input: string, options?: SendOptions) => Promise<void>;
    reload: (messageId?: string | null) => Promise<void>;
    cancel: () => void;
    clear: () => void;
    /**
     * Replace the current message list — e.g. to hydrate a stored conversation
     * loaded via `conversationRunsToMessages`. Aborts any in-flight stream. The
     * last assistant message's `runId` becomes the parent for the next `send`,
     * so continuing a loaded thread "just works".
     */
    loadMessages: (messages: ChatMessage[]) => void;
}
/**
 * Lower-level streaming hook for callers that don't want the full `<Thread>`
 * UI. Exposes the internal message state plus `send`, `reload`, `cancel`, and
 * `clear` actions. Use this to build custom chat surfaces while reusing the
 * Timbal SSE wire format and auth-aware fetching.
 */
declare function useTimbalStream({ workforceId, baseUrl, fetch: fetchFn, debug, }: UseTimbalStreamOptions): TimbalStreamApi;
/**
 * Access the underlying `useTimbalStream` API from inside a component tree
 * wrapped by `<TimbalRuntimeProvider>` (or `<TimbalChat>`). Useful for custom
 * UIs that need direct access to messages, send, or cancel without going
 * through the assistant-ui runtime.
 */
declare function useTimbalRuntime(): TimbalStreamApi;
interface TimbalRuntimeProviderProps {
    workforceId: string;
    children: ReactNode;
    /**
     * Base URL for API calls. Defaults to `/api`.
     * The provider will POST to `{baseUrl}/workforce/{workforceId}/stream`.
     */
    baseUrl?: string;
    /**
     * Custom fetch function for API calls. Defaults to `authFetch` which
     * attaches Bearer tokens from localStorage and auto-refreshes on 401.
     */
    fetch?: FetchFn;
    /**
     * Enable composer attachments. `true` or `{ uploadUrl?, accept? }` uses
     * the built-in upload adapter (`POST` to `${baseUrl}/files/upload` by
     * default). Pass a custom {@link AttachmentAdapter} for full control, or
     * `null` to disable. Omitted = ON by default (built-in upload adapter).
     */
    attachments?: TimbalAttachmentsProp;
    /**
     * Shorthand to enable the default upload adapter with a custom endpoint.
     * Equivalent to `attachments={{ uploadUrl }}` when `attachments` is omitted.
     */
    attachmentsUploadUrl?: string;
    /**
     * Shorthand MIME `accept` for the default upload adapter when `attachments`
     * is omitted or `true`.
     */
    attachmentsAccept?: string;
    /**
     * Forwarded to {@link useTimbalStream}. When `true`, every parsed SSE
     * event is logged via `console.debug` with a `[timbal]` prefix.
     */
    debug?: boolean;
}
declare function TimbalRuntimeProvider({ workforceId, children, baseUrl, fetch: fetchFn, attachments, attachmentsUploadUrl, attachmentsAccept, debug, }: TimbalRuntimeProviderProps): react_jsx_runtime.JSX.Element;

interface TimbalChatProps extends Omit<TimbalRuntimeProviderProps, "children">, ThreadProps {
}
declare function TimbalChat({ workforceId, baseUrl, fetch, attachments, attachmentsUploadUrl, attachmentsAccept, debug, ...threadProps }: TimbalChatProps): react_jsx_runtime.JSX.Element;

export { type UiButtonNode as $, type AnyArtifact as A, type ThreadSuggestionsProps as B, type ChartArtifact as C, DEFAULT_UPLOAD_ACCEPT as D, type ThreadVariant as E, type ThreadWelcomeConfig as F, type ThreadWelcomeProps as G, type HtmlArtifact as H, type TimbalArtifact as I, type JsonArtifact as J, type TimbalAttachmentsConfig as K, type TimbalAttachmentsProp as L, TimbalChat as M, type TimbalChatProps as N, TimbalRuntimeProvider as O, type TimbalRuntimeProviderProps as P, type QuestionArtifact as Q, type ResolveAttachmentAdapterOptions as R, type SendOptions as S, type TableArtifact as T, type UiArtifact as U, type TimbalStreamApi as V, type ToolCallContentPart as W, type UiAction as X, type UiBadgeNode as Y, type UiBindable as Z, type UiBoxNode as _, type UiNode as a, type UiCustomNode as a0, type UiCustomNodeProps as a1, UiCustomNodeRegistryProvider as a2, type UiCustomNodeRenderer as a3, type UiDraggableNode as a4, type UiEventEnvelope as a5, UiEventProvider as a6, type UiHeadingNode as a7, type UiSliderNode as a8, type UiState as a9, type UiStateAction as aa, UiStateProvider as ab, type UiTextNode as ac, type UiToggleNode as ad, type UiTooltipNode as ae, type UploadFetchFn as af, type UseTimbalStreamOptions as ag, createDefaultAttachmentAdapter as ah, createUploadAttachmentAdapter as ai, defaultArtifactRenderers as aj, getPath as ak, isArtifact as al, isUiBinding as am, resolveAttachmentAdapter as an, resolveBindable as ao, setPath as ap, uiStateReducer as aq, useArtifactRegistry as ar, useResolvedSuggestions as as, useTimbalRuntime as at, useTimbalStream as au, useUiCustomNodeRegistry as av, useUiDispatch as aw, useUiEventEmitter as ax, useUiState as ay, type ArtifactRegistry as b, ArtifactRegistryProvider as c, type ArtifactRenderer as d, type ArtifactRendererProps as e, ArtifactView as f, type ChartSeriesConfig as g, type ChatAttachment as h, type ChatMessage as i, Composer as j, type ComposerProps as k, type ContentPart as l, type CreateDefaultAttachmentAdapterOptions as m, type CreateUploadAttachmentAdapterOptions as n, type QuestionOption as o, Suggestions as p, type SuggestionsComponent as q, type SuggestionsSlotProps as r, type SuggestionsSource as s, type TextContentPart as t, type ThinkingContentPart as u, Thread as v, type ThreadArtifactsConfig as w, type ThreadComponents as x, type ThreadProps as y, type ThreadSuggestion as z };