import { AnyClientTool, SchemaInput, InterruptDefinition, ModelMessage, RunAgentResumeItem, InferSchemaType, StreamChunk, ImageGenerationResult, AudioGenerationResult, TTSResult, TranscriptionResult, SummarizationResult } from '@tanstack/ai';
import { InferredClientContext, DistributedOmit, ChatClientOptions, AIDevtoolsDisplayOptions, ClientContextOptionFromTools, UIMessage, MultimodalContent, SendMessageOptions, QueuedMessage, BoundInterrupts, ChatInterruptState, ResolvableChatInterrupt, ChatResumeState, ChatClientState, ConnectionStatus, ConnectConnectionAdapter, GenerationFetcher, GenerationRestoredResult, GenerationClientState, GenerationPersistenceOptions, InferGenerationOutputFromReturn, ImageGenerateInput, AudioGenerateInput, SpeechGenerateInput, TranscriptionGenerateInput, AudioRecorderOptions, AudioRecording, InferAudioRecordingOutput, SummarizeGenerateInput, VideoGenerateResult, VideoGenerateInput, VideoStatusInfo } from '@tanstack/ai-client';
export { AudioGenerateInput, ChatClientPersistence, ChatPersistedState, ChatPersistenceOption, ChatRequestBody, ChatStorageAdapter, ConnectConnectionAdapter, ConnectionAdapter, FetchConnectionOptions, GenerationClientState, ImageGenerateInput, IndexedDBPersistenceOptions, InferChatMessages, MultimodalContent, QueueConfig, QueueOption, QueueStrategy, QueuedMessage, RunAgentInputContext, SendMessageOptions, SpeechGenerateInput, StorageUnavailableError, SubscribeConnectionAdapter, SummarizeGenerateInput, TranscriptionGenerateInput, UIMessage, VideoGenerateInput, VideoGenerateResult, VideoStatusInfo, WebSocketConnectionOptions, WebStoragePersistenceOptions, WhenBusy, XhrConnectionOptions, createChatClientOptions, fetchHttpStream, fetchServerSentEvents, indexedDBPersistence, localStoragePersistence, rpcStream, sessionStoragePersistence, stream, webSocket, xhrHttpStream, xhrServerSentEvents } from '@tanstack/ai-client';
import { Signal } from '@angular/core';
import { ByokClient, ByokSnapshot } from '@tanstack/ai-client/byok';
import { ProviderId } from '@tanstack/ai/byok';

/**
 * A value that may be supplied to `injectChat` either as a static value, an
 * Angular `Signal`, or a zero-arg getter. The getter form lets callers read
 * other signals so the option stays reactive.
 */
type ReactiveOption<T> = T | Signal<T> | (() => T);

/**
 * Recursive partial — every property and every nested array element is optional.
 * Used to type the in-flight `partial` value while a structured-output stream
 * is still arriving.
 */
type DeepPartial<T> = T extends ReadonlyArray<infer U> ? Array<DeepPartial<U>> : T extends object ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : T;
/**
 * Options for {@link injectChat}.
 *
 * Mirrors the Vue `useChat` options, except:
 * - State-change callbacks are managed internally and exposed as signals.
 * - `body`, `forwardedProps`, and `live` accept a {@link ReactiveOption} so
 *   they can be a static value, a `Signal`, or a getter and stay reactive.
 */
type InjectChatOptions<TTools extends ReadonlyArray<AnyClientTool> = any, TSchema extends SchemaInput | undefined = undefined, TContext = InferredClientContext<TTools>, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> = DistributedOmit<ChatClientOptions<TTools, TContext, TInterrupts>, 'onMessagesChange' | 'onLoadingChange' | 'onErrorChange' | 'onStatusChange' | 'onSubscriptionChange' | 'onConnectionStatusChange' | 'onSessionGeneratingChange' | 'onQueueChange' | 'onResumeStateChange' | 'onRunIdChange' | 'context' | 'devtools' | 'body' | 'forwardedProps'> & {
    /** Display options for TanStack AI Devtools. */
    devtools?: AIDevtoolsDisplayOptions;
    /** Additional request body params. Reactive. */
    body?: ReactiveOption<Record<string, any>>;
    /** Forwarded request props (preferred over `body`). Reactive. */
    forwardedProps?: ReactiveOption<Record<string, any>>;
    /** Whether to keep a live subscription open. Reactive. */
    live?: ReactiveOption<boolean>;
    /**
     * Standard-schema-compatible schema (Zod, Valibot, ArkType, or JSON Schema).
     * Used to infer the shape of `partial` and `final`.
     */
    outputSchema?: TSchema;
} & ClientContextOptionFromTools<TTools, ReactiveOption<TContext>>;
/**
 * Return shape of {@link injectChat}. When `outputSchema` is supplied, adds
 * typed `partial` / `final` signals; otherwise the return is unchanged.
 */
