import type { JsonValue } from "../../core/types.js";
import type { LiveMapLibraries } from "../../types/livemap.types.js";
import type { LocusActionAuthorizer, LocusActionPayloads, LocusClientActionResult, LocusConnectionContext, LocusDisposer, LocusSessionId, LocusSessionOptions, LocusActionDedupeOptions, LocusSchema, LocusSocketLike } from "../../types/locus.types.js";
import { make_locus_action_dedupe_store } from "./locus.actions.js";
import { make_locus_session_manager } from "./locus.session.js";
import { type LocusHostedAggregate, type LocusHostedAggregateAction, type LocusHostedAggregateGateInput } from "./locus.hosted-multi-library.js";
/** The established Locus retained live-history budget. */
export declare const DEFAULT_LOCUS_HOSTED_AGGREGATE_HISTORY_BYTES: number;
export type LocusHostedAggregateSocketOptions<TActions extends LocusActionPayloads = LocusActionPayloads> = Readonly<{
    map: LiveMapLibraries;
    actions?: Readonly<Record<string, LocusHostedAggregateAction>>;
    gate?: (input: LocusHostedAggregateGateInput) => void | Promise<void>;
    maxWireBytes?: number;
    maxHistoryBytes?: number;
    authorizeAction?: LocusActionAuthorizer<TActions>;
    sessionId?: LocusSessionId | (() => LocusSessionId);
    sessions?: LocusSessionOptions;
    actionDedupe?: LocusActionDedupeOptions;
    schema?: Pick<LocusSchema<JsonValue | undefined, TActions>, "actions">;
    /** Internal deterministic interleave seam for pending-live proof coverage. */
    internal?: Readonly<{
        afterRecoveryCut?: () => void | Promise<void>;
        beforeRecoveryCaughtUp?: () => void | Promise<void>;
        afterRecoveryCaughtUp?: () => void | Promise<void>;
        acquireActionActivity?: () => LocusDisposer;
        acquireSessionActivity?: () => LocusDisposer;
        acquireConnectionActivity?: () => LocusDisposer;
        acquireRecoveryActivity?: () => LocusDisposer;
    }>;
}>;
export type LocusHostedAggregateSocketServer<TActions extends LocusActionPayloads = LocusActionPayloads> = Readonly<{
    map: LiveMapLibraries;
    readonly logicalMapId: string;
    readonly incarnationId: string;
    readonly registryDigest: string;
    readonly rev: number;
    connect: (socket: LocusSocketLike, context?: LocusConnectionContext) => LocusDisposer;
    mutate: LocusHostedAggregate["mutate"];
    dispatch_action: LocusHostedAggregate["dispatch_action"];
    dispatch_message: (message: import("../../types/locus.types.js").LocusClientActionMessage) => Promise<LocusClientActionResult>;
    sessions: Readonly<{
        debug: ReturnType<typeof make_locus_session_manager>["debug"];
        onChange: ReturnType<typeof make_locus_session_manager>["onChange"];
        dispose: () => void;
    }>;
    actionRequests: Readonly<{
        debug: ReturnType<typeof make_locus_action_dedupe_store>["debug"];
        dispose: () => void;
    }>;
    /** Ordered internal barrier used by persistence checkpointing. */
    run_exclusive: LocusHostedAggregate["run_exclusive"];
    debug: () => Readonly<{
        historyBaseRevision: number;
        retainedHistoryBytes: number;
        retainedCommits: number;
        connections: number;
        effectiveLiveWireBytes: number;
        effectiveSnapshotWireBytes: number;
    }>;
    dispose: () => void;
}>;
/**
 * Aggregate transport authority. It deliberately owns one aggregate
 * Locus, one global retained history and one map-wide recovery cut; it does
 * not route a library through the legacy solo Locus representation.
 */
export declare function create_locus_hosted_aggregate_socket_internal<TActions extends LocusActionPayloads = LocusActionPayloads>(options: LocusHostedAggregateSocketOptions<TActions>): LocusHostedAggregateSocketServer<TActions>;
//# sourceMappingURL=locus.hosted-multi-library.socket.d.ts.map