import type { Task, TaskEvent, TaskStatus, SeriesMode, SinceCursor, TaskError, SubscribeFilter } from '@taskcast/core';
export type CreateTaskInput = Pick<Partial<Task>, 'type' | 'params' | 'result' | 'metadata' | 'ttl' | 'authConfig' | 'webhooks' | 'cleanup'>;
export interface PublishEventInput {
    type: string;
    level: 'debug' | 'info' | 'warn' | 'error';
    data: unknown;
    seriesId?: string;
    seriesMode?: SeriesMode;
}
export interface TaskcastServerClientOptions {
    baseUrl: string;
    token?: string;
    fetch?: typeof globalThis.fetch;
}
export declare class TaskcastServerClient {
    private fetch;
    private baseUrl;
    private token?;
    constructor(opts: TaskcastServerClientOptions);
    createTask(input: CreateTaskInput): Promise<Task>;
    getTask(taskId: string): Promise<Task>;
    transitionTask(taskId: string, status: TaskStatus, payload?: {
        result?: Record<string, unknown>;
        error?: TaskError;
    }): Promise<Task>;
    publishEvent(taskId: string, input: PublishEventInput): Promise<TaskEvent>;
    publishEvents(taskId: string, inputs: PublishEventInput[]): Promise<TaskEvent[]>;
    getHistory(taskId: string, opts?: {
        since?: SinceCursor;
    }): Promise<TaskEvent[]>;
    /**
     * Subscribe to real-time events for a task via SSE.
     * Connects to the server's SSE endpoint and calls the handler for each event.
     * Returns a synchronous unsubscribe function that closes the connection.
     *
     * Always uses `wrap=false` so the handler receives raw `TaskEvent` objects.
     * The connection starts asynchronously; events begin flowing once established.
     * The stream closes automatically when the task reaches a terminal status.
     */
    subscribe(taskId: string, handler: (event: TaskEvent) => void, filter?: Omit<SubscribeFilter, 'wrap'>): () => void;
    private _consumeSSE;
    private _request;
}
//# sourceMappingURL=client.d.ts.map