type InjectChatResult<TTools extends ReadonlyArray<AnyClientTool> = any, TSchema extends SchemaInput | undefined = undefined, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> = BaseInjectChatResult<TTools, TSchema extends SchemaInput ? InferSchemaType<TSchema> : unknown, TInterrupts> & (TSchema extends SchemaInput ? {
    /** Live progressively-parsed structured output. */
    partial: Signal<DeepPartial<InferSchemaType<TSchema>>>;
    /** Final, schema-validated structured output. `null` until complete. */
    final: Signal<InferSchemaType<TSchema> | null>;
} : Record<never, never>);
interface BaseInjectChatResult<TTools extends ReadonlyArray<AnyClientTool> = any, TData = unknown, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> {
    /** Current messages in the conversation. */
    messages: Signal<Array<UIMessage<TTools, TData>>>;
    /**
     * Send a message (string or multimodal content).
     * Pass `{ whenBusy }` to override the queue policy for a single send, or
     * `{ body }` to merge per-call JSON into this request's `forwardedProps`.
     */
    sendMessage: (content: string | MultimodalContent, options?: SendMessageOptions) => Promise<void>;
    /** Pending messages queued while a stream is in flight. */
    queue: Signal<ReadonlyArray<QueuedMessage>>;
    /** Cancel a queued message before it drains. */
    cancelQueued: (id: string) => void;
    /** Append a message to the conversation. */
    append: (message: ModelMessage | UIMessage<TTools, TData>) => Promise<void>;
    /** Add the result of a client-side tool execution. */
    addToolResult: (result: {
        toolCallId: string;
        tool: string;
        output: any;
        state?: 'output-available' | 'output-error';
        errorText?: string;
    }) => Promise<void>;
    /** Respond to a tool approval request. */
    addToolApprovalResponse: (response: {
        id: string;
        approved: boolean;
    }) => Promise<void>;
    /**
     * The id of the run this client has in flight — one it started or rejoined —
     * or `null` when there is none (including while a run sits paused on an
     * interrupt, waiting on approval).
     *
     * A run is one turn of the conversation, so this changes from turn to turn. A
     * whole tool loop stays inside one run, while resuming after an interrupt
     * continues the turn under a new id — so one user message can produce several
     * run ids. Use it to talk to your own server about that run (cancel it, poll
     * it, correlate a log line).
     */
    runId: Signal<string | null>;
    /** Immutable bound interrupts for the current interrupted run. */
    interrupts: Signal<BoundInterrupts<TTools, TInterrupts>>;
    /** @deprecated Use `interrupts`. */
    pendingInterrupts: Signal<BoundInterrupts<TTools, TInterrupts>>;
    /** Batch-level interrupt errors. */
    interruptErrors: Signal<ChatInterruptState<TTools, TInterrupts>['interruptErrors']>;
    /** Whether the client is submitting an interrupt batch. */
    resuming: Signal<boolean>;
    resolveInterrupts: {
        (approved: boolean): void;
        (resolver: (interrupt: ResolvableChatInterrupt<TTools, TInterrupts>) => undefined): void;
    };
    cancelInterrupts: () => void;
    retryInterrupts: () => void;
    resumeInterruptsUnsafe: (resume: Array<RunAgentResumeItem>, state?: ChatResumeState) => Promise<boolean>;
    /** Reload the last assistant message. */
    reload: () => Promise<void>;
    /** Stop the current response generation. */
    stop: () => void;
    /** Whether a response is currently being generated. */
    isLoading: Signal<boolean>;
    /** Current error, if any. */
    error: Signal<Error | undefined>;
    /** Set messages manually. */
    setMessages: (messages: Array<UIMessage<TTools, TData>>) => void;
    /** Clear all messages. */
    clear: () => void;
    /** Current generation status. */
    status: Signal<ChatClientState>;
    /** Whether the subscription loop is active. */
    isSubscribed: Signal<boolean>;
    /** Current connection lifecycle status. */
    connectionStatus: Signal<ConnectionStatus>;
    /** Whether the shared session is actively generating. */
    sessionGenerating: Signal<boolean>;
}

