export type MultiplayerTopology = "shared" | "lobbies" | "private";
/**
 * Where the world simulation is authoritative.
 *
 * - `"client"` (default when omitted) — **presence-only multiplayer**: each client runs its own `onTick` and
 *   syncs presence / feeds / chat. Not competitive-safe; do not treat it as a shared sim.
 * - `"server"` — host-authoritative world replication: the host runs the loop; the shell mirrors the host's
 *   world into the local `ctx` instead of simulating locally.
 *
 * Prefer naming the product intent in game code: pass `authority: "server"` for shared worlds, leave unset or
 * `"client"` only for co-op presence / lobbies that intentionally tick independently.
 */
export type MultiplayerAuthority = "server" | "client";
export type MultiplayerAdapterConfig = {
    kind: "convex";
    topology?: MultiplayerTopology;
    authority?: MultiplayerAuthority;
} | {
    kind: "ws";
    topology?: MultiplayerTopology;
    url?: string;
    authority?: MultiplayerAuthority;
} | {
    kind: "socketio";
    topology?: MultiplayerTopology;
    url?: string;
    authority?: MultiplayerAuthority;
} | {
    kind: "p2p";
    topology?: MultiplayerTopology;
    room?: string;
    authority?: MultiplayerAuthority;
} | {
    kind: "lan";
    topology?: MultiplayerTopology;
    port?: number;
    path?: string;
    authority?: MultiplayerAuthority;
} | {
    kind: "offline";
};
/**
 * Convex transport. Omitting `authority` (or passing `"client"`) is **presence-only** — prefer
 * `convexPresence()` to name that intent explicitly. Pass `{ authority: "server" }` for a shared,
 * host-authoritative world — see `examples/HOSTED.md`.
 */
export declare function convex(config?: {
    topology?: MultiplayerTopology;
    authority?: MultiplayerAuthority;
}): MultiplayerAdapterConfig;
/** Presence-only Convex transport — each client runs its own `onTick`; only presence/feeds/chat sync. Sugar for `convex({ ...config, authority: "client" })`. */
export declare function convexPresence(config?: {
    topology?: MultiplayerTopology;
}): MultiplayerAdapterConfig;
/**
 * WebSocket transport. Omitting `authority` (or passing `"client"`) is **presence-only** — prefer
 * `wsPresence()` to name that intent explicitly. Pass `{ authority: "server" }` for a shared,
 * host-authoritative world — see `examples/HOSTED.md`.
 *
 * @capability multiplayer-ws server-hosted shared world over WebSocket — `multiplayer: ws({ authority: "server" })`
 */
export declare function ws(config?: {
    topology?: MultiplayerTopology;
    url?: string;
    authority?: MultiplayerAuthority;
}): MultiplayerAdapterConfig;
/** Presence-only WebSocket transport — each client runs its own `onTick`; only presence/feeds/chat sync. Sugar for `ws({ ...config, authority: "client" })`. */
export declare function wsPresence(config?: {
    topology?: MultiplayerTopology;
    url?: string;
}): MultiplayerAdapterConfig;
export declare function fly(config: {
    app: string;
    topology?: MultiplayerTopology;
    path?: string;
    authority?: MultiplayerAuthority;
}): MultiplayerAdapterConfig;
export declare function socketIo(config?: {
    topology?: MultiplayerTopology;
    url?: string;
    authority?: MultiplayerAuthority;
}): MultiplayerAdapterConfig;
/**
 * Serverless peer-to-peer (WebRTC) session — one peer hosts, friends join by room code.
 *
 * @capability multiplayer-p2p serverless co-op over WebRTC — `multiplayer: p2p({ room })`
 */
export declare function p2p(config?: {
    topology?: MultiplayerTopology;
    room?: string;
    authority?: MultiplayerAuthority;
}): MultiplayerAdapterConfig;
export declare function lan(config?: {
    topology?: MultiplayerTopology;
    port?: number;
    path?: string;
    authority?: MultiplayerAuthority;
}): MultiplayerAdapterConfig;
/** True when the adapter opts into host-authoritative world replication (`authority: "server"`). */
export declare function isServerAuthoritative(multiplayer: unknown): boolean;
/**
 * Resolved authority for a multiplayer config.
 * - `offline` / missing adapter → `null` (single-player; not multiplayer authority).
 * - unset or `"client"` → `"client"` (presence-only; each client ticks).
 * - `"server"` → host-authoritative shared sim.
 */
export declare function resolveAuthority(multiplayer: unknown): MultiplayerAuthority | null;
/**
 * True when multiplayer is on but the world sim is not host-authoritative — presence/feeds/chat only.
 * Equivalent to `resolveAuthority(m) === "client"`.
 */
export declare function isPresenceOnly(multiplayer: unknown): boolean;
/** True for a single-player world — no adapter, or an explicit `offline()` one. Gates offline-only wiring like local whole-world save. */
export declare function isOffline(multiplayer: unknown): boolean;
/**
 * Explicit single-player adapter. Solo games never need this — omitting `multiplayer` in the shell
 * `defineGame` already defaults to offline; pass it only where an adapter value is structurally required.
 *
 * @capability multiplayer-offline explicit solo adapter — omit `multiplayer` instead; offline is the shell default
 */
export declare function offline(): MultiplayerAdapterConfig;
export declare function adapterOf(multiplayer: unknown): MultiplayerAdapterConfig | null;
export declare function multiplayerAdapterKind(multiplayer: unknown): string | null;
export type ServersPoolConfig = {
    minPlayersToStart?: number;
    adapter: MultiplayerAdapterConfig;
} & ({
    topology: "shared";
    maxServers?: number;
    slotsPerServer?: number;
} | {
    topology?: "rooms";
    maxServers: number;
    slotsPerServer: number;
});
/** Resolve the shared-world pool to one unbounded world; room pools keep explicit capacities. */
export declare function servers(config: ServersPoolConfig): {
    minPlayersToStart?: number;
    adapter: MultiplayerAdapterConfig;
    topology: "rooms" | "shared";
    maxServers: number;
    slotsPerServer: number;
} | {
    minPlayersToStart?: number;
    adapter: MultiplayerAdapterConfig;
    topology: "rooms" | "shared";
    maxServers: number;
    slotsPerServer: number;
};