import { Await } from '../activities/await';
import { Cycle } from '../activities/cycle';
import { Hook } from '../activities/hook';
import { Interrupt } from '../activities/interrupt';
import { Signal } from '../activities/signal';
import { Worker } from '../activities/worker';
import { Trigger } from '../activities/trigger';
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 { JobExport } from '../../types/exporter';
import { JobState, JobData, JobMetadata, 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, StreamError, StreamStatus } from '../../types/stream';
import { WorkListTaskType } from '../../types/task';
declare class EngineService {
    namespace: string;
    apps: HotMeshApps | null;
    appId: string;
    guid: string;
    exporter: ExporterService | null;
    search: SearchService<ProviderClient> | null;
    store: StoreService<ProviderClient, ProviderTransaction> | null;
    stream: StreamService<ProviderClient, ProviderTransaction> | null;
    subscribe: SubService<ProviderClient> | null;
    router: Router<typeof this.stream> | null;
    taskService: TaskService | null;
    logger: ILogger;
    cacheMode: CacheMode;
    untilVersion: string | null;
    jobCallbacks: Record<string, JobMessageCallback>;
    reporting: boolean;
    jobId: number;
    inited: string;
    /**
     * @private
     */
    constructor();
    /**
     * @private
     */
    static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, logger: ILogger): Promise<EngineService>;
    /**
     * @private
     */
    verifyEngineFields(config: HotMeshConfig): void;
    /**
     * @private
     */
    initSearchChannel(search: ProviderClient, store?: ProviderClient): Promise<void>;
    /**
     * @private
     */
    initStoreChannel(store: ProviderClient): Promise<void>;
    /**
     * @private
     */
    initSubChannel(sub: ProviderClient, store: ProviderClient): Promise<void>;
    /**
     * @private
     */
    initStreamChannel(stream: ProviderClient, store: ProviderClient): Promise<void>;
    /**
     * @private
     */
    initRouter(config: HotMeshConfig): Promise<Router<StreamService<ProviderClient, ProviderTransaction>>>;
    /**
     * resolves the distributed executable version using a delay
     * to allow deployment race conditions to resolve
     * @private
     */
    fetchAndVerifyVID(vid: AppVID, count?: number): Promise<AppVID>;
    getVID(vid?: AppVID): Promise<AppVID>;
    /**
     * @private
     */
    setCacheMode(cacheMode: CacheMode, untilVersion: string): void;
    /**
     * @private
     */
    routeToSubscribers(topic: string, message: JobOutput): Promise<void>;
    /**
     * @private
     */
    processWebHooks(): Promise<void>;
    /**
     * @private
     */
    processTimeHooks(): Promise<void>;
    /**
     * @private
     */
    throttle(delayInMillis: number): Promise<void>;
    /**
     * @private
     */
    initActivity(topic: string, data?: JobData, context?: JobState): Promise<Await | Cycle | Hook | Signal | Trigger | Worker | Interrupt>;
    getSchema(topic: string): Promise<[activityId: string, schema: ActivityType]>;
    /**
     * @private
     */
    getSettings(): Promise<HotMeshSettings>;
    /**
     * @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?: any[]): Promise<IdsResponse>;
    /**
     * @private
     */
    resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions>;
    /**
     * @private
     */
    processStreamMessage(streamData: StreamDataResponse): Promise<void>;
    /**
     * @private
     */
    execAdjacentParent(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<string>;
    /**
     * @private
     */
    hasParentJob(context: JobState, checkSevered?: boolean): boolean;
    /**
     * @private
     */
    resolveError(metadata: JobMetadata): StreamError | undefined;
    /**
     * @private
     */
    interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<string>;
    /**
     * @private
     */
    scrub(jobId: string): Promise<void>;
    /**
     * @private
     */
    hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
    /**
     * @private
     */
    hookTime(jobId: string, gId: string, topicOrActivity: string, type?: WorkListTaskType): Promise<string | void>;
    /**
     * @private
     */
    hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
    /**
     * @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): Promise<void>;
    /**
     * @private
     */
    getPublishesTopic(context: JobState): Promise<string>;
    /**
     * @private
     */
    pubPermSubs(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
    /**
     * @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
     */
    runJobCompletionTasks(context: JobState, options?: JobCompletionOptions): Promise<string | void>;
    /**
     * Job hash expiration is typically reliant on the metadata field
     * if the activity concludes normally. However, if the job is `interrupted`,
     * it will be expired immediately.
     * @private
     */
    resolveExpires(context: JobState, options: JobCompletionOptions): number;
    /**
     * @private
     */
    export(jobId: string): 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 };