declare function injectChat<const TTools extends ReadonlyArray<AnyClientTool> = any, TSchema extends SchemaInput | undefined = undefined, TContext = InferredClientContext<TTools>, const TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []>(options?: InjectChatOptions<TTools, TSchema, TContext, TInterrupts>): InjectChatResult<TTools, TSchema, TInterrupts>;

declare function injectByok(client: ByokClient): Signal<ByokSnapshot>;

interface InjectGenerationOptions<TInput, TResult, TOutput = TResult> {
    /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */
    connection?: ConnectConnectionAdapter;
    /** Direct async function for one-shot generation (no streaming protocol needed) */
    fetcher?: GenerationFetcher<TInput, TResult>;
    /** Additional request body params. Reactive. */
    body?: ReactiveOption<Record<string, any>>;
    /** Optional BYOK keyring. Keys go in `x-byok-*` headers, never the body. */
    byok?: ByokClient;
    /** Optional provider id. If it returns a slug, only that key is sent. If no slug resolves (`byokProvider`, then `body.provider`), generate throws. */
    byokProvider?: () => ProviderId | undefined;
    /** Display options for TanStack AI Devtools. */
    devtools?: AIDevtoolsDisplayOptions;
    /**
     * How this generation persists across reloads.
     * - Omit / `false`: ephemeral, in-memory only.
     * - `true`: server-driven — on mount the client hydrates the last generation
     *   for its `threadId` from the server (needs a connection with a
     *   `hydrateGeneration` handler) and repaints it; it never auto-starts a run.
     */
    persistence?: boolean;
    /**
     * The **scope** this generation belongs to: a stable, app-chosen name for the
     * slot successive runs fill — not a link to a chat conversation.
     *
     * The hook starts empty and produces many runs over its life; each gets its
     * own `runId`, but all belong to one scope. Persistence keys on this, so
     * derive it from your own domain and keep it identical across reloads (e.g.
     * `` `video-${videoId}-start-frame` ``). It is also sent as the AG-UI thread
     * id on the wire, which the protocol requires.
     *
     * **Required whenever `persistence` is set** — an app that cannot name the
     * scope has nothing to restore to. Optional for ephemeral generations. If
     * omitted, the client mints a wire id after mount.
     */
    threadId?: string;
    /**
     * Server-driven hydration handler for `persistence: true` when the
     * connection doesn't carry one (e.g. alongside `fetcher`, or a `stream()` /
     * `rpcStream()` adapter built without handlers) — typically a one-line
     * server-function call. The connection's own handler takes precedence.
     */
    hydrateGeneration?: ConnectConnectionAdapter['hydrateGeneration'];
    /**
     * Re-attach handler that replays a run still generating to completion on
     * mount, when the connection doesn't carry one. Without it, a restored
     * `running` snapshot surfaces as an (interrupted) error. The connection's
     * own handler takes precedence.
     */
    joinRun?: ConnectConnectionAdapter['joinRun'];
    /**
     * Callback when a result is received. Can optionally return a transformed value.
     *
     * - Return a non-null value to transform and store it as the result
     * - Return `null` to keep the previous result unchanged
     * - Return nothing (`void`) to store the raw result as-is
     */
    onResult?: (result: TResult) => TOutput | null | void;
    /** Callback when an error occurs */
    onError?: (error: Error) => void;
    /** Callback when progress is reported (0-100) */
    onProgress?: (progress: number, message?: string) => void;
    /** Callback for each stream chunk (connect-based adapter mode only) */
    onChunk?: (chunk: StreamChunk) => void;
    /**
     * @internal Rebuild a typed result from a restored snapshot, injected by each
     * specialized injectable (image / speech / audio / transcription / summarize).
     * Forwarded to the client so a server-hydrate restore repaints `result`.
     */
    reconstructResult?: (restored: GenerationRestoredResult) => TResult | null;
}
/**
 * Return type for the injectGeneration function.
 *
 * @template TOutput - The output type (after optional transform)
 * @template TInput - The input type accepted by `generate` (defaults to any object)
 */
