import type { AtribRecord, UnsignedAtribRecord } from './types.js';
import type { ArchiveSubmissionOptions, ProofBundle } from './submission.js';
export declare const LOCAL_SUBSTRATE_REQUEST_SCHEMA = "atrib.local-substrate-coordinator.request.v0";
export declare const LOCAL_SUBSTRATE_RESPONSE_SCHEMA = "atrib.local-substrate-coordinator.response.v0";
export declare const LOCAL_SUBSTRATE_HEALTH_SCHEMA = "atrib.local-substrate-coordinator.health.v0";
export declare const LOCAL_SUBSTRATE_HTTP_DEFAULT_PATH = "/atrib/local-substrate";
export declare const LOCAL_SUBSTRATE_HTTP_DEFAULT_HEALTH_PATH = "/atrib/local-substrate/health";
export declare const LOCAL_SUBSTRATE_DEFAULT_TIMEOUT_MS = 1500;
export declare const LOCAL_SUBSTRATE_HEALTH_ACTIVE_CONTEXT_LIMIT = 25;
export declare const LOCAL_SUBSTRATE_HARNESS_CLASSES: readonly ["startup-spawn", "long-lived-agent", "watcher-wal"];
export type LocalSubstrateHarnessClass = (typeof LOCAL_SUBSTRATE_HARNESS_CLASSES)[number];
export declare const LOCAL_SUBSTRATE_OPERATIONS: readonly ["sign_record", "enqueue_record_and_join_receipt"];
export type LocalSubstrateOperation = (typeof LOCAL_SUBSTRATE_OPERATIONS)[number];
export declare const LOCAL_SUBSTRATE_REQUEST_MODES: readonly ["commit", "shadow_probe"];
export type LocalSubstrateRequestMode = (typeof LOCAL_SUBSTRATE_REQUEST_MODES)[number];
export declare const LOCAL_SUBSTRATE_RESPONSE_STATUSES: readonly ["accepted", "rejected"];
export type LocalSubstrateResponseStatus = (typeof LOCAL_SUBSTRATE_RESPONSE_STATUSES)[number];
export declare const LOCAL_SUBSTRATE_CREATOR_KEY_POLICIES: readonly ["implicit-single-creator", "explicit-single-creator", "explicit-watcher-creator", "explicit-signer-selection"];
export type LocalSubstrateCreatorKeyPolicy = (typeof LOCAL_SUBSTRATE_CREATOR_KEY_POLICIES)[number];
export interface LocalSubstrateProducer {
    name: string;
    harness_class: LocalSubstrateHarnessClass;
    pid?: number;
    transport?: string;
    creator_key_policy?: LocalSubstrateCreatorKeyPolicy;
}
export interface LocalSubstrateContext {
    source: string;
    context_id: string;
    chain_tail?: string;
    parent_record_hash?: string;
    join_back_target?: string;
}
export interface LocalSubstrateDegradationPolicy {
    if_unavailable: string;
    primary_path_blocking: false;
}
export interface LocalSubstrateWalJoin {
    entry_id: string;
    source_path: string;
    receipt_join_field: string;
}
export interface LocalSubstrateCoordinatorRequest {
    schema: typeof LOCAL_SUBSTRATE_REQUEST_SCHEMA;
    operation: LocalSubstrateOperation;
    /**
     * `commit` lets the coordinator own its configured side effects. `shadow_probe`
     * asks it to validate and sign the exact body, then return the hash without
     * queueing or mirroring so a direct producer can keep owning the hot path.
     * Absence preserves the original commit behavior.
     */
    mode?: LocalSubstrateRequestMode;
    producer: LocalSubstrateProducer;
    context?: LocalSubstrateContext;
    record_body: UnsignedAtribRecord;
    wal?: LocalSubstrateWalJoin;
    degradation: LocalSubstrateDegradationPolicy;
}
export interface LocalSubstrateHealthReport {
    schema: typeof LOCAL_SUBSTRATE_HEALTH_SCHEMA;
    coordinator: {
        pid: number;
        version: string;
        transport: string;
        creator_key_scope?: string;
    };
    queues: {
        log_submission_depth: number;
        archive_submission_depth?: number;
    };
    wal: {
        pending: number;
        joined?: number;
        orphan_receipts: number;
    };
    contexts: {
        active: string[];
        active_count?: number;
        active_truncated?: boolean;
    };
    processes: {
        active_wrappers?: number;
        stale_children: number;
    };
}
export interface LocalSubstrateCoordinatorResponse {
    schema: typeof LOCAL_SUBSTRATE_RESPONSE_SCHEMA;
    operation: LocalSubstrateOperation;
    status: LocalSubstrateResponseStatus;
    record_hash?: string;
    receipt_id?: string;
    rejection_reason?: string;
    warnings?: string[];
    health_report?: LocalSubstrateHealthReport;
}
export interface LocalSubstrateValidationIssue {
    path: string;
    message: string;
}
export interface LocalSubstrateValidationResult {
    ok: boolean;
    issues: LocalSubstrateValidationIssue[];
}
export interface ValidateLocalSubstrateRequestOptions {
    expectedHarnessClass?: LocalSubstrateHarnessClass;
    directRecordBody?: UnsignedAtribRecord;
}
export interface ValidateLocalSubstrateResponseOptions {
    request?: LocalSubstrateCoordinatorRequest;
}
export interface LocalSubstrateTransportOptions {
    timeoutMs: number;
    signal?: AbortSignal;
}
export type LocalSubstrateCoordinatorTransport = (request: LocalSubstrateCoordinatorRequest, options: LocalSubstrateTransportOptions) => Promise<unknown>;
export interface TryLocalSubstrateCoordinatorOptions extends ValidateLocalSubstrateRequestOptions {
    transport: LocalSubstrateCoordinatorTransport;
    timeoutMs?: number;
    now?: () => number;
}
export type TryLocalSubstrateCoordinatorResult = {
    ok: true;
    status: 'accepted';
    response: LocalSubstrateCoordinatorResponse;
    elapsed_ms: number;
} | {
    ok: false;
    status: 'invalid_request';
    issues: LocalSubstrateValidationIssue[];
    elapsed_ms: number;
} | {
    ok: false;
    status: 'invalid_response';
    issues: LocalSubstrateValidationIssue[];
    raw_response: unknown;
    elapsed_ms: number;
} | {
    ok: false;
    status: 'rejected';
    response: LocalSubstrateCoordinatorResponse;
    reason?: string;
    elapsed_ms: number;
} | {
    ok: false;
    status: 'unavailable';
    reason: string;
    elapsed_ms: number;
};
export interface CreateHttpLocalSubstrateTransportOptions {
    fetch?: typeof fetch;
    headers?: Record<string, string>;
}
export interface LocalSubstrateCoordinatorService {
    transport: LocalSubstrateCoordinatorTransport;
    health: () => LocalSubstrateHealthProbeResult;
}
export interface LocalSubstrateCoordinatorHttpOptions {
    endpointPath?: string;
    healthPath?: string;
    timeoutMs?: number;
}
export interface LocalSubstrateCoordinatorHttpResult {
    status: number;
    headers: Record<string, string>;
    body: string;
}
export interface BuildLocalSubstrateHealthReportInput {
    coordinator: {
        pid: number;
        version: string;
        transport: string;
        creatorKeyScope?: string;
    };
    queues?: {
        logSubmissionDepth?: number;
        archiveSubmissionDepth?: number;
    };
    wal?: {
        pending?: number;
        joined?: number;
        orphanReceipts?: number;
    };
    activeContextIds?: readonly string[];
    activeWrapperPids?: readonly number[];
    staleChildPids?: readonly number[];
    activeWrappers?: number;
    staleChildren?: number;
}
export interface LocalSubstrateHealthProbeResult {
    ok: boolean;
    status: 'healthy' | 'degraded' | 'invalid';
    report: LocalSubstrateHealthReport;
    issues: LocalSubstrateValidationIssue[];
    warnings: string[];
}
export interface LocalSubstrateCoordinatorRecordContext {
    request: LocalSubstrateCoordinatorRequest;
    record_hash: string;
    receipt_id: string;
}
export type LocalSubstrateCoordinatorRecordObserver = (record: AtribRecord, context: LocalSubstrateCoordinatorRecordContext) => void | Promise<void>;
export type LocalSubstrateHealthValue<T> = T | (() => T);
export interface InProcessLocalSubstrateCoordinatorHealthOptions {
    pid?: number;
    version?: string;
    transport?: string;
    creatorKeyScope?: string;
    logSubmissionDepth?: LocalSubstrateHealthValue<number>;
    archiveSubmissionDepth?: LocalSubstrateHealthValue<number | undefined>;
    walPending?: LocalSubstrateHealthValue<number>;
    walJoined?: LocalSubstrateHealthValue<number | undefined>;
    walOrphanReceipts?: LocalSubstrateHealthValue<number>;
    activeContextIds?: LocalSubstrateHealthValue<readonly string[]>;
    activeWrapperPids?: LocalSubstrateHealthValue<readonly number[] | undefined>;
    staleChildPids?: LocalSubstrateHealthValue<readonly number[] | undefined>;
    activeWrappers?: LocalSubstrateHealthValue<number | undefined>;
    staleChildren?: LocalSubstrateHealthValue<number | undefined>;
}
export interface CreateInProcessLocalSubstrateCoordinatorOptions {
    creatorKey: string;
    supportedHarnessClasses?: readonly LocalSubstrateHarnessClass[];
    logEndpoint?: string;
    logSubmission?: 'enabled' | 'disabled';
    archiveSubmission?: ArchiveSubmissionOptions;
    maxQueueDepth?: number;
    onRecord?: LocalSubstrateCoordinatorRecordObserver;
    health?: InProcessLocalSubstrateCoordinatorHealthOptions;
}
export interface InProcessLocalSubstrateCoordinator {
    transport: LocalSubstrateCoordinatorTransport;
    health: () => LocalSubstrateHealthProbeResult;
    flush: () => Promise<void>;
    getProof: (recordHash: string) => ProofBundle | undefined;
    destroy: () => void;
}
export interface LocalSubstrateFixture {
    name: string;
    harness_class: LocalSubstrateHarnessClass;
    input: {
        coordinator_request: LocalSubstrateCoordinatorRequest;
        direct_record_body: UnsignedAtribRecord;
        health_report: LocalSubstrateHealthReport;
    };
    expected: {
        record_bytes_unchanged: true;
        canonical_record_body_sha256: string;
        fallback_required: true;
    };
}
export interface ValidateLocalSubstrateFixtureOptions {
    expectedName?: string;
    expectedHarnessClass?: LocalSubstrateHarnessClass;
}
export declare function canonicalLocalSubstrateRecordBody(recordBody: UnsignedAtribRecord): Uint8Array;
export declare function hashLocalSubstrateRecordBody(recordBody: UnsignedAtribRecord): string;
export declare function localSubstrateRecordBodiesEqual(a: UnsignedAtribRecord, b: UnsignedAtribRecord): boolean;
export declare function validateLocalSubstrateRequest(request: unknown, options?: ValidateLocalSubstrateRequestOptions): LocalSubstrateValidationResult;
export declare function validateLocalSubstrateHealthReport(report: unknown): LocalSubstrateValidationResult;
export declare function validateLocalSubstrateResponse(response: unknown, options?: ValidateLocalSubstrateResponseOptions): LocalSubstrateValidationResult;
export declare function tryLocalSubstrateCoordinator(request: LocalSubstrateCoordinatorRequest, options: TryLocalSubstrateCoordinatorOptions): Promise<TryLocalSubstrateCoordinatorResult>;
export declare function createHttpLocalSubstrateTransport(endpoint: string, options?: CreateHttpLocalSubstrateTransportOptions): LocalSubstrateCoordinatorTransport;
export declare function handleLocalSubstrateCoordinatorHttpRequest(coordinator: LocalSubstrateCoordinatorService, method: string, pathname: string, body?: unknown, options?: LocalSubstrateCoordinatorHttpOptions): Promise<LocalSubstrateCoordinatorHttpResult | null>;
export declare function createLocalSubstrateCoordinatorHttpHandler(coordinator: LocalSubstrateCoordinatorService, options?: LocalSubstrateCoordinatorHttpOptions): (request: Request) => Promise<Response | null>;
export declare function buildLocalSubstrateHealthReport(input: BuildLocalSubstrateHealthReportInput): LocalSubstrateHealthReport;
export declare function probeLocalSubstrateHealth(input: BuildLocalSubstrateHealthReportInput): LocalSubstrateHealthProbeResult;
export declare function createInProcessLocalSubstrateCoordinator(options: CreateInProcessLocalSubstrateCoordinatorOptions): InProcessLocalSubstrateCoordinator;
export declare function validateLocalSubstrateFixture(fixture: unknown, options?: ValidateLocalSubstrateFixtureOptions): LocalSubstrateValidationResult;
//# sourceMappingURL=local-substrate.d.ts.map