import { AuditReceiptService } from '../services/audit/AuditReceiptService.ts';
import MaterializedViewService from '../services/MaterializedViewService.ts';
import StateHashService from '../services/state/StateHashService.ts';
import { type TrustMode, type NormalizedTrustConfig } from '../runtimeHelpers.ts';
import type { CorePersistence } from '../types/WarpPersistence.ts';
import type LoggerPort from '../../ports/LoggerPort.ts';
import type CryptoPort from '../../ports/CryptoPort.ts';
import type CodecPort from '../../ports/CodecPort.ts';
import type SeekCachePort from '../../ports/SeekCachePort.ts';
import type WarpStateCachePort from '../../ports/WarpStateCachePort.ts';
import type BlobStoragePort from '../../ports/BlobStoragePort.ts';
import type PatchJournalPort from '../../ports/PatchJournalPort.ts';
import type CommitMessageCodecPort from '../../ports/CommitMessageCodecPort.ts';
import type CheckpointStorePort from '../../ports/CheckpointStorePort.ts';
import type IndexStorePort from '../../ports/IndexStorePort.ts';
import type EffectSinkPort from '../../ports/EffectSinkPort.ts';
import type RuntimeStorageCapabilityPort from '../../ports/RuntimeStorageCapabilityPort.ts';
import type { EffectPipeline } from '../services/EffectPipeline.ts';
import type { ExternalizationPolicy } from '../types/ExternalizationPolicy.ts';
import GCPolicy, { type GCPolicyConfig } from '../services/GCPolicy.ts';
import type { MaterializeSessionOpener } from '../services/controllers/MaterializeSessionBridge.ts';
type DeletePolicy = 'reject' | 'cascade' | 'warn';
export type RuntimeHostConstructionOptions = {
    persistence: CorePersistence & Partial<RuntimeStorageCapabilityPort>;
    graphName: string;
    writerId: string;
    gcPolicy?: GCPolicyConfig | GCPolicy;
    adjacencyCacheSize?: number;
    checkpointPolicy?: {
        every: number;
    };
    autoMaterialize?: boolean;
    onDeleteWithData?: DeletePolicy;
    logger?: LoggerPort;
    crypto?: CryptoPort;
    codec?: CodecPort;
    seekCache?: SeekCachePort;
    stateCache?: WarpStateCachePort;
    audit?: boolean;
    blobStorage?: BlobStoragePort;
    patchBlobStorage?: BlobStoragePort;
    commitMessageCodec?: CommitMessageCodecPort;
    trust?: {
        mode?: TrustMode;
        pin?: string | null;
    };
    patchJournal: PatchJournalPort;
    checkpointStore: CheckpointStorePort;
    indexStore: IndexStorePort;
    viewService: MaterializedViewService;
    stateHashService?: StateHashService;
    auditService?: AuditReceiptService;
    effectPipeline?: EffectPipeline;
    openStateSession?: MaterializeSessionOpener;
};
export type RuntimeHostOpenOptions = {
    persistence: CorePersistence & Partial<RuntimeStorageCapabilityPort>;
    graphName: string;
    writerId: string;
    gcPolicy?: GCPolicyConfig | GCPolicy;
    adjacencyCacheSize?: number;
    checkpointPolicy?: {
        every: number;
    } | null;
    autoMaterialize?: boolean;
    onDeleteWithData?: DeletePolicy;
    logger?: LoggerPort;
    crypto?: CryptoPort;
    codec?: CodecPort;
    seekCache?: SeekCachePort;
    stateCache?: WarpStateCachePort;
    audit?: boolean;
    blobStorage?: BlobStoragePort;
    patchBlobStorage?: BlobStoragePort;
    commitMessageCodec?: CommitMessageCodecPort;
    patchJournal?: PatchJournalPort | null;
    checkpointStore?: CheckpointStorePort | null;
    indexStore?: IndexStorePort | null;
    trust?: {
        mode?: TrustMode;
        pin?: string | null;
    };
    effectPipeline?: EffectPipeline;
    effectSinks?: readonly EffectSinkPort[];
    externalizationPolicy?: ExternalizationPolicy;
    openStateSession?: MaterializeSessionOpener;
};
export declare class WarpOpenOptions {
    readonly persistence: CorePersistence & Partial<RuntimeStorageCapabilityPort>;
    readonly graphName: string;
    readonly writerId: string;
    readonly gcPolicy: GCPolicyConfig | GCPolicy;
    readonly adjacencyCacheSize?: number;
    readonly checkpointPolicy?: {
        every: number;
    };
    readonly autoMaterialize?: boolean;
    readonly onDeleteWithData?: DeletePolicy;
    readonly logger?: LoggerPort;
    readonly crypto: CryptoPort;
    readonly codec: CodecPort;
    readonly seekCache?: SeekCachePort;
    readonly stateCache?: WarpStateCachePort;
    readonly audit?: boolean;
    readonly blobStorage?: BlobStoragePort;
    readonly patchBlobStorage?: BlobStoragePort;
    readonly commitMessageCodec?: CommitMessageCodecPort;
    readonly patchJournal?: PatchJournalPort | null;
    readonly checkpointStore?: CheckpointStorePort | null;
    readonly indexStore?: IndexStorePort | null;
    readonly trust?: {
        mode?: TrustMode;
        pin?: string | null;
    };
    readonly effectPipeline?: EffectPipeline;
    readonly effectSinks?: readonly EffectSinkPort[];
    readonly externalizationPolicy?: ExternalizationPolicy;
    readonly openStateSession?: MaterializeSessionOpener;
    constructor(options: RuntimeHostOpenOptions);
    static from(options: RuntimeHostOpenOptions | WarpOpenOptions): WarpOpenOptions;
    static minimal(options: {
        persistence: CorePersistence & Partial<RuntimeStorageCapabilityPort>;
        graphName?: string;
        writerId?: string;
    }): WarpOpenOptions;
}
export type RuntimeHostOpenInput = RuntimeHostOpenOptions | WarpOpenOptions;
export type RuntimeMigrationBoundary = {
    _validateMigrationBoundary(): Promise<void>;
};
export type RuntimeBooted<T extends RuntimeMigrationBoundary> = {
    runtime: T;
    normalizedTrust: NormalizedTrustConfig;
};
export declare function resolveRuntimeHostConstructionOptions(input: RuntimeHostOpenInput): Promise<{
    options: RuntimeHostConstructionOptions;
    normalizedTrust: NormalizedTrustConfig;
}>;
export {};