interface InjectGenerationResult<TOutput, TInput extends Record<string, any> = Record<string, any>> {
    /** Trigger a generation request */
    generate: (input: TInput) => Promise<void>;
    /** The generation result, or null if not yet generated */
    result: Signal<TOutput | null>;
    /** Whether a generation is currently in progress */
    isLoading: Signal<boolean>;
    /** Current error, if any */
    error: Signal<Error | undefined>;
    /** Current state of the generation client */
    status: Signal<GenerationClientState>;
    /** Abort the current generation */
    stop: () => void;
    /** Clear result, error, and return to idle */
    reset: () => void;
    /** Identity of the in-flight run while one is streaming, or null after it ends */
    /**
     * The id of the generation job currently running, or `null` when nothing is in
     * flight. Each call to `generate` is one job with its own id. Pass it to your
     * own endpoint to cancel or poll the provider job — `stop()` only aborts the
     * local stream, it does not stop work already running on the provider.
     */
    runId: Signal<string | null>;
}
declare function injectGeneration<TInput extends Record<string, any>, TResult, TTransformed = void>(options: Omit<InjectGenerationOptions<TInput, TResult>, 'onResult' | 'persistence' | 'threadId'> & {
    onResult?: (result: TResult) => TTransformed;
} & GenerationPersistenceOptions): InjectGenerationResult<InferGenerationOutputFromReturn<TResult, TTransformed>, TInput>;

type InjectGenerateImageOptions<TOutput = ImageGenerationResult> = Omit<InjectGenerationOptions<ImageGenerateInput, ImageGenerationResult, TOutput>, 'onResult' | 'reconstructResult'> & {
    onResult?: (result: ImageGenerationResult) => TOutput | null | void;
};
interface InjectGenerateImageResult<TOutput = ImageGenerationResult> extends Omit<InjectGenerationResult<TOutput>, 'generate'> {
    generate: (input: ImageGenerateInput) => Promise<void>;
    result: Signal<TOutput | null>;
    isLoading: Signal<boolean>;
    error: Signal<Error | undefined>;
    status: Signal<GenerationClientState>;
}
declare function injectGenerateImage<TTransformed = void>(options: Omit<InjectGenerateImageOptions, 'onResult' | 'persistence' | 'threadId'> & {
    onResult?: (result: ImageGenerationResult) => TTransformed;
} & GenerationPersistenceOptions): InjectGenerateImageResult<InferGenerationOutputFromReturn<ImageGenerationResult, TTransformed>>;

/**
 * Options for the injectGenerateAudio injectable.
 *
 * @template TOutput - The output type after optional transform (defaults to AudioGenerationResult)
 */
interface InjectGenerateAudioOptions<TOutput = AudioGenerationResult> extends Pick<InjectGenerationOptions<AudioGenerateInput, AudioGenerationResult, TOutput>, 'persistence' | 'threadId' | 'hydrateGeneration' | 'joinRun' | 'byok' | 'byokProvider'> {
    /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */
    connection?: ConnectConnectionAdapter;
    /** Direct async function for audio generation */
    fetcher?: GenerationFetcher<AudioGenerateInput, AudioGenerationResult>;
    /** Additional body parameters to send with connect-based adapter requests. Reactive. */
    body?: ReactiveOption<Record<string, any>>;
    /** Display options for TanStack AI Devtools. */
    devtools?: AIDevtoolsDisplayOptions;
    /**
     * Callback when audio is generated. Can optionally return a transformed value.
     *
     * - Return a non-null value to transform and store it as the result
     * - Return `null` to keep the previous result unchanged
     * - Return nothing (`void`) to store the raw result as-is
     */
    onResult?: (result: AudioGenerationResult) => TOutput | null | void;
    /** Callback when an error occurs */
    onError?: (error: Error) => void;
    /** Callback when progress is reported (0-100) */
    onProgress?: (progress: number, message?: string) => void;
    /** Callback for each stream chunk (connect-based adapter mode only) */
    onChunk?: (chunk: StreamChunk) => void;
}
/**
 * Return type for the injectGenerateAudio injectable.
 *
 * @template TOutput - The output type (after optional transform)
 */
