@stryke/capnp 0.8.3 → 0.9.1

package/dts/index.d.cts

@@ -0,0 +1,4393 @@
+import { MessagePort as MessagePort$1 } from 'node:worker_threads';
+import { ParsedCommandLine } from 'typescript';
+
+export declare enum ListElementSize {
+	VOID = 0,
+	BIT = 1,
+	BYTE = 2,
+	BYTE_2 = 3,
+	BYTE_4 = 4,
+	BYTE_8 = 5,
+	POINTER = 6,
+	COMPOSITE = 7
+}
+/**
+ * A simple object that describes the size of a struct.
+ */
+export declare class ObjectSize {
+	readonly dataByteLength: number;
+	readonly pointerLength: number;
+	/**
+	 * Creates a new ObjectSize instance.
+	 *
+	 * @param dataByteLength - The number of bytes in the data section of the struct
+	 * @param pointerLength - The number of pointers in the pointer section of the struct
+	 */
+	constructor(dataByteLength: number, pointerLength: number);
+	toString(): string;
+}
+export interface _PointerCtor {
+	readonly displayName: string;
+}
+export interface PointerCtor<T extends Pointer> {
+	readonly _capnp: _PointerCtor;
+	new (segment: Segment, byteOffset: number, depthLimit?: number): T;
+}
+export declare enum PointerType {
+	STRUCT = 0,
+	LIST = 1,
+	FAR = 2,
+	OTHER = 3
+}
+export interface _Pointer {
+	compositeIndex?: number;
+	compositeList: boolean;
+	/**
+	 * A number that is decremented as nested pointers are traversed. When this hits zero errors will be thrown.
+	 */
+	depthLimit: number;
+}
+/**
+ * A pointer referencing a single byte location in a segment. This is typically used for Cap'n Proto pointers, but is
+ * also sometimes used to reference an offset to a pointer's content or tag words.
+ */
+export declare class Pointer<T extends _Pointer = _Pointer> {
+	static readonly _capnp: _PointerCtor;
+	readonly _capnp: T;
+	/** Offset, in bytes, from the start of the segment to the beginning of this pointer. */
+	byteOffset: number;
+	/**
+	 * The starting segment for this pointer's data. In the case of a far pointer, the actual content this pointer is
+	 * referencing will be in another segment within the same message.
+	 */
+	segment: Segment;
+	constructor(segment: Segment, byteOffset: number, depthLimit?: number);
+	[Symbol.toStringTag](): string;
+	toString(): string;
+}
+export interface _ListCtor {
+	readonly compositeSize?: ObjectSize;
+	readonly displayName: string;
+	readonly size: ListElementSize;
+}
+export interface ListCtor<T> {
+	readonly _capnp: _ListCtor;
+	new (segment: Segment, byteOffset: number, depthLimit?: number): List<T>;
+}
+export type ArrayCb<T, RT = boolean> = (this: any, value: T, index: number, array: T[]) => RT;
+/**
+ * A generic list class. Implements Filterable,
+ */
+export declare class List<T> extends Pointer implements Array<T> {
+	#private;
+	static readonly _capnp: _ListCtor;
+	[n: number]: T;
+	constructor(segment: Segment, byteOffset: number, depthLimit?: number);
+	get length(): number;
+	toArray(): T[];
+	get(_index: number): T;
+	set(_index: number, _value: T): void;
+	at(index: number): T;
+	concat(other: T[]): T[];
+	some(cb: ArrayCb<T>, _this?: any): boolean;
+	filter(cb: ArrayCb<T>, _this?: any): T[];
+	find(cb: ArrayCb<T>, _this?: any): T | undefined;
+	findIndex(cb: (v: T, i: number, arr: T[]) => boolean, _this?: any): number;
+	forEach(cb: ArrayCb<T, void>, _this?: any): void;
+	map<U>(cb: ArrayCb<T, U>, _this?: any): U[];
+	flatMap<U>(cb: ArrayCb<T, U | U[]>, _this?: any): U[];
+	every<S extends T>(cb: (v: T, i: number) => v is S, t?: any): this is S[];
+	reduce(cb: (p: T, c: T, i: number, a: T[]) => T, initialValue?: T): T;
+	reduceRight(cb: (p: T, c: T, i: number, a: T[]) => T, initialValue?: T): T;
+	slice(start?: number, end?: number): T[];
+	join(separator?: string): string;
+	toReversed(): T[];
+	toSorted(compareFn?: ((a: T, b: T) => number) | undefined): T[];
+	toSpliced(start: number, deleteCount: number, ...items: T[]): T[];
+	fill(value: T, start?: number, end?: number): this;
+	copyWithin(target: number, start: number, end?: number): this;
+	keys(): ArrayIterator<number>;
+	values(): ArrayIterator<T>;
+	entries(): ArrayIterator<[
+		number,
+		T
+	]>;
+	flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
+	with(index: number, value: T): T[];
+	includes(_searchElement: T, _fromIndex?: number): boolean;
+	findLast(_cb: unknown, _thisArg?: unknown): T | undefined;
+	findLastIndex(_cb: (v: T, i: number, a: T[]) => unknown, _t?: any): number;
+	indexOf(_searchElement: T, _fromIndex?: number): number;
+	lastIndexOf(_searchElement: T, _fromIndex?: number): number;
+	pop(): T | undefined;
+	push(..._items: T[]): number;
+	reverse(): T[];
+	shift(): T | undefined;
+	unshift(..._items: T[]): number;
+	splice(_start: unknown, _deleteCount?: unknown, ..._rest: unknown[]): T[];
+	sort(_fn?: ((a: T, b: T) => number) | undefined): this;
+	get [Symbol.unscopables](): {
+		[x: number]: boolean | undefined;
+		length?: boolean | undefined;
+		toString?: boolean | undefined;
+		toLocaleString?: boolean | undefined;
+		pop?: boolean | undefined;
+		push?: boolean | undefined;
+		concat?: boolean | undefined;
+		join?: boolean | undefined;
+		reverse?: boolean | undefined;
+		shift?: boolean | undefined;
+		slice?: boolean | undefined;
+		sort?: boolean | undefined;
+		splice?: boolean | undefined;
+		unshift?: boolean | undefined;
+		indexOf?: boolean | undefined;
+		lastIndexOf?: boolean | undefined;
+		every?: boolean | undefined;
+		some?: boolean | undefined;
+		forEach?: boolean | undefined;
+		map?: boolean | undefined;
+		filter?: boolean | undefined;
+		reduce?: boolean | undefined;
+		reduceRight?: boolean | undefined;
+		find?: boolean | undefined;
+		findIndex?: boolean | undefined;
+		fill?: boolean | undefined;
+		copyWithin?: boolean | undefined;
+		entries?: boolean | undefined;
+		keys?: boolean | undefined;
+		values?: boolean | undefined;
+		includes?: boolean | undefined;
+		flatMap?: boolean | undefined;
+		flat?: boolean | undefined;
+		at?: boolean | undefined;
+		findLast?: boolean | undefined;
+		findLastIndex?: boolean | undefined;
+		toReversed?: boolean | undefined;
+		toSorted?: boolean | undefined;
+		toSpliced?: boolean | undefined;
+		with?: boolean | undefined;
+		[Symbol.iterator]?: boolean | undefined;
+		readonly [Symbol.unscopables]?: boolean | undefined;
+	};
+	[Symbol.iterator](): ArrayIterator<T>;
+	toJSON(): unknown;
+	toString(): string;
+	toLocaleString(_locales?: unknown, _options?: unknown): string;
+	[Symbol.toStringTag](): string;
+	static [Symbol.toStringTag](): string;
+}
+declare const Message_Which: {
+	/**
+  * The sender previously received this message from the peer but didn't understand it or doesn't
+  * yet implement the functionality that was requested.  So, the sender is echoing the message
+  * back.  In some cases, the receiver may be able to recover from this by pretending the sender
+  * had taken some appropriate "null" action.
+  *
+  * For example, say `resolve` is received by a level 0 implementation (because a previous call
+  * or return happened to contain a promise).  The level 0 implementation will echo it back as
+  * `unimplemented`.  The original sender can then simply release the cap to which the promise
+  * had resolved, thus avoiding a leak.
+  *
+  * For any message type that introduces a question, if the message comes back unimplemented,
+  * the original sender may simply treat it as if the question failed with an exception.
+  *
+  * In cases where there is no sensible way to react to an `unimplemented` message (without
+  * resource leaks or other serious problems), the connection may need to be aborted.  This is
+  * a gray area; different implementations may take different approaches.
+  *
+  */
+	readonly UNIMPLEMENTED: 0;
+	/**
+  * Sent when a connection is being aborted due to an unrecoverable error.  This could be e.g.
+  * because the sender received an invalid or nonsensical message or because the sender had an
+  * internal error.  The sender will shut down the outgoing half of the connection after `abort`
+  * and will completely close the connection shortly thereafter (it's up to the sender how much
+  * of a time buffer they want to offer for the client to receive the `abort` before the
+  * connection is reset).
+  *
+  */
+	readonly ABORT: 1;
+	/**
+  * Request the peer's bootstrap interface.
+  *
+  */
+	readonly BOOTSTRAP: 8;
+	/**
+  * Begin a method call.
+  *
+  */
+	readonly CALL: 2;
+	/**
+  * Complete a method call.
+  *
+  */
+	readonly RETURN: 3;
+	/**
+  * Release a returned answer / cancel a call.
+  *
+  */
+	readonly FINISH: 4;
+	/**
+  * Resolve a previously-sent promise.
+  *
+  */
+	readonly RESOLVE: 5;
+	/**
+  * Release a capability so that the remote object can be deallocated.
+  *
+  */
+	readonly RELEASE: 6;
+	/**
+  * Lift an embargo used to enforce E-order over promise resolution.
+  *
+  */
+	readonly DISEMBARGO: 13;
+	/**
+  * Obsolete request to save a capability, resulting in a SturdyRef. This has been replaced
+  * by the `Persistent` interface defined in `persistent.capnp`. This operation was never
+  * implemented.
+  *
+  */
+	readonly OBSOLETE_SAVE: 7;
+	/**
+  * Obsolete way to delete a SturdyRef. This operation was never implemented.
+  *
+  */
+	readonly OBSOLETE_DELETE: 9;
+	/**
+  * Provide a capability to a third party.
+  *
+  */
+	readonly PROVIDE: 10;
+	/**
+  * Accept a capability provided by a third party.
+  *
+  */
+	readonly ACCEPT: 11;
+	/**
+  * Directly connect to the common root of two or more proxied caps.
+  *
+  */
+	readonly JOIN: 12;
+};
+export type Message_Which = (typeof Message_Which)[keyof typeof Message_Which];
+declare class Message$1 extends Struct {
+	static readonly UNIMPLEMENTED: 0;
+	static readonly ABORT: 1;
+	static readonly BOOTSTRAP: 8;
+	static readonly CALL: 2;
+	static readonly RETURN: 3;
+	static readonly FINISH: 4;
+	static readonly RESOLVE: 5;
+	static readonly RELEASE: 6;
+	static readonly DISEMBARGO: 13;
+	static readonly OBSOLETE_SAVE: 7;
+	static readonly OBSOLETE_DELETE: 9;
+	static readonly PROVIDE: 10;
+	static readonly ACCEPT: 11;
+	static readonly JOIN: 12;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	_adoptUnimplemented(value: Orphan<Message$1>): void;
+	_disownUnimplemented(): Orphan<Message$1>;
+	/**
+  * The sender previously received this message from the peer but didn't understand it or doesn't
+  * yet implement the functionality that was requested.  So, the sender is echoing the message
+  * back.  In some cases, the receiver may be able to recover from this by pretending the sender
+  * had taken some appropriate "null" action.
+  *
+  * For example, say `resolve` is received by a level 0 implementation (because a previous call
+  * or return happened to contain a promise).  The level 0 implementation will echo it back as
+  * `unimplemented`.  The original sender can then simply release the cap to which the promise
+  * had resolved, thus avoiding a leak.
+  *
+  * For any message type that introduces a question, if the message comes back unimplemented,
+  * the original sender may simply treat it as if the question failed with an exception.
+  *
+  * In cases where there is no sensible way to react to an `unimplemented` message (without
+  * resource leaks or other serious problems), the connection may need to be aborted.  This is
+  * a gray area; different implementations may take different approaches.
+  *
+  */
+	get unimplemented(): Message$1;
+	_hasUnimplemented(): boolean;
+	_initUnimplemented(): Message$1;
+	get _isUnimplemented(): boolean;
+	set unimplemented(value: Message$1);
+	_adoptAbort(value: Orphan<Exception>): void;
+	_disownAbort(): Orphan<Exception>;
+	/**
+  * Sent when a connection is being aborted due to an unrecoverable error.  This could be e.g.
+  * because the sender received an invalid or nonsensical message or because the sender had an
+  * internal error.  The sender will shut down the outgoing half of the connection after `abort`
+  * and will completely close the connection shortly thereafter (it's up to the sender how much
+  * of a time buffer they want to offer for the client to receive the `abort` before the
+  * connection is reset).
+  *
+  */
+	get abort(): Exception;
+	_hasAbort(): boolean;
+	_initAbort(): Exception;
+	get _isAbort(): boolean;
+	set abort(value: Exception);
+	_adoptBootstrap(value: Orphan<Bootstrap>): void;
+	_disownBootstrap(): Orphan<Bootstrap>;
+	/**
+  * Request the peer's bootstrap interface.
+  *
+  */
+	get bootstrap(): Bootstrap;
+	_hasBootstrap(): boolean;
+	_initBootstrap(): Bootstrap;
+	get _isBootstrap(): boolean;
+	set bootstrap(value: Bootstrap);
+	_adoptCall(value: Orphan<Call$1>): void;
+	_disownCall(): Orphan<Call$1>;
+	/**
+  * Begin a method call.
+  *
+  */
+	get call(): Call$1;
+	_hasCall(): boolean;
+	_initCall(): Call$1;
+	get _isCall(): boolean;
+	set call(value: Call$1);
+	_adoptReturn(value: Orphan<Return>): void;
+	_disownReturn(): Orphan<Return>;
+	/**
+  * Complete a method call.
+  *
+  */
+	get return(): Return;
+	_hasReturn(): boolean;
+	_initReturn(): Return;
+	get _isReturn(): boolean;
+	set return(value: Return);
+	_adoptFinish(value: Orphan<Finish>): void;
+	_disownFinish(): Orphan<Finish>;
+	/**
+  * Release a returned answer / cancel a call.
+  *
+  */
+	get finish(): Finish;
+	_hasFinish(): boolean;
+	_initFinish(): Finish;
+	get _isFinish(): boolean;
+	set finish(value: Finish);
+	_adoptResolve(value: Orphan<Resolve>): void;
+	_disownResolve(): Orphan<Resolve>;
+	/**
+  * Resolve a previously-sent promise.
+  *
+  */
+	get resolve(): Resolve;
+	_hasResolve(): boolean;
+	_initResolve(): Resolve;
+	get _isResolve(): boolean;
+	set resolve(value: Resolve);
+	_adoptRelease(value: Orphan<Release>): void;
+	_disownRelease(): Orphan<Release>;
+	/**
+  * Release a capability so that the remote object can be deallocated.
+  *
+  */
+	get release(): Release;
+	_hasRelease(): boolean;
+	_initRelease(): Release;
+	get _isRelease(): boolean;
+	set release(value: Release);
+	_adoptDisembargo(value: Orphan<Disembargo>): void;
+	_disownDisembargo(): Orphan<Disembargo>;
+	/**
+  * Lift an embargo used to enforce E-order over promise resolution.
+  *
+  */
+	get disembargo(): Disembargo;
+	_hasDisembargo(): boolean;
+	_initDisembargo(): Disembargo;
+	get _isDisembargo(): boolean;
+	set disembargo(value: Disembargo);
+	_adoptObsoleteSave(value: Orphan<Pointer>): void;
+	_disownObsoleteSave(): Orphan<Pointer>;
+	/**
+  * Obsolete request to save a capability, resulting in a SturdyRef. This has been replaced
+  * by the `Persistent` interface defined in `persistent.capnp`. This operation was never
+  * implemented.
+  *
+  */
+	get obsoleteSave(): Pointer;
+	_hasObsoleteSave(): boolean;
+	get _isObsoleteSave(): boolean;
+	set obsoleteSave(value: Pointer);
+	_adoptObsoleteDelete(value: Orphan<Pointer>): void;
+	_disownObsoleteDelete(): Orphan<Pointer>;
+	/**
+  * Obsolete way to delete a SturdyRef. This operation was never implemented.
+  *
+  */
+	get obsoleteDelete(): Pointer;
+	_hasObsoleteDelete(): boolean;
+	get _isObsoleteDelete(): boolean;
+	set obsoleteDelete(value: Pointer);
+	_adoptProvide(value: Orphan<Provide>): void;
+	_disownProvide(): Orphan<Provide>;
+	/**
+  * Provide a capability to a third party.
+  *
+  */
+	get provide(): Provide;
+	_hasProvide(): boolean;
+	_initProvide(): Provide;
+	get _isProvide(): boolean;
+	set provide(value: Provide);
+	_adoptAccept(value: Orphan<Accept>): void;
+	_disownAccept(): Orphan<Accept>;
+	/**
+  * Accept a capability provided by a third party.
+  *
+  */
+	get accept(): Accept;
+	_hasAccept(): boolean;
+	_initAccept(): Accept;
+	get _isAccept(): boolean;
+	set accept(value: Accept);
+	_adoptJoin(value: Orphan<Join>): void;
+	_disownJoin(): Orphan<Join>;
+	/**
+  * Directly connect to the common root of two or more proxied caps.
+  *
+  */
+	get join(): Join;
+	_hasJoin(): boolean;
+	_initJoin(): Join;
+	get _isJoin(): boolean;
+	set join(value: Join);
+	toString(): string;
+	which(): Message_Which;
+}
+declare class Bootstrap extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * A new question ID identifying this request, which will eventually receive a Return message
+  * containing the restored capability.
+  *
+  */
+	get questionId(): number;
+	set questionId(value: number);
+	_adoptDeprecatedObjectId(value: Orphan<Pointer>): void;
+	_disownDeprecatedObjectId(): Orphan<Pointer>;
+	/**
+  * ** DEPRECATED **
+  *
+  * A Vat may export multiple bootstrap interfaces. In this case, `deprecatedObjectId` specifies
+  * which one to return. If this pointer is null, then the default bootstrap interface is returned.
+  *
+  * As of version 0.5, use of this field is deprecated. If a service wants to export multiple
+  * bootstrap interfaces, it should instead define a single bootstrap interface that has methods
+  * that return each of the other interfaces.
+  *
+  * **History**
+  *
+  * In the first version of Cap'n Proto RPC (0.4.x) the `Bootstrap` message was called `Restore`.
+  * At the time, it was thought that this would eventually serve as the way to restore SturdyRefs
+  * (level 2). Meanwhile, an application could offer its "main" interface on a well-known
+  * (non-secret) SturdyRef.
+  *
+  * Since level 2 RPC was not implemented at the time, the `Restore` message was in practice only
+  * used to obtain the main interface. Since most applications had only one main interface that
+  * they wanted to restore, they tended to designate this with a null `objectId`.
+  *
+  * Unfortunately, the earliest version of the EZ RPC interfaces set a precedent of exporting
+  * multiple main interfaces by allowing them to be exported under string names. In this case,
+  * `objectId` was a Text value specifying the name.
+  *
+  * All of this proved problematic for several reasons:
+  *
+  * - The arrangement assumed that a client wishing to restore a SturdyRef would know exactly what
+  *   machine to connect to and would be able to immediately restore a SturdyRef on connection.
+  *   However, in practice, the ability to restore SturdyRefs is itself a capability that may
+  *   require going through an authentication process to obtain. Thus, it makes more sense to
+  *   define a "restorer service" as a full Cap'n Proto interface. If this restorer interface is
+  *   offered as the vat's bootstrap interface, then this is equivalent to the old arrangement.
+  *
+  * - Overloading "Restore" for the purpose of obtaining well-known capabilities encouraged the
+  *   practice of exporting singleton services with string names. If singleton services are desired,
+  *   it is better to have one main interface that has methods that can be used to obtain each
+  *   service, in order to get all the usual benefits of schemas and type checking.
+  *
+  * - Overloading "Restore" also had a security problem: Often, "main" or "well-known"
+  *   capabilities exported by a vat are in fact not public: they are intended to be accessed only
+  *   by clients who are capable of forming a connection to the vat. This can lead to trouble if
+  *   the client itself has other clients and wishes to forward some `Restore` requests from those
+  *   external clients -- it has to be very careful not to allow through `Restore` requests
+  *   addressing the default capability.
+  *
+  *   For example, consider the case of a sandboxed Sandstorm application and its supervisor. The
+  *   application exports a default capability to its supervisor that provides access to
+  *   functionality that only the supervisor is supposed to access. Meanwhile, though, applications
+  *   may publish other capabilities that may be persistent, in which case the application needs
+  *   to field `Restore` requests that could come from anywhere. These requests of course have to
+  *   pass through the supervisor, as all communications with the outside world must. But, the
+  *   supervisor has to be careful not to honor an external request addressing the application's
+  *   default capability, since this capability is privileged. Unfortunately, the default
+  *   capability cannot be given an unguessable name, because then the supervisor itself would not
+  *   be able to address it!
+  *
+  * As of Cap'n Proto 0.5, `Restore` has been renamed to `Bootstrap` and is no longer planned for
+  * use in restoring SturdyRefs.
+  *
+  * Note that 0.4 also defined a message type called `Delete` that, like `Restore`, addressed a
+  * SturdyRef, but indicated that the client would not restore the ref again in the future. This
+  * operation was never implemented, so it was removed entirely. If a "delete" operation is desired,
+  * it should exist as a method on the same interface that handles restoring SturdyRefs. However,
+  * the utility of such an operation is questionable. You wouldn't be able to rely on it for
+  * garbage collection since a client could always disappear permanently without remembering to
+  * delete all its SturdyRefs, thus leaving them dangling forever. Therefore, it is advisable to
+  * design systems such that SturdyRefs never represent "owned" pointers.
+  *
+  * For example, say a SturdyRef points to an image file hosted on some server. That image file
+  * should also live inside a collection (a gallery, perhaps) hosted on the same server, owned by
+  * a user who can delete the image at any time. If the user deletes the image, the SturdyRef
+  * stops working. On the other hand, if the SturdyRef is discarded, this has no effect on the
+  * existence of the image in its collection.
+  *
+  */
+	get deprecatedObjectId(): Pointer;
+	_hasDeprecatedObjectId(): boolean;
+	set deprecatedObjectId(value: Pointer);
+	toString(): string;
+}
+declare const Call_SendResultsTo_Which: {
+	/**
+  * Send the return message back to the caller (the usual).
+  *
+  */
+	readonly CALLER: 0;
+	/**
+  * **(level 1)**
+  *
+  * Don't actually return the results to the sender.  Instead, hold on to them and await
+  * instructions from the sender regarding what to do with them.  In particular, the sender
+  * may subsequently send a `Return` for some other call (which the receiver had previously made
+  * to the sender) with `takeFromOtherQuestion` set.  The results from this call are then used
+  * as the results of the other call.
+  *
+  * When `yourself` is used, the receiver must still send a `Return` for the call, but sets the
+  * field `resultsSentElsewhere` in that `Return` rather than including the results.
+  *
+  * This feature can be used to implement tail calls in which a call from Vat A to Vat B ends up
+  * returning the result of a call from Vat B back to Vat A.
+  *
+  * In particular, the most common use case for this feature is when Vat A makes a call to a
+  * promise in Vat B, and then that promise ends up resolving to a capability back in Vat A.
+  * Vat B must forward all the queued calls on that promise back to Vat A, but can set `yourself`
+  * in the calls so that the results need not pass back through Vat B.
+  *
+  * For example:
+  * - Alice, in Vat A, calls foo() on Bob in Vat B.
+  * - Alice makes a pipelined call bar() on the promise returned by foo().
+  * - Later on, Bob resolves the promise from foo() to point at Carol, who lives in Vat A (next
+  *   to Alice).
+  * - Vat B dutifully forwards the bar() call to Carol.  Let us call this forwarded call bar'().
+  *   Notice that bar() and bar'() are travelling in opposite directions on the same network
+  *   link.
+  * - The `Call` for bar'() has `sendResultsTo` set to `yourself`.
+  * - Vat B sends a `Return` for bar() with `takeFromOtherQuestion` set in place of the results,
+  *   with the value set to the question ID of bar'().  Vat B does not wait for bar'() to return,
+  *   as doing so would introduce unnecessary round trip latency.
+  * - Vat A receives bar'() and delivers it to Carol.
+  * - When bar'() returns, Vat A sends a `Return` for bar'() to Vat B, with `resultsSentElsewhere`
+  *   set in place of results.
+  * - Vat A sends a `Finish` for the bar() call to Vat B.
+  * - Vat B receives the `Finish` for bar() and sends a `Finish` for bar'().
+  *
+  */
+	readonly YOURSELF: 1;
+	/**
+  * **(level 3)**
+  *
+  * The call's result should be returned to a different vat.  The receiver (the callee) expects
+  * to receive an `Accept` message from the indicated vat, and should return the call's result
+  * to it, rather than to the sender of the `Call`.
+  *
+  * This operates much like `yourself`, above, except that Carol is in a separate Vat C.  `Call`
+  * messages are sent from Vat A -> Vat B and Vat B -> Vat C.  A `Return` message is sent from
+  * Vat B -> Vat A that contains `acceptFromThirdParty` in place of results.  When Vat A sends
+  * an `Accept` to Vat C, it receives back a `Return` containing the call's actual result.  Vat C
+  * also sends a `Return` to Vat B with `resultsSentElsewhere`.
+  *
+  */
+	readonly THIRD_PARTY: 2;
+};
+export type Call_SendResultsTo_Which = (typeof Call_SendResultsTo_Which)[keyof typeof Call_SendResultsTo_Which];
+declare class Call_SendResultsTo extends Struct {
+	static readonly CALLER: 0;
+	static readonly YOURSELF: 1;
+	static readonly THIRD_PARTY: 2;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get _isCaller(): boolean;
+	set caller(_: true);
+	get _isYourself(): boolean;
+	set yourself(_: true);
+	_adoptThirdParty(value: Orphan<Pointer>): void;
+	_disownThirdParty(): Orphan<Pointer>;
+	/**
+  * **(level 3)**
+  *
+  * The call's result should be returned to a different vat.  The receiver (the callee) expects
+  * to receive an `Accept` message from the indicated vat, and should return the call's result
+  * to it, rather than to the sender of the `Call`.
+  *
+  * This operates much like `yourself`, above, except that Carol is in a separate Vat C.  `Call`
+  * messages are sent from Vat A -> Vat B and Vat B -> Vat C.  A `Return` message is sent from
+  * Vat B -> Vat A that contains `acceptFromThirdParty` in place of results.  When Vat A sends
+  * an `Accept` to Vat C, it receives back a `Return` containing the call's actual result.  Vat C
+  * also sends a `Return` to Vat B with `resultsSentElsewhere`.
+  *
+  */
+	get thirdParty(): Pointer;
+	_hasThirdParty(): boolean;
+	get _isThirdParty(): boolean;
+	set thirdParty(value: Pointer);
+	toString(): string;
+	which(): Call_SendResultsTo_Which;
+}
+declare class Call$1 extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+		defaultAllowThirdPartyTailCall: DataView<ArrayBufferLike>;
+		defaultNoPromisePipelining: DataView<ArrayBufferLike>;
+		defaultOnlyPromisePipeline: DataView<ArrayBufferLike>;
+	};
+	/**
+  * A number, chosen by the caller, that identifies this call in future messages.  This number
+  * must be different from all other calls originating from the same end of the connection (but
+  * may overlap with question IDs originating from the opposite end).  A fine strategy is to use
+  * sequential question IDs, but the recipient should not assume this.
+  *
+  * A question ID can be reused once both:
+  * - A matching Return has been received from the callee.
+  * - A matching Finish has been sent from the caller.
+  *
+  */
+	get questionId(): number;
+	set questionId(value: number);
+	_adoptTarget(value: Orphan<MessageTarget>): void;
+	_disownTarget(): Orphan<MessageTarget>;
+	/**
+  * The object that should receive this call.
+  *
+  */
+	get target(): MessageTarget;
+	_hasTarget(): boolean;
+	_initTarget(): MessageTarget;
+	set target(value: MessageTarget);
+	/**
+  * The type ID of the interface being called.  Each capability may implement multiple interfaces.
+  *
+  */
+	get interfaceId(): bigint;
+	set interfaceId(value: bigint);
+	/**
+  * The ordinal number of the method to call within the requested interface.
+  *
+  */
+	get methodId(): number;
+	set methodId(value: number);
+	/**
+  * Indicates whether or not the receiver is allowed to send a `Return` containing
+  * `acceptFromThirdParty`.  Level 3 implementations should set this true.  Otherwise, the callee
+  * will have to proxy the return in the case of a tail call to a third-party vat.
+  *
+  */
+	get allowThirdPartyTailCall(): boolean;
+	set allowThirdPartyTailCall(value: boolean);
+	/**
+  * If true, the sender promises that it won't make any promise-pipelined calls on the results of
+  * this call. If it breaks this promise, the receiver may throw an arbitrary error from such
+  * calls.
+  *
+  * The receiver may use this as an optimization, by skipping the bookkeeping needed for pipelining
+  * when no pipelined calls are expected. The sender typically sets this to false when the method's
+  * schema does not specify any return capabilities.
+  *
+  */
+	get noPromisePipelining(): boolean;
+	set noPromisePipelining(value: boolean);
+	/**
+  * If true, the sender only plans to use this call to make pipelined calls. The receiver need not
+  * send a `Return` message (but is still allowed to do so).
+  *
+  * Since the sender does not know whether a `Return` will be sent, it must release all state
+  * related to the call when it sends `Finish`. However, in the case that the callee does not
+  * recognize this hint and chooses to send a `Return`, then technically the caller is not allowed
+  * to reuse the question ID until it receives said `Return`. This creates a conundrum: How does
+  * the caller decide when it's OK to reuse the ID? To sidestep the problem, the C++ implementation
+  * uses high-numbered IDs (with the high-order bit set) for such calls, and cycles through the
+  * IDs in order. If all 2^31 IDs in this space are used without ever seeing a `Return`, then the
+  * implementation assumes that the other end is in fact honoring the hint, and the ID counter is
+  * allowed to loop around. If a `Return` is ever seen when `onlyPromisePipeline` was set, then
+  * the implementation stops using this hint.
+  *
+  */
+	get onlyPromisePipeline(): boolean;
+	set onlyPromisePipeline(value: boolean);
+	_adoptParams(value: Orphan<Payload>): void;
+	_disownParams(): Orphan<Payload>;
+	/**
+  * The call parameters.  `params.content` is a struct whose fields correspond to the parameters of
+  * the method.
+  *
+  */
+	get params(): Payload;
+	_hasParams(): boolean;
+	_initParams(): Payload;
+	set params(value: Payload);
+	/**
+  * Where should the return message be sent?
+  *
+  */
+	get sendResultsTo(): Call_SendResultsTo;
+	_initSendResultsTo(): Call_SendResultsTo;
+	toString(): string;
+}
+declare const Return_Which: {
+	/**
+  * Equal to the QuestionId of the corresponding `Call` message.
+  *
+  */
+	readonly RESULTS: 0;
+	/**
+  * If true, all capabilities that were in the params should be considered released.  The sender
+  * must not send separate `Release` messages for them.  Level 0 implementations in particular
+  * should always set this true.  This defaults true because if level 0 implementations forget to
+  * set it they'll never notice (just silently leak caps), but if level >=1 implementations forget
+  * to set it to false they'll quickly get errors.
+  *
+  * The receiver should act as if the sender had sent a release message with count=1 for each
+  * CapDescriptor in the original Call message.
+  *
+  */
+	readonly EXCEPTION: 1;
+	/**
+  * The result.
+  *
+  * For regular method calls, `results.content` points to the result struct.
+  *
+  * For a `Return` in response to an `Accept` or `Bootstrap`, `results` contains a single
+  * capability (rather than a struct), and `results.content` is just a capability pointer with
+  * index 0.  A `Finish` is still required in this case.
+  *
+  */
+	readonly CANCELED: 2;
+	/**
+  * Indicates that the call failed and explains why.
+  *
+  */
+	readonly RESULTS_SENT_ELSEWHERE: 3;
+	/**
+  * Indicates that the call was canceled due to the caller sending a Finish message
+  * before the call had completed.
+  *
+  */
+	readonly TAKE_FROM_OTHER_QUESTION: 4;
+	/**
+  * This is set when returning from a `Call` that had `sendResultsTo` set to something other
+  * than `caller`.
+  *
+  * It doesn't matter too much when this is sent, as the receiver doesn't need to do anything
+  * with it, but the C++ implementation appears to wait for the call to finish before sending
+  * this.
+  *
+  */
+	readonly ACCEPT_FROM_THIRD_PARTY: 5;
+};
+export type Return_Which = (typeof Return_Which)[keyof typeof Return_Which];
+declare class Return extends Struct {
+	static readonly RESULTS: 0;
+	static readonly EXCEPTION: 1;
+	static readonly CANCELED: 2;
+	static readonly RESULTS_SENT_ELSEWHERE: 3;
+	static readonly TAKE_FROM_OTHER_QUESTION: 4;
+	static readonly ACCEPT_FROM_THIRD_PARTY: 5;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+		defaultReleaseParamCaps: DataView<ArrayBufferLike>;
+		defaultNoFinishNeeded: DataView<ArrayBufferLike>;
+	};
+	/**
+  * Equal to the QuestionId of the corresponding `Call` message.
+  *
+  */
+	get answerId(): number;
+	set answerId(value: number);
+	/**
+  * If true, all capabilities that were in the params should be considered released.  The sender
+  * must not send separate `Release` messages for them.  Level 0 implementations in particular
+  * should always set this true.  This defaults true because if level 0 implementations forget to
+  * set it they'll never notice (just silently leak caps), but if level >=1 implementations forget
+  * to set it to false they'll quickly get errors.
+  *
+  * The receiver should act as if the sender had sent a release message with count=1 for each
+  * CapDescriptor in the original Call message.
+  *
+  */
+	get releaseParamCaps(): boolean;
+	set releaseParamCaps(value: boolean);
+	/**
+  * If true, the sender does not need the receiver to send a `Finish` message; its answer table
+  * entry has already been cleaned up. This implies that the results do not contain any
+  * capabilities, since the `Finish` message would normally release those capabilities from
+  * promise pipelining responsibility. The caller may still send a `Finish` message if it wants,
+  * which will be silently ignored by the callee.
+  *
+  */
+	get noFinishNeeded(): boolean;
+	set noFinishNeeded(value: boolean);
+	_adoptResults(value: Orphan<Payload>): void;
+	_disownResults(): Orphan<Payload>;
+	/**
+  * The result.
+  *
+  * For regular method calls, `results.content` points to the result struct.
+  *
+  * For a `Return` in response to an `Accept` or `Bootstrap`, `results` contains a single
+  * capability (rather than a struct), and `results.content` is just a capability pointer with
+  * index 0.  A `Finish` is still required in this case.
+  *
+  */
+	get results(): Payload;
+	_hasResults(): boolean;
+	_initResults(): Payload;
+	get _isResults(): boolean;
+	set results(value: Payload);
+	_adoptException(value: Orphan<Exception>): void;
+	_disownException(): Orphan<Exception>;
+	/**
+  * Indicates that the call failed and explains why.
+  *
+  */
+	get exception(): Exception;
+	_hasException(): boolean;
+	_initException(): Exception;
+	get _isException(): boolean;
+	set exception(value: Exception);
+	get _isCanceled(): boolean;
+	set canceled(_: true);
+	get _isResultsSentElsewhere(): boolean;
+	set resultsSentElsewhere(_: true);
+	/**
+  * The sender has also sent (before this message) a `Call` with the given question ID and with
+  * `sendResultsTo.yourself` set, and the results of that other call should be used as the
+  * results here.  `takeFromOtherQuestion` can only used once per question.
+  *
+  */
+	get takeFromOtherQuestion(): number;
+	get _isTakeFromOtherQuestion(): boolean;
+	set takeFromOtherQuestion(value: number);
+	_adoptAcceptFromThirdParty(value: Orphan<Pointer>): void;
+	_disownAcceptFromThirdParty(): Orphan<Pointer>;
+	/**
+  * **(level 3)**
+  *
+  * The caller should contact a third-party vat to pick up the results.  An `Accept` message
+  * sent to the vat will return the result.  This pairs with `Call.sendResultsTo.thirdParty`.
+  * It should only be used if the corresponding `Call` had `allowThirdPartyTailCall` set.
+  *
+  */
+	get acceptFromThirdParty(): Pointer;
+	_hasAcceptFromThirdParty(): boolean;
+	get _isAcceptFromThirdParty(): boolean;
+	set acceptFromThirdParty(value: Pointer);
+	toString(): string;
+	which(): Return_Which;
+}
+declare class Finish extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+		defaultReleaseResultCaps: DataView<ArrayBufferLike>;
+		defaultRequireEarlyCancellationWorkaround: DataView<ArrayBufferLike>;
+	};
+	/**
+  * ID of the call whose result is to be released.
+  *
+  */
+	get questionId(): number;
+	set questionId(value: number);
+	/**
+  * If true, all capabilities that were in the results should be considered released.  The sender
+  * must not send separate `Release` messages for them.  Level 0 implementations in particular
+  * should always set this true.  This defaults true because if level 0 implementations forget to
+  * set it they'll never notice (just silently leak caps), but if level >=1 implementations forget
+  * set it false they'll quickly get errors.
+  *
+  */
+	get releaseResultCaps(): boolean;
+	set releaseResultCaps(value: boolean);
+	/**
+  * If true, if the RPC system receives this Finish message before the original call has even been
+  * delivered, it should defer cancellation util after delivery. In particular, this gives the
+  * destination object a chance to opt out of cancellation, e.g. as controlled by the
+  * `allowCancellation` annotation defined in `c++.capnp`.
+  *
+  * This is a work-around. Versions 1.0 and up of Cap'n Proto always set this to false. However,
+  * older versions of Cap'n Proto unintentionally exhibited this errant behavior by default, and
+  * as a result programs built with older versions could be inadvertently relying on their peers
+  * to implement the behavior. The purpose of this flag is to let newer versions know when the
+  * peer is an older version, so that it can attempt to work around the issue.
+  *
+  * See also comments in handleFinish() in rpc.c++ for more details.
+  *
+  */
+	get requireEarlyCancellationWorkaround(): boolean;
+	set requireEarlyCancellationWorkaround(value: boolean);
+	toString(): string;
+}
+declare const Resolve_Which: {
+	/**
+  * The ID of the promise to be resolved.
+  *
+  * Unlike all other instances of `ExportId` sent from the exporter, the `Resolve` message does
+  * _not_ increase the reference count of `promiseId`.  In fact, it is expected that the receiver
+  * will release the export soon after receiving `Resolve`, and the sender will not send this
+  * `ExportId` again until it has been released and recycled.
+  *
+  * When an export ID sent over the wire (e.g. in a `CapDescriptor`) is indicated to be a promise,
+  * this indicates that the sender will follow up at some point with a `Resolve` message.  If the
+  * same `promiseId` is sent again before `Resolve`, still only one `Resolve` is sent.  If the
+  * same ID is sent again later _after_ a `Resolve`, it can only be because the export's
+  * reference count hit zero in the meantime and the ID was re-assigned to a new export, therefore
+  * this later promise does _not_ correspond to the earlier `Resolve`.
+  *
+  * If a promise ID's reference count reaches zero before a `Resolve` is sent, the `Resolve`
+  * message may or may not still be sent (the `Resolve` may have already been in-flight when
+  * `Release` was sent, but if the `Release` is received before `Resolve` then there is no longer
+  * any reason to send a `Resolve`).  Thus a `Resolve` may be received for a promise of which
+  * the receiver has no knowledge, because it already released it earlier.  In this case, the
+  * receiver should simply release the capability to which the promise resolved.
+  *
+  */
+	readonly CAP: 0;
+	/**
+  * The object to which the promise resolved.
+  *
+  * The sender promises that from this point forth, until `promiseId` is released, it shall
+  * simply forward all messages to the capability designated by `cap`.  This is true even if
+  * `cap` itself happens to designate another promise, and that other promise later resolves --
+  * messages sent to `promiseId` shall still go to that other promise, not to its resolution.
+  * This is important in the case that the receiver of the `Resolve` ends up sending a
+  * `Disembargo` message towards `promiseId` in order to control message ordering -- that
+  * `Disembargo` really needs to reflect back to exactly the object designated by `cap` even
+  * if that object is itself a promise.
+  *
+  */
+	readonly EXCEPTION: 1;
+};
+export type Resolve_Which = (typeof Resolve_Which)[keyof typeof Resolve_Which];
+declare class Resolve extends Struct {
+	static readonly CAP: 0;
+	static readonly EXCEPTION: 1;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * The ID of the promise to be resolved.
+  *
+  * Unlike all other instances of `ExportId` sent from the exporter, the `Resolve` message does
+  * _not_ increase the reference count of `promiseId`.  In fact, it is expected that the receiver
+  * will release the export soon after receiving `Resolve`, and the sender will not send this
+  * `ExportId` again until it has been released and recycled.
+  *
+  * When an export ID sent over the wire (e.g. in a `CapDescriptor`) is indicated to be a promise,
+  * this indicates that the sender will follow up at some point with a `Resolve` message.  If the
+  * same `promiseId` is sent again before `Resolve`, still only one `Resolve` is sent.  If the
+  * same ID is sent again later _after_ a `Resolve`, it can only be because the export's
+  * reference count hit zero in the meantime and the ID was re-assigned to a new export, therefore
+  * this later promise does _not_ correspond to the earlier `Resolve`.
+  *
+  * If a promise ID's reference count reaches zero before a `Resolve` is sent, the `Resolve`
+  * message may or may not still be sent (the `Resolve` may have already been in-flight when
+  * `Release` was sent, but if the `Release` is received before `Resolve` then there is no longer
+  * any reason to send a `Resolve`).  Thus a `Resolve` may be received for a promise of which
+  * the receiver has no knowledge, because it already released it earlier.  In this case, the
+  * receiver should simply release the capability to which the promise resolved.
+  *
+  */
+	get promiseId(): number;
+	set promiseId(value: number);
+	_adoptCap(value: Orphan<CapDescriptor>): void;
+	_disownCap(): Orphan<CapDescriptor>;
+	/**
+  * The object to which the promise resolved.
+  *
+  * The sender promises that from this point forth, until `promiseId` is released, it shall
+  * simply forward all messages to the capability designated by `cap`.  This is true even if
+  * `cap` itself happens to designate another promise, and that other promise later resolves --
+  * messages sent to `promiseId` shall still go to that other promise, not to its resolution.
+  * This is important in the case that the receiver of the `Resolve` ends up sending a
+  * `Disembargo` message towards `promiseId` in order to control message ordering -- that
+  * `Disembargo` really needs to reflect back to exactly the object designated by `cap` even
+  * if that object is itself a promise.
+  *
+  */
+	get cap(): CapDescriptor;
+	_hasCap(): boolean;
+	_initCap(): CapDescriptor;
+	get _isCap(): boolean;
+	set cap(value: CapDescriptor);
+	_adoptException(value: Orphan<Exception>): void;
+	_disownException(): Orphan<Exception>;
+	/**
+  * Indicates that the promise was broken.
+  *
+  */
+	get exception(): Exception;
+	_hasException(): boolean;
+	_initException(): Exception;
+	get _isException(): boolean;
+	set exception(value: Exception);
+	toString(): string;
+	which(): Resolve_Which;
+}
+declare class Release extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * What to release.
+  *
+  */
+	get id(): number;
+	set id(value: number);
+	/**
+  * The amount by which to decrement the reference count.  The export is only actually released
+  * when the reference count reaches zero.
+  *
+  */
+	get referenceCount(): number;
+	set referenceCount(value: number);
+	toString(): string;
+}
+declare const Disembargo_Context_Which: {
+	/**
+  * The sender is requesting a disembargo on a promise that is known to resolve back to a
+  * capability hosted by the sender.  As soon as the receiver has echoed back all pipelined calls
+  * on this promise, it will deliver the Disembargo back to the sender with `receiverLoopback`
+  * set to the same value as `senderLoopback`.  This value is chosen by the sender, and since
+  * it is also consumed be the sender, the sender can use whatever strategy it wants to make sure
+  * the value is unambiguous.
+  *
+  * The receiver must verify that the target capability actually resolves back to the sender's
+  * vat.  Otherwise, the sender has committed a protocol error and should be disconnected.
+  *
+  */
+	readonly SENDER_LOOPBACK: 0;
+	/**
+  * The receiver previously sent a `senderLoopback` Disembargo towards a promise resolving to
+  * this capability, and that Disembargo is now being echoed back.
+  *
+  */
+	readonly RECEIVER_LOOPBACK: 1;
+	/**
+  * **(level 3)**
+  *
+  * The sender is requesting a disembargo on a promise that is known to resolve to a third-party
+  * capability that the sender is currently in the process of accepting (using `Accept`).
+  * The receiver of this `Disembargo` has an outstanding `Provide` on said capability.  The
+  * receiver should now send a `Disembargo` with `provide` set to the question ID of that
+  * `Provide` message.
+  *
+  * See `Accept.embargo` for an example.
+  *
+  */
+	readonly ACCEPT: 2;
+	/**
+  * **(level 3)**
+  *
+  * The sender is requesting a disembargo on a capability currently being provided to a third
+  * party.  The question ID identifies the `Provide` message previously sent by the sender to
+  * this capability.  On receipt, the receiver (the capability host) shall release the embargo
+  * on the `Accept` message that it has received from the third party.  See `Accept.embargo` for
+  * an example.
+  *
+  */
+	readonly PROVIDE: 3;
+};
+export type Disembargo_Context_Which = (typeof Disembargo_Context_Which)[keyof typeof Disembargo_Context_Which];
+declare class Disembargo_Context extends Struct {
+	static readonly SENDER_LOOPBACK: 0;
+	static readonly RECEIVER_LOOPBACK: 1;
+	static readonly ACCEPT: 2;
+	static readonly PROVIDE: 3;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * The sender is requesting a disembargo on a promise that is known to resolve back to a
+  * capability hosted by the sender.  As soon as the receiver has echoed back all pipelined calls
+  * on this promise, it will deliver the Disembargo back to the sender with `receiverLoopback`
+  * set to the same value as `senderLoopback`.  This value is chosen by the sender, and since
+  * it is also consumed be the sender, the sender can use whatever strategy it wants to make sure
+  * the value is unambiguous.
+  *
+  * The receiver must verify that the target capability actually resolves back to the sender's
+  * vat.  Otherwise, the sender has committed a protocol error and should be disconnected.
+  *
+  */
+	get senderLoopback(): number;
+	get _isSenderLoopback(): boolean;
+	set senderLoopback(value: number);
+	/**
+  * The receiver previously sent a `senderLoopback` Disembargo towards a promise resolving to
+  * this capability, and that Disembargo is now being echoed back.
+  *
+  */
+	get receiverLoopback(): number;
+	get _isReceiverLoopback(): boolean;
+	set receiverLoopback(value: number);
+	get _isAccept(): boolean;
+	set accept(_: true);
+	/**
+  * **(level 3)**
+  *
+  * The sender is requesting a disembargo on a capability currently being provided to a third
+  * party.  The question ID identifies the `Provide` message previously sent by the sender to
+  * this capability.  On receipt, the receiver (the capability host) shall release the embargo
+  * on the `Accept` message that it has received from the third party.  See `Accept.embargo` for
+  * an example.
+  *
+  */
+	get provide(): number;
+	get _isProvide(): boolean;
+	set provide(value: number);
+	toString(): string;
+	which(): Disembargo_Context_Which;
+}
+declare class Disembargo extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	_adoptTarget(value: Orphan<MessageTarget>): void;
+	_disownTarget(): Orphan<MessageTarget>;
+	/**
+  * What is to be disembargoed.
+  *
+  */
+	get target(): MessageTarget;
+	_hasTarget(): boolean;
+	_initTarget(): MessageTarget;
+	set target(value: MessageTarget);
+	get context(): Disembargo_Context;
+	_initContext(): Disembargo_Context;
+	toString(): string;
+}
+declare class Provide extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * Question ID to be held open until the recipient has received the capability.  A result will be
+  * returned once the third party has successfully received the capability.  The sender must at some
+  * point send a `Finish` message as with any other call, and that message can be used to cancel the
+  * whole operation.
+  *
+  */
+	get questionId(): number;
+	set questionId(value: number);
+	_adoptTarget(value: Orphan<MessageTarget>): void;
+	_disownTarget(): Orphan<MessageTarget>;
+	/**
+  * What is to be provided to the third party.
+  *
+  */
+	get target(): MessageTarget;
+	_hasTarget(): boolean;
+	_initTarget(): MessageTarget;
+	set target(value: MessageTarget);
+	_adoptRecipient(value: Orphan<Pointer>): void;
+	_disownRecipient(): Orphan<Pointer>;
+	/**
+  * Identity of the third party that is expected to pick up the capability.
+  *
+  */
+	get recipient(): Pointer;
+	_hasRecipient(): boolean;
+	set recipient(value: Pointer);
+	toString(): string;
+}
+declare class Accept extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * A new question ID identifying this accept message, which will eventually receive a Return
+  * message containing the provided capability (or the call result in the case of a redirected
+  * return).
+  *
+  */
+	get questionId(): number;
+	set questionId(value: number);
+	_adoptProvision(value: Orphan<Pointer>): void;
+	_disownProvision(): Orphan<Pointer>;
+	/**
+  * Identifies the provided object to be picked up.
+  *
+  */
+	get provision(): Pointer;
+	_hasProvision(): boolean;
+	set provision(value: Pointer);
+	/**
+  * If true, this accept shall be temporarily embargoed.  The resulting `Return` will not be sent,
+  * and any pipelined calls will not be delivered, until the embargo is released.  The receiver
+  * (the capability host) will expect the provider (the vat that sent the `Provide` message) to
+  * eventually send a `Disembargo` message with the field `context.provide` set to the question ID
+  * of the original `Provide` message.  At that point, the embargo is released and the queued
+  * messages are delivered.
+  *
+  * For example:
+  * - Alice, in Vat A, holds a promise P, which currently points toward Vat B.
+  * - Alice calls foo() on P.  The `Call` message is sent to Vat B.
+  * - The promise P in Vat B ends up resolving to Carol, in Vat C.
+  * - Vat B sends a `Provide` message to Vat C, identifying Vat A as the recipient.
+  * - Vat B sends a `Resolve` message to Vat A, indicating that the promise has resolved to a
+  *   `ThirdPartyCapId` identifying Carol in Vat C.
+  * - Vat A sends an `Accept` message to Vat C to pick up the capability.  Since Vat A knows that
+  *   it has an outstanding call to the promise, it sets `embargo` to `true` in the `Accept`
+  *   message.
+  * - Vat A sends a `Disembargo` message to Vat B on promise P, with `context.accept` set.
+  * - Alice makes a call bar() to promise P, which is now pointing towards Vat C.  Alice doesn't
+  *   know anything about the mechanics of promise resolution happening under the hood, but she
+  *   expects that bar() will be delivered after foo() because that is the order in which she
+  *   initiated the calls.
+  * - Vat A sends the bar() call to Vat C, as a pipelined call on the result of the `Accept` (which
+  *   hasn't returned yet, due to the embargo).  Since calls to the newly-accepted capability
+  *   are embargoed, Vat C does not deliver the call yet.
+  * - At some point, Vat B forwards the foo() call from the beginning of this example on to Vat C.
+  * - Vat B forwards the `Disembargo` from Vat A on to vat C.  It sets `context.provide` to the
+  *   question ID of the `Provide` message it had sent previously.
+  * - Vat C receives foo() before `Disembargo`, thus allowing it to correctly deliver foo()
+  *   before delivering bar().
+  * - Vat C receives `Disembargo` from Vat B.  It can now send a `Return` for the `Accept` from
+  *   Vat A, as well as deliver bar().
+  *
+  */
+	get embargo(): boolean;
+	set embargo(value: boolean);
+	toString(): string;
+}
+declare class Join extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * Question ID used to respond to this Join.  (Note that this ID only identifies one part of the
+  * request for one hop; each part has a different ID and relayed copies of the request have
+  * (probably) different IDs still.)
+  *
+  * The receiver will reply with a `Return` whose `results` is a JoinResult.  This `JoinResult`
+  * is relayed from the joined object's host, possibly with transformation applied as needed
+  * by the network.
+  *
+  * Like any return, the result must be released using a `Finish`.  However, this release
+  * should not occur until the joiner has either successfully connected to the joined object.
+  * Vats relaying a `Join` message similarly must not release the result they receive until the
+  * return they relayed back towards the joiner has itself been released.  This allows the
+  * joined object's host to detect when the Join operation is canceled before completing -- if
+  * it receives a `Finish` for one of the join results before the joiner successfully
+  * connects.  It can then free any resources it had allocated as part of the join.
+  *
+  */
+	get questionId(): number;
+	set questionId(value: number);
+	_adoptTarget(value: Orphan<MessageTarget>): void;
+	_disownTarget(): Orphan<MessageTarget>;
+	/**
+  * The capability to join.
+  *
+  */
+	get target(): MessageTarget;
+	_hasTarget(): boolean;
+	_initTarget(): MessageTarget;
+	set target(value: MessageTarget);
+	_adoptKeyPart(value: Orphan<Pointer>): void;
+	_disownKeyPart(): Orphan<Pointer>;
+	/**
+  * A part of the join key.  These combine to form the complete join key, which is used to establish
+  * a direct connection.
+  *
+  */
+	get keyPart(): Pointer;
+	_hasKeyPart(): boolean;
+	set keyPart(value: Pointer);
+	toString(): string;
+}
+declare const MessageTarget_Which: {
+	/**
+  * This message is to a capability or promise previously imported by the caller (exported by
+  * the receiver).
+  *
+  */
+	readonly IMPORTED_CAP: 0;
+	/**
+  * This message is to a capability that is expected to be returned by another call that has not
+  * yet been completed.
+  *
+  * At level 0, this is supported only for addressing the result of a previous `Bootstrap`, so
+  * that initial startup doesn't require a round trip.
+  *
+  */
+	readonly PROMISED_ANSWER: 1;
+};
+export type MessageTarget_Which = (typeof MessageTarget_Which)[keyof typeof MessageTarget_Which];
+declare class MessageTarget extends Struct {
+	static readonly IMPORTED_CAP: 0;
+	static readonly PROMISED_ANSWER: 1;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * This message is to a capability or promise previously imported by the caller (exported by
+  * the receiver).
+  *
+  */
+	get importedCap(): number;
+	get _isImportedCap(): boolean;
+	set importedCap(value: number);
+	_adoptPromisedAnswer(value: Orphan<PromisedAnswer>): void;
+	_disownPromisedAnswer(): Orphan<PromisedAnswer>;
+	/**
+  * This message is to a capability that is expected to be returned by another call that has not
+  * yet been completed.
+  *
+  * At level 0, this is supported only for addressing the result of a previous `Bootstrap`, so
+  * that initial startup doesn't require a round trip.
+  *
+  */
+	get promisedAnswer(): PromisedAnswer;
+	_hasPromisedAnswer(): boolean;
+	_initPromisedAnswer(): PromisedAnswer;
+	get _isPromisedAnswer(): boolean;
+	set promisedAnswer(value: PromisedAnswer);
+	toString(): string;
+	which(): MessageTarget_Which;
+}
+declare class Payload extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _CapTable: ListCtor<CapDescriptor>;
+	_adoptContent(value: Orphan<Pointer>): void;
+	_disownContent(): Orphan<Pointer>;
+	/**
+  * Some Cap'n Proto data structure.  Capability pointers embedded in this structure index into
+  * `capTable`.
+  *
+  */
+	get content(): Pointer;
+	_hasContent(): boolean;
+	set content(value: Pointer);
+	_adoptCapTable(value: Orphan<List<CapDescriptor>>): void;
+	_disownCapTable(): Orphan<List<CapDescriptor>>;
+	/**
+  * Descriptors corresponding to the cap pointers in `content`.
+  *
+  */
+	get capTable(): List<CapDescriptor>;
+	_hasCapTable(): boolean;
+	_initCapTable(length: number): List<CapDescriptor>;
+	set capTable(value: List<CapDescriptor>);
+	toString(): string;
+}
+declare const CapDescriptor_Which: {
+	/**
+  * There is no capability here.  This `CapDescriptor` should not appear in the payload content.
+  * A `none` CapDescriptor can be generated when an application inserts a capability into a
+  * message and then later changes its mind and removes it -- rewriting all of the other
+  * capability pointers may be hard, so instead a tombstone is left, similar to the way a removed
+  * struct or list instance is zeroed out of the message but the space is not reclaimed.
+  * Hopefully this is unusual.
+  *
+  */
+	readonly NONE: 0;
+	/**
+  * The ID of a capability in the sender's export table (receiver's import table).  It may be a
+  * newly allocated table entry, or an existing entry (increments the reference count).
+  *
+  */
+	readonly SENDER_HOSTED: 1;
+	/**
+  * A promise that the sender will resolve later.  The sender will send exactly one Resolve
+  * message at a future point in time to replace this promise.  Note that even if the same
+  * `senderPromise` is received multiple times, only one `Resolve` is sent to cover all of
+  * them.  If `senderPromise` is released before the `Resolve` is sent, the sender (of this
+  * `CapDescriptor`) may choose not to send the `Resolve` at all.
+  *
+  */
+	readonly SENDER_PROMISE: 2;
+	/**
+  * A capability (or promise) previously exported by the receiver (imported by the sender).
+  *
+  */
+	readonly RECEIVER_HOSTED: 3;
+	/**
+  * A capability expected to be returned in the results of a currently-outstanding call posed
+  * by the sender.
+  *
+  */
+	readonly RECEIVER_ANSWER: 4;
+	/**
+  * **(level 3)**
+  *
+  * A capability that lives in neither the sender's nor the receiver's vat.  The sender needs
+  * to form a direct connection to a third party to pick up the capability.
+  *
+  * Level 1 and 2 implementations that receive a `thirdPartyHosted` may simply send calls to its
+  * `vine` instead.
+  *
+  */
+	readonly THIRD_PARTY_HOSTED: 5;
+};
+export type CapDescriptor_Which = (typeof CapDescriptor_Which)[keyof typeof CapDescriptor_Which];
+declare class CapDescriptor extends Struct {
+	static readonly NONE: 0;
+	static readonly SENDER_HOSTED: 1;
+	static readonly SENDER_PROMISE: 2;
+	static readonly RECEIVER_HOSTED: 3;
+	static readonly RECEIVER_ANSWER: 4;
+	static readonly THIRD_PARTY_HOSTED: 5;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+		defaultAttachedFd: DataView<ArrayBufferLike>;
+	};
+	get _isNone(): boolean;
+	set none(_: true);
+	/**
+  * The ID of a capability in the sender's export table (receiver's import table).  It may be a
+  * newly allocated table entry, or an existing entry (increments the reference count).
+  *
+  */
+	get senderHosted(): number;
+	get _isSenderHosted(): boolean;
+	set senderHosted(value: number);
+	/**
+  * A promise that the sender will resolve later.  The sender will send exactly one Resolve
+  * message at a future point in time to replace this promise.  Note that even if the same
+  * `senderPromise` is received multiple times, only one `Resolve` is sent to cover all of
+  * them.  If `senderPromise` is released before the `Resolve` is sent, the sender (of this
+  * `CapDescriptor`) may choose not to send the `Resolve` at all.
+  *
+  */
+	get senderPromise(): number;
+	get _isSenderPromise(): boolean;
+	set senderPromise(value: number);
+	/**
+  * A capability (or promise) previously exported by the receiver (imported by the sender).
+  *
+  */
+	get receiverHosted(): number;
+	get _isReceiverHosted(): boolean;
+	set receiverHosted(value: number);
+	_adoptReceiverAnswer(value: Orphan<PromisedAnswer>): void;
+	_disownReceiverAnswer(): Orphan<PromisedAnswer>;
+	/**
+  * A capability expected to be returned in the results of a currently-outstanding call posed
+  * by the sender.
+  *
+  */
+	get receiverAnswer(): PromisedAnswer;
+	_hasReceiverAnswer(): boolean;
+	_initReceiverAnswer(): PromisedAnswer;
+	get _isReceiverAnswer(): boolean;
+	set receiverAnswer(value: PromisedAnswer);
+	_adoptThirdPartyHosted(value: Orphan<ThirdPartyCapDescriptor>): void;
+	_disownThirdPartyHosted(): Orphan<ThirdPartyCapDescriptor>;
+	/**
+  * **(level 3)**
+  *
+  * A capability that lives in neither the sender's nor the receiver's vat.  The sender needs
+  * to form a direct connection to a third party to pick up the capability.
+  *
+  * Level 1 and 2 implementations that receive a `thirdPartyHosted` may simply send calls to its
+  * `vine` instead.
+  *
+  */
+	get thirdPartyHosted(): ThirdPartyCapDescriptor;
+	_hasThirdPartyHosted(): boolean;
+	_initThirdPartyHosted(): ThirdPartyCapDescriptor;
+	get _isThirdPartyHosted(): boolean;
+	set thirdPartyHosted(value: ThirdPartyCapDescriptor);
+	/**
+  * If the RPC message in which this CapDescriptor was delivered also had file descriptors
+  * attached, and `fd` is a valid index into the list of attached file descriptors, then
+  * that file descriptor should be attached to this capability. If `attachedFd` is out-of-bounds
+  * for said list, then no FD is attached.
+  *
+  * For example, if the RPC message arrived over a Unix socket, then file descriptors may be
+  * attached by sending an SCM_RIGHTS ancillary message attached to the data bytes making up the
+  * raw message. Receivers who wish to opt into FD passing should arrange to receive SCM_RIGHTS
+  * whenever receiving an RPC message. Senders who wish to send FDs need not verify whether the
+  * receiver knows how to receive them, because the operating system will automatically discard
+  * ancillary messages like SCM_RIGHTS if the receiver doesn't ask to receive them, including
+  * automatically closing any FDs.
+  *
+  * It is up to the application protocol to define what capabilities are expected to have file
+  * descriptors attached, and what those FDs mean. But, for example, an application could use this
+  * to open a file on disk and then transmit the open file descriptor to a sandboxed process that
+  * does not otherwise have permission to access the filesystem directly. This is usually an
+  * optimization: the sending process could instead provide an RPC interface supporting all the
+  * operations needed (such as reading and writing a file), but by passing the file descriptor
+  * directly, the recipient can often perform operations much more efficiently. Application
+  * designers are encouraged to provide such RPC interfaces and automatically fall back to them
+  * when FD passing is not available, so that the application can still work when the parties are
+  * remote over a network.
+  *
+  * An attached FD is most often associated with a `senderHosted` descriptor. It could also make
+  * sense in the case of `thirdPartyHosted`: in this case, the sender is forwarding the FD that
+  * they received from the third party, so that the receiver can start using it without first
+  * interacting with the third party. This is an optional optimization -- the middleman may choose
+  * not to forward capabilities, in which case the receiver will need to complete the handshake
+  * with the third party directly before receiving the FD. If an implementation receives a second
+  * attached FD after having already received one previously (e.g. both in a `thirdPartyHosted`
+  * CapDescriptor and then later again when receiving the final capability directly from the
+  * third party), the implementation should discard the later FD and stick with the original. At
+  * present, there is no known reason why other capability types (e.g. `receiverHosted`) would want
+  * to carry an attached FD, but we reserve the right to define a meaning for this in the future.
+  *
+  * Each file descriptor attached to the message must be used in no more than one CapDescriptor,
+  * so that the receiver does not need to use dup() or refcounting to handle the possibility of
+  * multiple capabilities using the same descriptor. If multiple CapDescriptors do point to the
+  * same FD index, then the receiver can arbitrarily choose which capability ends up having the
+  * FD attached.
+  *
+  * To mitigate DoS attacks, RPC implementations should limit the number of FDs they are willing to
+  * receive in a single message to a small value. If a message happens to contain more than that,
+  * the list is truncated. Moreover, in some cases, FD passing needs to be blocked entirely for
+  * security or implementation reasons, in which case the list may be truncated to zero. Hence,
+  * `attachedFd` might point past the end of the list, which the implementation should treat as if
+  * no FD was attached at all.
+  *
+  * The type of this field was chosen to be UInt8 because Linux supports sending only a maximum
+  * of 253 file descriptors in an SCM_RIGHTS message anyway, and CapDescriptor had two bytes of
+  * padding left -- so after adding this, there is still one byte for a future feature.
+  * Conveniently, this also means we're able to use 0xff as the default value, which will always
+  * be out-of-range (of course, the implementation should explicitly enforce that 255 descriptors
+  * cannot be sent at once, rather than relying on Linux to do so).
+  *
+  */
+	get attachedFd(): number;
+	set attachedFd(value: number);
+	toString(): string;
+	which(): CapDescriptor_Which;
+}
+declare const PromisedAnswer_Op_Which: {
+	/**
+  * Does nothing.  This member is mostly defined so that we can make `Op` a union even
+  * though (as of this writing) only one real operation is defined.
+  *
+  */
+	readonly NOOP: 0;
+	/**
+  * Get a pointer field within a struct.  The number is an index into the pointer section, NOT
+  * a field ordinal, so that the receiver does not need to understand the schema.
+  *
+  */
+	readonly GET_POINTER_FIELD: 1;
+};
+export type PromisedAnswer_Op_Which = (typeof PromisedAnswer_Op_Which)[keyof typeof PromisedAnswer_Op_Which];
+declare class PromisedAnswer_Op extends Struct {
+	static readonly NOOP: 0;
+	static readonly GET_POINTER_FIELD: 1;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get _isNoop(): boolean;
+	set noop(_: true);
+	/**
+  * Get a pointer field within a struct.  The number is an index into the pointer section, NOT
+  * a field ordinal, so that the receiver does not need to understand the schema.
+  *
+  */
+	get getPointerField(): number;
+	get _isGetPointerField(): boolean;
+	set getPointerField(value: number);
+	toString(): string;
+	which(): PromisedAnswer_Op_Which;
+}
+declare class PromisedAnswer extends Struct {
+	static readonly Op: typeof PromisedAnswer_Op;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Transform: ListCtor<PromisedAnswer_Op>;
+	/**
+  * ID of the question (in the sender's question table / receiver's answer table) whose answer is
+  * expected to contain the capability.
+  *
+  */
+	get questionId(): number;
+	set questionId(value: number);
+	_adoptTransform(value: Orphan<List<PromisedAnswer_Op>>): void;
+	_disownTransform(): Orphan<List<PromisedAnswer_Op>>;
+	/**
+  * Operations / transformations to apply to the result in order to get the capability actually
+  * being addressed.  E.g. if the result is a struct and you want to call a method on a capability
+  * pointed to by a field of the struct, you need a `getPointerField` op.
+  *
+  */
+	get transform(): List<PromisedAnswer_Op>;
+	_hasTransform(): boolean;
+	_initTransform(length: number): List<PromisedAnswer_Op>;
+	set transform(value: List<PromisedAnswer_Op>);
+	toString(): string;
+}
+declare class ThirdPartyCapDescriptor extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	_adoptId(value: Orphan<Pointer>): void;
+	_disownId(): Orphan<Pointer>;
+	/**
+  * Identifies the third-party host and the specific capability to accept from it.
+  *
+  */
+	get id(): Pointer;
+	_hasId(): boolean;
+	set id(value: Pointer);
+	/**
+  * A proxy for the third-party object exported by the sender.  In CapTP terminology this is called
+  * a "vine", because it is an indirect reference to the third-party object that snakes through the
+  * sender vat.  This serves two purposes:
+  *
+  * * Level 1 and 2 implementations that don't understand how to connect to a third party may
+  *   simply send calls to the vine.  Such calls will be forwarded to the third-party by the
+  *   sender.
+  *
+  * * Level 3 implementations must release the vine only once they have successfully picked up the
+  *   object from the third party.  This ensures that the capability is not released by the sender
+  *   prematurely.
+  *
+  * The sender will close the `Provide` request that it has sent to the third party as soon as
+  * it receives either a `Call` or a `Release` message directed at the vine.
+  *
+  */
+	get vineId(): number;
+	set vineId(value: number);
+	toString(): string;
+}
+declare const Exception_Type: {
+	/**
+  * A generic problem occurred, and it is believed that if the operation were repeated without
+  * any change in the state of the world, the problem would occur again.
+  *
+  * A client might respond to this error by logging it for investigation by the developer and/or
+  * displaying it to the user.
+  *
+  */
+	readonly FAILED: 0;
+	/**
+  * The request was rejected due to a temporary lack of resources.
+  *
+  * Examples include:
+  * - There's not enough CPU time to keep up with incoming requests, so some are rejected.
+  * - The server ran out of RAM or disk space during the request.
+  * - The operation timed out (took significantly longer than it should have).
+  *
+  * A client might respond to this error by scheduling to retry the operation much later. The
+  * client should NOT retry again immediately since this would likely exacerbate the problem.
+  *
+  */
+	readonly OVERLOADED: 1;
+	/**
+  * The method failed because a connection to some necessary capability was lost.
+  *
+  * Examples include:
+  * - The client introduced the server to a third-party capability, the connection to that third
+  *   party was subsequently lost, and then the client requested that the server use the dead
+  *   capability for something.
+  * - The client previously requested that the server obtain a capability from some third party.
+  *   The server returned a capability to an object wrapping the third-party capability. Later,
+  *   the server's connection to the third party was lost.
+  * - The capability has been revoked. Revocation does not necessarily mean that the client is
+  *   no longer authorized to use the capability; it is often used simply as a way to force the
+  *   client to repeat the setup process, perhaps to efficiently move them to a new back-end or
+  *   get them to recognize some other change that has occurred.
+  *
+  * A client should normally respond to this error by releasing all capabilities it is currently
+  * holding related to the one it called and then re-creating them by restoring SturdyRefs and/or
+  * repeating the method calls used to create them originally. In other words, disconnect and
+  * start over. This should in turn cause the server to obtain a new copy of the capability that
+  * it lost, thus making everything work.
+  *
+  * If the client receives another `disconnected` error in the process of rebuilding the
+  * capability and retrying the call, it should treat this as an `overloaded` error: the network
+  * is currently unreliable, possibly due to load or other temporary issues.
+  *
+  */
+	readonly DISCONNECTED: 2;
+	/**
+  * The server doesn't implement the requested method. If there is some other method that the
+  * client could call (perhaps an older and/or slower interface), it should try that instead.
+  * Otherwise, this should be treated like `failed`.
+  *
+  */
+	readonly UNIMPLEMENTED: 3;
+};
+export type Exception_Type = (typeof Exception_Type)[keyof typeof Exception_Type];
+declare class Exception extends Struct {
+	static readonly Type: {
+		/**
+	  * A generic problem occurred, and it is believed that if the operation were repeated without
+	  * any change in the state of the world, the problem would occur again.
+	  *
+	  * A client might respond to this error by logging it for investigation by the developer and/or
+	  * displaying it to the user.
+	  *
+	  */
+		readonly FAILED: 0;
+		/**
+	  * The request was rejected due to a temporary lack of resources.
+	  *
+	  * Examples include:
+	  * - There's not enough CPU time to keep up with incoming requests, so some are rejected.
+	  * - The server ran out of RAM or disk space during the request.
+	  * - The operation timed out (took significantly longer than it should have).
+	  *
+	  * A client might respond to this error by scheduling to retry the operation much later. The
+	  * client should NOT retry again immediately since this would likely exacerbate the problem.
+	  *
+	  */
+		readonly OVERLOADED: 1;
+		/**
+	  * The method failed because a connection to some necessary capability was lost.
+	  *
+	  * Examples include:
+	  * - The client introduced the server to a third-party capability, the connection to that third
+	  *   party was subsequently lost, and then the client requested that the server use the dead
+	  *   capability for something.
+	  * - The client previously requested that the server obtain a capability from some third party.
+	  *   The server returned a capability to an object wrapping the third-party capability. Later,
+	  *   the server's connection to the third party was lost.
+	  * - The capability has been revoked. Revocation does not necessarily mean that the client is
+	  *   no longer authorized to use the capability; it is often used simply as a way to force the
+	  *   client to repeat the setup process, perhaps to efficiently move them to a new back-end or
+	  *   get them to recognize some other change that has occurred.
+	  *
+	  * A client should normally respond to this error by releasing all capabilities it is currently
+	  * holding related to the one it called and then re-creating them by restoring SturdyRefs and/or
+	  * repeating the method calls used to create them originally. In other words, disconnect and
+	  * start over. This should in turn cause the server to obtain a new copy of the capability that
+	  * it lost, thus making everything work.
+	  *
+	  * If the client receives another `disconnected` error in the process of rebuilding the
+	  * capability and retrying the call, it should treat this as an `overloaded` error: the network
+	  * is currently unreliable, possibly due to load or other temporary issues.
+	  *
+	  */
+		readonly DISCONNECTED: 2;
+		/**
+	  * The server doesn't implement the requested method. If there is some other method that the
+	  * client could call (perhaps an older and/or slower interface), it should try that instead.
+	  * Otherwise, this should be treated like `failed`.
+	  *
+	  */
+		readonly UNIMPLEMENTED: 3;
+	};
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * Human-readable failure description.
+  *
+  */
+	get reason(): string;
+	set reason(value: string);
+	/**
+  * The type of the error. The purpose of this enum is not to describe the error itself, but
+  * rather to describe how the client might want to respond to the error.
+  *
+  */
+	get type(): Exception_Type;
+	set type(value: Exception_Type);
+	/**
+  * OBSOLETE. Ignore.
+  *
+  */
+	get obsoleteIsCallersFault(): boolean;
+	set obsoleteIsCallersFault(value: boolean);
+	/**
+  * OBSOLETE. See `type` instead.
+  *
+  */
+	get obsoleteDurability(): number;
+	set obsoleteDurability(value: number);
+	/**
+  * Stack trace text from the remote server. The format is not specified. By default,
+  * implementations do not provide stack traces; the application must explicitly enable them
+  * when desired.
+  *
+  */
+	get trace(): string;
+	set trace(value: string);
+	toString(): string;
+}
+export type CapabilityID = number;
+export interface Method<P extends Struct, R extends Struct> {
+	interfaceId: bigint;
+	methodId: number;
+	interfaceName?: string;
+	methodName?: string;
+	ParamsClass: StructCtor<P>;
+	ResultsClass: StructCtor<R>;
+}
+export type Call<P extends Struct, R extends Struct> = FuncCall<P, R> | DataCall<P, R>;
+export interface BaseCall<P extends Struct, R extends Struct> {
+	method: Method<P, R>;
+}
+export type FuncCall<P extends Struct, R extends Struct> = BaseCall<P, R> & {
+	paramsFunc?(params: P): void;
+};
+export type DataCall<P extends Struct, R extends Struct> = BaseCall<P, R> & {
+	params: P;
+};
+export declare function isFuncCall<P extends Struct, R extends Struct>(call: Call<P, R>): call is FuncCall<P, R>;
+export declare function isDataCall<P extends Struct, R extends Struct>(call: Call<P, R>): call is DataCall<P, R>;
+export declare function copyCall<P extends Struct, R extends Struct>(call: Call<P, R>): DataCall<P, R>;
+export declare function placeParams<P extends Struct, R extends Struct>(call: Call<P, R>, contentPtr: Pointer | undefined): P;
+declare class IDGen {
+	i: number;
+	free: number[];
+	next(): number;
+	remove(i: number): void;
+}
+export interface PipelineOp {
+	field: number;
+	defaultValue?: Pointer;
+}
+export declare class Deferred<T> {
+	static fromPromise<T>(p: Promise<T>): Deferred<T>;
+	promise: Promise<T>;
+	reject: (reason?: unknown) => void;
+	resolve: (value: T | PromiseLike<T>) => void;
+	constructor();
+}
+export interface ecall {
+	call: Call<any, any>;
+	f: Fulfiller<any>;
+}
+export interface pcall extends ecall {
+	transform: PipelineOp[];
+}
+export type ecallSlot = ecall | null;
+declare class Ecalls {
+	data: ecallSlot[];
+	constructor(data: ecallSlot[]);
+	static copyOf(data: ecallSlot[]): Ecalls;
+	len(): number;
+	clear(i: number): void;
+	copy(): Ecalls;
+}
+declare class Fulfiller<R extends Struct> implements Answer<R> {
+	resolved: boolean;
+	answer?: Answer<R>;
+	queue: pcall[];
+	queueCap: number;
+	deferred: Deferred<R>;
+	fulfill(s: R): void;
+	reject(err: Error): void;
+	peek(): Answer<R> | undefined;
+	struct(): Promise<R>;
+	pipelineCall<CallParams extends Struct, CallResults extends Struct>(transform: PipelineOp[], call: Call<CallParams, CallResults>): Answer<CallResults>;
+	pipelineClose(transform: PipelineOp[]): void;
+	emptyQueue(s: Struct): Record<number, Ecalls>;
+}
+export interface Answer<R extends Struct> {
+	struct(): Promise<R>;
+	pipelineCall<CallParams extends Struct, CallResults extends Struct>(transform: PipelineOp[], call: Call<CallParams, CallResults>): Answer<CallResults>;
+	pipelineClose(transform: PipelineOp[]): void;
+}
+declare class AnswerEntry<R extends Struct> {
+	id: number;
+	conn: Conn;
+	resultCaps: number[];
+	done: boolean;
+	obj?: R;
+	err?: Error;
+	deferred: Deferred<R>;
+	queue: AnswerPCall[];
+	constructor(conn: Conn, id: number);
+	fulfill(obj: R): void;
+	reject(err: Error): void;
+	emptyQueue(obj: R): [
+		{
+			[key: number]: AnswerQCall[];
+		},
+		Error | undefined
+	];
+	queueCall<P extends Struct, R extends Struct>(call: Call<P, R>, transform: PipelineOp[], a: AnswerEntry<R>): void;
+}
+export type AnswerQCall = QCallRemoteCall | QCallLocalCall | QCallDisembargo;
+export interface QCallRemoteCall {
+	call: Call<any, any>;
+	a: AnswerEntry<any>;
+}
+export interface QCallLocalCall {
+	call: Call<any, any>;
+	f: Fulfiller<any>;
+}
+export interface QCallDisembargo {
+	embargoID: number;
+	embargoTarget: MessageTarget;
+}
+export interface AnswerPCall {
+	qcall: AnswerQCall;
+	transform: PipelineOp[];
+}
+export type Finalize = (obj: unknown, finalizer: Finalizer) => void;
+export type Finalizer = () => void;
+declare class Ref implements Client {
+	rc: RefCount;
+	closeState: {
+		closed: boolean;
+	};
+	constructor(rc: RefCount, finalize: Finalize);
+	call<P extends Struct, R extends Struct>(cl: Call<P, R>): Answer<R>;
+	client(): Client;
+	close(): void;
+}
+declare class RefCount implements Client {
+	refs: number;
+	finalize: Finalize;
+	_client: Client;
+	private constructor();
+	static new(c: Client, finalize: Finalize): [
+		RefCount,
+		Ref
+	];
+	call<P extends Struct, R extends Struct>(cl: Call<P, R>): Answer<R>;
+	client(): Client;
+	close(): void;
+	ref(): Client;
+	newRef(): Ref;
+	decref(): void;
+}
+export interface Transport {
+	sendMessage(msg: Message$1): void;
+	recvMessage(): Promise<Message$1>;
+	close(): void;
+}
+declare enum QuestionState {
+	IN_PROGRESS = 0,
+	RESOLVED = 1,
+	CANCELED = 2
+}
+declare class Question<P extends Struct, R extends Struct> implements Answer<R> {
+	conn: Conn;
+	id: number;
+	method?: Method<P, R> | undefined;
+	paramCaps: number[];
+	state: QuestionState;
+	obj?: R;
+	err?: Error;
+	derived: PipelineOp[][];
+	deferred: Deferred<R>;
+	constructor(conn: Conn, id: number, method?: Method<P, R> | undefined);
+	struct(): Promise<R>;
+	start(): void;
+	fulfill(obj: Pointer): void;
+	reject(err: Error): void;
+	cancel(err: Error): boolean;
+	pipelineCall<CallParams extends Struct, CallResults extends Struct>(transform: PipelineOp[], call: Call<CallParams, CallResults>): Answer<CallResults>;
+	addPromise(transform: PipelineOp[]): void;
+	pipelineClose(): void;
+}
+export interface ServerMethod<P extends Struct, R extends Struct> extends Method<P, R> {
+	impl(params: P, results: R): Promise<void>;
+}
+export interface ServerCall<P extends Struct, R extends Struct> extends DataCall<P, R> {
+	serverMethod: ServerMethod<P, R>;
+	answer: Fulfiller<R>;
+}
+export declare class Server implements Client {
+	target: any;
+	methods: Array<ServerMethod<any, any>>;
+	constructor(target: any, methods: Array<ServerMethod<any, any>>);
+	startCall<P extends Struct, R extends Struct>(call: ServerCall<P, R>): void;
+	call<P extends Struct, R extends Struct>(call: Call<P, R>): Answer<R>;
+	close(): void;
+}
+export type QuestionSlot = Question<any, any> | null;
+export declare class Conn {
+	transport: Transport;
+	finalize: Finalize;
+	questionID: IDGen;
+	questions: QuestionSlot[];
+	answers: {
+		[key: number]: AnswerEntry<any>;
+	};
+	exportID: IDGen;
+	exports: Array<Export | null>;
+	imports: {
+		[key: number]: ImportEntry;
+	};
+	onError?: (err?: Error) => void;
+	main?: Client;
+	working: boolean;
+	/**
+	 * Create a new connection
+	 * @param transport The transport used to receive/send messages.
+	 * @param finalize Weak reference implementation. Compatible with
+	 * the 'weak' module on node.js (just add weak as a dependency and pass
+	 * require("weak")), but alternative implementations can be provided for
+	 * other platforms like Electron. Defaults to using FinalizationRegistry if
+	 * available.
+	 * @returns A new connection.
+	 */
+	constructor(transport: Transport, finalize?: Finalize);
+	bootstrap<C>(InterfaceClass: InterfaceCtor<C, Server>): C;
+	initMain<S extends InterfaceCtor<unknown, Server>>(InterfaceClass: S, target: ServerTarget<S>): void;
+	startWork(): void;
+	sendReturnException(id: number, err: Error): void;
+	handleBootstrapMessage(m: Message$1): void;
+	handleFinishMessage(m: Message$1): void;
+	handleMessage(m: Message$1): void;
+	handleReturnMessage(m: Message$1): void;
+	handleCallMessage(m: Message$1): void;
+	routeCallMessage<P extends Struct, R extends Struct>(result: AnswerEntry<R>, mt: MessageTarget, cl: Call<P, R>): void;
+	populateMessageCapTable(payload: Payload): void;
+	addImport(id: number): Client;
+	findExport(id: number): Export | null;
+	addExport(client: Client): number;
+	releaseExport(id: number, refs: number): void;
+	error(s: string): void;
+	newQuestion<CallParams extends Struct, CallResults extends Struct>(method?: Method<CallParams, CallResults>): Question<CallParams, CallResults>;
+	findQuestion<P extends Struct, R extends Struct>(id: number): Question<P, R> | null;
+	popQuestion<P extends Struct, R extends Struct>(id: number): Question<P, R> | null;
+	insertAnswer(id: number): AnswerEntry<any> | null;
+	popAnswer(id: number): AnswerEntry<any> | null;
+	shutdown(_err?: Error): void;
+	call<P extends Struct, R extends Struct>(client: Client, call: Call<P, R>): Answer<R>;
+	fillParams<P extends Struct, R extends Struct>(payload: Payload, cl: Call<P, R>): void;
+	makeCapTable(s: Segment, init: (length: number) => List<CapDescriptor>): void;
+	descriptorForClient(desc: CapDescriptor, _client: Client): void;
+	sendMessage(msg: Message$1): void;
+	private work;
+}
+export interface Export {
+	id: number;
+	rc: RefCount;
+	client: Client;
+	wireRefs: number;
+}
+export interface ImportEntry {
+	rc: RefCount;
+	refs: number;
+}
+export declare function answerPipelineClient<T extends Struct>(a: AnswerEntry<T>, transform: PipelineOp[]): Client;
+export type ServerTarget<S extends InterfaceCtor<unknown, Server>> = ConstructorParameters<S["Server"]>[0];
+export interface InterfaceCtor<C, S extends Server> {
+	readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	readonly Client: {
+		new (client: Client): C;
+	};
+	readonly Server: {
+		new (target: any): S;
+	};
+	new (segment: Segment, byteOffset: number, depthLimit?: number): Interface;
+}
+export declare class Interface extends Pointer {
+	static readonly _capnp: {
+		displayName: string;
+	};
+	static readonly getCapID: typeof getCapID;
+	static readonly getAsInterface: typeof getAsInterface;
+	static readonly isInterface: typeof isInterface;
+	static readonly getClient: typeof getClient;
+	constructor(segment: Segment, byteOffset: number, depthLimit?: number);
+	static fromPointer(p: Pointer): Interface | null;
+	getCapId(): CapabilityID;
+	getClient(): Client | null;
+}
+declare function getAsInterface(p: Pointer): Interface | null;
+declare function isInterface(p: Pointer): boolean;
+declare function getCapID(i: Interface): CapabilityID;
+declare function getClient(i: Interface): Client | null;
+export interface _Orphan {
+	capId: number;
+	elementSize: ListElementSize;
+	length: number;
+	size: ObjectSize;
+	type: PointerType;
+}
+/**
+ * An orphaned pointer. This object itself is technically a pointer to the original pointer's content, which was left
+ * untouched in its original message. The original pointer data is encoded as attributes on the Orphan object, ready to
+ * be reconstructed once another pointer is ready to adopt it.
+ */
+export declare class Orphan<T extends Pointer> {
+	/** If this member is not present then the orphan has already been adopted, or something went very wrong. */
+	_capnp?: _Orphan;
+	byteOffset: number;
+	segment: Segment;
+	constructor(src: T);
+	/**
+	 * Adopt (move) this orphan into the target pointer location. This will allocate far pointers in `dst` as needed.
+	 *
+	 * @param dst The destination pointer.
+	 */
+	_moveTo(dst: T): void;
+	dispose(): void;
+}
+declare class Segment implements DataView {
+	readonly id: number;
+	readonly message: Message;
+	buffer: ArrayBuffer;
+	/** The number of bytes currently allocated in the segment. */
+	byteLength: number;
+	/**
+	 * This value should always be zero. It's only here to satisfy the DataView interface.
+	 *
+	 * In the future the Segment implementation (or a child class) may allow accessing the buffer from a nonzero offset,
+	 * but that adds a lot of extra arithmetic.
+	 */
+	byteOffset: number;
+	readonly [Symbol.toStringTag]: "DataView";
+	private _dv;
+	constructor(id: number, message: Message, buffer: ArrayBuffer, byteLength?: number);
+	/**
+	 * Attempt to allocate the requested number of bytes in this segment. If this segment is full this method will return
+	 * a pointer to freshly allocated space in another segment from the same message.
+	 *
+	 * @param byteLength The number of bytes to allocate, will be rounded up to the nearest word.
+	 * @returns A pointer to the newly allocated space.
+	 */
+	allocate(byteLength: number): Pointer;
+	/**
+	 * Quickly copy a word (8 bytes) from `srcSegment` into this one at the given offset.
+	 *
+	 * @param byteOffset The offset to write the word to.
+	 * @param srcSegment The segment to copy the word from.
+	 * @param srcByteOffset The offset from the start of `srcSegment` to copy from.
+	 */
+	copyWord(byteOffset: number, srcSegment: Segment, srcByteOffset: number): void;
+	/**
+	 * Quickly copy words from `srcSegment` into this one.
+	 *
+	 * @param byteOffset The offset to start copying into.
+	 * @param srcSegment The segment to copy from.
+	 * @param srcByteOffset The start offset to copy from.
+	 * @param wordLength The number of words to copy.
+	 */
+	copyWords(byteOffset: number, srcSegment: Segment, srcByteOffset: number, wordLength: number): void;
+	/**
+	 * Quickly fill a number of words in the buffer with zeroes.
+	 *
+	 * @param byteOffset The first byte to set to zero.
+	 * @param wordLength The number of words (not bytes!) to zero out.
+	 */
+	fillZeroWords(byteOffset: number, wordLength: number): void;
+	getBigInt64(byteOffset: number, littleEndian?: boolean): bigint;
+	getBigUint64(byteOffset: number, littleEndian?: boolean): bigint;
+	/**
+	 * Get the total number of bytes available in this segment (the size of its underlying buffer).
+	 *
+	 * @returns The total number of bytes this segment can hold.
+	 */
+	getCapacity(): number;
+	/**
+	 * Read a float32 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getFloat32(byteOffset: number): number;
+	/**
+	 * Read a float64 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getFloat64(byteOffset: number): number;
+	/**
+	 * Read an int16 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getInt16(byteOffset: number): number;
+	/**
+	 * Read an int32 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getInt32(byteOffset: number): number;
+	/**
+	 * Read an int64 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getInt64(byteOffset: number): bigint;
+	/**
+	 * Read an int8 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getInt8(byteOffset: number): number;
+	/**
+	 * Read a uint16 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getUint16(byteOffset: number): number;
+	/**
+	 * Read a uint32 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getUint32(byteOffset: number): number;
+	/**
+	 * Read a uint64 value (as a bigint) out of this segment.
+	 * NOTE: this does not copy the memory region, so updates to the underlying buffer will affect the returned value!
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getUint64(byteOffset: number): bigint;
+	/**
+	 * Read a uint8 value out of this segment.
+	 *
+	 * @param byteOffset The offset in bytes to the value.
+	 * @returns The value.
+	 */
+	getUint8(byteOffset: number): number;
+	hasCapacity(byteLength: number): boolean;
+	/**
+	 * Quickly check the word at the given offset to see if it is equal to zero.
+	 *
+	 * PERF_V8: Fastest way to do this is by reading the whole word as a `number` (float64) in the _native_ endian format
+	 * and see if it's zero.
+	 *
+	 * Benchmark: http://jsben.ch/#/Pjooc
+	 *
+	 * @param byteOffset The offset to the word.
+	 * @returns `true` if the word is zero.
+	 */
+	isWordZero(byteOffset: number): boolean;
+	/**
+	 * Swap out this segment's underlying buffer with a new one. It's assumed that the new buffer has the same content but
+	 * more free space, otherwise all existing pointers to this segment will be hilariously broken.
+	 *
+	 * @param buffer The new buffer to use.
+	 */
+	replaceBuffer(buffer: ArrayBuffer): void;
+	/**
+	 * Read a float16 value from the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param littleEndian If true, read the value as little-endian, otherwise read it as big-endian.
+	 * @returns The value read from the buffer.
+	 */
+	getFloat16(byteOffset: number, littleEndian?: boolean | undefined): number;
+	/**
+	 * Write an float16 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setFloat16(byteOffset: number, val: number): void;
+	setBigInt64(byteOffset: number, value: bigint, littleEndian?: boolean): void;
+	/** WARNING: This function is not yet implemented.  */
+	setBigUint64(byteOffset: number, value: bigint, littleEndian?: boolean): void;
+	/**
+	 * Write a float32 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setFloat32(byteOffset: number, val: number): void;
+	/**
+	 * Write an float64 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setFloat64(byteOffset: number, val: number): void;
+	/**
+	 * Write an int16 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setInt16(byteOffset: number, val: number): void;
+	/**
+	 * Write an int32 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setInt32(byteOffset: number, val: number): void;
+	/**
+	 * Write an int8 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setInt8(byteOffset: number, val: number): void;
+	/**
+	 * Write an int64 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setInt64(byteOffset: number, val: bigint): void;
+	/**
+	 * Write a uint16 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setUint16(byteOffset: number, val: number): void;
+	/**
+	 * Write a uint32 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setUint32(byteOffset: number, val: number): void;
+	/**
+	 * Write a uint64 value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setUint64(byteOffset: number, val: bigint): void;
+	/**
+	 * Write a uint8 (byte) value to the specified offset.
+	 *
+	 * @param byteOffset The offset from the beginning of the buffer.
+	 * @param val The value to store.
+	 */
+	setUint8(byteOffset: number, val: number): void;
+	/**
+	 * Write a zero word (8 bytes) to the specified offset. This is slightly faster than calling `setUint64` or
+	 * `setFloat64` with a zero value.
+	 *
+	 * Benchmark: http://jsben.ch/#/dUdPI
+	 *
+	 * @param byteOffset The offset of the word to set to zero.
+	 */
+	setWordZero(byteOffset: number): void;
+	toString(): string;
+}
+export interface _StructCtor extends _PointerCtor {
+	readonly id: string;
+	readonly size: ObjectSize;
+}
+export interface StructCtor<T extends Struct> {
+	readonly _capnp: _StructCtor;
+	new (segment: Segment, byteOffset: number, depthLimit?: number, compositeIndex?: number): T;
+}
+export interface _Struct extends _Pointer {
+	compositeIndex?: number;
+}
+export declare class Struct extends Pointer<_Struct> {
+	static readonly _capnp: {
+		displayName: string;
+	};
+	/**
+	 * Create a new pointer to a struct.
+	 *
+	 * @param segment The segment the pointer resides in.
+	 * @param byteOffset The offset from the beginning of the segment to the beginning of the pointer data.
+	 * @param depthLimit The nesting depth limit for this object.
+	 * @param compositeIndex If set, then this pointer is actually a reference to a composite list
+	 * (`this._getPointerTargetType() === PointerType.LIST`), and this number is used as the index of the struct within
+	 * the list. It is not valid to call `initStruct()` on a composite struct – the struct contents are initialized when
+	 * the list pointer is initialized.
+	 */
+	constructor(segment: Segment, byteOffset: number, depthLimit?: number, compositeIndex?: number);
+	static [Symbol.toStringTag](): string;
+	[Symbol.toStringTag](): string;
+}
+export interface Client {
+	call<P extends Struct, R extends Struct>(call: Call<P, R>): Answer<R>;
+	close(): void;
+}
+export declare function isSameClient(c: Client, d: Client): boolean;
+export declare function clientFromResolution(transform: PipelineOp[], obj?: Struct, err?: Error): Client;
+declare class ArenaAllocationResult {
+	/**
+	 * The newly allocated buffer. This buffer might be a copy of an existing segment's buffer with free space appended.
+	 */
+	readonly buffer: ArrayBuffer;
+	/**
+	 * The id of the newly-allocated segment.
+	 */
+	readonly id: number;
+	constructor(id: number, buffer: ArrayBuffer);
+}
+declare enum ArenaKind {
+	SINGLE_SEGMENT = 0,
+	MULTI_SEGMENT = 1
+}
+declare class MultiSegmentArena {
+	readonly buffers: ArrayBuffer[];
+	static readonly allocate: typeof allocate$1;
+	static readonly getBuffer: typeof getBuffer$1;
+	static readonly getNumSegments: typeof getNumSegments$1;
+	readonly kind = ArenaKind.MULTI_SEGMENT;
+	constructor(buffers?: ArrayBuffer[]);
+	toString(): string;
+}
+declare function allocate$1(minSize: number, m: MultiSegmentArena): ArenaAllocationResult;
+declare function getBuffer$1(id: number, m: MultiSegmentArena): ArrayBuffer;
+declare function getNumSegments$1(m: MultiSegmentArena): number;
+declare class SingleSegmentArena {
+	static readonly allocate: typeof allocate;
+	static readonly getBuffer: typeof getBuffer;
+	static readonly getNumSegments: typeof getNumSegments;
+	buffer: ArrayBuffer;
+	readonly kind = ArenaKind.SINGLE_SEGMENT;
+	constructor(buffer?: ArrayBuffer);
+	toString(): string;
+}
+declare function allocate(minSize: number, segments: Segment[], s: SingleSegmentArena): ArenaAllocationResult;
+declare function getBuffer(id: number, s: SingleSegmentArena): ArrayBuffer;
+declare function getNumSegments(): number;
+export type AnyArena = MultiSegmentArena | SingleSegmentArena;
+export interface _Message {
+	readonly arena: AnyArena;
+	segments: Segment[];
+	traversalLimit: number;
+	capTable?: Array<Client | null>;
+}
+export declare class Message {
+	static readonly allocateSegment: typeof allocateSegment;
+	static readonly dump: typeof dump;
+	static readonly getRoot: typeof getRoot;
+	static readonly getSegment: typeof getSegment;
+	static readonly initRoot: typeof initRoot;
+	static readonly readRawPointer: typeof readRawPointer;
+	static readonly toArrayBuffer: typeof toArrayBuffer;
+	static readonly toPackedArrayBuffer: typeof toPackedArrayBuffer;
+	readonly _capnp: _Message;
+	/**
+	 * A Cap'n Proto message.
+	 *
+	 * SECURITY WARNING: In Node.js do not pass a Buffer's internal array buffer into this constructor. Pass the buffer
+	 * directly and everything will be fine. If not, your message will potentially be initialized with random memory
+	 * contents!
+	 *
+	 * The constructor method creates a new Message, optionally using a provided arena for segment allocation, or a buffer
+	 * to read from.
+	 *
+	 * @param src The source for the message.
+	 * A value of `undefined` will cause the message to initialize with a single segment arena only big enough for the
+	 * root pointer; it will expand as you go. This is a reasonable choice for most messages.
+	 *
+	 * Passing an arena will cause the message to use that arena for its segment allocation. Contents will be accepted
+	 * as-is.
+	 *
+	 * Passing an array buffer view (like `DataView`, `Uint8Array` or `Buffer`) will create a **copy** of the source
+	 * buffer; beware of the potential performance cost!
+	 *
+	 * @param packed Whether or not the message is packed. If `true` (the default), the message will be
+	 * unpacked.
+	 *
+	 * @param singleSegment If true, `src` will be treated as a message consisting of a single segment without
+	 * a framing header.
+	 *
+	 */
+	constructor(src?: AnyArena | ArrayBufferView | ArrayBuffer, packed?: boolean, singleSegment?: boolean);
+	allocateSegment(byteLength: number): Segment;
+	/**
+	 * Copies the contents of this message into an identical message with its own ArrayBuffers.
+	 *
+	 * @returns A copy of this message.
+	 */
+	copy(): Message;
+	/**
+	 * Create a pretty-printed string dump of this message; incredibly useful for debugging.
+	 *
+	 * WARNING: Do not call this method on large messages!
+	 *
+	 * @returns A big steaming pile of pretty hex digits.
+	 */
+	dump(): string;
+	/**
+	 * Get a struct pointer for the root of this message. This is primarily used when reading a message; it will not
+	 * overwrite existing data.
+	 *
+	 * @param RootStruct The struct type to use as the root.
+	 * @returns A struct representing the root of the message.
+	 */
+	getRoot<T extends Struct>(RootStruct: StructCtor<T>): T;
+	/**
+	 * Get a segment by its id.
+	 *
+	 * This will lazily allocate the first segment if it doesn't already exist.
+	 *
+	 * @param id The segment id.
+	 * @returns The requested segment.
+	 */
+	getSegment(id: number): Segment;
+	/**
+	 * Initialize a new message using the provided struct type as the root.
+	 *
+	 * @param RootStruct The struct type to use as the root.
+	 * @returns An initialized struct pointing to the root of the message.
+	 */
+	initRoot<T extends Struct>(RootStruct: StructCtor<T>): T;
+	/**
+	 * Set the root of the message to a copy of the given pointer. Used internally
+	 * to make copies of pointers for default values.
+	 *
+	 * @param src The source pointer to copy.
+	 */
+	setRoot(src: Pointer): void;
+	/**
+	 * Combine the contents of this message's segments into a single array buffer and prepend a stream framing header
+	 * containing information about the following segment data.
+	 *
+	 * @returns An ArrayBuffer with the contents of this message.
+	 */
+	toArrayBuffer(): ArrayBuffer;
+	/**
+	 * Like `toArrayBuffer()`, but also applies the packing algorithm to the output. This is typically what you want to
+	 * use if you're sending the message over a network link or other slow I/O interface where size matters.
+	 *
+	 * @returns A packed message.
+	 */
+	toPackedArrayBuffer(): ArrayBuffer;
+	addCap(client: Client | null): number;
+	toString(): string;
+}
+declare function allocateSegment(byteLength: number, m: Message): Segment;
+declare function dump(m: Message): string;
+declare function getRoot<T extends Struct>(RootStruct: StructCtor<T>, m: Message): T;
+declare function getSegment(id: number, m: Message): Segment;
+declare function initRoot<T extends Struct>(RootStruct: StructCtor<T>, m: Message): T;
+/**
+ * Read a pointer in raw form (a packed message with framing headers). Does not
+ * care or attempt to validate the input beyond parsing the message
+ * segments.
+ *
+ * This is typically used by the compiler to load default values, but can be
+ * useful to work with messages with an unknown schema.
+ *
+ * @param data The raw data to read.
+ * @returns A root pointer.
+ */
+export declare function readRawPointer(data: ArrayBuffer): Pointer;
+declare function toArrayBuffer(m: Message): ArrayBuffer;
+declare function toPackedArrayBuffer(m: Message): ArrayBuffer;
+/**
+ * A generic blob of bytes. Can be converted to a DataView or Uint8Array to access its contents using `toDataView()` and
+ * `toUint8Array()`. Use `copyBuffer()` to copy an entire buffer at once.
+ */
+export declare class Data extends List<number> {
+	static fromPointer(pointer: Pointer): Data;
+	protected static _fromPointerUnchecked(pointer: Pointer): Data;
+	/**
+	 * Copy the contents of `src` into this Data pointer. If `src` is smaller than the length of this pointer then the
+	 * remaining bytes will be zeroed out. Extra bytes in `src` are ignored.
+	 *
+	 * @param src The source buffer.
+	 */
+	copyBuffer(src: ArrayBuffer | ArrayBufferView): void;
+	/**
+	 * Read a byte from the specified offset.
+	 *
+	 * @param byteOffset The byte offset to read.
+	 * @returns The byte value.
+	 */
+	get(byteOffset: number): number;
+	/**
+	 * Write a byte at the specified offset.
+	 *
+	 * @param byteOffset The byte offset to set.
+	 * @param value The byte value to set.
+	 */
+	set(byteOffset: number, value: number): void;
+	/**
+	 * Creates a **copy** of the underlying buffer data and returns it as an ArrayBuffer.
+	 *
+	 * To obtain a reference to the underlying buffer instead, use `toUint8Array()` or `toDataView()`.
+	 *
+	 * @returns A copy of this data buffer.
+	 */
+	toArrayBuffer(): ArrayBuffer;
+	/**
+	 * Convert this Data pointer to a DataView representing the pointer's contents.
+	 *
+	 * WARNING: The DataView references memory from a message segment, so do not venture outside the bounds of the
+	 * DataView or else BAD THINGS.
+	 *
+	 * @returns A live reference to the underlying buffer.
+	 */
+	toDataView(): DataView;
+	[Symbol.toStringTag](): string;
+	/**
+	 * Convert this Data pointer to a Uint8Array representing the pointer's contents.
+	 *
+	 * WARNING: The Uint8Array references memory from a message segment, so do not venture outside the bounds of the
+	 * Uint8Array or else BAD THINGS.
+	 *
+	 * @returns A live reference to the underlying buffer.
+	 */
+	toUint8Array(): Uint8Array;
+}
+declare class PipelineClient<AnswerResults extends Struct, ParentResults extends Struct, Results extends Struct> implements Client {
+	pipeline: Pipeline<AnswerResults, ParentResults, Results>;
+	constructor(pipeline: Pipeline<AnswerResults, ParentResults, Results>);
+	transform(): PipelineOp[];
+	call<CallParams extends Struct, CallResults extends Struct>(call: Call<CallParams, CallResults>): Answer<CallResults>;
+	close(): void;
+}
+/**
+ * A Pipeline is a generic wrapper for an answer
+ */
+export declare class Pipeline<AnswerResults extends Struct, ParentResults extends Struct, Results extends Struct> {
+	ResultsClass: StructCtor<Results>;
+	answer: Answer<AnswerResults>;
+	parent?: Pipeline<AnswerResults, Struct, ParentResults> | undefined;
+	op: PipelineOp;
+	pipelineClient?: PipelineClient<AnswerResults, ParentResults, Results>;
+	constructor(ResultsClass: StructCtor<Results>, answer: Answer<AnswerResults>, op?: PipelineOp, parent?: Pipeline<AnswerResults, Struct, ParentResults> | undefined);
+	transform(): PipelineOp[];
+	struct(): Promise<Results>;
+	client(): PipelineClient<AnswerResults, ParentResults, Results>;
+	getPipeline<RR extends Struct>(ResultsClass: StructCtor<RR>, off: number, defaultValue?: Pointer): Pipeline<AnswerResults, Results, RR>;
+}
+export declare abstract class DeferredTransport implements Transport {
+	protected d?: Deferred<Message$1>;
+	protected closed: boolean;
+	abstract sendMessage(msg: Message$1): void;
+	close(): void;
+	recvMessage(): Promise<Message$1>;
+	protected reject: (err: unknown) => void;
+	protected resolve: (buf: ArrayBuffer) => void;
+}
+export declare class ErrorClient implements Client {
+	err: Error;
+	constructor(err: Error);
+	call<P extends Struct, R extends Struct>(_call: Call<P, R>): Answer<R>;
+	close(): void;
+}
+export declare function clientOrNull(client: Client | null): Client;
+export interface InterfaceDefinition {
+	methods: Array<Method<any, any>>;
+}
+export declare class Registry {
+	static readonly interfaces: Map<bigint, InterfaceDefinition>;
+	static register(id: bigint, def: InterfaceDefinition): void;
+	static lookup(id: bigint): InterfaceDefinition | undefined;
+}
+export declare class Text extends List<string> {
+	static fromPointer(pointer: Pointer): Text;
+	/**
+	 * Read a utf-8 encoded string value from this pointer.
+	 *
+	 * @param index The index at which to start reading; defaults to zero.
+	 * @returns The string value.
+	 */
+	get(index?: number): string;
+	/**
+	 * Get the number of utf-8 encoded bytes in this text. This does **not** include the NUL byte.
+	 *
+	 * @returns The number of bytes allocated for the text.
+	 */
+	get length(): number;
+	/**
+	 * Write a utf-8 encoded string value starting at the specified index.
+	 *
+	 * @param index The index at which to start copying the string. Note that if this is not zero the bytes
+	 * before `index` will be left as-is. All bytes after `index` will be overwritten.
+	 * @param value The string value to set.
+	 */
+	set(index: number, value: string): void;
+	toString(): string;
+	toJSON(): string;
+	[Symbol.toPrimitive](): string;
+	[Symbol.toStringTag](): string;
+}
+export declare class Void extends Struct {
+	static readonly _capnp: _StructCtor;
+}
+declare function initStruct(size: ObjectSize, s: Struct): void;
+declare function initStructAt<T extends Struct>(index: number, StructClass: StructCtor<T>, p: Pointer): T;
+declare function checkPointerBounds(index: number, s: Struct): void;
+declare function getInterfaceClientOrNullAt(index: number, s: Struct): Client;
+declare function getInterfaceClientOrNull(p: Pointer): Client;
+declare function resize(dstSize: ObjectSize, s: Struct): void;
+declare function getAs<T extends Struct>(StructClass: StructCtor<T>, s: Struct): T;
+declare function getBit(bitOffset: number, s: Struct, defaultMask?: DataView): boolean;
+declare function getData(index: number, s: Struct, defaultValue?: Pointer): Data;
+declare function getDataSection(s: Struct): Pointer;
+declare function getFloat32(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+declare function getFloat64(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+declare function getInt16(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+declare function getInt32(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+declare function getInt64(byteOffset: number, s: Struct, defaultMask?: DataView): bigint;
+declare function getInt8(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+declare function getList<T>(index: number, ListClass: ListCtor<T>, s: Struct, defaultValue?: Pointer): List<T>;
+declare function getPointer(index: number, s: Struct): Pointer;
+declare function getPointerAs<T extends Pointer>(index: number, PointerClass: PointerCtor<T>, s: Struct): T;
+declare function getPointerSection(s: Struct): Pointer;
+declare function getSize(s: Struct): ObjectSize;
+declare function getStruct<T extends Struct>(index: number, StructClass: StructCtor<T>, s: Struct, defaultValue?: Pointer): T;
+declare function getText(index: number, s: Struct, defaultValue?: string): string;
+declare function getUint16(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+declare function getUint32(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+declare function getUint64(byteOffset: number, s: Struct, defaultMask?: DataView): bigint;
+declare function getUint8(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+declare function initData(index: number, length: number, s: Struct): Data;
+declare function initList<T>(index: number, ListClass: ListCtor<T>, length: number, s: Struct): List<T>;
+declare function setBit(bitOffset: number, value: boolean, s: Struct, defaultMask?: DataView): void;
+declare function setFloat32(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function setFloat64(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function setInt16(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function setInt32(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function setInt64(byteOffset: number, value: bigint, s: Struct, defaultMask?: DataView): void;
+declare function setInt8(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function setText(index: number, value: string, s: Struct): void;
+declare function setUint16(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function setUint32(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function setUint64(byteOffset: number, value: bigint, s: Struct, defaultMask?: DataView): void;
+declare function setUint8(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function testWhich(name: string, found: number, wanted: number, s: Struct): void;
+declare function checkDataBounds(byteOffset: number, byteLength: number, s: Struct): void;
+declare function adopt<T extends Pointer>(src: Orphan<T>, p: T): void;
+declare function disown<T extends Pointer>(p: T): Orphan<T>;
+declare function dump$1(p: Pointer): string;
+declare function getListByteLength(elementSize: ListElementSize, length: number, compositeSize?: ObjectSize): number;
+declare function getListElementByteLength(elementSize: ListElementSize): number;
+declare function add(offset: number, p: Pointer): Pointer;
+declare function copyFrom(src: Pointer, p: Pointer): void;
+declare function erase(p: Pointer): void;
+declare function erasePointer(p: Pointer): void;
+declare function followFar(p: Pointer): Pointer;
+declare function followFars(p: Pointer): Pointer;
+declare function getCapabilityId(p: Pointer): number;
+declare function getContent(p: Pointer, ignoreCompositeIndex?: boolean): Pointer;
+declare function getFarSegmentId(p: Pointer): number;
+declare function getListElementSize(p: Pointer): ListElementSize;
+declare function getListLength(p: Pointer): number;
+declare function getOffsetWords(p: Pointer): number;
+declare function getPointerType(p: Pointer): PointerType;
+declare function getStructDataWords(p: Pointer): number;
+declare function getStructPointerLength(p: Pointer): number;
+declare function getStructSize(p: Pointer): ObjectSize;
+declare function getTargetCompositeListTag(p: Pointer): Pointer;
+declare function getTargetCompositeListSize(p: Pointer): ObjectSize;
+declare function getTargetListElementSize(p: Pointer): ListElementSize;
+declare function getTargetListLength(p: Pointer): number;
+declare function getTargetPointerType(p: Pointer): PointerType;
+declare function getTargetStructSize(p: Pointer): ObjectSize;
+declare function initPointer(contentSegment: Segment, contentOffset: number, p: Pointer): PointerAllocationResult;
+declare function isDoubleFar(p: Pointer): boolean;
+declare function isNull(p: Pointer): boolean;
+declare function relocateTo(dst: Pointer, src: Pointer): void;
+declare function setFarPointer(doubleFar: boolean, offsetWords: number, segmentId: number, p: Pointer): void;
+declare function setInterfacePointer(capId: number, p: Pointer): void;
+declare function getInterfacePointer(p: Pointer): number;
+declare function setListPointer(offsetWords: number, size: ListElementSize, length: number, p: Pointer, compositeSize?: ObjectSize): void;
+declare function setStructPointer(offsetWords: number, size: ObjectSize, p: Pointer): void;
+declare function validate(pointerType: PointerType, p: Pointer, elementSize?: ListElementSize): void;
+declare function copyFromInterface(src: Pointer, dst: Pointer): void;
+declare function copyFromList(src: Pointer, dst: Pointer): void;
+declare function copyFromStruct(src: Pointer, dst: Pointer): void;
+declare function trackPointerAllocation(message: Message, p: Pointer): void;
+declare class PointerAllocationResult {
+	readonly pointer: Pointer;
+	readonly offsetWords: number;
+	constructor(pointer: Pointer, offsetWords: number);
+}
+export type utils_PointerAllocationResult = PointerAllocationResult;
+declare const utils_PointerAllocationResult: typeof PointerAllocationResult;
+declare const utils_add: typeof add;
+declare const utils_adopt: typeof adopt;
+declare const utils_checkDataBounds: typeof checkDataBounds;
+declare const utils_checkPointerBounds: typeof checkPointerBounds;
+declare const utils_copyFrom: typeof copyFrom;
+declare const utils_copyFromInterface: typeof copyFromInterface;
+declare const utils_copyFromList: typeof copyFromList;
+declare const utils_copyFromStruct: typeof copyFromStruct;
+declare const utils_disown: typeof disown;
+declare const utils_dump: typeof dump$1;
+declare const utils_erase: typeof erase;
+declare const utils_erasePointer: typeof erasePointer;
+declare const utils_followFar: typeof followFar;
+declare const utils_followFars: typeof followFars;
+declare const utils_getAs: typeof getAs;
+declare const utils_getBit: typeof getBit;
+declare const utils_getCapabilityId: typeof getCapabilityId;
+declare const utils_getContent: typeof getContent;
+declare const utils_getData: typeof getData;
+declare const utils_getDataSection: typeof getDataSection;
+declare const utils_getFarSegmentId: typeof getFarSegmentId;
+declare const utils_getFloat32: typeof getFloat32;
+declare const utils_getFloat64: typeof getFloat64;
+declare const utils_getInt16: typeof getInt16;
+declare const utils_getInt32: typeof getInt32;
+declare const utils_getInt64: typeof getInt64;
+declare const utils_getInt8: typeof getInt8;
+declare const utils_getInterfaceClientOrNull: typeof getInterfaceClientOrNull;
+declare const utils_getInterfaceClientOrNullAt: typeof getInterfaceClientOrNullAt;
+declare const utils_getInterfacePointer: typeof getInterfacePointer;
+declare const utils_getList: typeof getList;
+declare const utils_getListByteLength: typeof getListByteLength;
+declare const utils_getListElementByteLength: typeof getListElementByteLength;
+declare const utils_getListElementSize: typeof getListElementSize;
+declare const utils_getListLength: typeof getListLength;
+declare const utils_getOffsetWords: typeof getOffsetWords;
+declare const utils_getPointer: typeof getPointer;
+declare const utils_getPointerAs: typeof getPointerAs;
+declare const utils_getPointerSection: typeof getPointerSection;
+declare const utils_getPointerType: typeof getPointerType;
+declare const utils_getSize: typeof getSize;
+declare const utils_getStruct: typeof getStruct;
+declare const utils_getStructDataWords: typeof getStructDataWords;
+declare const utils_getStructPointerLength: typeof getStructPointerLength;
+declare const utils_getStructSize: typeof getStructSize;
+declare const utils_getTargetCompositeListSize: typeof getTargetCompositeListSize;
+declare const utils_getTargetCompositeListTag: typeof getTargetCompositeListTag;
+declare const utils_getTargetListElementSize: typeof getTargetListElementSize;
+declare const utils_getTargetListLength: typeof getTargetListLength;
+declare const utils_getTargetPointerType: typeof getTargetPointerType;
+declare const utils_getTargetStructSize: typeof getTargetStructSize;
+declare const utils_getText: typeof getText;
+declare const utils_getUint16: typeof getUint16;
+declare const utils_getUint32: typeof getUint32;
+declare const utils_getUint64: typeof getUint64;
+declare const utils_getUint8: typeof getUint8;
+declare const utils_initData: typeof initData;
+declare const utils_initList: typeof initList;
+declare const utils_initPointer: typeof initPointer;
+declare const utils_initStruct: typeof initStruct;
+declare const utils_initStructAt: typeof initStructAt;
+declare const utils_isDoubleFar: typeof isDoubleFar;
+declare const utils_isNull: typeof isNull;
+declare const utils_relocateTo: typeof relocateTo;
+declare const utils_resize: typeof resize;
+declare const utils_setBit: typeof setBit;
+declare const utils_setFarPointer: typeof setFarPointer;
+declare const utils_setFloat32: typeof setFloat32;
+declare const utils_setFloat64: typeof setFloat64;
+declare const utils_setInt16: typeof setInt16;
+declare const utils_setInt32: typeof setInt32;
+declare const utils_setInt64: typeof setInt64;
+declare const utils_setInt8: typeof setInt8;
+declare const utils_setInterfacePointer: typeof setInterfacePointer;
+declare const utils_setListPointer: typeof setListPointer;
+declare const utils_setStructPointer: typeof setStructPointer;
+declare const utils_setText: typeof setText;
+declare const utils_setUint16: typeof setUint16;
+declare const utils_setUint32: typeof setUint32;
+declare const utils_setUint64: typeof setUint64;
+declare const utils_setUint8: typeof setUint8;
+declare const utils_testWhich: typeof testWhich;
+declare const utils_trackPointerAllocation: typeof trackPointerAllocation;
+declare const utils_validate: typeof validate;
+export declare namespace utils {
+	export { utils_PointerAllocationResult as utils_PointerAllocationResult, utils_add as utils_add, utils_adopt as utils_adopt, utils_checkDataBounds as utils_checkDataBounds, utils_checkPointerBounds as utils_checkPointerBounds, utils_copyFrom as utils_copyFrom, utils_copyFromInterface as utils_copyFromInterface, utils_copyFromList as utils_copyFromList, utils_copyFromStruct as utils_copyFromStruct, utils_disown as utils_disown, utils_dump as utils_dump, utils_erase as utils_erase, utils_erasePointer as utils_erasePointer, utils_followFar as utils_followFar, utils_followFars as utils_followFars, utils_getAs as utils_getAs, utils_getBit as utils_getBit, utils_getCapabilityId as utils_getCapabilityId, utils_getContent as utils_getContent, utils_getData as utils_getData, utils_getDataSection as utils_getDataSection, utils_getFarSegmentId as utils_getFarSegmentId, utils_getFloat32 as utils_getFloat32, utils_getFloat64 as utils_getFloat64, utils_getInt16 as utils_getInt16, utils_getInt32 as utils_getInt32, utils_getInt64 as utils_getInt64, utils_getInt8 as utils_getInt8, utils_getInterfaceClientOrNull as utils_getInterfaceClientOrNull, utils_getInterfaceClientOrNullAt as utils_getInterfaceClientOrNullAt, utils_getInterfacePointer as utils_getInterfacePointer, utils_getList as utils_getList, utils_getListByteLength as utils_getListByteLength, utils_getListElementByteLength as utils_getListElementByteLength, utils_getListElementSize as utils_getListElementSize, utils_getListLength as utils_getListLength, utils_getOffsetWords as utils_getOffsetWords, utils_getPointer as utils_getPointer, utils_getPointerAs as utils_getPointerAs, utils_getPointerSection as utils_getPointerSection, utils_getPointerType as utils_getPointerType, utils_getSize as utils_getSize, utils_getStruct as utils_getStruct, utils_getStructDataWords as utils_getStructDataWords, utils_getStructPointerLength as utils_getStructPointerLength, utils_getStructSize as utils_getStructSize, utils_getTargetCompositeListSize as utils_getTargetCompositeListSize, utils_getTargetCompositeListTag as utils_getTargetCompositeListTag, utils_getTargetListElementSize as utils_getTargetListElementSize, utils_getTargetListLength as utils_getTargetListLength, utils_getTargetPointerType as utils_getTargetPointerType, utils_getTargetStructSize as utils_getTargetStructSize, utils_getText as utils_getText, utils_getUint16 as utils_getUint16, utils_getUint32 as utils_getUint32, utils_getUint64 as utils_getUint64, utils_getUint8 as utils_getUint8, utils_initData as utils_initData, utils_initList as utils_initList, utils_initPointer as utils_initPointer, utils_initStruct as utils_initStruct, utils_initStructAt as utils_initStructAt, utils_isDoubleFar as utils_isDoubleFar, utils_isNull as utils_isNull, utils_relocateTo as utils_relocateTo, utils_resize as utils_resize, utils_setBit as utils_setBit, utils_setFarPointer as utils_setFarPointer, utils_setFloat32 as utils_setFloat32, utils_setFloat64 as utils_setFloat64, utils_setInt16 as utils_setInt16, utils_setInt32 as utils_setInt32, utils_setInt64 as utils_setInt64, utils_setInt8 as utils_setInt8, utils_setInterfacePointer as utils_setInterfacePointer, utils_setListPointer as utils_setListPointer, utils_setStructPointer as utils_setStructPointer, utils_setText as utils_setText, utils_setUint16 as utils_setUint16, utils_setUint32 as utils_setUint32, utils_setUint64 as utils_setUint64, utils_setUint8 as utils_setUint8, utils_testWhich as utils_testWhich, utils_trackPointerAllocation as utils_trackPointerAllocation, utils_validate as utils_validate };
+}
+export declare const AnyPointerList: ListCtor<Pointer>;
+export declare class BoolList extends List<boolean> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): boolean;
+	set(index: number, value: boolean): void;
+	[Symbol.toStringTag](): string;
+}
+export declare function CompositeList<T extends Struct>(CompositeClass: StructCtor<T>): ListCtor<T>;
+export declare const DataList: ListCtor<Data>;
+export declare class Float32List extends List<number> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): number;
+	set(index: number, value: number): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Float64List extends List<number> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): number;
+	set(index: number, value: number): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Int8List extends List<number> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): number;
+	set(index: number, value: number): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Int16List extends List<number> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): number;
+	set(index: number, value: number): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Int32List extends List<number> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): number;
+	set(index: number, value: number): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Int64List extends List<bigint> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): bigint;
+	set(index: number, value: bigint): void;
+	[Symbol.toStringTag](): string;
+}
+export declare const InterfaceList: ListCtor<Interface>;
+export declare function PointerList<T extends Pointer>(PointerClass: PointerCtor<T>): ListCtor<T>;
+export declare class TextList extends List<string> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): string;
+	set(index: number, value: string): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Uint8List extends List<number> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): number;
+	set(index: number, value: number): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Uint16List extends List<number> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): number;
+	set(index: number, value: number): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Uint32List extends List<number> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): number;
+	set(index: number, value: number): void;
+	[Symbol.toStringTag](): string;
+}
+export declare class Uint64List extends List<bigint> {
+	static readonly _capnp: _ListCtor;
+	get(index: number): bigint;
+	set(index: number, value: bigint): void;
+	[Symbol.toStringTag](): string;
+}
+export declare const VoidList: ListCtor<Void>;
+export declare const getFloat32Mask: (x: number) => DataView;
+export declare const getFloat64Mask: (x: number) => DataView;
+export declare const getInt16Mask: (x: number) => DataView;
+export declare const getInt32Mask: (x: number) => DataView;
+export declare const getInt64Mask: (x: bigint) => DataView;
+export declare const getInt8Mask: (x: number) => DataView;
+export declare const getUint16Mask: (x: number) => DataView;
+export declare const getUint32Mask: (x: number) => DataView;
+export declare const getUint64Mask: (x: bigint) => DataView;
+export declare const getUint8Mask: (x: number) => DataView;
+export declare function getBitMask(value: boolean, bitOffset: number): DataView;
+/**
+ * A class that manages Cap'n Proto RPC connections.
+ */
+export declare class CapnpRPC {
+	protected acceptQueue: Deferred<Conn>[];
+	protected connections: Record<number, Conn>;
+	protected connectQueue: MessagePort$1[];
+	/**
+	 * Creates a new {@link Conn} instance.
+	 *
+	 * @remarks
+	 * This class is used to manage connections and accept incoming connections using the {@link MessageChannel} API.
+	 */
+	connect(id?: number): Conn;
+	/**
+	 * Accepts a connection from the connect queue.
+	 *
+	 * @returns A promise that resolves to a Conn instance when a connection is accepted.
+	 * @throws If no connections are available in the connect queue.
+	 */
+	accept(): Promise<Conn>;
+	/**
+	 * Closes all connections and clears the queues.
+	 *
+	 * @remarks
+	 * This method will reject all pending accept promises and close all
+	 * connections in the connect queue.
+	 */
+	close(): void;
+}
+export declare class MessageChannelTransport extends DeferredTransport {
+	port: MessagePort$1;
+	constructor(port: MessagePort$1);
+	close: () => void;
+	sendMessage(msg: Message$1): void;
+}
+declare class Node_Parameter extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get name(): string;
+	set name(value: string);
+	toString(): string;
+}
+declare class Node_NestedNode extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * Unqualified symbol name.  Unlike Node.displayName, this *can* be used programmatically.
+  *
+  * (On Zooko's triangle, this is the node's petname according to its parent scope.)
+  *
+  */
+	get name(): string;
+	set name(value: string);
+	/**
+  * ID of the nested node.  Typically, the target node's scopeId points back to this node, but
+  * robust code should avoid relying on this.
+  *
+  */
+	get id(): bigint;
+	set id(value: bigint);
+	toString(): string;
+}
+declare class Node_SourceInfo_Member extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * Doc comment on the member.
+  *
+  */
+	get docComment(): string;
+	set docComment(value: string);
+	toString(): string;
+}
+declare class Node_SourceInfo extends Struct {
+	static readonly Member: typeof Node_SourceInfo_Member;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Members: ListCtor<Node_SourceInfo_Member>;
+	/**
+  * ID of the Node which this info describes.
+  *
+  */
+	get id(): bigint;
+	set id(value: bigint);
+	/**
+  * The top-level doc comment for the Node.
+  *
+  */
+	get docComment(): string;
+	set docComment(value: string);
+	_adoptMembers(value: Orphan<List<Node_SourceInfo_Member>>): void;
+	_disownMembers(): Orphan<List<Node_SourceInfo_Member>>;
+	/**
+  * Information about each member -- i.e. fields (for structs), enumerants (for enums), or
+  * methods (for interfaces).
+  *
+  * This list is the same length and order as the corresponding list in the Node, i.e.
+  * Node.struct.fields, Node.enum.enumerants, or Node.interface.methods.
+  *
+  */
+	get members(): List<Node_SourceInfo_Member>;
+	_hasMembers(): boolean;
+	_initMembers(length: number): List<Node_SourceInfo_Member>;
+	set members(value: List<Node_SourceInfo_Member>);
+	toString(): string;
+}
+declare class Node_Struct extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Fields: ListCtor<Field>;
+	/**
+  * Size of the data section, in words.
+  *
+  */
+	get dataWordCount(): number;
+	set dataWordCount(value: number);
+	/**
+  * Size of the pointer section, in pointers (which are one word each).
+  *
+  */
+	get pointerCount(): number;
+	set pointerCount(value: number);
+	/**
+  * The preferred element size to use when encoding a list of this struct.  If this is anything
+  * other than `inlineComposite` then the struct is one word or less in size and is a candidate
+  * for list packing optimization.
+  *
+  */
+	get preferredListEncoding(): ElementSize;
+	set preferredListEncoding(value: ElementSize);
+	/**
+  * If true, then this "struct" node is actually not an independent node, but merely represents
+  * some named union or group within a particular parent struct.  This node's scopeId refers
+  * to the parent struct, which may itself be a union/group in yet another struct.
+  *
+  * All group nodes share the same dataWordCount and pointerCount as the top-level
+  * struct, and their fields live in the same ordinal and offset spaces as all other fields in
+  * the struct.
+  *
+  * Note that a named union is considered a special kind of group -- in fact, a named union
+  * is exactly equivalent to a group that contains nothing but an unnamed union.
+  *
+  */
+	get isGroup(): boolean;
+	set isGroup(value: boolean);
+	/**
+  * Number of fields in this struct which are members of an anonymous union, and thus may
+  * overlap.  If this is non-zero, then a 16-bit discriminant is present indicating which
+  * of the overlapping fields is active.  This can never be 1 -- if it is non-zero, it must be
+  * two or more.
+  *
+  * Note that the fields of an unnamed union are considered fields of the scope containing the
+  * union -- an unnamed union is not its own group.  So, a top-level struct may contain a
+  * non-zero discriminant count.  Named unions, on the other hand, are equivalent to groups
+  * containing unnamed unions.  So, a named union has its own independent schema node, with
+  * `isGroup` = true.
+  *
+  */
+	get discriminantCount(): number;
+	set discriminantCount(value: number);
+	/**
+  * If `discriminantCount` is non-zero, this is the offset of the union discriminant, in
+  * multiples of 16 bits.
+  *
+  */
+	get discriminantOffset(): number;
+	set discriminantOffset(value: number);
+	_adoptFields(value: Orphan<List<Field>>): void;
+	_disownFields(): Orphan<List<Field>>;
+	/**
+  * Fields defined within this scope (either the struct's top-level fields, or the fields of
+  * a particular group; see `isGroup`).
+  *
+  * The fields are sorted by ordinal number, but note that because groups share the same
+  * ordinal space, the field's index in this list is not necessarily exactly its ordinal.
+  * On the other hand, the field's position in this list does remain the same even as the
+  * protocol evolves, since it is not possible to insert or remove an earlier ordinal.
+  * Therefore, for most use cases, if you want to identify a field by number, it may make the
+  * most sense to use the field's index in this list rather than its ordinal.
+  *
+  */
+	get fields(): List<Field>;
+	_hasFields(): boolean;
+	_initFields(length: number): List<Field>;
+	set fields(value: List<Field>);
+	toString(): string;
+}
+declare class Node_Enum extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Enumerants: ListCtor<Enumerant>;
+	_adoptEnumerants(value: Orphan<List<Enumerant>>): void;
+	_disownEnumerants(): Orphan<List<Enumerant>>;
+	/**
+  * Enumerants ordered by numeric value (ordinal).
+  *
+  */
+	get enumerants(): List<Enumerant>;
+	_hasEnumerants(): boolean;
+	_initEnumerants(length: number): List<Enumerant>;
+	set enumerants(value: List<Enumerant>);
+	toString(): string;
+}
+declare class Node_Interface extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Methods: ListCtor<Method$1>;
+	static _Superclasses: ListCtor<Superclass>;
+	_adoptMethods(value: Orphan<List<Method$1>>): void;
+	_disownMethods(): Orphan<List<Method$1>>;
+	/**
+  * Methods ordered by ordinal.
+  *
+  */
+	get methods(): List<Method$1>;
+	_hasMethods(): boolean;
+	_initMethods(length: number): List<Method$1>;
+	set methods(value: List<Method$1>);
+	_adoptSuperclasses(value: Orphan<List<Superclass>>): void;
+	_disownSuperclasses(): Orphan<List<Superclass>>;
+	/**
+  * Superclasses of this interface.
+  *
+  */
+	get superclasses(): List<Superclass>;
+	_hasSuperclasses(): boolean;
+	_initSuperclasses(length: number): List<Superclass>;
+	set superclasses(value: List<Superclass>);
+	toString(): string;
+}
+declare class Node_Const extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	_adoptType(value: Orphan<Type>): void;
+	_disownType(): Orphan<Type>;
+	get type(): Type;
+	_hasType(): boolean;
+	_initType(): Type;
+	set type(value: Type);
+	_adoptValue(value: Orphan<Value>): void;
+	_disownValue(): Orphan<Value>;
+	get value(): Value;
+	_hasValue(): boolean;
+	_initValue(): Value;
+	set value(value: Value);
+	toString(): string;
+}
+declare class Node_Annotation extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	_adoptType(value: Orphan<Type>): void;
+	_disownType(): Orphan<Type>;
+	get type(): Type;
+	_hasType(): boolean;
+	_initType(): Type;
+	set type(value: Type);
+	get targetsFile(): boolean;
+	set targetsFile(value: boolean);
+	get targetsConst(): boolean;
+	set targetsConst(value: boolean);
+	get targetsEnum(): boolean;
+	set targetsEnum(value: boolean);
+	get targetsEnumerant(): boolean;
+	set targetsEnumerant(value: boolean);
+	get targetsStruct(): boolean;
+	set targetsStruct(value: boolean);
+	get targetsField(): boolean;
+	set targetsField(value: boolean);
+	get targetsUnion(): boolean;
+	set targetsUnion(value: boolean);
+	get targetsGroup(): boolean;
+	set targetsGroup(value: boolean);
+	get targetsInterface(): boolean;
+	set targetsInterface(value: boolean);
+	get targetsMethod(): boolean;
+	set targetsMethod(value: boolean);
+	get targetsParam(): boolean;
+	set targetsParam(value: boolean);
+	get targetsAnnotation(): boolean;
+	set targetsAnnotation(value: boolean);
+	toString(): string;
+}
+declare const Node_Which: {
+	readonly FILE: 0;
+	/**
+  * Name to present to humans to identify this Node.  You should not attempt to parse this.  Its
+  * format could change.  It is not guaranteed to be unique.
+  *
+  * (On Zooko's triangle, this is the node's nickname.)
+  *
+  */
+	readonly STRUCT: 1;
+	/**
+  * If you want a shorter version of `displayName` (just naming this node, without its surrounding
+  * scope), chop off this many characters from the beginning of `displayName`.
+  *
+  */
+	readonly ENUM: 2;
+	/**
+  * ID of the lexical parent node.  Typically, the scope node will have a NestedNode pointing back
+  * at this node, but robust code should avoid relying on this (and, in fact, group nodes are not
+  * listed in the outer struct's nestedNodes, since they are listed in the fields).  `scopeId` is
+  * zero if the node has no parent, which is normally only the case with files, but should be
+  * allowed for any kind of node (in order to make runtime type generation easier).
+  *
+  */
+	readonly INTERFACE: 3;
+	/**
+  * List of nodes nested within this node, along with the names under which they were declared.
+  *
+  */
+	readonly CONST: 4;
+	/**
+  * Annotations applied to this node.
+  *
+  */
+	readonly ANNOTATION: 5;
+};
+export type Node_Which = (typeof Node_Which)[keyof typeof Node_Which];
+declare class Node extends Struct {
+	static readonly FILE: 0;
+	static readonly STRUCT: 1;
+	static readonly ENUM: 2;
+	static readonly INTERFACE: 3;
+	static readonly CONST: 4;
+	static readonly ANNOTATION: 5;
+	static readonly Parameter: typeof Node_Parameter;
+	static readonly NestedNode: typeof Node_NestedNode;
+	static readonly SourceInfo: typeof Node_SourceInfo;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Parameters: ListCtor<Node_Parameter>;
+	static _NestedNodes: ListCtor<Node_NestedNode>;
+	static _Annotations: ListCtor<Annotation>;
+	get id(): bigint;
+	set id(value: bigint);
+	/**
+  * Name to present to humans to identify this Node.  You should not attempt to parse this.  Its
+  * format could change.  It is not guaranteed to be unique.
+  *
+  * (On Zooko's triangle, this is the node's nickname.)
+  *
+  */
+	get displayName(): string;
+	set displayName(value: string);
+	/**
+  * If you want a shorter version of `displayName` (just naming this node, without its surrounding
+  * scope), chop off this many characters from the beginning of `displayName`.
+  *
+  */
+	get displayNamePrefixLength(): number;
+	set displayNamePrefixLength(value: number);
+	/**
+  * ID of the lexical parent node.  Typically, the scope node will have a NestedNode pointing back
+  * at this node, but robust code should avoid relying on this (and, in fact, group nodes are not
+  * listed in the outer struct's nestedNodes, since they are listed in the fields).  `scopeId` is
+  * zero if the node has no parent, which is normally only the case with files, but should be
+  * allowed for any kind of node (in order to make runtime type generation easier).
+  *
+  */
+	get scopeId(): bigint;
+	set scopeId(value: bigint);
+	_adoptParameters(value: Orphan<List<Node_Parameter>>): void;
+	_disownParameters(): Orphan<List<Node_Parameter>>;
+	/**
+  * If this node is parameterized (generic), the list of parameters. Empty for non-generic types.
+  *
+  */
+	get parameters(): List<Node_Parameter>;
+	_hasParameters(): boolean;
+	_initParameters(length: number): List<Node_Parameter>;
+	set parameters(value: List<Node_Parameter>);
+	/**
+  * True if this node is generic, meaning that it or one of its parent scopes has a non-empty
+  * `parameters`.
+  *
+  */
+	get isGeneric(): boolean;
+	set isGeneric(value: boolean);
+	_adoptNestedNodes(value: Orphan<List<Node_NestedNode>>): void;
+	_disownNestedNodes(): Orphan<List<Node_NestedNode>>;
+	/**
+  * List of nodes nested within this node, along with the names under which they were declared.
+  *
+  */
+	get nestedNodes(): List<Node_NestedNode>;
+	_hasNestedNodes(): boolean;
+	_initNestedNodes(length: number): List<Node_NestedNode>;
+	set nestedNodes(value: List<Node_NestedNode>);
+	_adoptAnnotations(value: Orphan<List<Annotation>>): void;
+	_disownAnnotations(): Orphan<List<Annotation>>;
+	/**
+  * Annotations applied to this node.
+  *
+  */
+	get annotations(): List<Annotation>;
+	_hasAnnotations(): boolean;
+	_initAnnotations(length: number): List<Annotation>;
+	set annotations(value: List<Annotation>);
+	get _isFile(): boolean;
+	set file(_: true);
+	get struct(): Node_Struct;
+	_initStruct(): Node_Struct;
+	get _isStruct(): boolean;
+	set struct(_: true);
+	get enum(): Node_Enum;
+	_initEnum(): Node_Enum;
+	get _isEnum(): boolean;
+	set enum(_: true);
+	get interface(): Node_Interface;
+	_initInterface(): Node_Interface;
+	get _isInterface(): boolean;
+	set interface(_: true);
+	get const(): Node_Const;
+	_initConst(): Node_Const;
+	get _isConst(): boolean;
+	set const(_: true);
+	get annotation(): Node_Annotation;
+	_initAnnotation(): Node_Annotation;
+	get _isAnnotation(): boolean;
+	set annotation(_: true);
+	toString(): string;
+	which(): Node_Which;
+}
+declare class Field_Slot extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * Offset, in units of the field's size, from the beginning of the section in which the field
+  * resides.  E.g. for a UInt32 field, multiply this by 4 to get the byte offset from the
+  * beginning of the data section.
+  *
+  */
+	get offset(): number;
+	set offset(value: number);
+	_adoptType(value: Orphan<Type>): void;
+	_disownType(): Orphan<Type>;
+	get type(): Type;
+	_hasType(): boolean;
+	_initType(): Type;
+	set type(value: Type);
+	_adoptDefaultValue(value: Orphan<Value>): void;
+	_disownDefaultValue(): Orphan<Value>;
+	get defaultValue(): Value;
+	_hasDefaultValue(): boolean;
+	_initDefaultValue(): Value;
+	set defaultValue(value: Value);
+	/**
+  * Whether the default value was specified explicitly.  Non-explicit default values are always
+  * zero or empty values.  Usually, whether the default value was explicit shouldn't matter.
+  * The main use case for this flag is for structs representing method parameters:
+  * explicitly-defaulted parameters may be allowed to be omitted when calling the method.
+  *
+  */
+	get hadExplicitDefault(): boolean;
+	set hadExplicitDefault(value: boolean);
+	toString(): string;
+}
+declare class Field_Group extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * The ID of the group's node.
+  *
+  */
+	get typeId(): bigint;
+	set typeId(value: bigint);
+	toString(): string;
+}
+declare const Field_Ordinal_Which: {
+	readonly IMPLICIT: 0;
+	/**
+  * The original ordinal number given to the field.  You probably should NOT use this; if you need
+  * a numeric identifier for a field, use its position within the field array for its scope.
+  * The ordinal is given here mainly just so that the original schema text can be reproduced given
+  * the compiled version -- i.e. so that `capnp compile -ocapnp` can do its job.
+  *
+  */
+	readonly EXPLICIT: 1;
+};
+export type Field_Ordinal_Which = (typeof Field_Ordinal_Which)[keyof typeof Field_Ordinal_Which];
+declare class Field_Ordinal extends Struct {
+	static readonly IMPLICIT: 0;
+	static readonly EXPLICIT: 1;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get _isImplicit(): boolean;
+	set implicit(_: true);
+	/**
+  * The original ordinal number given to the field.  You probably should NOT use this; if you need
+  * a numeric identifier for a field, use its position within the field array for its scope.
+  * The ordinal is given here mainly just so that the original schema text can be reproduced given
+  * the compiled version -- i.e. so that `capnp compile -ocapnp` can do its job.
+  *
+  */
+	get explicit(): number;
+	get _isExplicit(): boolean;
+	set explicit(value: number);
+	toString(): string;
+	which(): Field_Ordinal_Which;
+}
+declare const Field_Which: {
+	readonly SLOT: 0;
+	/**
+  * Indicates where this member appeared in the code, relative to other members.
+  * Code ordering may have semantic relevance -- programmers tend to place related fields
+  * together.  So, using code ordering makes sense in human-readable formats where ordering is
+  * otherwise irrelevant, like JSON.  The values of codeOrder are tightly-packed, so the maximum
+  * value is count(members) - 1.  Fields that are members of a union are only ordered relative to
+  * the other members of that union, so the maximum value there is count(union.members).
+  *
+  */
+	readonly GROUP: 1;
+};
+export type Field_Which = (typeof Field_Which)[keyof typeof Field_Which];
+declare class Field extends Struct {
+	static readonly NO_DISCRIMINANT = 65535;
+	static readonly SLOT: 0;
+	static readonly GROUP: 1;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+		defaultDiscriminantValue: DataView<ArrayBufferLike>;
+	};
+	static _Annotations: ListCtor<Annotation>;
+	get name(): string;
+	set name(value: string);
+	/**
+  * Indicates where this member appeared in the code, relative to other members.
+  * Code ordering may have semantic relevance -- programmers tend to place related fields
+  * together.  So, using code ordering makes sense in human-readable formats where ordering is
+  * otherwise irrelevant, like JSON.  The values of codeOrder are tightly-packed, so the maximum
+  * value is count(members) - 1.  Fields that are members of a union are only ordered relative to
+  * the other members of that union, so the maximum value there is count(union.members).
+  *
+  */
+	get codeOrder(): number;
+	set codeOrder(value: number);
+	_adoptAnnotations(value: Orphan<List<Annotation>>): void;
+	_disownAnnotations(): Orphan<List<Annotation>>;
+	get annotations(): List<Annotation>;
+	_hasAnnotations(): boolean;
+	_initAnnotations(length: number): List<Annotation>;
+	set annotations(value: List<Annotation>);
+	/**
+  * If the field is in a union, this is the value which the union's discriminant should take when
+  * the field is active.  If the field is not in a union, this is 0xffff.
+  *
+  */
+	get discriminantValue(): number;
+	set discriminantValue(value: number);
+	/**
+  * A regular, non-group, non-fixed-list field.
+  *
+  */
+	get slot(): Field_Slot;
+	_initSlot(): Field_Slot;
+	get _isSlot(): boolean;
+	set slot(_: true);
+	/**
+  * A group.
+  *
+  */
+	get group(): Field_Group;
+	_initGroup(): Field_Group;
+	get _isGroup(): boolean;
+	set group(_: true);
+	get ordinal(): Field_Ordinal;
+	_initOrdinal(): Field_Ordinal;
+	toString(): string;
+	which(): Field_Which;
+}
+declare class Enumerant extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Annotations: ListCtor<Annotation>;
+	get name(): string;
+	set name(value: string);
+	/**
+  * Specifies order in which the enumerants were declared in the code.
+  * Like utils.Field.codeOrder.
+  *
+  */
+	get codeOrder(): number;
+	set codeOrder(value: number);
+	_adoptAnnotations(value: Orphan<List<Annotation>>): void;
+	_disownAnnotations(): Orphan<List<Annotation>>;
+	get annotations(): List<Annotation>;
+	_hasAnnotations(): boolean;
+	_initAnnotations(length: number): List<Annotation>;
+	set annotations(value: List<Annotation>);
+	toString(): string;
+}
+declare class Superclass extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get id(): bigint;
+	set id(value: bigint);
+	_adoptBrand(value: Orphan<Brand>): void;
+	_disownBrand(): Orphan<Brand>;
+	get brand(): Brand;
+	_hasBrand(): boolean;
+	_initBrand(): Brand;
+	set brand(value: Brand);
+	toString(): string;
+}
+declare class Method$1 extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _ImplicitParameters: ListCtor<Node_Parameter>;
+	static _Annotations: ListCtor<Annotation>;
+	get name(): string;
+	set name(value: string);
+	/**
+  * Specifies order in which the methods were declared in the code.
+  * Like utils.Field.codeOrder.
+  *
+  */
+	get codeOrder(): number;
+	set codeOrder(value: number);
+	_adoptImplicitParameters(value: Orphan<List<Node_Parameter>>): void;
+	_disownImplicitParameters(): Orphan<List<Node_Parameter>>;
+	/**
+  * The parameters listed in [] (typically, type / generic parameters), whose bindings are intended
+  * to be inferred rather than specified explicitly, although not all languages support this.
+  *
+  */
+	get implicitParameters(): List<Node_Parameter>;
+	_hasImplicitParameters(): boolean;
+	_initImplicitParameters(length: number): List<Node_Parameter>;
+	set implicitParameters(value: List<Node_Parameter>);
+	/**
+  * ID of the parameter struct type.  If a named parameter list was specified in the method
+  * declaration (rather than a single struct parameter type) then a corresponding struct type is
+  * auto-generated.  Such an auto-generated type will not be listed in the interface's
+  * `nestedNodes` and its `scopeId` will be zero -- it is completely detached from the namespace.
+  * (Awkwardly, it does of course inherit generic parameters from the method's scope, which makes
+  * this a situation where you can't just climb the scope chain to find where a particular
+  * generic parameter was introduced. Making the `scopeId` zero was a mistake.)
+  *
+  */
+	get paramStructType(): bigint;
+	set paramStructType(value: bigint);
+	_adoptParamBrand(value: Orphan<Brand>): void;
+	_disownParamBrand(): Orphan<Brand>;
+	/**
+  * Brand of param struct type.
+  *
+  */
+	get paramBrand(): Brand;
+	_hasParamBrand(): boolean;
+	_initParamBrand(): Brand;
+	set paramBrand(value: Brand);
+	/**
+  * ID of the return struct type; similar to `paramStructType`.
+  *
+  */
+	get resultStructType(): bigint;
+	set resultStructType(value: bigint);
+	_adoptResultBrand(value: Orphan<Brand>): void;
+	_disownResultBrand(): Orphan<Brand>;
+	/**
+  * Brand of result struct type.
+  *
+  */
+	get resultBrand(): Brand;
+	_hasResultBrand(): boolean;
+	_initResultBrand(): Brand;
+	set resultBrand(value: Brand);
+	_adoptAnnotations(value: Orphan<List<Annotation>>): void;
+	_disownAnnotations(): Orphan<List<Annotation>>;
+	get annotations(): List<Annotation>;
+	_hasAnnotations(): boolean;
+	_initAnnotations(length: number): List<Annotation>;
+	set annotations(value: List<Annotation>);
+	toString(): string;
+}
+declare class Type_List extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	_adoptElementType(value: Orphan<Type>): void;
+	_disownElementType(): Orphan<Type>;
+	get elementType(): Type;
+	_hasElementType(): boolean;
+	_initElementType(): Type;
+	set elementType(value: Type);
+	toString(): string;
+}
+declare class Type_Enum extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get typeId(): bigint;
+	set typeId(value: bigint);
+	_adoptBrand(value: Orphan<Brand>): void;
+	_disownBrand(): Orphan<Brand>;
+	get brand(): Brand;
+	_hasBrand(): boolean;
+	_initBrand(): Brand;
+	set brand(value: Brand);
+	toString(): string;
+}
+declare class Type_Struct extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get typeId(): bigint;
+	set typeId(value: bigint);
+	_adoptBrand(value: Orphan<Brand>): void;
+	_disownBrand(): Orphan<Brand>;
+	get brand(): Brand;
+	_hasBrand(): boolean;
+	_initBrand(): Brand;
+	set brand(value: Brand);
+	toString(): string;
+}
+declare class Type_Interface extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get typeId(): bigint;
+	set typeId(value: bigint);
+	_adoptBrand(value: Orphan<Brand>): void;
+	_disownBrand(): Orphan<Brand>;
+	get brand(): Brand;
+	_hasBrand(): boolean;
+	_initBrand(): Brand;
+	set brand(value: Brand);
+	toString(): string;
+}
+declare const Type_AnyPointer_Unconstrained_Which: {
+	/**
+  * truly AnyPointer
+  *
+  */
+	readonly ANY_KIND: 0;
+	/**
+  * AnyStruct
+  *
+  */
+	readonly STRUCT: 1;
+	/**
+  * AnyList
+  *
+  */
+	readonly LIST: 2;
+	/**
+  * Capability
+  *
+  */
+	readonly CAPABILITY: 3;
+};
+export type Type_AnyPointer_Unconstrained_Which = (typeof Type_AnyPointer_Unconstrained_Which)[keyof typeof Type_AnyPointer_Unconstrained_Which];
+declare class Type_AnyPointer_Unconstrained extends Struct {
+	static readonly ANY_KIND: 0;
+	static readonly STRUCT: 1;
+	static readonly LIST: 2;
+	static readonly CAPABILITY: 3;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get _isAnyKind(): boolean;
+	set anyKind(_: true);
+	get _isStruct(): boolean;
+	set struct(_: true);
+	get _isList(): boolean;
+	set list(_: true);
+	get _isCapability(): boolean;
+	set capability(_: true);
+	toString(): string;
+	which(): Type_AnyPointer_Unconstrained_Which;
+}
+declare class Type_AnyPointer_Parameter extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * ID of the generic type whose parameter we're referencing. This should be a parent of the
+  * current scope.
+  *
+  */
+	get scopeId(): bigint;
+	set scopeId(value: bigint);
+	/**
+  * Index of the parameter within the generic type's parameter list.
+  *
+  */
+	get parameterIndex(): number;
+	set parameterIndex(value: number);
+	toString(): string;
+}
+declare class Type_AnyPointer_ImplicitMethodParameter extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get parameterIndex(): number;
+	set parameterIndex(value: number);
+	toString(): string;
+}
+declare const Type_AnyPointer_Which: {
+	/**
+  * A regular AnyPointer.
+  *
+  * The name "unconstrained" means as opposed to constraining it to match a type parameter.
+  * In retrospect this name is probably a poor choice given that it may still be constrained
+  * to be a struct, list, or capability.
+  *
+  */
+	readonly UNCONSTRAINED: 0;
+	/**
+  * This is actually a reference to a type parameter defined within this scope.
+  *
+  */
+	readonly PARAMETER: 1;
+	/**
+  * This is actually a reference to an implicit (generic) parameter of a method. The only
+  * legal context for this type to appear is inside Method.paramBrand or Method.resultBrand.
+  *
+  */
+	readonly IMPLICIT_METHOD_PARAMETER: 2;
+};
+export type Type_AnyPointer_Which = (typeof Type_AnyPointer_Which)[keyof typeof Type_AnyPointer_Which];
+declare class Type_AnyPointer extends Struct {
+	static readonly UNCONSTRAINED: 0;
+	static readonly PARAMETER: 1;
+	static readonly IMPLICIT_METHOD_PARAMETER: 2;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * A regular AnyPointer.
+  *
+  * The name "unconstrained" means as opposed to constraining it to match a type parameter.
+  * In retrospect this name is probably a poor choice given that it may still be constrained
+  * to be a struct, list, or capability.
+  *
+  */
+	get unconstrained(): Type_AnyPointer_Unconstrained;
+	_initUnconstrained(): Type_AnyPointer_Unconstrained;
+	get _isUnconstrained(): boolean;
+	set unconstrained(_: true);
+	/**
+  * This is actually a reference to a type parameter defined within this scope.
+  *
+  */
+	get parameter(): Type_AnyPointer_Parameter;
+	_initParameter(): Type_AnyPointer_Parameter;
+	get _isParameter(): boolean;
+	set parameter(_: true);
+	/**
+  * This is actually a reference to an implicit (generic) parameter of a method. The only
+  * legal context for this type to appear is inside Method.paramBrand or Method.resultBrand.
+  *
+  */
+	get implicitMethodParameter(): Type_AnyPointer_ImplicitMethodParameter;
+	_initImplicitMethodParameter(): Type_AnyPointer_ImplicitMethodParameter;
+	get _isImplicitMethodParameter(): boolean;
+	set implicitMethodParameter(_: true);
+	toString(): string;
+	which(): Type_AnyPointer_Which;
+}
+declare const Type_Which: {
+	readonly VOID: 0;
+	readonly BOOL: 1;
+	readonly INT8: 2;
+	readonly INT16: 3;
+	readonly INT32: 4;
+	readonly INT64: 5;
+	readonly UINT8: 6;
+	readonly UINT16: 7;
+	readonly UINT32: 8;
+	readonly UINT64: 9;
+	readonly FLOAT32: 10;
+	readonly FLOAT64: 11;
+	readonly TEXT: 12;
+	readonly DATA: 13;
+	readonly LIST: 14;
+	readonly ENUM: 15;
+	readonly STRUCT: 16;
+	readonly INTERFACE: 17;
+	readonly ANY_POINTER: 18;
+};
+export type Type_Which = (typeof Type_Which)[keyof typeof Type_Which];
+declare class Type extends Struct {
+	static readonly VOID: 0;
+	static readonly BOOL: 1;
+	static readonly INT8: 2;
+	static readonly INT16: 3;
+	static readonly INT32: 4;
+	static readonly INT64: 5;
+	static readonly UINT8: 6;
+	static readonly UINT16: 7;
+	static readonly UINT32: 8;
+	static readonly UINT64: 9;
+	static readonly FLOAT32: 10;
+	static readonly FLOAT64: 11;
+	static readonly TEXT: 12;
+	static readonly DATA: 13;
+	static readonly LIST: 14;
+	static readonly ENUM: 15;
+	static readonly STRUCT: 16;
+	static readonly INTERFACE: 17;
+	static readonly ANY_POINTER: 18;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get _isVoid(): boolean;
+	set void(_: true);
+	get _isBool(): boolean;
+	set bool(_: true);
+	get _isInt8(): boolean;
+	set int8(_: true);
+	get _isInt16(): boolean;
+	set int16(_: true);
+	get _isInt32(): boolean;
+	set int32(_: true);
+	get _isInt64(): boolean;
+	set int64(_: true);
+	get _isUint8(): boolean;
+	set uint8(_: true);
+	get _isUint16(): boolean;
+	set uint16(_: true);
+	get _isUint32(): boolean;
+	set uint32(_: true);
+	get _isUint64(): boolean;
+	set uint64(_: true);
+	get _isFloat32(): boolean;
+	set float32(_: true);
+	get _isFloat64(): boolean;
+	set float64(_: true);
+	get _isText(): boolean;
+	set text(_: true);
+	get _isData(): boolean;
+	set data(_: true);
+	get list(): Type_List;
+	_initList(): Type_List;
+	get _isList(): boolean;
+	set list(_: true);
+	get enum(): Type_Enum;
+	_initEnum(): Type_Enum;
+	get _isEnum(): boolean;
+	set enum(_: true);
+	get struct(): Type_Struct;
+	_initStruct(): Type_Struct;
+	get _isStruct(): boolean;
+	set struct(_: true);
+	get interface(): Type_Interface;
+	_initInterface(): Type_Interface;
+	get _isInterface(): boolean;
+	set interface(_: true);
+	get anyPointer(): Type_AnyPointer;
+	_initAnyPointer(): Type_AnyPointer;
+	get _isAnyPointer(): boolean;
+	set anyPointer(_: true);
+	toString(): string;
+	which(): Type_Which;
+}
+declare const Brand_Scope_Which: {
+	/**
+  * ID of the scope to which these params apply.
+  *
+  */
+	readonly BIND: 0;
+	/**
+  * List of parameter bindings.
+  *
+  */
+	readonly INHERIT: 1;
+};
+export type Brand_Scope_Which = (typeof Brand_Scope_Which)[keyof typeof Brand_Scope_Which];
+declare class Brand_Scope extends Struct {
+	static readonly BIND: 0;
+	static readonly INHERIT: 1;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Bind: ListCtor<Brand_Binding>;
+	/**
+  * ID of the scope to which these params apply.
+  *
+  */
+	get scopeId(): bigint;
+	set scopeId(value: bigint);
+	_adoptBind(value: Orphan<List<Brand_Binding>>): void;
+	_disownBind(): Orphan<List<Brand_Binding>>;
+	/**
+  * List of parameter bindings.
+  *
+  */
+	get bind(): List<Brand_Binding>;
+	_hasBind(): boolean;
+	_initBind(length: number): List<Brand_Binding>;
+	get _isBind(): boolean;
+	set bind(value: List<Brand_Binding>);
+	get _isInherit(): boolean;
+	set inherit(_: true);
+	toString(): string;
+	which(): Brand_Scope_Which;
+}
+declare const Brand_Binding_Which: {
+	readonly UNBOUND: 0;
+	readonly TYPE: 1;
+};
+export type Brand_Binding_Which = (typeof Brand_Binding_Which)[keyof typeof Brand_Binding_Which];
+declare class Brand_Binding extends Struct {
+	static readonly UNBOUND: 0;
+	static readonly TYPE: 1;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get _isUnbound(): boolean;
+	set unbound(_: true);
+	_adoptType(value: Orphan<Type>): void;
+	_disownType(): Orphan<Type>;
+	get type(): Type;
+	_hasType(): boolean;
+	_initType(): Type;
+	get _isType(): boolean;
+	set type(value: Type);
+	toString(): string;
+	which(): Brand_Binding_Which;
+}
+declare class Brand extends Struct {
+	static readonly Scope: typeof Brand_Scope;
+	static readonly Binding: typeof Brand_Binding;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	static _Scopes: ListCtor<Brand_Scope>;
+	_adoptScopes(value: Orphan<List<Brand_Scope>>): void;
+	_disownScopes(): Orphan<List<Brand_Scope>>;
+	/**
+  * For each of the target type and each of its parent scopes, a parameterization may be included
+  * in this list. If no parameterization is included for a particular relevant scope, then either
+  * that scope has no parameters or all parameters should be considered to be `AnyPointer`.
+  *
+  */
+	get scopes(): List<Brand_Scope>;
+	_hasScopes(): boolean;
+	_initScopes(length: number): List<Brand_Scope>;
+	set scopes(value: List<Brand_Scope>);
+	toString(): string;
+}
+declare const Value_Which: {
+	readonly VOID: 0;
+	readonly BOOL: 1;
+	readonly INT8: 2;
+	readonly INT16: 3;
+	readonly INT32: 4;
+	readonly INT64: 5;
+	readonly UINT8: 6;
+	readonly UINT16: 7;
+	readonly UINT32: 8;
+	readonly UINT64: 9;
+	readonly FLOAT32: 10;
+	readonly FLOAT64: 11;
+	readonly TEXT: 12;
+	readonly DATA: 13;
+	readonly LIST: 14;
+	readonly ENUM: 15;
+	readonly STRUCT: 16;
+	/**
+  * The only interface value that can be represented statically is "null", whose methods always
+  * throw exceptions.
+  *
+  */
+	readonly INTERFACE: 17;
+	readonly ANY_POINTER: 18;
+};
+export type Value_Which = (typeof Value_Which)[keyof typeof Value_Which];
+declare class Value extends Struct {
+	static readonly VOID: 0;
+	static readonly BOOL: 1;
+	static readonly INT8: 2;
+	static readonly INT16: 3;
+	static readonly INT32: 4;
+	static readonly INT64: 5;
+	static readonly UINT8: 6;
+	static readonly UINT16: 7;
+	static readonly UINT32: 8;
+	static readonly UINT64: 9;
+	static readonly FLOAT32: 10;
+	static readonly FLOAT64: 11;
+	static readonly TEXT: 12;
+	static readonly DATA: 13;
+	static readonly LIST: 14;
+	static readonly ENUM: 15;
+	static readonly STRUCT: 16;
+	static readonly INTERFACE: 17;
+	static readonly ANY_POINTER: 18;
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	get _isVoid(): boolean;
+	set void(_: true);
+	get bool(): boolean;
+	get _isBool(): boolean;
+	set bool(value: boolean);
+	get int8(): number;
+	get _isInt8(): boolean;
+	set int8(value: number);
+	get int16(): number;
+	get _isInt16(): boolean;
+	set int16(value: number);
+	get int32(): number;
+	get _isInt32(): boolean;
+	set int32(value: number);
+	get int64(): bigint;
+	get _isInt64(): boolean;
+	set int64(value: bigint);
+	get uint8(): number;
+	get _isUint8(): boolean;
+	set uint8(value: number);
+	get uint16(): number;
+	get _isUint16(): boolean;
+	set uint16(value: number);
+	get uint32(): number;
+	get _isUint32(): boolean;
+	set uint32(value: number);
+	get uint64(): bigint;
+	get _isUint64(): boolean;
+	set uint64(value: bigint);
+	get float32(): number;
+	get _isFloat32(): boolean;
+	set float32(value: number);
+	get float64(): number;
+	get _isFloat64(): boolean;
+	set float64(value: number);
+	get text(): string;
+	get _isText(): boolean;
+	set text(value: string);
+	_adoptData(value: Orphan<Data>): void;
+	_disownData(): Orphan<Data>;
+	get data(): Data;
+	_hasData(): boolean;
+	_initData(length: number): Data;
+	get _isData(): boolean;
+	set data(value: Data);
+	_adoptList(value: Orphan<Pointer>): void;
+	_disownList(): Orphan<Pointer>;
+	get list(): Pointer;
+	_hasList(): boolean;
+	get _isList(): boolean;
+	set list(value: Pointer);
+	get enum(): number;
+	get _isEnum(): boolean;
+	set enum(value: number);
+	_adoptStruct(value: Orphan<Pointer>): void;
+	_disownStruct(): Orphan<Pointer>;
+	get struct(): Pointer;
+	_hasStruct(): boolean;
+	get _isStruct(): boolean;
+	set struct(value: Pointer);
+	get _isInterface(): boolean;
+	set interface(_: true);
+	_adoptAnyPointer(value: Orphan<Pointer>): void;
+	_disownAnyPointer(): Orphan<Pointer>;
+	get anyPointer(): Pointer;
+	_hasAnyPointer(): boolean;
+	get _isAnyPointer(): boolean;
+	set anyPointer(value: Pointer);
+	toString(): string;
+	which(): Value_Which;
+}
+declare class Annotation extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * ID of the annotation node.
+  *
+  */
+	get id(): bigint;
+	set id(value: bigint);
+	_adoptBrand(value: Orphan<Brand>): void;
+	_disownBrand(): Orphan<Brand>;
+	/**
+  * Brand of the annotation.
+  *
+  * Note that the annotation itself is not allowed to be parameterized, but its scope might be.
+  *
+  */
+	get brand(): Brand;
+	_hasBrand(): boolean;
+	_initBrand(): Brand;
+	set brand(value: Brand);
+	_adoptValue(value: Orphan<Value>): void;
+	_disownValue(): Orphan<Value>;
+	get value(): Value;
+	_hasValue(): boolean;
+	_initValue(): Value;
+	set value(value: Value);
+	toString(): string;
+}
+declare const ElementSize: {
+	/**
+  * aka "void", but that's a keyword.
+  *
+  */
+	readonly EMPTY: 0;
+	readonly BIT: 1;
+	readonly BYTE: 2;
+	readonly TWO_BYTES: 3;
+	readonly FOUR_BYTES: 4;
+	readonly EIGHT_BYTES: 5;
+	readonly POINTER: 6;
+	readonly INLINE_COMPOSITE: 7;
+};
+export type ElementSize = (typeof ElementSize)[keyof typeof ElementSize];
+declare class CodeGeneratorRequest_RequestedFile_Import extends Struct {
+	static readonly _capnp: {
+		displayName: string;
+		id: string;
+		size: ObjectSize;
+	};
+	/**
+  * ID of the imported file.
+  *
+  */
+	get id(): bigint;
+	set id(value: bigint);
+	/**
+  * Name which *this* file used to refer to the foreign file.  This may be a relative name.
+  * This information is provided because it might be useful for code generation, e.g. to
+  * generate #include directives in C++.  We don't put this in Node.file because this
+  * information is only meaningful at compile time anyway.
+  *
+  * (On Zooko's triangle, this is the import's petname according to the importing file.)
+  *
+  */
+	get name(): string;
+	set name(value: string);
+	toString(): string;
+}
+export interface CodeGeneratorFileContext {
+	readonly nodes: Node[];
+	readonly imports: CodeGeneratorRequest_RequestedFile_Import[];
+	concreteLists: Array<[
+		string,
+		Field
+	]>;
+	generatedNodeIds: Set<string>;
+	generatedResultsPromiseIds: Set<bigint>;
+	tsPath: string;
+	codeParts?: string[];
+	constructor: any;
+	toString: () => string;
+}
+export declare class CodeGeneratorContext {
+	files: CodeGeneratorFileContext[];
+}
+export interface CapnpcCLIOptions {
+	ts?: boolean;
+	noTs?: boolean;
+	js?: boolean;
+	dts?: boolean;
+	noDts?: boolean;
+	schema: string;
+	output?: string;
+	importPath?: string[];
+	tsconfig: string;
+	generateId?: boolean;
+	standardImport?: boolean;
+	projectRoot: string;
+	workspaceRoot: string;
+	tty?: boolean;
+}
+export type CapnpcOptions = Omit<CapnpcCLIOptions, "noTs" | "noDts" | "tsconfig" | "schema"> & {
+	tsconfig: ParsedCommandLine;
+	schemas: string[];
+};
+export interface CapnpcResult {
+	ctx: CodeGeneratorContext;
+	files: Map<string, string>;
+}
+
+export {};