/**
 * In-process client that wraps an {@link Engine} instance directly.
 * Use this when running Weft as an embedded library — no network hop.
 *
 * Implements the same {@link WeftClient} interface as {@link HttpClient},
 * so switching from library mode to server mode is a constructor change.
 *
 * @module client/local
 */
import { type ClientOperationName, type ClientOperationTypes, type ClientOperations } from '../cli/generated/operation-client.generated.ts';
import type { Engine } from '../core/engine.ts';
import type { AttributeFilterKey, BulkCancelResult, BulkDeleteResult, BulkRetryFailedResult, BulkSignalResult, BulkTagResult, CoordinatedUpdateResult, DefaultActivityTypes, DefaultWorkflowRegistry, ForkOptions, ListFilter, PaginatedResult, PurgeResult, QueryDefinition, RetentionOverview, ReviewListEntry, ReviewListFilter, ScheduleFilter, ScheduleOptions, ScheduleSpec, ScheduleSummary, ScheduleUpdateOptions, SearchAttributeValue, SignalDefinition, SignalDeliveryOptions, StartOptions, StartOrSignalOptions, 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 { ClientHandle, ClientScheduleHandle, UpdateResult, WeftClient, WeftClientActivity } from './interface.ts';
import type { KnownWorkflowName, UnknownNameWhenRegistryEmpty } from './workflow-name-typing.ts';
/**
 * In-process Weft client backed by a local {@link Engine}.
 *
 * @example
 * ```ts
 * import { workflow, Engine, MemoryStorage, LocalClient, type WorkflowContext } from '@lostgradient/weft';
 *
 * await using engine = new Engine({ storage: new MemoryStorage() });
 * engine.register(
 *   workflow({ name: 'greet' }).execute(async function* (ctx: WorkflowContext, input: { name: string }) {
 *     return `Hello, ${input.name}!`;
 *   }),
 * );
 *
 * const client = new LocalClient(engine);
 * const handle = await client.start('greet', { name: 'World' });
 * console.log(await handle.result()); // 'Hello, World!'
 * ```
 */
export declare class LocalClient<TWorkflows extends object = DefaultWorkflowRegistry, TActivities extends object = DefaultActivityTypes> implements WeftClient {
    #private;
    /** Typed low-level accessor for every client-callable operation, routed in-process. */
    readonly operations: ClientOperations;
    /** Raw storage administration against the engine-owned backend. */
    readonly storage: WeftClientStorage;
    /**
     * Out-of-band ("async") activity completion. An activity that called
     * `ActivityContext.completeAsync()` parks its workflow until an external
     * system resolves it by task token through these methods.
     *
     * @example
     * ```ts
     * import { Engine, LocalClient } from '@lostgradient/weft';
     *
     * const engine = new Engine();
     * const client = new LocalClient(engine);
     * // `token` came from the engine's `activity:async-pending` event.
     * // await client.activity.complete(token, { ok: true });
     * void client;
     * ```
     */
    readonly activity: WeftClientActivity;
    constructor(engine: Engine<TWorkflows, TActivities> | Engine);
    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?: StartOptions): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>>>;
    start<TName extends string>(type: UnknownNameWhenRegistryEmpty<TName>, input: unknown, options?: StartOptions): Promise<ClientHandle>;
    startOrSignal<TName extends KnownWorkflowName>(type: TName, input: WorkflowInput<WorkflowRegistry, TName>, signal: StartOrSignalSignal, options?: StartOrSignalOptions): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>>>;
    startOrSignal<TName extends string>(type: UnknownNameWhenRegistryEmpty<TName>, input: unknown, signal: StartOrSignalSignal, options?: StartOrSignalOptions): 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<TOutput>(id: string, name: UpdateDefinition<void, TOutput>, payload?: void, options?: {
        timeout?: number;
    }): Promise<TOutput>;
    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[]>;
    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;
    }): ReturnType<Engine['getStreamChunks']>;
    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>;
}