interface InjectGenerateAudioResult<TOutput = AudioGenerationResult> extends Omit<InjectGenerationResult<TOutput>, 'generate'> {
    /** Trigger audio generation */
    generate: (input: AudioGenerateInput) => Promise<void>;
    /** The generation result containing audio, or null */
    result: Signal<TOutput | null>;
    /** Whether generation is in progress */
    isLoading: Signal<boolean>;
    /** Current error, if any */
    error: Signal<Error | undefined>;
    /** Current state of the generation */
    status: Signal<GenerationClientState>;
}
/**
 * Angular injectable for generating audio (music, sound effects) using AI models.
 *
 * @example
 * ```typescript
 * import { Component } from '@angular/core'
 * import { injectGenerateAudio } from '@tanstack/ai-angular'
 * import { fetchServerSentEvents } from '@tanstack/ai-client'
 *
 * @Component({
 *   selector: 'app-audio',
 *   template: `
 *     <button (click)="generate({ prompt: 'An upbeat electronic track', duration: 10 })">
 *       Generate
 *     </button>
 *     @if (result()) {
 *       <audio [src]="result()!.audio.url" controls></audio>
 *     }
 *   `,
 * })
 * export class AudioComponent {
 *   private gen = injectGenerateAudio({
 *     connection: fetchServerSentEvents('/api/generate/audio'),
 *   })
 *
 *   generate = this.gen.generate
 *   result = this.gen.result
 *   isLoading = this.gen.isLoading
 * }
 * ```
 */
declare function injectGenerateAudio<TTransformed = void>(options: Omit<InjectGenerateAudioOptions, 'onResult' | 'persistence' | 'threadId'> & {
    onResult?: (result: AudioGenerationResult) => TTransformed;
} & GenerationPersistenceOptions): InjectGenerateAudioResult<InferGenerationOutputFromReturn<AudioGenerationResult, TTransformed>>;

type InjectGenerateSpeechOptions<TOutput = TTSResult> = Omit<InjectGenerationOptions<SpeechGenerateInput, TTSResult, TOutput>, 'onResult' | 'reconstructResult'> & {
    onResult?: (result: TTSResult) => TOutput | null | void;
};
interface InjectGenerateSpeechResult<TOutput = TTSResult> extends Omit<InjectGenerationResult<TOutput>, 'generate'> {
    generate: (input: SpeechGenerateInput) => Promise<void>;
    result: Signal<TOutput | null>;
    isLoading: Signal<boolean>;
    error: Signal<Error | undefined>;
    status: Signal<GenerationClientState>;
}
declare function injectGenerateSpeech<TTransformed = void>(options: Omit<InjectGenerateSpeechOptions, 'onResult' | 'persistence' | 'threadId'> & {
    onResult?: (result: TTSResult) => TTransformed;
} & GenerationPersistenceOptions): InjectGenerateSpeechResult<InferGenerationOutputFromReturn<TTSResult, TTransformed>>;

