127 lines
5.4 KiB
TypeScript
127 lines
5.4 KiB
TypeScript
/// <reference types="node" resolution-mode="require"/>
|
|
declare module 'prismarine-nbt'{
|
|
// @ts-expect-error - protodef is untyped
|
|
import type { Compiler, Interpreter } from "protodef";
|
|
|
|
export type Byte = { type: `${TagType.Byte}`, value: number };
|
|
|
|
export type Short = { type: `${TagType.Short}`, value: number };
|
|
|
|
export type Int = { type: `${TagType.Int}`, value: number };
|
|
|
|
export type Long = { type: `${TagType.Long}`, value: [number, number] };
|
|
|
|
export type Float = { type: `${TagType.Float}`, value: number };
|
|
|
|
export type Double = { type: `${TagType.Double}`, value: number };
|
|
|
|
export type String = { type: `${TagType.String}`, value: string };
|
|
|
|
export type List<T extends TagType> = {
|
|
type: `${TagType.List}`,
|
|
value: { type: Tags[T]['type'], value: Tags[T]['value'][] }
|
|
};
|
|
|
|
export type Compound = { type: `${TagType.Compound}`, value: Record<string, undefined | Tags[TagType]> };
|
|
|
|
export type ByteArray = { type: `${TagType.ByteArray}`, value: Byte["value"][] };
|
|
|
|
export type ShortArray = { type: `${TagType.ShortArray}`, value: Short["value"][] };
|
|
|
|
export type IntArray = { type: `${TagType.IntArray}`, value: Int["value"][] };
|
|
|
|
export type LongArray = { type: `${TagType.LongArray}`, value: Long["value"][] };
|
|
|
|
export enum TagType {
|
|
Byte = 'byte',
|
|
Short = 'short',
|
|
Int = 'int',
|
|
Long = 'long',
|
|
Float = 'float',
|
|
Double = 'double',
|
|
String = 'string',
|
|
List = 'list',
|
|
Compound = 'compound',
|
|
ByteArray = 'byteArray',
|
|
ShortArray = 'shortArray',
|
|
IntArray = 'intArray',
|
|
LongArray = 'longArray',
|
|
}
|
|
|
|
export type Tags = {
|
|
[TagType.Byte]: Byte;
|
|
[TagType.Short]: Short;
|
|
[TagType.Int]: Int;
|
|
[TagType.Long]: Long;
|
|
[TagType.Float]: Float;
|
|
[TagType.Double]: Double;
|
|
[TagType.String]: String;
|
|
[TagType.List]: List<TagType>;
|
|
[TagType.Compound]: Compound;
|
|
[TagType.ByteArray]: ByteArray;
|
|
[TagType.ShortArray]: ShortArray;
|
|
[TagType.IntArray]: IntArray;
|
|
[TagType.LongArray]: LongArray;
|
|
}
|
|
|
|
interface ParseOptions {
|
|
noArraySizeCheck?: boolean;
|
|
}
|
|
|
|
export type NBTFormat = 'big' | 'little' | 'littleVarint'
|
|
|
|
export type NBT = Tags['compound'] & {name: string};
|
|
export type Metadata = {
|
|
// The decompressed buffer
|
|
buffer: Buffer
|
|
// The length of bytes read from the buffer
|
|
size: number
|
|
}
|
|
export function writeUncompressed(value: NBT, format?: NBTFormat): Buffer;
|
|
export function parseUncompressed(value: Buffer, format?: NBTFormat, options?: ParseOptions): NBT;
|
|
export function parseAs(value: Buffer, type: NBTFormat, options?: ParseOptions): Promise<{parsed: NBT, type: NBTFormat, metadata: Metadata}>;
|
|
|
|
export function parse(data: Buffer, nbtType?: NBTFormat): Promise<{parsed: NBT, type: NBTFormat, metadata: Metadata}>;
|
|
export function simplify(data: Tags[TagType]): any
|
|
export function equal(nbt1: Tags[TagType], nbt2: Tags[TagType]): boolean
|
|
// ProtoDef compiled protocols
|
|
export const protos: { big: any, little: any, littleVarint: any };
|
|
// Big Endian protocol
|
|
export const proto: any;
|
|
// Little Endian protocol
|
|
export const protoLE: any;
|
|
// Adds prismarine-nbt types to an ProtoDef compiler instance
|
|
export function addTypesToCompiler(type: NBTFormat, compiler: Compiler): void;
|
|
// Adds prismarine-nbt types to a ProtoDef interpreter instance
|
|
export function addTypesToInterpreter(type: NBTFormat, protodef: Interpreter): void;
|
|
|
|
/** @deprecated */
|
|
export function writeUncompressed(value: NBT, little?: boolean): Buffer;
|
|
/** @deprecated */
|
|
export function parseUncompressed(value: Buffer, little?: boolean): NBT;
|
|
/** @deprecated */
|
|
export function parse(data: Buffer, little: boolean, callback: (err: Error | null, value: NBT) => any): void;
|
|
/** @deprecated */
|
|
export function parse(data: Buffer, nbtType: NBTFormat, callback: (err: Error | null, value: NBT) => any): void;
|
|
/** @deprecated */
|
|
export function parse(data: Buffer, callback: (err: Error | null, value: NBT) => any): void;
|
|
|
|
export function bool(val: number): { type: `${TagType.Short}`, value: number }
|
|
export function short (val: number): { type: `${TagType.Short}`, value: number }
|
|
export function byte<T extends number> (val: number): { type: `${TagType.Byte}`, value: number }
|
|
export function string<T extends string | string[]> (val: T): { type: `${TagType.String}`, value: T }
|
|
export function comp<T extends object | object[]> (val: T, name?: string): { type: `${TagType.Compound}`, name?: string, value: T }
|
|
export function int<T extends number | number[]> (val: T): { type: `${TagType.Int}`, value: T }
|
|
export function list<T extends string, K extends {type: T}>(value: K): { type: `${TagType.List}`; value: { type: T | 'end', value: K } }
|
|
export function float<T extends number | number[]> (value: T): { type: `${TagType.Float}`, value: T}
|
|
export function double<T extends number | number[]> (value: T): { type: `${TagType.Double}`, value: T}
|
|
/**
|
|
* @param value Takes a BigInt or an array of two 32-bit integers
|
|
*/
|
|
export function long<T extends number | number[] | BigInt> (value: T): { type: `${TagType.Long}`, value: T}
|
|
// Arrays
|
|
export function byteArray (value: number[]): { type: `${TagType.ByteArray}`, value: number[]}
|
|
export function shortArray (value: number[]): { type: `${TagType.ShortArray}`, value: number[]}
|
|
export function intArray (value: number[]): { type: `${TagType.ByteArray}`, value: number[]}
|
|
export function longArray<T extends number[] | BigInt[]> (value: T): { type: `${TagType.LongArray}`, value: T}
|
|
}
|