import { Faculty, type BeingClass, type Stance } from '../being/index.ts';
import type { RootRequest } from './root-line.ts';
import type { Terrain } from './terrain.ts';
export interface Arrivals {
    arrive(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
}
export interface Ground extends Arrivals {
    readonly terrain: Terrain;
}
export declare const groundOf: (stance: Stance) => Ground;
export declare const UNDIALED: unique symbol;
export type Dialed = Uint8Array | null | typeof UNDIALED;
export type WebListen = {
    host: string;
    port: number;
    path: string;
    origins: string[];
};
export interface WebListener {
    readonly at: string[];
    readonly port: number;
    close(): Promise<void>;
}
export type WebServe = (ground: Arrivals, listen: WebListen) => Promise<WebListener>;
export interface TcpListening {
    readonly at: string;
    close(): Promise<void>;
}
export interface Sockets {
    dial(address: string, pk: string, bytes: Uint8Array): Promise<Dialed>;
    listen(ground: Arrivals, host: string, port: number): Promise<TcpListening>;
    close(): Promise<void>;
}
export declare abstract class CarrierFaculty extends Faculty {
    static readonly kind: string;
    static readonly carries: string | null;
    abstract accepts(address: string): boolean;
    abstract dial(address: string, pk: string, bytes: Uint8Array): Promise<Dialed>;
    listening(): string[];
    relay(_pk: string, _bytes: Uint8Array): Promise<Uint8Array | null> | null;
    heard(): Promise<void>;
    awake(): Promise<void>;
    sleep(): Promise<void>;
}
export declare const carrierIn: (beings: Readonly<Record<string, {
    class: string;
}>>, classes: readonly BeingClass[], carries: string) => {
    key: string;
    open?: RootRequest;
} | null;