@bedrock-apis/nbt/dist/index-CxKCPxKy.d.ts

Solid NBT package, with multiple formats

import { Byte, Double, Float, IDataCursor, Int, Short, TagType } from "@bedrock-apis/nbt-core";

//#region main/readers/reader-like.d.ts
interface ReaderLike {
  readType(cursor: IDataCursor): TagType;
  readStringLength(cursor: IDataCursor): number;
  readArrayLength(cursor: IDataCursor): number;
  [TagType.Byte](cursor: IDataCursor): number;
  [TagType.Short](cursor: IDataCursor): number;
  [TagType.Int](cursor: IDataCursor): number;
  [TagType.Long](cursor: IDataCursor): bigint;
  [TagType.Float](cursor: IDataCursor): number;
  [TagType.Double](cursor: IDataCursor): number;
  [TagType.ByteArray](cursor: IDataCursor): Uint8Array;
  [TagType.String](cursor: IDataCursor): string;
  [TagType.IntArray](cursor: IDataCursor): Int32Array;
  [TagType.LongArray](cursor: IDataCursor): BigInt64Array;
  [TagType.List](cursor: IDataCursor): unknown[];
  [TagType.Compound](cursor: IDataCursor): object;
}
//#endregion
//#region main/readers/general.d.ts
declare class GeneralReader implements ReaderLike {
  readonly littleEndian: boolean;
  readonly textEncoder: TextDecoder;
  constructor(littleEndian: boolean, textEncoder: TextDecoder);
  readType(_: IDataCursor): TagType;
  readArrayLength(_: IDataCursor): number;
  readStringLength(_: IDataCursor): number;
  /**
  
  *  TagType.byte
  
  */
  1(cursor: IDataCursor): number;
  /**
  
  *  TagType.Short
  
  */
  2(cursor: IDataCursor): number;
  /**
  
  *  TagType.Int
  
  */
  3(cursor: IDataCursor): number;
  /**
  
  *  TagType.Long
  
  */
  4(cursor: IDataCursor): bigint;
  /**
  
  *  TagType.Float
  
  */
  5(cursor: IDataCursor): number;
  /**
  
  *  TagType.Double
  
  */
  6(cursor: IDataCursor): number;
  /**
  
  *  TagType.ByteArray
  
  */
  7(cursor: IDataCursor): Uint8Array;
  /**
  
  *  TagType.String
  
  */
  8(cursor: IDataCursor): string;
  11(cursor: IDataCursor): Int32Array;
  12(cursor: IDataCursor): BigInt64Array;
  9(cursor: IDataCursor): unknown[];
  10(cursor: IDataCursor): object;
}
declare class GeneralVariantReader extends GeneralReader {}
declare const NBT_FORMAT_READER: GeneralReader;
declare const NBT_NETWORK_VARIANT_FORMAT_READER: GeneralReader;
declare const NBT_BIG_ENDIAN_FORMAT_READER: GeneralReader;
declare const NBT_BIG_ENDIAN_NETWORK_VARIANT_FORMAT_READER: GeneralReader;
//#endregion
//#region main/readers/typed-reader.d.ts
declare class TypedReader {
  static 1(cursor: IDataCursor, format: ReaderLike): Byte;
  static 2(cursor: IDataCursor, format: ReaderLike): Short;
  static 3(cursor: IDataCursor, format: ReaderLike): Int;
  static 5(cursor: IDataCursor, format: ReaderLike): Float;
  static 6(cursor: IDataCursor, format: ReaderLike): Double;
  static 4(cursor: IDataCursor, format: ReaderLike): bigint;
  static 7(cursor: IDataCursor, format: ReaderLike): Uint8Array;
  static 8(cursor: IDataCursor, format: ReaderLike): string;
  static 11(cursor: IDataCursor, format: ReaderLike): Int32Array;
  static 12(cursor: IDataCursor, format: ReaderLike): BigInt64Array;
  static 10(cursor: IDataCursor, format: ReaderLike): object;
  static 9(cursor: IDataCursor, format: ReaderLike): unknown[];
  static parseRootSync<T>(this: typeof TypedReader, cursor: IDataCursor, format: ReaderLike): T;
  static parseSync<T>(this: typeof TypedReader, cursor: IDataCursor, format: ReaderLike): T;
  static parseExplicitSync<T>(this: typeof TypedReader, cursor: IDataCursor, type: TagType, format: ReaderLike): T;
}
//#endregion
//#region main/readers/index.d.ts
declare function parseRootSync<T = unknown>(cursor: IDataCursor, format?: ReaderLike): T;
declare function parseExplicitSync<T = unknown>(cursor: IDataCursor, type: TagType, format?: ReaderLike): T;
declare function parseSync<T = unknown>(cursor: IDataCursor, format?: ReaderLike): T;
//#endregion
//#region main/writers/writer-like.d.ts
interface WriterLike {
  writeType(cursor: IDataCursor, value: TagType): void;
  writeStringLength(cursor: IDataCursor, length: number): void;
  writeArrayLength(cursor: IDataCursor, length: number): void;
  [TagType.Byte](cursor: IDataCursor, value: number): void;
  [TagType.Short](cursor: IDataCursor, value: number): void;
  [TagType.Int](cursor: IDataCursor, value: number): void;
  [TagType.Long](cursor: IDataCursor, value: bigint): void;
  [TagType.Float](cursor: IDataCursor, value: number): void;
  [TagType.Double](cursor: IDataCursor, value: number): void;
  [TagType.ByteArray](cursor: IDataCursor, value: Uint8Array): void;
  [TagType.String](cursor: IDataCursor, value: string): void;
  [TagType.IntArray](cursor: IDataCursor, value: Int32Array): void;
  [TagType.LongArray](cursor: IDataCursor, value: BigInt64Array): void;
  [TagType.List](cursor: IDataCursor, value: unknown[]): void;
  [TagType.Compound](cursor: IDataCursor, value: object): void;
  determinateType(_: unknown): TagType;
}
//#endregion
//#region main/writers/general.d.ts
declare class GeneralWriter implements WriterLike {
  readonly littleEndian: boolean;
  readonly textEncoder: TextEncoder;
  constructor(littleEndian: boolean, textEncoder: TextEncoder);
  writeType(_cursor: IDataCursor, _: number): void;
  writeStringLength(_cursor: IDataCursor, _: number): void;
  writeArrayLength(_cursor: IDataCursor, _: number): void;
  1(cursor: IDataCursor, _: number): void;
  2(cursor: IDataCursor, _: number): void;
  3(cursor: IDataCursor, _: number): void;
  4(cursor: IDataCursor, _: bigint): void;
  5(cursor: IDataCursor, _: number): void;
  6(cursor: IDataCursor, _: number): void;
  7(cursor: IDataCursor, _: Uint8Array): void;
  8(cursor: IDataCursor, _: string): void;
  9(cursor: IDataCursor, _: unknown[]): void;
  10(cursor: IDataCursor, _: object): void;
  11(cursor: IDataCursor, _: Int32Array): void;
  12(cursor: IDataCursor, _: BigInt64Array): void;
  //NOTE - We could think of prototype based serialization something like
  // new Byte().serializeNBT(cursor, format); and recursively like that
  determinateType(_: unknown): TagType;
}
declare class GeneralVariantWriter extends GeneralWriter {}
declare const NBT_FORMAT_WRITER: GeneralWriter;
declare const NBT_NETWORK_VARIANT_FORMAT_WRITER: GeneralWriter;
declare const NBT_BIG_ENDIAN_FORMAT_WRITER: GeneralWriter;
declare const NBT_BIG_ENDIAN_NETWORK_VARIANT_FORMAT_WRITER: GeneralWriter;
//#endregion
//#region main/writers/index.d.ts
declare function writeRootSync(cursor: IDataCursor, value: unknown, format?: WriterLike, root?: string): void;
declare function writeExplicitSync(cursor: IDataCursor, value: unknown, type: TagType, format?: WriterLike): void;
declare function writeSync(cursor: IDataCursor, value: unknown, format?: WriterLike): void;
//#endregion
export { GeneralReader, GeneralVariantReader, GeneralVariantWriter, GeneralWriter, NBT_BIG_ENDIAN_FORMAT_READER, NBT_BIG_ENDIAN_FORMAT_WRITER, NBT_BIG_ENDIAN_NETWORK_VARIANT_FORMAT_READER, NBT_BIG_ENDIAN_NETWORK_VARIANT_FORMAT_WRITER, NBT_FORMAT_READER, NBT_FORMAT_WRITER, NBT_NETWORK_VARIANT_FORMAT_READER, NBT_NETWORK_VARIANT_FORMAT_WRITER, ReaderLike, TypedReader, WriterLike, parseExplicitSync, parseRootSync, parseSync, writeExplicitSync, writeRootSync, writeSync };