import type { WeftEventMap } from '../core/events.ts';
import type { QueryDefinition, ScheduleSpec, ScheduleSummary, ScheduleUpdateOptions, SearchAttributeValue, SignalDefinition, SignalDeliveryOptions, UpdateDefinition } from '../core/types.ts';
import type { WorkflowEventTail } from './event-tail.ts';
import type { ClientHandle, ClientScheduleHandle, StartOrSignalOutcome } from './interface.ts';
export interface WorkflowHandleDelegationClient {
    cancel(id: string): Promise<void>;
    suspend(id: string): Promise<void>;
    resume(id: string): Promise<ClientHandle>;
    tail(id: string): WorkflowEventTail;
    signal(id: string, name: string, payload?: unknown, options?: SignalDeliveryOptions): Promise<void>;
    update(id: string, name: string, payload?: unknown, options?: {
        timeout?: number;
    }): Promise<unknown>;
    query(id: string, name: string, input?: unknown): Promise<unknown>;
    getAttributes(id: string): Promise<Record<string, SearchAttributeValue> | null>;
    setAttributes(id: string, attributes: Record<string, SearchAttributeValue>): Promise<void>;
    addTags(id: string, ...tags: string[]): Promise<void>;
    removeTags(id: string, ...tags: string[]): Promise<void>;
}
export declare abstract class WorkflowHandleDelegation<TClient extends WorkflowHandleDelegationClient = WorkflowHandleDelegationClient> implements ClientHandle {
    readonly id: string;
    protected readonly client: TClient;
    readonly outcome: StartOrSignalOutcome | undefined;
    constructor(id: string, client: TClient, outcome?: StartOrSignalOutcome);
    abstract result(): Promise<unknown>;
    cancel(): Promise<void>;
    suspend(): Promise<void>;
    resume(): Promise<void>;
    signal(name: SignalDefinition): Promise<void>;
    signal<TInput>(name: SignalDefinition<TInput>, payload: TInput, options?: SignalDeliveryOptions): Promise<void>;
    signal(name: string, payload?: unknown, options?: SignalDeliveryOptions): Promise<void>;
    update<TOutput>(name: UpdateDefinition<void, TOutput>, payload?: void, options?: {
        timeout?: number;
    }): Promise<TOutput>;
    update<TInput, TOutput>(name: UpdateDefinition<TInput, TOutput>, payload: TInput, options?: {
        timeout?: number;
    }): Promise<TOutput>;
    update(name: string, payload?: unknown, options?: {
        timeout?: number;
    }): Promise<unknown>;
    query<TOutput>(name: QueryDefinition<void, TOutput>): Promise<TOutput>;
    query<TInput, TOutput>(name: QueryDefinition<TInput, TOutput>, input: TInput): Promise<TOutput>;
    query(name: string, input?: unknown): Promise<unknown>;
    getAttributes(): Promise<Record<string, SearchAttributeValue> | null>;
    setAttributes(attributes: Record<string, SearchAttributeValue>): Promise<void>;
    addTags(...tags: string[]): Promise<void>;
    removeTags(...tags: string[]): Promise<void>;
    tail(): WorkflowEventTail;
    /**
     * Default readiness: resolved immediately. Transports whose event stream has
     * connection latency (e.g. the HTTP watch socket) override this to reflect
     * their own connection state.
     */
    whenConnected(): Promise<void>;
    abstract addEventListener<K extends keyof WeftEventMap>(type: K, listener: (event: WeftEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
    abstract addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
    abstract removeEventListener<K extends keyof WeftEventMap>(type: K, listener: (event: WeftEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
    abstract removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    abstract [Symbol.dispose](): void;
}
export interface ScheduleHandleDelegationClient {
    pauseSchedule(id: string): Promise<void>;
    resumeSchedule(id: string): Promise<void>;
    cancelSchedule(id: string): Promise<void>;
    updateSchedule(id: string, newSpec: string | ScheduleSpec, options?: ScheduleUpdateOptions): Promise<void>;
    getSchedule(id: string): Promise<ScheduleSummary | null>;
}
export declare abstract class ScheduleHandleDelegation<TClient extends ScheduleHandleDelegationClient = ScheduleHandleDelegationClient> implements ClientScheduleHandle {
    readonly id: string;
    protected readonly client: TClient;
    constructor(id: string, client: TClient);
    pause(): Promise<void>;
    resume(): Promise<void>;
    cancel(): Promise<void>;
    update(newSpec: string | ScheduleSpec, options?: ScheduleUpdateOptions): Promise<void>;
    describe(): Promise<ScheduleSummary | null>;
    abstract [Symbol.dispose](): void;
}