@stryke/capnp 0.12.96 → 0.12.97

package/schemas/index-DprjZUdT.d.mts

@@ -0,0 +1,742 @@
+//#region ../../node_modules/.pnpm/capnp-es@0.0.11_patch_hash=503a440bd2bef41c0cb22819bc4ced5a7f04993fb999f0d944e284220f14916b_typescript@6.0.3/node_modules/capnp-es/dist/shared/capnp-es.Dd0AvjKJ.d.mts
+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.
+ */
+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;
+}
+interface _PointerCtor {
+  readonly displayName: string;
+}
+declare enum PointerType {
+  STRUCT = 0,
+  LIST = 1,
+  FAR = 2,
+  OTHER = 3
+}
+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.
+ */
+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;
+}
+interface _ListCtor {
+  readonly compositeSize?: ObjectSize;
+  readonly displayName: string;
+  readonly size: ListElementSize;
+}
+interface ListCtor<T> {
+  readonly _capnp: _ListCtor;
+  new (segment: Segment, byteOffset: number, depthLimit?: number): List<T>;
+}
+type ArrayCb<T, RT = boolean> = (this: any, value: T, index: number, array: T[]) => RT;
+/**
+ * A generic list class. Implements Filterable,
+ */
+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;
+}
+type CapabilityID = number;
+interface Method<P extends Struct, R extends Struct> {
+  interfaceId: bigint;
+  methodId: number;
+  interfaceName?: string;
+  methodName?: string;
+  ParamsClass: StructCtor<P>;
+  ResultsClass: StructCtor<R>;
+}
+type Call<P extends Struct, R extends Struct> = FuncCall<P, R> | DataCall<P, R>;
+interface BaseCall<P extends Struct, R extends Struct> {
+  method: Method<P, R>;
+}
+type FuncCall<P extends Struct, R extends Struct> = BaseCall<P, R> & {
+  paramsFunc?(params: P): void;
+};
+type DataCall<P extends Struct, R extends Struct> = BaseCall<P, R> & {
+  params: P;
+};
+interface PipelineOp {
+  field: number;
+  defaultValue?: Pointer;
+}
+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();
+}
+interface ecall {
+  call: Call<any, any>;
+  f: Fulfiller<any>;
+}
+interface pcall extends ecall {
+  transform: PipelineOp[];
+}
+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>;
+}
+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;
+}
+interface ServerMethod<P extends Struct, R extends Struct> extends Method<P, R> {
+  impl(params: P, results: R): Promise<void>;
+}
+interface ServerCall<P extends Struct, R extends Struct> extends DataCall<P, R> {
+  serverMethod: ServerMethod<P, R>;
+  answer: Fulfiller<R>;
+}
+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;
+}
+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;
+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.
+ */
+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;
+}
+interface _StructCtor extends _PointerCtor {
+  readonly id: string;
+  readonly size: ObjectSize;
+}
+interface StructCtor<T extends Struct> {
+  readonly _capnp: _StructCtor;
+  new (segment: Segment, byteOffset: number, depthLimit?: number, compositeIndex?: number): T;
+}
+interface _Struct extends _Pointer {
+  compositeIndex?: number;
+}
+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;
+}
+interface Client {
+  call<P extends Struct, R extends Struct>(call: Call<P, R>): Answer<R>;
+  close(): void;
+}
+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;
+type AnyArena = MultiSegmentArena | SingleSegmentArena;
+interface _Message {
+  readonly arena: AnyArena;
+  segments: Segment[];
+  traversalLimit: number;
+  capTable?: Array<Client | null>;
+}
+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.
+ */
+declare function readRawPointer(data: ArrayBuffer): Pointer;
+declare function toArrayBuffer(m: Message): ArrayBuffer;
+declare function toPackedArrayBuffer(m: Message): ArrayBuffer;
+//#endregion
+export { List as a, ObjectSize as c, Pointer as d, type Server as f, type Interface as i, Orphan as l, type StructCtor as m, type Call as n, type ListCtor as o, Struct as p, Client as r, Method as s, Answer as t, PipelineOp as u };
+//# sourceMappingURL=index-DprjZUdT.d.mts.map