@stryke/capnp 0.12.95 → 0.12.97

package/dist/index-LYXu6eWz.d.mts

@@ -0,0 +1,736 @@
+import { A as Transport, C as PointerType, N as _StructCtor, O as Struct, S as PointerCtor, _ as Method, a as Client, b as PipelineOp, c as Deferred, d as Interface, f as List, g as Message$1, h as Message, i as Call, j as _ListCtor, k as StructCtor, m as ListElementSize, n as Answer, p as ListCtor, t as Data, v as ObjectSize, w as Segment, x as Pointer, y as Orphan } from "./capnp-es.BHkXHvyK-B3-d8RNu.mjs";
+
+//#region ../../node_modules/.pnpm/capnp-es@0.0.11_patch_hash=503a440bd2bef41c0cb22819bc4ced5a7f04993fb999f0d944e284220f14916b_typescript@6.0.3/node_modules/capnp-es/dist/shared/capnp-es.CMmWj66v.d.mts
+/**
+ * PipelineClient implements Client by calling to the pipeline's answer.
+ */
+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
+ */
+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>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/capnp-es@0.0.11_patch_hash=503a440bd2bef41c0cb22819bc4ced5a7f04993fb999f0d944e284220f14916b_typescript@6.0.3/node_modules/capnp-es/dist/index.d.mts
+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;
+}
+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;
+}
+declare function clientOrNull(client: Client | null): Client;
+interface InterfaceDefinition {
+  methods: Array<Method<any, any>>;
+}
+declare class Registry {
+  static readonly interfaces: Map<bigint, InterfaceDefinition>;
+  static register(id: bigint, def: InterfaceDefinition): void;
+  static lookup(id: bigint): InterfaceDefinition | undefined;
+}
+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;
+}
+declare class Void extends Struct {
+  static readonly _capnp: _StructCtor;
+}
+/**
+ * Initialize a struct with the provided object size. This will allocate new space for the struct contents, ideally in
+ * the same segment as this pointer.
+ *
+ * @param size An object describing the size of the struct's data and pointer sections.
+ * @param s The struct to initialize.
+ */
+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;
+/**
+ * Make a shallow copy of a struct's contents and update the pointer to point to the new content. The data and pointer
+ * sections will be resized to the provided size.
+ *
+ * WARNING: This method can cause data loss if `dstSize` is smaller than the original size!
+ *
+ * @param dstSize The desired size for the struct contents.
+ * @param s The struct to resize.
+ */
+declare function resize(dstSize: ObjectSize, s: Struct): void;
+/**
+ * Convert a struct to a struct of the provided class. Particularly useful when casting to nested group types.
+ *
+ * @param StructClass The struct class to convert to. Not particularly useful if `Struct`.
+ * @param s The struct to convert.
+ * @returns A new instance of the desired struct class pointing to the same location.
+ */
+declare function getAs<T extends Struct>(StructClass: StructCtor<T>, s: Struct): T;
+/**
+ * Read a boolean (bit) value out of a struct.
+ *
+ * @param bitOffset The offset in **bits** from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+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;
+/**
+ * Read a float32 value out of a struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+declare function getFloat32(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+/**
+ * Read a float64 value out of this segment.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+declare function getFloat64(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+/**
+ * Read an int16 value out of this segment.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+declare function getInt16(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+/**
+ * Read an int32 value out of this segment.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+declare function getInt32(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+/**
+ * Read an int64 value out of this segment.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+declare function getInt64(byteOffset: number, s: Struct, defaultMask?: DataView): bigint;
+/**
+ * Read an int8 value out of this segment.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+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;
+/**
+ * Read an uint16 value out of a struct..
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+declare function getUint16(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+/**
+ * Read an uint32 value out of a struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+declare function getUint32(byteOffset: number, s: Struct, defaultMask?: DataView): number;
+/**
+ * Read an uint64 value out of a struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+declare function getUint64(byteOffset: number, s: Struct, defaultMask?: DataView): bigint;
+/**
+ * Read an uint8 value out of a struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param s The struct to read from.
+ * @param defaultMask The default value as a DataView.
+ * @returns The value.
+ */
+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>;
+/**
+ * Write a boolean (bit) value to the struct.
+ *
+ * @param bitOffset The offset in **bits** from the start of the data section.
+ * @param value The value to write (writes a 0 for `false`, 1 for `true`).
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setBit(bitOffset: number, value: boolean, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive float32 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setFloat32(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive float64 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setFloat64(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive int16 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setInt16(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive int32 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setInt32(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive int64 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setInt64(byteOffset: number, value: bigint, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive int8 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setInt8(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+declare function setText(index: number, value: string, s: Struct): void;
+/**
+ * Write a primitive uint16 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setUint16(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive uint32 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setUint32(byteOffset: number, value: number, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive uint64 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+declare function setUint64(byteOffset: number, value: bigint, s: Struct, defaultMask?: DataView): void;
+/**
+ * Write a primitive uint8 value to the struct.
+ *
+ * @param byteOffset The offset in bytes from the start of the data section.
+ * @param value The value to write.
+ * @param s The struct to write to.
+ * @param defaultMask The default value as a DataView.
+ */
+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;
+/**
+ * Convert a pointer to an Orphan, zeroing out the pointer and leaving its content untouched. If the content is no
+ * longer needed, call `disown()` on the orphaned pointer to erase the contents as well.
+ *
+ * Call `adopt()` on the orphan with the new target pointer location to move it back into the message; the orphan
+ * object is then invalidated after adoption (can only adopt once!).
+ *
+ * @param p The pointer to turn into an Orphan.
+ * @returns An orphaned pointer.
+ */
+declare function disown<T extends Pointer>(p: T): Orphan<T>;
+declare function dump(p: Pointer): string;
+/**
+ * Get the total number of bytes required to hold a list of the provided size with the given length, rounded up to the
+ * nearest word.
+ *
+ * @param elementSize A number describing the size of the list elements.
+ * @param length The length of the list.
+ * @param compositeSize The size of each element in a composite list; required if
+ * `elementSize === ListElementSize.COMPOSITE`.
+ * @returns The number of bytes required to hold an element of that size, or `NaN` if that is undefined.
+ */
+declare function getListByteLength(elementSize: ListElementSize, length: number, compositeSize?: ObjectSize): number;
+/**
+ * Get the number of bytes required to hold a list element of the provided size. `COMPOSITE` elements do not have a
+ * fixed size, and `BIT` elements are packed into exactly a single bit, so these both return `NaN`.
+ *
+ * @param elementSize A number describing the size of the list elements.
+ * @returns The number of bytes required to hold an element of that size, or `NaN` if that is undefined.
+ */
+declare function getListElementByteLength(elementSize: ListElementSize): number;
+/**
+ * Add an offset to the pointer's offset and return a new Pointer for that address.
+ *
+ * @param offset The number of bytes to add to the offset.
+ * @param p The pointer to add from.
+ * @returns A new pointer to the address.
+ */
+declare function add(offset: number, p: Pointer): Pointer;
+/**
+ * Replace a pointer with a deep copy of the pointer at `src` and all of its contents.
+ *
+ * @param src The pointer to copy.
+ * @param p The pointer to copy into.
+ */
+declare function copyFrom(src: Pointer, p: Pointer): void;
+/**
+ * Recursively erase a pointer, any far pointers/landing pads/tag words, and the content it points to.
+ *
+ * Note that this will leave "holes" of zeroes in the message, since the space cannot be reclaimed. With packing this
+ * will have a negligible effect on the final message size.
+ *
+ * FIXME: This may need protection against infinite recursion...
+ *
+ * @param p The pointer to erase.
+ */
+declare function erase(p: Pointer): void;
+/**
+ * Set the pointer (and far pointer landing pads, if applicable) to zero. Does not touch the pointer's content.
+ *
+ * @param p The pointer to erase.
+ */
+declare function erasePointer(p: Pointer): void;
+/**
+ * Interpret the pointer as a far pointer, returning its target segment and offset.
+ *
+ * @param p The pointer to read from.
+ * @returns A pointer to the far target.
+ */
+declare function followFar(p: Pointer): Pointer;
+/**
+ * If the pointer address references a far pointer, follow it to the location where the actual pointer data is written.
+ * Otherwise, returns the pointer unmodified.
+ *
+ * @param p The pointer to read from.
+ * @returns A new pointer representing the target location, or `p` if it is not a far pointer.
+ */
+declare function followFars(p: Pointer): Pointer;
+declare function getCapabilityId(p: Pointer): number;
+/**
+ * Obtain the location of the pointer's content, following far pointers as needed.
+ * If the pointer is a struct pointer and `compositeIndex` is set, it will be offset by a multiple of the struct's size.
+ *
+ * @param p The pointer to read from.
+ * @param ignoreCompositeIndex If true, will not follow the composite struct pointer's composite index and
+ * instead return a pointer to the parent list's contents (also the beginning of the first struct).
+ * @returns A pointer to the beginning of the pointer's content.
+ */
+declare function getContent(p: Pointer, ignoreCompositeIndex?: boolean): Pointer;
+/**
+ * Read the target segment ID from a far pointer.
+ *
+ * @param p The pointer to read from.
+ * @returns The target segment ID.
+ */
+declare function getFarSegmentId(p: Pointer): number;
+/**
+ * Get a number indicating the size of the list's elements.
+ *
+ * @param p The pointer to read from.
+ * @returns The size of the list's elements.
+ */
+declare function getListElementSize(p: Pointer): ListElementSize;
+/**
+ * Get the number of elements in a list pointer. For composite lists, it instead represents the total number of words in
+ * the list (not counting the tag word).
+ *
+ * This method does **not** attempt to distinguish between composite and non-composite lists. To get the correct
+ * length for composite lists use `getTargetListLength()` instead.
+ *
+ * @param p The pointer to read from.
+ * @returns The length of the list, or total number of words for composite lists.
+ */
+declare function getListLength(p: Pointer): number;
+/**
+ * Get the offset (in words) from the end of a pointer to the start of its content. For struct pointers, this is the
+ * beginning of the data section, and for list pointers it is the location of the first element. The value should
+ * always be zero for interface pointers.
+ *
+ * @param p The pointer to read from.
+ * @returns The offset, in words, from the end of the pointer to the start of the data section.
+ */
+declare function getOffsetWords(p: Pointer): number;
+/**
+ * Look up the pointer's type.
+ *
+ * @param p The pointer to read from.
+ * @returns The type of pointer.
+ */
+declare function getPointerType(p: Pointer): PointerType;
+/**
+ * Read the number of data words from this struct pointer.
+ *
+ * @param p The pointer to read from.
+ * @returns The number of data words in the struct.
+ */
+declare function getStructDataWords(p: Pointer): number;
+/**
+ * Read the number of pointers contained in this struct pointer.
+ *
+ * @param p The pointer to read from.
+ * @returns The number of pointers in this struct.
+ */
+declare function getStructPointerLength(p: Pointer): number;
+/**
+ * Get an object describing this struct pointer's size.
+ *
+ * @param p The pointer to read from.
+ * @returns The size of the struct.
+ */
+declare function getStructSize(p: Pointer): ObjectSize;
+/**
+ * Get a pointer to this pointer's composite list tag word, following far pointers as needed.
+ *
+ * @param p The pointer to read from.
+ * @returns A pointer to the list's composite tag word.
+ */
+declare function getTargetCompositeListTag(p: Pointer): Pointer;
+/**
+ * Get the object size for the target composite list, following far pointers as needed.
+ *
+ * @param p The pointer to read from.
+ * @returns An object describing the size of each struct in the list.
+ */
+declare function getTargetCompositeListSize(p: Pointer): ObjectSize;
+/**
+ * Get the size of the list elements referenced by this pointer, following far pointers if necessary.
+ *
+ * @param p The pointer to read from.
+ * @returns The size of the elements in the list.
+ */
+declare function getTargetListElementSize(p: Pointer): ListElementSize;
+/**
+ * Get the length of the list referenced by this pointer, following far pointers if necessary. If the list is a
+ * composite list, it will look up the tag word and read the length from there.
+ *
+ * @param p The pointer to read from.
+ * @returns The number of elements in the list.
+ */
+declare function getTargetListLength(p: Pointer): number;
+/**
+ * Get the type of a pointer, following far pointers if necessary. For non-far pointers this is equivalent to calling
+ * `getPointerType()`.
+ *
+ * The target of a far pointer can never be another far pointer, and this method will throw if such a situation is
+ * encountered.
+ *
+ * @param p The pointer to read from.
+ * @returns The type of pointer referenced by this pointer.
+ */
+declare function getTargetPointerType(p: Pointer): PointerType;
+/**
+ * Get the size of the struct referenced by a pointer, following far pointers if necessary.
+ *
+ * @param p The pointer to read from.
+ * @returns The size of the struct referenced by this pointer.
+ */
+declare function getTargetStructSize(p: Pointer): ObjectSize;
+/**
+ * Initialize a pointer to point at the data in the content segment. If the content segment is not the same as the
+ * pointer's segment, this will allocate and write far pointers as needed. Nothing is written otherwise.
+ *
+ * The return value includes a pointer to write the pointer's actual data to (the eventual far target), and the offset
+ * value (in words) to use for that pointer. In the case of double-far pointers this offset will always be zero.
+ *
+ * @param contentSegment The segment containing this pointer's content.
+ * @param contentOffset The offset within the content segment for the beginning of this pointer's content.
+ * @param p The pointer to initialize.
+ * @returns An object containing a pointer (where the pointer data should be written), and
+ * the value to use as the offset for that pointer.
+ */
+declare function initPointer(contentSegment: Segment, contentOffset: number, p: Pointer): PointerAllocationResult;
+/**
+ * Check if the pointer is a double-far pointer.
+ *
+ * @param p The pointer to read from.
+ * @returns `true` if it is a double-far pointer, `false` otherwise.
+ */
+declare function isDoubleFar(p: Pointer): boolean;
+/**
+ * Quickly check to see if the pointer is "null". A "null" pointer is a zero word, equivalent to an empty struct
+ * pointer.
+ *
+ * @param p The pointer to read from.
+ * @returns `true` if the pointer is "null".
+ */
+declare function isNull(p: Pointer): boolean;
+/**
+ * Relocate a pointer to the given destination, ensuring that it points to the same content. This will create far
+ * pointers as needed if the content is in a different segment than the destination. After the relocation the source
+ * pointer will be erased and is no longer valid.
+ *
+ * @param dst The desired location for the `src` pointer. Any existing contents will be erased before
+ * relocating!
+ * @param src The pointer to relocate.
+ */
+declare function relocateTo(dst: Pointer, src: Pointer): void;
+/**
+ * Write a far pointer.
+ *
+ * @param doubleFar Set to `true` if this is a double far pointer.
+ * @param offsetWords The offset, in words, to the target pointer.
+ * @param segmentId The segment the target pointer is located in.
+ * @param p The pointer to write to.
+ */
+declare function setFarPointer(doubleFar: boolean, offsetWords: number, segmentId: number, p: Pointer): void;
+/**
+ * Write a raw interface pointer.
+ *
+ * @param capId The capability ID.
+ * @param p The pointer to write to.
+ */
+declare function setInterfacePointer(capId: number, p: Pointer): void;
+/**
+ * Reads a raw interface pointer
+ *
+ * @param p The pointer to read.
+ * @returns The capability ID.
+ */
+declare function getInterfacePointer(p: Pointer): number;
+/**
+ * Write a raw list pointer.
+ *
+ * @param offsetWords The number of words from the end of this pointer to the beginning of the list content.
+ * @param size The size of each element in the list.
+ * @param length The number of elements in the list.
+ * @param p The pointer to write to.
+ * @param compositeSize For composite lists this describes the size of each element in this list. This
+ * is required for composite lists.
+ */
+declare function setListPointer(offsetWords: number, size: ListElementSize, length: number, p: Pointer, compositeSize?: ObjectSize): void;
+/**
+ * Write a raw struct pointer.
+ *
+ * @param offsetWords The number of words from the end of this pointer to the beginning of the struct's data
+ * section.
+ * @param size An object describing the size of the struct.
+ * @param p The pointer to write to.
+ */
+declare function setStructPointer(offsetWords: number, size: ObjectSize, p: Pointer): void;
+/**
+ * Read some bits off a pointer to make sure it has the right pointer data.
+ *
+ * @param pointerType The expected pointer type.
+ * @param p The pointer to validate.
+ * @param elementSize For list pointers, the expected element size. Leave this
+ * undefined for struct pointers.
+ */
+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;
+/**
+ * Track the allocation of a new Pointer object.
+ *
+ * This will decrement an internal counter tracking how many bytes have been traversed in the message so far. After
+ * a certain limit, this method will throw an error in order to prevent a certain class of DoS attacks.
+ *
+ * @param message The message the pointer belongs to.
+ * @param p The pointer being allocated.
+ */
+declare function trackPointerAllocation(message: Message, p: Pointer): void;
+/**
+ * This is used as the return value for `Pointer.prototype.initPointer`. Turns out using a class in V8 for multiple
+ * return values is faster than using an array or anonymous object.
+ *
+ * http://jsben.ch/#/zTdbD
+ */
+declare class PointerAllocationResult {
+  readonly pointer: Pointer;
+  readonly offsetWords: number;
+  constructor(pointer: Pointer, offsetWords: number);
+}
+declare namespace utils {
+  export { PointerAllocationResult, add, adopt, checkDataBounds, checkPointerBounds, copyFrom, copyFromInterface, copyFromList, copyFromStruct, disown, dump, erase, erasePointer, followFar, followFars, getAs, getBit, getCapabilityId, getContent, getData, getDataSection, getFarSegmentId, getFloat32, getFloat64, getInt16, getInt32, getInt64, getInt8, getInterfaceClientOrNull, getInterfaceClientOrNullAt, getInterfacePointer, getList, getListByteLength, getListElementByteLength, getListElementSize, getListLength, getOffsetWords, getPointer, getPointerAs, getPointerSection, getPointerType, getSize, getStruct, getStructDataWords, getStructPointerLength, getStructSize, getTargetCompositeListSize, getTargetCompositeListTag, getTargetListElementSize, getTargetListLength, getTargetPointerType, getTargetStructSize, getText, getUint16, getUint32, getUint64, getUint8, initData, initList, initPointer, initStruct, initStructAt, isDoubleFar, isNull, relocateTo, resize, setBit, setFarPointer, setFloat32, setFloat64, setInt16, setInt32, setInt64, setInt8, setInterfacePointer, setListPointer, setStructPointer, setText, setUint16, setUint32, setUint64, setUint8, testWhich, trackPointerAllocation, validate };
+}
+declare const AnyPointerList: ListCtor<Pointer>;
+declare class BoolList extends List<boolean> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): boolean;
+  set(index: number, value: boolean): void;
+  [Symbol.toStringTag](): string;
+}
+declare function CompositeList<T extends Struct>(CompositeClass: StructCtor<T>): ListCtor<T>;
+declare const DataList: ListCtor<Data>;
+declare class Float32List extends List<number> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): number;
+  set(index: number, value: number): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Float64List extends List<number> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): number;
+  set(index: number, value: number): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Int8List extends List<number> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): number;
+  set(index: number, value: number): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Int16List extends List<number> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): number;
+  set(index: number, value: number): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Int32List extends List<number> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): number;
+  set(index: number, value: number): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Int64List extends List<bigint> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): bigint;
+  set(index: number, value: bigint): void;
+  [Symbol.toStringTag](): string;
+}
+declare const InterfaceList: ListCtor<Interface>;
+declare function PointerList<T extends Pointer>(PointerClass: PointerCtor<T>): ListCtor<T>;
+declare class TextList extends List<string> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): string;
+  set(index: number, value: string): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Uint8List extends List<number> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): number;
+  set(index: number, value: number): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Uint16List extends List<number> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): number;
+  set(index: number, value: number): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Uint32List extends List<number> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): number;
+  set(index: number, value: number): void;
+  [Symbol.toStringTag](): string;
+}
+declare class Uint64List extends List<bigint> {
+  static readonly _capnp: _ListCtor;
+  get(index: number): bigint;
+  set(index: number, value: bigint): void;
+  [Symbol.toStringTag](): string;
+}
+declare const VoidList: ListCtor<Void>;
+declare const getFloat32Mask: (x: number) => DataView;
+declare const getFloat64Mask: (x: number) => DataView;
+declare const getInt16Mask: (x: number) => DataView;
+declare const getInt32Mask: (x: number) => DataView;
+declare const getInt64Mask: (x: bigint) => DataView;
+declare const getInt8Mask: (x: number) => DataView;
+declare const getUint16Mask: (x: number) => DataView;
+declare const getUint32Mask: (x: number) => DataView;
+declare const getUint64Mask: (x: bigint) => DataView;
+declare const getUint8Mask: (x: number) => DataView;
+declare function getBitMask(value: boolean, bitOffset: number): DataView;
+//#endregion
+export { getInt64Mask as A, VoidList as C, getFloat64Mask as D, getFloat32Mask as E, getUint8Mask as F, utils as I, Pipeline as L, getUint16Mask as M, getUint32Mask as N, getInt16Mask as O, getUint64Mask as P, Void as S, getBitMask as T, TextList as _, DeferredTransport as a, Uint64List as b, Float64List as c, Int64List as d, Int8List as f, Text as g, Registry as h, DataList as i, getInt8Mask as j, getInt32Mask as k, Int16List as l, PointerList as m, BoolList as n, ErrorClient as o, InterfaceList as p, CompositeList as r, Float32List as s, AnyPointerList as t, Int32List as u, Uint16List as v, clientOrNull as w, Uint8List as x, Uint32List as y };
+//# sourceMappingURL=index-LYXu6eWz.d.mts.map