forked from JaylyDev/ScriptAPI
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathindex.d.ts
More file actions
178 lines (173 loc) · 6.71 KB
/
index.d.ts
File metadata and controls
178 lines (173 loc) · 6.71 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
import {ScoreboardObjective, ScoreboardIdentity, Entity} from "@minecraft/server";
//////////////////////////////////////
// NBT-SERIALIZER.D.TS
//////////////////////////////////////
type StringBase = 16|8|32;
type IStreamType = number | number | {buffer: ArrayBuffer};
declare class Stream extends DataView{
constructor(buffer: ArrayBuffer | number, offset?: number)
protected __offset__: number
readonly offset: number
readonly size: number
readonly EndOfStream: boolean
setOffset(num: number): void
static fromString(text: string, options?: {bufferLength?: number, base?:StringBase},...params: any): Stream
/**@param {Stream} stream @param {8|16|32} base*/
static toString(stream: Stream, base?: StringBase): string
toString(base?: StringBase): string
}
declare class BinaryStreamWriter extends Stream{
constructor(stream: IStreamType)
writeBytes(buffer: ArrayBuffer,length?:number ): number
writeString(text: string, base?: StringBase): number
writeByte(num: number): number
writeUint8(num: number): number
writeInt8(num: number): number
writeInt16(num: number): number
writeUint16(num: number): number
writeInt32(num: number): number
writeUint32(num: number): number
writeFloat32(num: number): number
writeFloat64(num: number): number
static fromString(text: string, options?: {bufferLength?: number, base?:StringBase},...params: any): BinaryStreamWriter
}
declare class BinaryStreamReader extends Stream{
constructor(stream: IStreamType)
readBytes(length?: number): Uint8Array
readString(length: number, base?: StringBase):string
readByte():number
readUint8():number
readInt8():number
readInt16():number
readUint16():number
readInt32():number
readUint32():number
readFloat32():number
readFloat64():number
static fromString(text: string, options?: {bufferLength?: number, base?:StringBase},...params: any): BinaryStreamReader
}
declare class EndOfStreamError extends Error{}
declare enum NBTTypes {
"EndOfCompoud"=0,
"Compoud"=1,
"Array"=2,
"TypedArray"=3,
"Uint8"=4,
"Uint16"=5,
"Int32"=6,
"Double"=7,
"String"=8,
"Empty"=9,
"Boolean"=10
}
declare class NBTStreamWriter extends BinaryStreamWriter{
constructor(stream: IStreamType, options?: object | NBTStreamWriter)
protected __options__: NBTWriterOptions;
writeTypedArray<t>(array: Array<t>): number
writeBoolean(bool: boolean):number
writeString(text: string): number
writeArray(array: any[]): number
writeCompoud(object: object): number
writeEmpty(): number
writeType(type: NBTTypes): number
static fromString(text: string, options?: {bufferLength?: number, base?:StringBase},...params: any): NBTStreamWriter
}
declare class NBTStreamReader extends BinaryStreamReader{
constructor(stream: IStreamType, options?: object | NBTReaderOptions)
protected __options__: NBTReaderOptions;
readTypedArray(): Array<any>
readBoolean(): boolean
readString(): string
readArray(): any[]
readCompoud(): object
readEmpty(): undefined
readType(): NBTTypes
static fromString(text: string, options?: {bufferLength?: number, base?:StringBase},...params: any): NBTStreamReader
}
declare const NBT: {
ReadNBT(stream: NBTStreamReader): any
WriteNBT(data: any, stream: NBTStreamWriter, type?: NBTTypes): number
getType(data: any): NBTTypes
stringify(object:any, options?: NBTWriterOptions): string
parse(string: string, options?: NBTReaderOptions): any
createNewWriters<t extends Partial<typeof defaultWriters>>(object?: t): t & typeof defaultWriters
createNewReaders<t extends Partial<typeof defualtReaders>>(object?: t): t & typeof defualtReaders
}
type WriterCall = (stream: NBTStreamWriter, data: any)=>number
type ReaderCall = (stream: NBTStreamReader)=>any
declare const defaultWriters: {
[NBTTypes.Compoud]:WriterCall,
[NBTTypes.Empty]:WriterCall,
[NBTTypes.Array]:WriterCall,
[NBTTypes.String]:WriterCall,
[NBTTypes.Boolean]:WriterCall,
[NBTTypes.Uint8]:WriterCall,
[NBTTypes.Uint16]:WriterCall,
[NBTTypes.Int32]:WriterCall,
[NBTTypes.Double]:WriterCall,
[NBTTypes.TypedArray]:WriterCall
}
declare const defualtReaders: {
[NBTTypes.Compoud]:ReaderCall,
[NBTTypes.Empty]:ReaderCall,
[NBTTypes.Array]:ReaderCall,
[NBTTypes.String]:ReaderCall,
[NBTTypes.Boolean]:ReaderCall,
[NBTTypes.Uint8]:ReaderCall,
[NBTTypes.Uint16]:ReaderCall,
[NBTTypes.Int32]:ReaderCall,
[NBTTypes.Double]:ReaderCall,
[NBTTypes.TypedArray]:ReaderCall
}
declare class NBTStreamOptions{
nbtTypes: object & NBTTypes
getType:(data: any)=>NBTStreamOptions["nbtTypes"][keyof NBTStreamOptions["nbtTypes"]]
}
declare class NBTWriterOptions extends NBTStreamOptions{
writers: ReturnType<typeof NBT["createNewWriters"]>;
}
declare class NBTReaderOptions extends NBTStreamOptions{
readers: ReturnType<typeof NBT["createNewReaders"]>;
}
//////////////////////////////////////
// DATABASE.JS
//////////////////////////////////////
export enum DatabaseSavingModes {
OneTimeSave="OneTimeSave",
EndTickSave="EndTickSave",
TickInterval="TickInterval"
}
export enum ChangeAction {
Change=0,
Remove=1
}
/**@extends {Map<string,any>}*/
declare class ScoreboardDatabaseManager extends Map<string,any>{
private _saveMode_: DatabaseSavingModes;
private hasChanges: boolean;
readonly maxLength: number;
private readonly _scoreboard_: ScoreboardObjective;
protected readonly _source_: Map<string,string|ScoreboardIdentity|Entity>;
protected readonly _parser_: {stringify:(data: any)=>string,parse:(data: string)=>any};
readonly savingMode: DatabaseSavingModes;
constructor(objective: string | ScoreboardObjective, saveMode?: DatabaseSavingModes);
constructor(objective: string | ScoreboardObjective, saveMode: DatabaseSavingModes.EndTickSave, interval?: number);
/**@inheritdoc */
set(key: string, value: any): this
/**@inheritdoc */
delete(key: string): boolean
clear(): void
load(): this
loadAsync(): Promise<this>
rebuild(): this;
rebuildAsync(): Promise<this>;
readonly objective: ScoreboardObjective
readonly id: string;
readonly loaded: boolean;
}
export class JsonDatabase extends ScoreboardDatabaseManager{}
export class NBTDatabase extends ScoreboardDatabaseManager{}
export class CustomDatabase extends ScoreboardDatabaseManager{
constructor(parser: {parse:(data:string)=>any,stringify:(data: any)=>string}, objective: string | ScoreboardObjective, saveMode?: DatabaseSavingModes);
constructor(parser: {parse:(data:string)=>any,stringify:(data: any)=>string}, objective: string | ScoreboardObjective, saveMode: DatabaseSavingModes.EndTickSave, interval?: number);
}