import { type ClientOperationName, type ClientOperationTypes, type ClientOperations } from '../cli/generated/operation-client.generated.ts';
import type { StoredStreamChunk } from '../core/context.ts';
import type { AttributeFilterKey, BulkCancelResult, BulkDeleteResult, BulkRetryFailedResult, BulkSignalResult, BulkTagResult, CoordinatedUpdateResult, ForkOptions, ListFilter, PaginatedResult, PurgeResult, QueryDefinition, RetentionOverview, ReviewListEntry, ReviewListFilter, ScheduleFilter, ScheduleOptions, ScheduleSpec, ScheduleSummary, ScheduleUpdateOptions, SearchAttributeValue, SignalDefinition, SignalDeliveryOptions, StartOrSignalSignal, SubmitReviewOptions, TypedListFilter, UpdateDefinition, WorkflowEvent, WorkflowInput, WorkflowOutput, WorkflowRegistry, WorkflowReplay, WorkflowState, WorkflowSummary, WorkflowTimelineEntry } from '../core/types.ts';
import type { WeftClientStorage } from './client-storage.ts';
import type { WorkflowEventTail } from './event-tail.ts';
import { type HttpClientOptions } from './http-request.ts';
import type { ClientHandle, ClientScheduleHandle, ClientStartOptions, ClientStartOrSignalOptions, UpdateResult, WeftClient, WeftClientActivity } from './interface.ts';
import type { KnownWorkflowName, UnknownNameWhenRegistryEmpty } from './workflow-name-typing.ts';
/**
 * Remote Weft client backed by HTTP requests.
 *
 * **Error handling**
 *
 * - **404 on GET → `null`:** When a GET request returns 404, the client
 *   treats it as "resource not found" and resolves with `null` instead of
 *   throwing `HttpClientError`.
 * - **400/422 in `submitCoordinatedUpdate` → error envelope:** A 400 or 422
 *   response from `submitCoordinatedUpdate` is translated into a
 *   `CoordinatedUpdateResult` with an `error` field rather than throwing.
 *
 * **Connection resolution**
 *
 * With no `baseUrl`/`token`, the client resolves the server address and bearer
 * token through {@link resolveConnection}: explicit options, then `WEFT_ADDR`/
 * `WEFT_TOKEN`, then the `~/.weft/config` profile, then `http://localhost:7233`.
 * The CLI-only run lockfile is not consulted. A caller-supplied
 * `headers.Authorization` always takes precedence over a resolved token.
 *
 * @example
 * ```ts
 * import { HttpClient } from '@lostgradient/weft';
 *
 * // Explicit address and token.
 * const client = new HttpClient({
 *   baseUrl: 'http://localhost:3000',
 *   headers: { Authorization: 'Bearer my-token' },
 * });
 * const handle = await client.start('greet', { name: 'Alice' });
 * const result = await handle.result();
 * void result;
 *
 * // Or resolve WEFT_ADDR / WEFT_TOKEN from the environment.
 * const envClient = new HttpClient();
 * void envClient;
 * ```
 */