type InjectTranscriptionOptions<TOutput = TranscriptionResult> = Omit<InjectGenerationOptions<TranscriptionGenerateInput, TranscriptionResult, TOutput>, 'onResult' | 'reconstructResult'> & {
    onResult?: (result: TranscriptionResult) => TOutput | null | void;
};
interface InjectTranscriptionResult<TOutput = TranscriptionResult> extends Omit<InjectGenerationResult<TOutput>, 'generate'> {
    generate: (input: TranscriptionGenerateInput) => Promise<void>;
    result: Signal<TOutput | null>;
    isLoading: Signal<boolean>;
    error: Signal<Error | undefined>;
    status: Signal<GenerationClientState>;
}
declare function injectTranscription<TTransformed = void>(options: Omit<InjectTranscriptionOptions, 'onResult' | 'persistence' | 'threadId'> & {
    onResult?: (result: TranscriptionResult) => TTransformed;
} & GenerationPersistenceOptions): InjectTranscriptionResult<InferGenerationOutputFromReturn<TranscriptionResult, TTransformed>>;

type InjectAudioRecorderOptions<TOnComplete> = AudioRecorderOptions & {
    /**
     * Optional transform applied to the recording when `stop()` resolves. Its
     * (awaited) return value becomes `recording` and the resolved value of
     * `stop()`. Return nothing to keep the raw `AudioRecording`.
     */
    onComplete?: TOnComplete;
};
interface InjectAudioRecorderResult<TOutput> {
    /** Reactive: latest recording (transformed if `onComplete` provided), or null. */
    recording: Signal<TOutput | null>;
    /** Reactive: true while actively capturing audio. */
    isRecording: Signal<boolean>;
    /** Whether the browser supports recording. */
    isSupported: boolean;
    start: () => Promise<void>;
    /** Stop and resolve with the completed recording (transformed if `onComplete` provided). */
    stop: () => Promise<TOutput>;
    /** Discard the in-progress recording and release the mic. */
    cancel: () => void;
}
/**
 * Angular injectable for recording an audio message. The resolved recording
 * carries `.part` (for `injectChat`'s `sendMessage`) and `.base64` (for the
 * generation injectables). Must be called in an injection context.
 *
 * Errors are delivered via `onError`. `start()` and `stop()` also reject on
 * failure (and `stop()` rejects with `Recording cancelled` if `cancel()` runs
 * while a stop is in flight, e.g. on destroy) — handle one channel, not both.
 */
declare function injectAudioRecorder<TOnComplete extends (recording: AudioRecording) => unknown>(options: InjectAudioRecorderOptions<TOnComplete> & {
    onComplete: TOnComplete;
}): InjectAudioRecorderResult<InferAudioRecordingOutput<TOnComplete>>;
declare function injectAudioRecorder(options?: InjectAudioRecorderOptions<undefined>): InjectAudioRecorderResult<AudioRecording>;

type InjectSummarizeOptions<TOutput = SummarizationResult> = Omit<InjectGenerationOptions<SummarizeGenerateInput, SummarizationResult, TOutput>, 'onResult' | 'reconstructResult'> & {
    onResult?: (result: SummarizationResult) => TOutput | null | void;
};
interface InjectSummarizeResult<TOutput = SummarizationResult> extends Omit<InjectGenerationResult<TOutput>, 'generate'> {
    generate: (input: SummarizeGenerateInput) => Promise<void>;
    result: Signal<TOutput | null>;
    isLoading: Signal<boolean>;
    error: Signal<Error | undefined>;
    status: Signal<GenerationClientState>;
}
declare function injectSummarize<TTransformed = void>(options: Omit<InjectSummarizeOptions, 'onResult' | 'persistence' | 'threadId'> & {
    onResult?: (result: SummarizationResult) => TTransformed;
} & GenerationPersistenceOptions): InjectSummarizeResult<InferGenerationOutputFromReturn<SummarizationResult, TTransformed>>;

