import { AgentServerOptions as AgentServerOptions$1, CustomAdapterOptions as CustomAdapterOptions$1, UseStreamReturn } from "./use-stream.js";
import { ReactNode } from "react";
import { InferStateType } from "@langchain/langgraph-sdk/stream";

//#region src/context.d.ts
/**
 * Props for {@link StreamProvider} when talking to the default
 * LangGraph Platform agent server. Mirrors {@link AgentServerOptions}
 * plus `children`.
 */
type StreamProviderProps<T = Record<string, unknown>> = AgentServerOptions$1<InferStateType<T>> & {
  children: ReactNode;
};
/**
 * Props for {@link StreamProvider} when wiring a custom
 * {@link AgentServerAdapter}. Mirrors {@link CustomAdapterOptions}
 * plus `children`.
 */
type StreamProviderCustomProps<T = Record<string, unknown>> = CustomAdapterOptions$1<InferStateType<T>> & {
  children: ReactNode;
};
/**
 * Provides a shared {@link useStream} instance to all descendants via
 * React Context.
 *
 * Use `StreamProvider` when multiple components in a subtree need
 * access to the same stream state (messages, loading status, errors,
 * interrupts, …) without prop drilling.
 *
 * @example
 * ```tsx
 * import { StreamProvider, useStreamContext } from "@langchain/react";
 *
 * function App() {
 *   return (
 *     <StreamProvider assistantId="agent" apiUrl="http://localhost:2024">
 *       <ChatHeader />
 *       <MessageList />
 *       <MessageInput />
 *     </StreamProvider>
 *   );
 * }
 *
 * function ChatHeader() {
 *   const { isLoading, error } = useStreamContext();
 *   return (
 *     <header>
 *       {isLoading && <span>Thinking...</span>}
 *       {error && <span>Error</span>}
 *     </header>
 *   );
 * }
 * ```
 *
 * Multiple providers can be nested for multi-agent scenarios:
 *
 * @example
 * ```tsx
 * <StreamProvider assistantId="researcher" apiUrl="http://localhost:2024">
 *   <ResearchPanel />
 * </StreamProvider>
 * <StreamProvider assistantId="writer" apiUrl="http://localhost:2024">
 *   <WriterPanel />
 * </StreamProvider>
 * ```
 */
declare function StreamProvider<T = Record<string, unknown>>(props: StreamProviderProps<T> | StreamProviderCustomProps<T>): ReactNode;
/**
 * Accesses the shared stream instance from the nearest
 * {@link StreamProvider}. Throws if called outside of one.
 *
 * @example
 * ```tsx
 * function MessageList() {
 *   const { messages } = useStreamContext();
 *   return messages.map((m, i) => <div key={m.id ?? i}>{String(m.content)}</div>);
 * }
 * ```
 *
 * @example With a type parameter for full type safety:
 * ```tsx
 * import type { agent } from "./agent";
 *
 * function Chat() {
 *   const { toolCalls } = useStreamContext<typeof agent>();
 * }
 * ```
 */
declare function useStreamContext<T = Record<string, unknown>>(): UseStreamReturn<T>;
//#endregion
export { StreamProvider, StreamProviderCustomProps, StreamProviderProps, useStreamContext };
//# sourceMappingURL=context.d.ts.map