import type QueryCapability from './capabilities/QueryCapability.ts';
import type PatchCapability from './capabilities/PatchCapability.ts';
import type SyncCapability from './capabilities/SyncCapability.ts';
import type StrandCapability from './capabilities/StrandCapability.ts';
import type CheckpointCapability from './capabilities/CheckpointCapability.ts';
import type ProvenanceCapability from './capabilities/ProvenanceCapability.ts';
import type ComparisonCapability from './capabilities/ComparisonCapability.ts';
import type SubscriptionCapability from './capabilities/SubscriptionCapability.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 BlobStoragePort from '../ports/BlobStoragePort.ts';
import type PatchJournalPort from '../ports/PatchJournalPort.ts';
import type CheckpointStorePort from '../ports/CheckpointStorePort.ts';
import type IndexStorePort from '../ports/IndexStorePort.ts';
import type EffectSinkPort from '../ports/EffectSinkPort.ts';
import type { EffectPipeline } from './services/EffectPipeline.ts';
import type { ExternalizationPolicy } from './types/ExternalizationPolicy.ts';
import type { GCPolicyConfig } from './services/GCPolicy.ts';
/**
 * Commitment capabilities — admitting claims into frontier-relative truth.
 *
 * Local tick admission (patches), speculative lane management (strands),
 * and braid presentation for comparison and transfer planning.
 */
export interface CommitmentSurface {
    /** Local tick admission: create patches, commit CRDT state. */
    readonly patches: PatchCapability;
    /** Speculative lanes: fork, collapse, braid. */
    readonly strands: StrandCapability;
    /** Braid presentation: compare coordinates, plan transfers. */
    readonly comparison: ComparisonCapability;
}
/**
 * Folding capabilities — re-expressing admitted history as explicit
 * operational artifacts.
 */
export interface FoldingSurface {
    /** History folding: create/restore checkpoints. */
    readonly checkpoint: CheckpointCapability;
}
/**
 * Revelation capabilities — bounded observer access to admitted truth.
 *
 * Queries, reactive subscriptions, and provenance witness access.
 */
export interface RevelationSurface {
    /** Bounded observer reads: nodes, edges, content, worldlines, observers. */
    readonly query: QueryCapability;
    /** Reactive revelation: subscribe to state changes. */
    readonly subscriptions: SubscriptionCapability;
    /** Witness access: provenance, audit, boundary transition records. */
    readonly provenance: ProvenanceCapability;
}
/**
 * Governance capabilities — distributed suffix admission and transport.
 */
export interface GovernanceSurface {
    /** Distributed suffix admission: sync, serve, transport. */
    readonly sync: SyncCapability;
}
/** The public API surface returned by openWarpGraph(). */
export interface WarpGraph {
    readonly graphName: string;
    readonly writerId: string;
    readonly commitment: CommitmentSurface;
    readonly folding: FoldingSurface;
    readonly revelation: RevelationSurface;
    readonly governance: GovernanceSurface;
    readonly query: QueryCapability;
    readonly patches: PatchCapability;
    readonly sync: SyncCapability;
    readonly strands: StrandCapability;
    readonly checkpoint: CheckpointCapability;
    readonly provenance: ProvenanceCapability;
    readonly comparison: ComparisonCapability;
    readonly subscriptions: SubscriptionCapability;
}
type TrustMode = 'off' | 'log-only' | 'enforce';
/**
 * Dependencies for openWarpGraph().
 *
 * The composition root accepts:
 * - persistence substrate (GraphPersistencePort)
 * - identity (graphName, writerId)
 * - governing policy (trust, GC, checkpoint, onDeleteWithData)
 * - witness infrastructure (crypto, codec, audit)
 * - revelation regime (logger, effectSinks, externalizationPolicy)
 * - optional accelerators (seekCache, blobStorage, indexStore)
 */
export interface WarpGraphDeps {
    readonly persistence: CorePersistence;
    readonly graphName: string;
    readonly writerId: string;
    readonly trust?: {
        mode?: TrustMode;
        pin?: string | null;
    };
    readonly gcPolicy?: GCPolicyConfig;
    readonly checkpointPolicy?: {
        every: number;
    };
    readonly onDeleteWithData?: 'reject' | 'cascade' | 'warn';
    readonly autoMaterialize?: boolean;
    readonly crypto?: CryptoPort;
    readonly codec?: CodecPort;
    readonly audit?: boolean;
    readonly logger?: LoggerPort;
    readonly effectPipeline?: EffectPipeline;
    readonly effectSinks?: EffectSinkPort[];
    readonly externalizationPolicy?: ExternalizationPolicy;
    readonly seekCache?: SeekCachePort;
    readonly blobStorage?: BlobStoragePort;
    readonly patchBlobStorage?: BlobStoragePort;
    readonly patchJournal?: PatchJournalPort | null;
    readonly checkpointStore?: CheckpointStorePort | null;
    readonly indexStore?: IndexStorePort | null;
    readonly adjacencyCacheSize?: number;
}
/**
 * Opens a WARP multi-writer graph compatibility capability bag.
 *
 * Application workflows should use openWarpWorldline(), which opens a named
 * causal worldline and keeps reads on explicit worldline, coordinate, observer,
 * or optic bases instead of graph-wide materialization.
 *
 * @deprecated For application workflows, use openWarpWorldline(). This advanced
 * compatibility bag remains supported for tooling and substrate diagnostics.
 */
export declare function openWarpGraph(deps: WarpGraphDeps): Promise<WarpGraph>;
export {};