export declare class HttpClient implements WeftClient {
    #private;
    /** @internal Exposed for handle access. */
    readonly baseUrl: string;
    /** @internal Exposed for handle access. */
    readonly headers: Record<string, string>;
    /** Typed low-level accessor over JSON-RPC and generated ordinary REST bindings. */
    readonly operations: ClientOperations;
    /** Raw storage administration over the byte-oriented REST bindings. */
    readonly storage: WeftClientStorage;
    /**
     * Out-of-band ("async") activity completion over HTTP. POSTs to
     * `/v1/activities/{complete,fail}`; mirrors {@link LocalClient}'s `activity`.
     */
    readonly activity: WeftClientActivity;
    constructor(options?: HttpClientOptions);
    call<Name extends ClientOperationName>(name: Name, input: ClientOperationTypes[Name]['input']): Promise<ClientOperationTypes[Name]['output']>;
    start<TName extends KnownWorkflowName>(type: TName, input: WorkflowInput<WorkflowRegistry, TName>, options?: ClientStartOptions): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>>>;
    start<TName extends string>(type: UnknownNameWhenRegistryEmpty<TName>, input: unknown, options?: ClientStartOptions): Promise<ClientHandle>;
    startOrSignal<TName extends KnownWorkflowName>(type: TName, input: WorkflowInput<WorkflowRegistry, TName>, signal: StartOrSignalSignal, options?: ClientStartOrSignalOptions): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>>>;
    startOrSignal<TName extends string>(type: UnknownNameWhenRegistryEmpty<TName>, input: unknown, signal: StartOrSignalSignal, options?: ClientStartOrSignalOptions): Promise<ClientHandle>;
    schedule<TName extends KnownWorkflowName>(type: TName, input: WorkflowInput<WorkflowRegistry, TName>, spec: string | ScheduleSpec, options?: ScheduleOptions): Promise<ClientScheduleHandle>;
    schedule<TName extends string>(type: UnknownNameWhenRegistryEmpty<TName>, input: unknown, spec: string | ScheduleSpec, options?: ScheduleOptions): Promise<ClientScheduleHandle>;
    get(id: string): Promise<WorkflowState | null>;
    getHandle(id: string): Promise<ClientHandle | null>;
    getHandle<TName extends KnownWorkflowName>(id: string): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>> | null>;
    getSchedule(id: string): Promise<ScheduleSummary | null>;
    list<const TAttributeKeys extends readonly AttributeFilterKey[] = readonly AttributeFilterKey[]>(filter?: TypedListFilter<TAttributeKeys>): Promise<PaginatedResult<WorkflowSummary>>;
    listSchedules(filter?: ScheduleFilter): Promise<PaginatedResult<ScheduleSummary>>;
    cancel(id: string): Promise<void>;
    suspend(id: string): Promise<void>;
    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>;
    signal(id: string, name: SignalDefinition): Promise<void>;
    signal<TInput>(id: string, name: SignalDefinition<TInput>, payload: TInput, options?: SignalDeliveryOptions): Promise<void>;
    signal(id: string, name: string, payload?: unknown, options?: SignalDeliveryOptions): Promise<void>;
    query<TOutput>(id: string, name: QueryDefinition<void, TOutput>): Promise<TOutput>;
    query<TInput, TOutput>(id: string, name: QueryDefinition<TInput, TOutput>, input: TInput): Promise<TOutput>;
    query(id: string, name: string, input?: unknown): Promise<unknown>;
    update(id: string, name: UpdateDefinition, payload?: void, options?: {
        timeout?: number;
    }): Promise<unknown>;
    update<TInput, TOutput>(id: string, name: UpdateDefinition<TInput, TOutput>, payload: TInput, options?: {
        timeout?: number;
    }): Promise<TOutput>;
    update(id: string, name: string, payload?: unknown, options?: {
        timeout?: number;
    }): Promise<unknown>;
    resume(id: string): Promise<ClientHandle>;
    recoverAll(): Promise<ClientHandle[]>;
    timeout(id: string): Promise<void>;
    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>;
    getEvents(id: string): Promise<WorkflowEvent[]>;
    /**
     * @internal Open a live event subscription over the `/watch` WebSocket
     * channel. Shared by {@link HttpHandle} (push-based `addEventListener`) and
     * {@link tail}. The subscription catches up from `getEvents` on every
     * (re)connect, so it covers events emitted before it connected.
     *
     * `bufferForIteration` defaults off for the callback-only `addEventListener`
     * path; {@link tail} sets it so the connect catch-up is buffered for the
     * async iterator instead of dropped.
     */
    openEventSubscription(id: string, onEvent: (event: WorkflowEvent) => void, bufferForIteration?: boolean): WorkflowEventTail;
    tail(id: string): WorkflowEventTail;
    getTimeline(id: string): Promise<WorkflowTimelineEntry[]>;
    replayTo(id: string, step: number): Promise<WorkflowReplay | null>;
    listReviews(filter?: ReviewListFilter): Promise<ReviewListEntry[]>;
    submitReview(reviewId: string, options: SubmitReviewOptions): Promise<void>;
    getStreamChunks(workflowId: string, key: string, options?: {
        after?: number;
    }): Promise<StoredStreamChunk[]>;
    fork(id: string, options?: ForkOptions): Promise<ClientHandle>;
    getRetentionOverview(): Promise<RetentionOverview>;
    purge(filter?: ListFilter): Promise<PurgeResult>;
    cancelAll(filter: ListFilter): Promise<BulkCancelResult>;
    retryFailedAll(filter: ListFilter): Promise<BulkRetryFailedResult>;
    signalAll(filter: ListFilter, name: string, payload?: unknown): Promise<BulkSignalResult>;
    deleteAll(filter: ListFilter): Promise<BulkDeleteResult>;
    tagAll(filter: ListFilter, tags: string[]): Promise<BulkTagResult>;
    untagAll(filter: ListFilter, tags: string[]): Promise<BulkTagResult>;
    submitCoordinatedUpdate(id: string, name: string, payload?: unknown, options?: {
        timeout?: number;
        idempotencyKey?: string;
    }): Promise<CoordinatedUpdateResult>;
    getUpdateResult(updateId: string): Promise<UpdateResult>;
}