/** * 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. * * E.get(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. * * E.when(x, res, rej) is equivalent to HandledPromise.resolve(x).then(res, rej) */ export const E: ((x: T) => ECallableOrMethods>) & { readonly get: (x: T) => EGetters>; readonly resolve: { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; }; readonly sendOnly: (x: T) => ESendOnlyCallableOrMethods>; readonly when: (x: T | PromiseLike, onfulfilled?: (value: T) => ERef, onrejected?: (reason: any) => ERef) => Promise; }; export { hp as HandledPromise }; export * from "./exports.js"; import type { RemoteFunctions } from './E.js'; import type { ECallableOrMethods } from './E.js'; import type { LocalRecord } from './E.js'; import type { EGetters } from './E.js'; import type { ESendOnlyCallableOrMethods } from './E.js'; import type { ERef } from './E.js'; /** @import {Handler, HandledExecutor} from './handled-promise.js' */ /** @import {ECallableOrMethods, EGetters, ERef, ESendOnlyCallableOrMethods, LocalRecord, RemoteFunctions} from './E.js' */ declare const hp: { new (executor: HandledExecutor, unfulfilledHandler?: Handler>): Promise; prototype: Promise; } & PromiseConstructor & import("./handled-promise.js").HandledPromiseStaticMethods; import type { HandledExecutor } from './handled-promise.js'; import type { Handler } from './handled-promise.js'; //# sourceMappingURL=no-shim.d.ts.map