@imaduddin/fastbrain 1.1.1 → 2.0.1

package/src/Softmax/index.ts

@@ -0,0 +1,82 @@
+import { GPUManager, Buffer } from "@imaduddin/webgpu-manager";
+import { isBufferOrNumber } from '../fileManager.js'
+
+export class Softmax {
+    forwardShader: GPUComputePipeline | undefined;
+    lossShader: GPUComputePipeline | undefined;
+    backwardShader: GPUComputePipeline | undefined;
+    output: Buffer | undefined;
+    loss: Buffer | undefined;
+    gpu: GPUManager | undefined;
+    forwardParams: Buffer | undefined;
+    gradOutput: Buffer | undefined
+    targetBuffer: Buffer | undefined;
+    constructor(public device: GPUDevice, public VocabSize: number) {
+        this.gpu = new GPUManager(device, {
+            shaderDir: './shaders/softmax'
+        })
+    }
+    async forward(logit: Buffer | number[], encoderShared: GPUCommandEncoder | undefined) {
+        let logits = await isBufferOrNumber(logit, this.gpu!)
+        const tokenCount = logits.buffer.size / (this.VocabSize * 4)
+        const encoder = encoderShared ? encoderShared : await this.gpu?.CreateEncoder()
+        if (!this.forwardShader) {
+            this.forwardShader = await this.gpu?.getPiplineShader("forward.wgsl")
+        }
+        if (!this.output || this.output.buffer.size !== logits.buffer.size || this.output.isDestroy()) {
+            if (this.output) this.output.destroy()
+            this.output = await this.gpu?.createBuffer(new Float32Array(tokenCount * this.VocabSize), "storage")
+        }
+        if (!this.forwardParams) {
+            this.forwardParams = await this.gpu?.createBuffer(new Uint32Array([this.VocabSize, tokenCount]), "uniform")
+        } else {
+            await this.forwardParams.changeData(new Uint32Array([this.VocabSize, tokenCount]))
+        }
+        const bindGroup = await this.gpu?.createBindGroup(this.forwardShader!, [logits!, this.output!, this.forwardParams!], 0)
+        await this.gpu?.RunPipline(encoder, this.forwardShader!, bindGroup!, tokenCount)
+        if (!encoderShared) await this.gpu?.SumbitEncoder(encoder!)
+        return this.output
+    }
+    async backward(probs: Buffer, target: number[], encoderShared: GPUCommandEncoder | undefined) {
+        let tokenCount = probs.buffer.size / (4 * this.VocabSize)
+        if (!this.backwardShader) {
+            this.backwardShader = await this.gpu?.getPiplineShader("backward.wgsl")
+        }
+        const encoder = encoderShared ? encoderShared : await this.gpu?.CreateEncoder()
+        if (!this.gradOutput || this.gradOutput.buffer.size !== probs.buffer.size || this.gradOutput.isDestroy()) {
+            if (this.gradOutput) this.gradOutput.destroy()
+            this.gradOutput = await this.gpu?.createBuffer(new Float32Array(tokenCount * this.VocabSize), "storage")
+        }
+        if (!this.targetBuffer || this.targetBuffer.buffer.size !== tokenCount * Uint32Array.BYTES_PER_ELEMENT) {
+            if (this.targetBuffer) this.targetBuffer.destroy()
+            this.targetBuffer = await this.gpu?.createBuffer(new Uint32Array(target), "storage")
+        } else {
+            this.targetBuffer.changeData(new Uint32Array(target))
+        }
+        const bindGroup = await this.gpu?.createBindGroup(this.backwardShader!, [probs, this.gradOutput!, this.targetBuffer!, this.forwardParams!], 0)
+        await this.gpu?.RunPipline(encoder, this.backwardShader!, bindGroup!, Math.ceil(this.VocabSize / 64), tokenCount)
+        if (!encoderShared) await this.gpu?.SumbitEncoder(encoder!)
+        return this.gradOutput
+    }
+    async crossEntropy(probs: Buffer, target: number[], encoderShared : GPUCommandEncoder | undefined) {
+        let encoder = encoderShared ? encoderShared : await this.gpu?.CreateEncoder()
+        let tokenCount = probs.buffer.size / (4 * this.VocabSize)
+        if (!this.targetBuffer || this.targetBuffer.buffer.size !== tokenCount * Uint32Array.BYTES_PER_ELEMENT) {
+            if (this.targetBuffer) this.targetBuffer.destroy()
+            this.targetBuffer = await this.gpu?.createBuffer(new Uint32Array(target), "storage")
+        } else {
+            this.targetBuffer.changeData(new Uint32Array(target))
+        }
+        if(!this.loss || this.loss.buffer.size !== tokenCount * 4){
+            if(this.loss) this.loss.destroy()
+            this.loss = await this.gpu?.createBuffer(new Float32Array(tokenCount), "storage")
+        }
+        if(!this.lossShader){
+            this.lossShader = await this.gpu?.getPiplineShader("crossEntropy.wgsl")
+        }
+        const bindGroup = await this.gpu?.createBindGroup(this.lossShader!, [probs,this.targetBuffer!, this.loss!, this.forwardParams!], 0)
+        await this.gpu?.RunPipline(encoder, this.lossShader!, bindGroup!, Math.ceil(tokenCount / 16))
+        if(!encoderShared) await this.gpu?.SumbitEncoder(encoder!)
+        return this.loss
+    }
+}

