export interface ReadOnlyGrain {
    get: () => Promise<any>;
    subscribe: (listener: Listener) => Promise<RemoveListener>;
}
export declare type Listener = (updatedValue: any) => void;
export declare type RemoveListener = () => void;
export interface AbstractGrain extends ReadOnlyGrain {
    set: (newValue: any) => Promise<any>;
    there: (expression: string) => Promise<Grain | ExclusiveGrain>;
}
export interface Grain extends AbstractGrain {
    getExclusive: () => Promise<ExclusiveGrain>;
}
export interface ExclusiveGrain extends AbstractGrain {
    release: () => Promise<Grain>;
}
export interface ReadOnlyGrainMap {
    get: (key: string) => Promise<any>;
    subscribe: (key: string, listener: Listener) => Promise<RemoveListener>;
    getGrain: (key: string) => Promise<ReadOnlyGrain>;
}
export interface GrainMap extends ReadOnlyGrainMap {
    set: (key: string, value: any) => Promise<any>;
    lock: (key: string) => Promise<Unlock>;
    there: (code: string) => Promise<any>;
    getGrain: (key: string) => Promise<Grain>;
}
export declare type GrainMapGenerator = (bootstrap: {
    [key: string]: any;
}) => GrainMap;
export declare type GrainGenerator = (value: any) => Grain;
export declare type Unlock = () => Promise<Grain>;
export declare type CaptpWsServerGenerator = (bootstrap: ServerBootstrap, port: number) => void;
export declare type CaptpWsClientGenerator = (address: string) => CapTpSetup;
declare type CapTpSetup = {
    getBootstrap: () => HandledPromise;
    abort: () => void;
    E: EProxy;
};
declare type ServerBootstrap = Object;
declare type Property = string | number | symbol;
interface EHandler<T> {
    get?: (p: T, name: Property) => any;
    applyMethod?: (p: T, name: Property, args: unknown[]) => any;
}
declare type HandledExecutor<R> = (resolveHandled: (value?: R) => void, rejectHandled: (reason?: unknown) => void, resolveWithPresence: (presenceHandler: EHandler<{}>) => object) => void;
interface HandledPromiseConstructor {
    new <R>(executor: HandledExecutor<R>, unfulfilledHandler: EHandler<Promise<unknown>>): any;
    prototype: Promise<unknown>;
    applyFunction(target: unknown, args: unknown[]): Promise<unknown>;
    applyFunctionSendOnly(target: unknown, args: unknown[]): void;
    applyMethod(target: unknown, prop: Property, args: unknown[]): Promise<unknown>;
    applyMethodSendOnly(target: unknown, prop: Property, args: unknown[]): void;
    get(target: unknown, prop: Property): Promise<unknown>;
    getSendOnly(target: unknown, prop: Property): void;
    resolve(target: unknown): Promise<any>;
}
declare type HandledPromise = HandledPromiseConstructor;
interface ESingleMethod<R = Promise<unknown>> {
    (...args: unknown[]): R;
    readonly [prop: string]: (...args: unknown[]) => R;
}
interface ESingleGet<R = Promise<unknown>> {
    readonly [prop: string]: R;
}
interface ESendOnly {
    (x: unknown): ESingleMethod<void>;
    G(x: unknown): ESingleGet<void>;
}
interface EProxy {
    /**
     * E(x) returns a proxy on which you can call arbitrary methods. Each of
     * these method calls returns a promise. The method will be invoked on
     * whatever 'x' designates (or resolves to) in a future turn, not this
     * one.
     *
     * @param {*} x target for method call
     * @returns {ESingleMethod} method call proxy
     */
    (x: unknown): ESingleMethod;
    /**
     * E.G(x) returns a proxy on which you can get arbitrary properties.
     * Each of these properties returns a promise for the property.  The promise
     * value will be the property fetched from whatever 'x' designates (or resolves to)
     * in a future turn, not this one.
     *
     * @param {*} x target for property get
     * @returns {ESingleGet} property get proxy
     */
    G(x: unknown): ESingleGet;
    /**
     * E.when(x, res, rej) is equivalent to HandledPromise.resolve(x).then(res, rej)
     */
    when(x: unknown, onfulfilled?: (value: unknown) => unknown | PromiseLike<unknown>, onrejected?: (reason: any) => PromiseLike<never>): Promise<unknown>;
    /**
     * E.sendOnly returns a proxy similar to E, but for which the results
     * are ignored (undefined is returned).
     */
    readonly sendOnly: ESendOnly;
}
export {};