interface InjectGenerateVideoOptions<TOutput = VideoGenerateResult> {
    connection?: ConnectConnectionAdapter;
    fetcher?: GenerationFetcher<VideoGenerateInput, VideoGenerateResult>;
    body?: ReactiveOption<Record<string, any>>;
    /** Optional BYOK keyring. Keys go in `x-byok-*` headers, never the body. */
    byok?: ByokClient;
    /** Optional provider id. If it returns a slug, only that key is sent. If no slug resolves (`byokProvider`, then `body.provider`), generate throws. */
    byokProvider?: () => ProviderId | undefined;
    devtools?: AIDevtoolsDisplayOptions;
    /**
     * How this generation persists across reloads.
     * - Omit / `false`: ephemeral, in-memory only.
     * - `true`: server-driven — on mount the client hydrates the last generation
     *   for its `threadId` from the server (needs a connection with a
     *   `hydrateGeneration` handler) and repaints it; it never auto-starts a run.
     */
    persistence?: boolean;
    /**
     * The **scope** this generation belongs to: a stable, app-chosen name for the
     * slot successive runs fill — not a link to a chat conversation.
     *
     * The hook starts empty and produces many runs over its life; each gets its
     * own `runId`, but all belong to one scope. Persistence keys on this, so
     * derive it from your own domain and keep it identical across reloads (e.g.
     * `` `video-${videoId}-start-frame` ``). It is also sent as the AG-UI thread
     * id on the wire, which the protocol requires.
     *
     * **Required whenever `persistence` is set** — an app that cannot name the
     * scope has nothing to restore to. Optional for ephemeral generations. If
     * omitted, the client mints a wire id after mount.
     */
    threadId?: string;
    /**
     * Server-driven hydration handler for `persistence: true` when the
     * connection doesn't carry one (e.g. alongside `fetcher`, or a `stream()` /
     * `rpcStream()` adapter built without handlers) — typically a one-line
     * server-function call. The connection's own handler takes precedence.
     */
    hydrateGeneration?: ConnectConnectionAdapter['hydrateGeneration'];
    /**
     * Re-attach handler that replays a run still generating to completion on
     * mount, when the connection doesn't carry one. Without it, a restored
     * `running` snapshot surfaces as an (interrupted) error. The connection's
     * own handler takes precedence.
     */
    joinRun?: ConnectConnectionAdapter['joinRun'];
    onResult?: (result: VideoGenerateResult) => TOutput | null | void;
    onError?: (error: Error) => void;
    onProgress?: (progress: number, message?: string) => void;
    onJobCreated?: (jobId: string) => void;
    onStatusUpdate?: (status: VideoStatusInfo) => void;
    onChunk?: (chunk: StreamChunk) => void;
}
interface InjectGenerateVideoResult<TOutput = VideoGenerateResult> {
    generate: (input: VideoGenerateInput) => Promise<void>;
    result: Signal<TOutput | null>;
    jobId: Signal<string | null>;
    videoStatus: Signal<VideoStatusInfo | null>;
    isLoading: Signal<boolean>;
    error: Signal<Error | undefined>;
    status: Signal<GenerationClientState>;
    stop: () => void;
    reset: () => void;
    /**
     * The id of the generation job currently running, or `null` when nothing is in
     * flight. Each call to `generate` is one job with its own id. Pass it to your
     * own endpoint to cancel or poll the provider job — `stop()` only aborts the
     * local stream, it does not stop work already running on the provider.
     */
    runId: Signal<string | null>;
}
declare function injectGenerateVideo<TTransformed = void>(options: Omit<InjectGenerateVideoOptions, 'onResult' | 'persistence' | 'threadId'> & {
    onResult?: (result: VideoGenerateResult) => TTransformed;
} & GenerationPersistenceOptions): InjectGenerateVideoResult<InferGenerationOutputFromReturn<VideoGenerateResult, TTransformed>>;

export { injectAudioRecorder, injectByok, injectChat, injectGenerateAudio, injectGenerateImage, injectGenerateSpeech, injectGenerateVideo, injectGeneration, injectSummarize, injectTranscription };
export type { DeepPartial, InjectAudioRecorderOptions, InjectAudioRecorderResult, InjectChatOptions, InjectChatResult, InjectGenerateAudioOptions, InjectGenerateAudioResult, InjectGenerateImageOptions, InjectGenerateImageResult, InjectGenerateSpeechOptions, InjectGenerateSpeechResult, InjectGenerateVideoOptions, InjectGenerateVideoResult, InjectGenerationOptions, InjectGenerationResult, InjectSummarizeOptions, InjectSummarizeResult, InjectTranscriptionOptions, InjectTranscriptionResult, ReactiveOption };