/**
 * EngineService — the workflow execution engine.
 *
 * Consumes stream messages from the router and dispatches them
 * to the appropriate activity handler (Trigger, Worker, Hook, …).
 *
 * Each section delegates to a purpose-specific module inside `engine/`.
 * Open the module when you need implementation detail; read this file
 * when you need the big picture.
 *
 * Lifecycle (maps to modules):
 *   1. INIT       → init.ts       (channel setup, router, config)
 *   2. VERSION    → version.ts    (app version resolution, caching)
 *   3. SCHEMA     → schema.ts     (activity lookup, handler factory)
 *   4. COMPILE    → compiler.ts   (YAML plan & deploy)
 *   5. REPORT     → reporting.ts  (stats, IDs, query resolution)
 *   6. DISPATCH   → dispatch.ts   (stream message → activity handler)
 *   7. COMPLETION → completion.ts (parent notify, cleanup, expiry)
 *   8. SIGNAL     → signal.ts     (webhook/timehook delivery, fan-out)
 *   9. PUB/SUB    → pubsub.ts     (topic messaging, subscriptions)
 *  10. STATE      → state.ts      (job state retrieval, export)
 */
import { ExporterService } from '../exporter';
import { ILogger } from '../logger';
import { Router } from '../router';
import { SearchService } from '../search';
import { StoreService } from '../store';
import { StreamService } from '../stream';
import { SubService } from '../sub';
import { TaskService } from '../task';
import { AppVID } from '../../types/app';
import { ActivityType } from '../../types/activity';
import { CacheMode } from '../../types/cache';
import { ExportOptions, JobExport } from '../../types/exporter';
import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions, JobCompletionOptions, ExtensionType } from '../../types/job';
import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
import { ProviderClient, ProviderTransaction } from '../../types/provider';
import { JobMessageCallback } from '../../types/quorum';
import { StringAnyType, StringStringType } from '../../types/serializer';
import { GetStatsOptions, IdsResponse, JobStatsInput, StatsResponse } from '../../types/stats';
import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
import { WorkListTaskType } from '../../types/task';
declare class EngineService {
    namespace: string;
    apps: HotMeshApps | null;
    appId: string;
    guid: string;
    inited: string;
    exporter: ExporterService | null;
    /** @hidden */
    search: SearchService<ProviderClient> | null;
    /** @hidden */
    store: StoreService<ProviderClient, ProviderTransaction> | null;
    /** @hidden */
    stream: StreamService<ProviderClient, ProviderTransaction> | null;
    /** @hidden */
    subscribe: SubService<ProviderClient> | null;
    /** @hidden */
    router: Router<typeof this.stream> | null;
    /** @hidden */
    taskService: TaskService | null;
    logger: ILogger;
    cacheMode: CacheMode;
    untilVersion: string | null;
    jobCallbacks: Record<string, JobMessageCallback>;
    /**
     * @private
     */
    constructor();
    /**
     * @private
     */
    static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, logger: ILogger): Promise<EngineService>;
    /**
     * @private
     */
    getSettings(): Promise<HotMeshSettings>;
    /**
     * @private
     */
    getVID(vid?: AppVID): Promise<AppVID>;
    /**
     * @private
     */
    setCacheMode(cacheMode: CacheMode, untilVersion: string): void;
    /**
     * @private
     */
    initActivity(topic: string, data?: JobData, context?: JobState): Promise<any>;
    /**
     * @private
     */
    getSchema(topic: string): Promise<[activityId: string, schema: ActivityType]>;
    /**
     * @private
     */
    isPrivate(topic: string): boolean;
    /**
     * @private
     */
    plan(pathOrYAML: string): Promise<HotMeshManifest>;
    /**
     * @private
     */
    deploy(pathOrYAML: string): Promise<HotMeshManifest>;
    /**
     * @private
     */
    getStats(topic: string, query: JobStatsInput): Promise<StatsResponse>;
    /**
     * @private
     */
    getIds(topic: string, query: JobStatsInput, queryFacets?: string[]): Promise<IdsResponse>;
    /**
     * @private
     */
    resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions>;
    /**
     * @private
     */
    processStreamMessage(streamData: StreamDataResponse): Promise<void>;
    /**
     * @private
     */
    execAdjacentParent(context: JobState, jobOutput: JobOutput, emit?: boolean, transaction?: ProviderTransaction): Promise<string>;
    /**
     * @private
     */
    hasParentJob(context: JobState, checkSevered?: boolean): boolean;
    /**
     * @private
     */
    interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<string>;
    /**
     * @private
     */
    scrub(jobId: string): Promise<void>;
    /**
     * @private
     */
    runJobCompletionTasks(context: JobState, options?: JobCompletionOptions, transaction?: ProviderTransaction): Promise<string | void>;
    /**
     * @private
     */
    signal(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode, transaction?: ProviderTransaction): Promise<string>;
    /**
     * @private
     */
    hookTime(jobId: string, gId: string, topicOrActivity: string, type?: WorkListTaskType): Promise<string | void>;
    /**
     * @private
     */
    signalAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
    /**
     * @private
     */
    routeToSubscribers(topic: string, message: JobOutput): Promise<void>;
    /**
     * @private
     */
    processWebHooks(): Promise<void>;
    /**
     * @private
     */
    processTimeHooks(): Promise<void>;
    /**
     * @private
     */
    throttle(delayInMillis: number): Promise<void>;
    /**
     * Apply a remote duress signal from the quorum.
     * Delegates to the router's duress manager.
     * @private
     */
    applyRemoteDuress(throttleMs: number, level: string): void;
    /**
     * @private
     */
    pub(topic: string, data: JobData, context?: JobState, extended?: ExtensionType): Promise<string>;
    /**
     * @private
     */
    sub(topic: string, callback: JobMessageCallback): Promise<void>;
    /**
     * @private
     */
    unsub(topic: string): Promise<void>;
    /**
     * @private
     */
    psub(wild: string, callback: JobMessageCallback): Promise<void>;
    /**
     * @private
     */
    punsub(wild: string): Promise<void>;
    /**
     * @private
     */
    pubsub(topic: string, data: JobData, context?: JobState | null, timeout?: number): Promise<JobOutput>;
    /**
     * @private
     */
    pubOneTimeSubs(context: JobState, jobOutput: JobOutput, emit?: boolean, transaction?: ProviderTransaction): Promise<void>;
    /**
     * @private
     */
    pubPermSubs(context: JobState, jobOutput: JobOutput, emit?: boolean, transaction?: ProviderTransaction): Promise<void>;
    /**
     * @private
     */
    getPublishesTopic(context: JobState): Promise<string>;
    /**
     * @private
     */
    add(streamData: StreamData | StreamDataResponse): Promise<string>;
    /**
     * @private
     */
    registerJobCallback(jobId: string, jobCallback: JobMessageCallback): void;
    /**
     * @private
     */
    delistJobCallback(jobId: string): void;
    /**
     * @private
     */
    hasOneTimeSubscription(context: JobState): boolean;
    /**
     * @private
     */
    export(jobId: string, options?: ExportOptions): Promise<JobExport>;
    /**
     * @private
     */
    getRaw(jobId: string): Promise<StringStringType>;
    /**
     * @private
     */
    getStatus(jobId: string): Promise<JobStatus>;
    /**
     * @private
     */
    getState(topic: string, jobId: string): Promise<JobOutput>;
    /**
     * @private
     */
    getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
    /**
     * @private
     * @deprecated
     */
    compress(terms: string[]): Promise<boolean>;
}
export { EngineService };