package/src/Tokenizer/index.ts

@@ -0,0 +1,60 @@
+import { GPUManager } from '@imaduddin/webgpu-manager';
+import fs from 'fs'
+
+
+export class Tokenizer {
+    vocabs:  string[] = ["hi"]
+    vocabSize: number | undefined = 0
+    idToString: Record<number, string> = {12: "hi"};
+    stringToID: Record<string, number> = {"hi": 12};
+    constructor(public configs:{
+        vocabFile: string
+    }) {
+        const isVocabExist = fs.existsSync(configs.vocabFile);
+        if(isVocabExist){
+            console.log(`[LOG] Tokenizer is Loaded with ${configs.vocabFile}`)
+            this.vocabs = JSON.parse(fs.readFileSync(configs.vocabFile , "utf-8"))
+            this.vocabSize = this.vocabs?.length;
+            this.idToString = Object.fromEntries(this.vocabs?.map((e,idx)=> [idx,e]))
+            this.stringToID = Object.fromEntries(this.vocabs?.map((e,idx)=> [e,idx]))
+        }else{
+            console.log(`[LOG] Tokenizer exited with error 1. No such File or Dir.`)
+        }
+    }
+    encode(text: string){
+        const split = text.toLocaleLowerCase().split(/(\s+|[.:?,;!:'-()])/).filter(Boolean)
+        const tokens : number[] | []= []
+        for(let a = 0; a < split.length; a++){
+            const token : number | undefined = this.stringToID[split[a]] as never;
+            if(token !== undefined){
+                tokens.push(token)
+            }else{
+                const unkToken = this.stringToID["<unk>"] as never
+                tokens.push(unkToken)
+            }
+        }
+        return tokens
+    }
+    decode(token: number[]){
+        let text = ""
+        for(let a = 0; a < token.length; a++){
+            const string = this.idToString[token[a]];
+            if(string !== undefined){
+                text += string
+            }else{
+               text += "<unk>"
+            }
+        }
+        return text
+    }
+    trainTokenizer(text: string, file: string) {
+        let oldArray = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : []
+        const splitedText = text.toLocaleLowerCase().split(/\r\n|\r|\n/).filter((e) => e.trim().length > 0).map((e) => e.replaceAll("<eos>", "<eos>").split(/(\s+|[.:?,;:'!-()])/).filter(Boolean)).flat()
+        const uqiuneText = [...new Set([...splitedText, "<unk>", "_m", "_e", "<eos>", ...oldArray])]
+        console.log("Operation Completed!")
+        console.log("New Vocab Size", uqiuneText.length - oldArray.length);
+        fs.writeFileSync(file, JSON.stringify(uqiuneText))
+    }
+    
+    
+}

package/src/TransformerBlock/index.ts

@@ -0,0 +1,41 @@
+import {FFN, RMSNorm, SelfAttention, residualConnection} from '../index.js'
+import { Buffer } from '@imaduddin/webgpu-manager'
+
+export class TransformerBlock{
+   ffn: FFN | undefined
+   attention: SelfAttention | undefined
+   norm : RMSNorm | undefined
+   norm1 : RMSNorm | undefined
+   residualConnection1: residualConnection | undefined;
+   residualConnection2: residualConnection | undefined; 
+   constructor(public device : GPUDevice, public embeddingSize : number, public configs : {
+    dirname: string
+   }){
+    this.ffn = new FFN(device, embeddingSize, configs)
+    this.norm = new RMSNorm(device, embeddingSize)
+    this.norm1 = new RMSNorm(device, embeddingSize)
+    this.attention = new SelfAttention(device, embeddingSize, configs)
+    this.residualConnection1 = new residualConnection(device)
+    this.residualConnection2 = new residualConnection(device)
+   }
+   async forward(input : Buffer){
+     const norm = await this.norm?.forward(input, undefined);
+     const att = await this.attention?.forward(norm!)
+     const residual = await this.residualConnection1?.add(att!, input);
+     const norm1 = await this.norm1?.forward(residual!, undefined)
+     const ff = await this.ffn?.forward(norm1!, undefined);
+     return await this.residualConnection2?.add(residual!, ff!);
+   }
+   async backward(outGradient: Buffer , lr : number){
+      const d_FFN = await this.ffn?.backward(outGradient, lr, undefined)
+      const d_norm1 = await this.norm1?.backward(d_FFN!, undefined)
+      let d_residual2 = await this.residualConnection2?.add(outGradient, d_norm1!);
+      const d_att = await this.attention?.backward(d_residual2!, lr)
+      const d_norm2 = await this.norm?.backward(d_att!,undefined)
+      return await this.residualConnection1?.add(outGradient, d_norm2!)
+   }
+   async Save(){
+      await this.ffn?.Save()
+      await this.attention?.Save()
+   }
+}

package/src/fileManager.ts

@@ -0,0 +1,46 @@
+import fs from 'fs'
+import path, { join } from 'path'
+import { Buffer as WEBB, GPUManager } from '@imaduddin/webgpu-manager';
+
+process.stdout.write("\x1bc")
+
+let totalParameter = 0;
+export function GetVectorsForFile(file: string, total: number, isBias: boolean = false, aSize: number, bSize: number) {
+    if (!fs.existsSync(file)) return null;
+totalParameter += total;
+
+        console.log(`Loading File ${join(file)} (${aSize}x${bSize})...`)
+  
+    const rawBuffer = fs.readFileSync(file)
+    const vec = new Float32Array(rawBuffer.buffer, rawBuffer.byteOffset, rawBuffer.byteLength / 4)
+    if (total <= vec.length) {
+        return vec;
+    }
+    const expanded = new Float32Array(total);
+    expanded.set(vec);
+    for (let i = vec.length; i < total; i++) {
+        expanded[i] = isBias ? 0 : (Math.random() * 2 - 1) * 0.05;
+    }
+    return expanded;
+}
+
+
+export function SaveFileVector(file: string, vector: Float32Array) {
+    fs.writeFileSync(file, Buffer.from(
+        vector.buffer,
+        vector.byteOffset,
+        vector.byteLength
+    ))
+}
+
+export function initRandomVector(total: number) {
+    return new Float32Array(total).map((e) => (Math.random() * 2 - 1) * 0.02)
+}
+
+export async function isBufferOrNumber(f: WEBB | number[], gpu: GPUManager) {
+    return f instanceof WEBB ? f : await gpu.createBuffer(new Float32Array(f), "storage");
+}
+
+export function getParameter() {
+    console.log(`Total Parameter ${(totalParameter / 1000000).toFixed(2)}M.`)
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './Embedding/index.js'
+export * from './Linear/index.js'
+export * from './Softmax/index.js'
+export * from './Gelu/index.js'
+export * from './FFN/index.js'
+export * from './RMSNorm/index.js'
+export * from './SelfAttention/index.js'
+export * from './Tokenizer/index.js'
+export * from './TransformerBlock/index.js'
+export * from './residualConnection/index.js'

package/src/residualConnection/index.ts

@@ -0,0 +1,24 @@
+import {Buffer,GPUManager} from "@imaduddin/webgpu-manager"
+
+
+export class residualConnection{
+    output: Buffer | undefined;
+    gpu : GPUManager | undefined;
+    addShader: GPUComputePipeline | undefined;
+    constructor(public device : GPUDevice){
+        this.gpu = new GPUManager(device, {
+            shaderDir: "./shaders"
+        })
+    }
+    async add(a: Buffer, b: Buffer){
+         const encoder = await this.gpu?.CreateEncoder()
+         if(!this.output || this.output.buffer.size !== a.buffer.size / 4){
+            if(this.output) this.output.destroy()
+            this.output = await this.gpu?.createBuffer(new Float32Array(a.buffer.size / 4), "storage")
+         }
+         const bindGroup = await this.gpu?.createBindGroup(this.addShader!, [a,b,this.output!], 0)
+         await this.gpu?.RunPipline(encoder, this.addShader!, bindGroup!, Math.ceil((a.buffer.size / 4) / 64))
+         await this.gpu?.SumbitEncoder(encoder!)
+         return this.output;
+    }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "declaration": true,
+    "lib": [
+      "ES2022",
+      "DOM"
+    ],
+    "types": [
+      "node",
+      "@webgpu/types"
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/index.js

@@ -1,22 +0,0 @@
-import { Embedding as E } from "./src/Embedding/index.js";
-import { Linear as L } from "./src/Linear/index.js";
-import { Softmax as S } from "./src/Softmax/index.js";
-import { Relu as r } from "./src/Relu/index.js";
-import { FFN as ffn } from "./src/FFN/index.js";
-import { Tokenizer as to } from './src/Tokenizer/index.js'
-import {SelfAttention as ST} from './src/SelfAttention/index.js'
-import {TransformerBlock as TT} from './src/TransformerBlock/index.js'
-import {PositionEmbedding as PM } from './src/PositionEmbedding/index.js'
-import { RMSNorm as RM } from "./src/RMSNorm/index.js";
-import {model as M} from './src/model/index.js'
-export const Embedding = E
-export const Linear = L
-export const Softmax = S;
-export const RELU = r
-export const FFN = ffn
-export const Tokenizer = to;
-export const SelfAttention = ST
-export const TransformerBlock = TT;
-export const PositionEmbedding = PM;
-export const RMSNorm = RM
-export const model = M

package/src/Embedding/index.d.ts

@@ -1,21 +0,0 @@
-export class Embedding {
-    constructor(device: GPUBuffer, embedding: number, vocabSize: number, config: {
-        cpuReadBack: boolean,
-        save: {
-            filename: string
-        }
-    })
-    async forward(tokens: number[]): Promise<{
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }>
-    async Save(): void
-    async backward(inputGradient: {
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }, lr: number): Promise<void>
-}

package/src/Embedding/index.js

@@ -1,140 +0,0 @@
-import { config } from "process";
-
-import { SaveVector, getVector } from '../getVec.js'
-import { OperationManager } from "../OperationManager.js";
-
-function GenerateVectors(embeddingSize, vocabSize) {
-    const vec = new Float32Array(embeddingSize * vocabSize).map(() => (Math.random() * 2 - 1) * 0.02)
-    return vec
-}
-
-export class Embedding {
-    embeddingSize;
-    vocabSize;
-    gpu;
-    firstTrue;
-    vectors;
-    configs;
-    vectorsBuffer;
-    forwardPipline;
-    constructor(device, embeddingSize, vocabSize, configs) {
-        this.configs = configs
-        this.embeddingSize = embeddingSize;
-        this.vocabSize = vocabSize;
-        this.device = device
-        let total = embeddingSize * vocabSize;
-        if (configs && configs.save) {
-            const vec = getVector(configs.save.filename, total);
-            if (vec) {
-                this.vectors = vec;
-
-            } else {
-                this.vectors = GenerateVectors(embeddingSize, vocabSize)
-            }
-
-        } else {
-            this.vectors = GenerateVectors(embeddingSize, vocabSize)
-
-        }
-        this.gpu = new OperationManager(device)
-        this.forwardPipline = this.gpu.getShaderPipline("./src/shaders/EF.wgsl", {
-            embeddingSize: embeddingSize
-        })
-        this.backwardPipline = this.gpu.getShaderPipline("./src/shaders/EB.wgsl", {
-            embeddingSize: embeddingSize
-        })
-        SaveVector(this.configs.save.filename, this.vectors)
-    }
-    async forward(input, encoder2) {
-        const encoder = encoder2 ? encoder2 : this.device.createCommandEncoder()
-        if (!this.vectorsBuffer) {
-            this.vectorsBuffer = await this.gpu.createBuffer(Float32Array.BYTES_PER_ELEMENT * this.vocabSize * this.embeddingSize);
-            await this.gpu.WriteBuffer(this.vectorsBuffer, this.vectors)
-        }
-        if (!this.tokenBuffer) this.tokenBuffer = await this.gpu.createBuffer(Uint32Array.BYTES_PER_ELEMENT * input.length);
-        if (this.tokenBuffer.size !== Uint32Array.BYTES_PER_ELEMENT * input.length) {
-            this.tokenBuffer.destroy()
-            this.tokenBuffer = await this.gpu.createBuffer(Uint32Array.BYTES_PER_ELEMENT * input.length);
-        }
-        
-        await this.gpu.WriteBuffer(this.tokenBuffer, new Uint32Array(input))
-        if (!this.outputBuffer) this.outputBuffer = await this.gpu.ManageBuffer(Float32Array.BYTES_PER_ELEMENT * this.embeddingSize * input.length)
-            if (this.outputBuffer.mainBuffer.size !== Float32Array.BYTES_PER_ELEMENT * this.embeddingSize * input.length || this.outputBuffer.isDestroyed()) {
-            this.outputBuffer.destroy()
-            this.outputBuffer = await this.gpu.ManageBuffer(Float32Array.BYTES_PER_ELEMENT * this.embeddingSize * input.length);
-        }
-        const bind = await this.device.createBindGroup({
-            layout: await this.forwardPipline.getBindGroupLayout(0),
-            entries: [
-                {
-                    binding: 0,
-                    resource: {
-                        buffer: this.vectorsBuffer
-                    }
-                },
-                {
-                    binding: 1,
-                    resource: {
-                        buffer: this.outputBuffer.mainBuffer
-                    }
-                }, {
-                    binding: 2,
-                    resource: {
-                        buffer: this.tokenBuffer
-                    }
-                }
-            ]
-        })
-        await this.gpu.RunPipline(encoder, this.forwardPipline, bind, Math.ceil((this.embeddingSize * input.length) / 256))
-        if(!encoder2) await this.device.queue.submit([encoder.finish()])
-        return this.outputBuffer
-
-    }
-    async Save() {
-        const vec = await this.gpu.readBuffer(Float32Array.BYTES_PER_ELEMENT * this.vocabSize * this.embeddingSize, this.vectorsBuffer)
-        SaveVector(this.configs.save.filename, vec)
-    }
-    async backward(inputGradient, lr, en2) {
-        const encoder = en2 ? en2 : this.device.createCommandEncoder()
-        if (!this.oldParam) {
-            this.oldParam = new Float32Array([0, 0]);
-            this.param = await this.gpu.createUniFormBuffer(this.oldParam.byteLength);
-        }
-        if (this.oldParam[0] !== lr) {
-            this.oldParam = new Float32Array([lr, 0]);
-            this.gpu.WriteBuffer(this.param, this.oldParam)
-        }
-        const bind = await this.device.createBindGroup({
-            layout: await this.backwardPipline.getBindGroupLayout(0),
-            entries: [
-                {
-                    binding: 0,
-                    resource: {
-                        buffer: this.vectorsBuffer
-                    }
-                },
-                {
-                    binding: 1,
-                    resource: {
-                        buffer: inputGradient.mainBuffer
-                    }
-                }, {
-                    binding: 2,
-                    resource: {
-                        buffer: this.tokenBuffer
-                    }
-
-                }, {
-                    binding: 3,
-                    resource: {
-                        buffer: this.param
-                    }
-
-                }
-            ]
-        })
-        await this.gpu.RunPipline(encoder, this.backwardPipline, bind, Math.ceil((this.embeddingSize * (this.tokenBuffer.size / 4)) / 256))
-        if(!en2) this.device.queue.submit([encoder.finish()])
-    }
-
-}

package/src/FFN/index.d.ts

@@ -1,23 +0,0 @@
-export class FFN {
-    constructor(device: GPUAdapter, embeddingSize: number, configs: {
-        dirname: string
-    })
-    async forward(vec: GPUBuffer): Promise<{
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }>
-    async backward(inputGradient: {
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }, lr: number): Promise<{
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }>
-    async Save(): Promise<void>
-}

package/src/FFN/index.js

@@ -1,45 +0,0 @@
-import { RELU, Linear } from "../../index.js";
-import { join } from 'path'
-import { OperationManager } from "../OperationManager.js";
-
-
-export class FFN {
-    linear1;
-    linear2;
-    hiddenLayer;
-    Op
-    constructor(device, embeddingSize, configs) {
-        this.Op = new OperationManager(device)
-        this.linear1 = new Linear(device, embeddingSize, embeddingSize * 4, {
-            save: {
-                filename: [join(configs.dirname, "FFN_weights1.bin"), join(configs.dirname, "FFN_bias1.bin")]
-            }
-        });
-        this.hiddenLayer = new RELU(device, embeddingSize * 4);
-        this.linear2 = new Linear(device, embeddingSize * 4, embeddingSize, {
-            save: {
-                filename: [join(configs.dirname, "FFN_weights2.bin"), join(configs.dirname, "FFN_bias2.bin")]
-            }
-        })
-    }
-    async forward(vec, encoderMain) {
-        const logit1 = await this.linear1.forward(vec, encoderMain)
-        const hidden = await this.hiddenLayer.forward(logit1, encoderMain)
-        const final = await this.linear2.forward(hidden, encoderMain)
-        return final
-    }
-    async backward(inputGradient, lr, encoder) {
-        const logit2 = await this.linear2.backward(inputGradient, lr, encoder)
-        const hidden = await this.hiddenLayer.backward(logit2,encoder)
-        const final = await this.linear1.backward(hidden, lr, encoder)
-        return final
-    }
-    async Save() {
-        await this.linear1.Save()
-        await this.linear2.Save()
-    }
-    async ClearInputCache() {
-        this.linear1.ClearInputCache()
-        this.linear2.ClearInputCache()
-    }
-}

package/src/Linear/index.d.ts

@@ -1,31 +0,0 @@
-export class Linear {
-    constructor(device: GPUAdapter, embeddingSize: number, vocabSize: number, configs: {
-        save: {
-            filename: string[]
-        }
-    })
-    async forward(vec: {
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }): Promise<{
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }>
-    async backward(dOutput: {
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }, lr: number): Promise<{
-        read: function(): Promise<Float32Array>,
-        mainBuffer: GPUBuffer,
-        isDestroyed: function(): Boolean,
-        destroy: function(): void
-    }>
-    async Save(): Promise<void>
-
-}