import { Custody, Loader, Memory, type Entropy, type Module } from '../contract/index.ts';
import { type Carried, type Defaults, type Dialed, type GroundProbe, type Sockets, type TcpListening, type WebListen } from '../harbor/index.ts';
import { PointerTerrain } from '../pointer/index.ts';
export type { Carried } from '../harbor/index.ts';
export declare const EDGE = "edge";
export interface EdgeStorage {
    get(key: string): Promise<unknown>;
    put(entries: Record<string, unknown>): Promise<void>;
    delete(keys: string[]): Promise<number>;
    list(options: {
        prefix: string;
    }): Promise<Map<string, unknown>>;
    transaction<T>(work: (txn: EdgeStorage) => Promise<T>): Promise<T>;
}
export interface EdgeState {
    readonly storage: EdgeStorage;
    blockConcurrencyWhile<T>(work: () => Promise<T>): Promise<T>;
}
export type EdgeEnv = {
    readonly NERVUR_SECRET?: string;
};
export type EdgeGiven = {
    readonly state: EdgeState;
    readonly env: EdgeEnv;
    readonly loader?: EdgeLoader;
    readonly calls?: ChildCalls;
    readonly package?: Packed;
};
export type CarriedModule = {
    readonly blob: string;
    readonly module: unknown;
};
export type CallContext = {
    run<R>(call: number, work: () => R): R;
    getStore(): number | undefined;
};
export declare class ChildCalls {
    #private;
    constructor(context?: CallContext);
    run<R>(call: number, work: () => R): R;
    refused(): void;
    kept(): void;
    again(call: number): boolean;
}
export declare class EdgeLoader extends Loader {
    #private;
    constructor(carried?: readonly CarriedModule[], calls?: ChildCalls);
    get carried(): string[];
    refuse(refused: Readonly<Record<string, string>>): void;
    get refused(): ReadonlyMap<string, string>;
    load(source: string, id: string): Promise<Module>;
    get missing(): boolean;
    missed(): Map<string, string>;
}
export type Packed = {
    readonly sealed: string;
    readonly places: Carried['places'];
};
export type Pack = Record<string, Packed>;
export declare const isHarborName: (name: unknown) => name is string;
export declare const readPack: (value: unknown) => Pack | null;
export declare const sealSeed: (secret: string, seed: Uint8Array, entropy?: Entropy) => Promise<string>;
export declare class EdgeMemory extends Memory {
    #private;
    constructor(storage: EdgeStorage, root?: string, voided?: () => boolean, calls?: ChildCalls);
    read(place: string): Promise<Map<string, Uint8Array>>;
    write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
    places(): Promise<string[]>;
    forget(place: string): Promise<void>;
}
export declare class EdgeCustody extends Custody {
    #private;
    constructor(storage: EdgeStorage, secret: string | undefined, entropy?: Entropy, root?: string);
    kept(): Promise<boolean>;
    land(sealed: string, txn?: EdgeStorage): Promise<void>;
    seed(): Promise<Uint8Array>;
}
export declare class EdgeSockets implements Sockets {
    #private;
    dial(address: string, pk: string, bytes: Uint8Array): Promise<Dialed>;
    listen(): Promise<TcpListening>;
    close(): Promise<void>;
}
export type EdgeParts = {
    readonly given: EdgeGiven;
    readonly defaults: Defaults;
};
export declare class EdgeTerrain extends PointerTerrain {
    #private;
    readonly given: EdgeGiven;
    constructor(parts: EdgeParts);
    get listening(): WebListen | undefined;
    claim(): Promise<void>;
}
export declare const edgeGround: GroundProbe;
export declare const harborNameOf: (request: Request) => string | null;
export type Wanted = {
    readonly live: string;
    readonly liveBlobs: readonly string[];
    readonly modules: Readonly<Record<string, string>>;
    readonly missed: readonly string[];
};
export type Opened = {
    readonly listen: WebListen | null;
    readonly wanted: Wanted | null;
};
export type Arrived = {
    readonly reply: Uint8Array | null;
    readonly wanted: Wanted | null;
    readonly again: boolean;
};
export declare const childKey: (live: string, blobs: readonly string[], liveBlobs: readonly string[]) => string;
export declare class HarborChild {
    #private;
    constructor(state: EdgeState, env: EdgeEnv, key: string, carried: readonly CarriedModule[], context: CallContext);
    open(name: string, host: string, port: number, packed: Packed | null, refused: Readonly<Record<string, string>>): Promise<Opened>;
    arrive(pk: string, box: Uint8Array, call: number): Promise<Arrived>;
}
type WorkerCode = {
    readonly compatibilityDate: string;
    readonly compatibilityFlags?: readonly string[];
    readonly mainModule: string;
    readonly modules: Record<string, {
        js: string;
    }>;
    readonly env: Record<string, unknown>;
};
type LoadedWorker = {
    getDurableObjectClass(name: string): unknown;
    getEntrypoint(): {
        fetch(request: Request): Promise<Response>;
    };
};
export type WorkerLoader = {
    get(id: string, code: () => Promise<WorkerCode>): LoadedWorker;
};
type ChildStub = {
    open(name: string, host: string, port: number, packed: Packed | null, refused: Record<string, string>): Promise<Opened>;
    arrive(pk: string, box: Uint8Array, call: number): Promise<Arrived>;
};
type Facets = {
    get(name: string, start: () => Promise<{
        class: unknown;
    }>): ChildStub;
    abort(name: string, reason: unknown): void;
};
export type ShellState = {
    readonly facets: Facets;
};
export type ShellEnv = EdgeEnv & {
    readonly LOADER?: WorkerLoader;
};
export type HarborShellParts = {
    readonly kit: string;
    readonly pack: Pack | ((env: EdgeEnv) => Pack | undefined);
};
export type HarborShell = {
    fetch(request: Request): Promise<Response>;
};
export type HarborShellClass = new (state: ShellState, env: ShellEnv) => HarborShell;
export declare const harborShell: ({ kit, pack }: HarborShellParts) => HarborShellClass;
export declare const harborWorker: (binding?: string) => {
    fetch(request: Request, env: Record<string, unknown>): Promise<Response>;
};