UDP Circuit basics, message changes

example/testBot.js

@@ -1,4 +1,4 @@
-const nmv = require('../dist/index');
+const nmv             = require('../dist/index');
 const loginParameters = new nmv.LoginParameters();
 
 const parameters = require('./loginParameters.json');
@@ -10,11 +10,16 @@ loginParameters.start = "last";
 
 const bot = new nmv.Bot(loginParameters);
 
-bot.Login().then(() =>
+bot.Login().then((response) =>
 {
-
+    //Establish circuit wit region
+    return response.region.circuit.establish(response.agent.agentID);
+}).then(() =>
+{
+    console.log("Region circuit established");
 }).catch((error) =>
 {
+    console.log("Error:");
     console.error(error);
 });
 

lib/classes/Circuit.ts

@@ -1,5 +1,18 @@
 import {UUID} from './UUID';
-import {MessageDecoder} from './MessageDecoder';
+import {AddressInfo, Socket} from 'dgram';
+import * as dgram from 'dgram';
+import {PacketFlags} from '../enums/PacketFlags';
+import {Packet} from './Packet';
+import {UseCircuitCodeMessage} from './messages/UseCircuitCode';
+import {MessageBase} from './MessageBase';
+import {PacketAckMessage} from './messages/PacketAck';
+import {Message} from '../enums/Message';
+import {StartPingCheckMessage} from './messages/StartPingCheck';
+import {CompletePingCheckMessage} from './messages/CompletePingCheck';
+import {CompleteAgentMovementMessage} from './messages/CompleteAgentMovement';
+import {Subscription} from 'rxjs/Subscription';
+import {Subject} from 'rxjs/Subject';
+import Timer = NodeJS.Timer;
 
 export class Circuit
 {
@@ -9,10 +22,213 @@ export class Circuit
     udpBlacklist: string[];
     timestamp: number;
     seedCapability: string;
-    decoder: MessageDecoder;
+    client: Socket | null = null;
+    port: number;
+    ipAddress: string;
+    sequenceNumber = 0;
+
+    awaitingAck: {
+        [key: number]: {
+            packet: Packet,
+            timeout: number
+        }
+    } = {};
+
+    onPacketReceived: Subject<Packet>;
 
     constructor()
     {
-        this.decoder = new MessageDecoder();
+        this.onPacketReceived = new Subject<Packet>();
+    }
+
+    sendMessage(message: MessageBase, flags: PacketFlags)
+    {
+        const packet: Packet = new Packet();
+        packet.message = message;
+        packet.sequenceNumber = this.sequenceNumber++;
+        packet.packetFlags = flags;
+        this.sendPacket(packet);
+    }
+
+    resend(sequenceNumber: number)
+    {
+        if (this.awaitingAck[sequenceNumber])
+        {
+            const toResend: Packet = this.awaitingAck[sequenceNumber].packet;
+            toResend.packetFlags = toResend.packetFlags | PacketFlags.Resent;
+            this.sendPacket(toResend);
+        }
+    }
+
+    waitForMessage(id: Message, timeout: number)
+    {
+        return new Promise<Packet>((resolve, reject) =>
+        {
+            const handleObj: {
+                timeout: Timer | null,
+                subscription: Subscription | null
+            } = {
+                timeout: null,
+                subscription: null
+            };
+            handleObj.timeout = setTimeout(() =>
+            {
+                if (handleObj.subscription !== null)
+                {
+                    handleObj.subscription.unsubscribe();
+                    reject(new Error('Timeout'));
+                }
+            }, timeout);
+
+            handleObj.subscription = this.onPacketReceived.subscribe((packet: Packet) =>
+                {
+                    if (packet.message.id === id)
+                    {
+                        if (handleObj.timeout !== null)
+                        {
+                            clearTimeout(handleObj.timeout);
+                            handleObj.timeout = null;
+                        }
+                        if (handleObj.subscription !== null)
+                        {
+                            handleObj.subscription.unsubscribe();
+                            handleObj.subscription = null;
+                        }
+                        resolve(packet);
+                    }
+                },
+                (err) =>
+                {
+                    console.error(err);
+                }, () =>
+                {
+                    console.log('Subscription complete');
+                });
+        });
+    }
+
+    sendPacket(packet: Packet)
+    {
+        if (packet.packetFlags & PacketFlags.Reliable)
+        {
+            this.awaitingAck[packet.sequenceNumber] =
+                {
+                    packet: packet,
+                    timeout: setTimeout(this.resend.bind(this, packet.sequenceNumber), 1000)
+                };
+        }
+        let size = packet.getSize();
+        const dataToSend: Buffer = Buffer.allocUnsafe(size);
+        packet.writeToBuffer(dataToSend, 0);
+        if (this.client !== null)
+        {
+            this.client.send(dataToSend, 0, dataToSend.length, this.port, this.ipAddress, (err, bytes) =>
+            {
+                let resend = '';
+                if (packet.packetFlags & PacketFlags.Resent)
+                {
+                    resend = ' (resent)';
+                }
+                console.log('--> ' + packet.message.name + resend);
+            })
+        }
+        else
+        {
+            console.error('Attempted to send packet but UDP client is null');
+        }
+    }
+
+    ackReceived(sequenceID: number)
+    {
+        if (this.awaitingAck[sequenceID])
+        {
+            clearTimeout(this.awaitingAck[sequenceID].timeout);
+            delete this.awaitingAck[sequenceID];
+        }
+    }
+
+    sendAck(sequenceID: number)
+    {
+        const msg: PacketAckMessage = new PacketAckMessage();
+        msg.Packets = [
+            {
+                ID: sequenceID
+            }
+        ];
+        this.sendMessage(msg, 0);
+    }
+
+    receivedPacket(bytes: Buffer)
+    {
+        const packet = new Packet();
+        packet.readFromBuffer(bytes, 0, this.ackReceived.bind(this), this.sendAck.bind(this));
+        console.log('<--- ' + packet.message.name);
+
+        if (packet.message.id === Message.PacketAck)
+        {
+            const msg = packet.message as PacketAckMessage;
+            msg.Packets.forEach((obj) =>
+            {
+                this.ackReceived(obj.ID);
+            });
+        }
+        else if (packet.message.id === Message.StartPingCheck)
+        {
+            const msg = packet.message as StartPingCheckMessage;
+            const reply: CompletePingCheckMessage = new CompletePingCheckMessage();
+            reply.PingID = {
+                PingID: msg.PingID.PingID
+            };
+            this.sendMessage(reply, 0);
+        }
+        this.onPacketReceived.next(packet);
+    }
+
+    establish(agentID: UUID)
+    {
+        return new Promise((resolve, reject) =>
+        {
+            if (this.client !== null)
+            {
+                this.client.close();
+            }
+            this.client = dgram.createSocket('udp4');
+            this.client.on('listening', () =>
+            {
+
+            });
+
+            this.client.on('message', (message, remote) =>
+            {
+                if (remote.address === this.ipAddress)
+                {
+                    this.receivedPacket(message);
+                }
+            });
+
+            const msg: UseCircuitCodeMessage = new UseCircuitCodeMessage();
+            msg.CircuitCode = {
+                SessionID: this.sessionID,
+                ID: agentID,
+                Code: this.circuitCode
+            };
+            this.sendMessage(msg, PacketFlags.Reliable);
+
+            const agentMovement: CompleteAgentMovementMessage = new CompleteAgentMovementMessage();
+            agentMovement.AgentData = {
+                AgentID: agentID,
+                SessionID: this.sessionID,
+                CircuitCode: this.circuitCode
+            };
+            this.sendMessage(agentMovement, PacketFlags.Reliable);
+
+            this.waitForMessage(Message.RegionHandshake, 10000).then((packet: Packet) =>
+            {
+                resolve();
+            }).catch((error) =>
+            {
+                reject(error);
+            });
+        });
     }
 }

lib/classes/LoginResponse.ts

@@ -1,6 +1,5 @@
 import {UUID} from './UUID';
 import {Agent} from './Agent';
-import {Circuit} from './Circuit';
 import {Region} from './Region';
 import {LoginFlags} from '../enums/LoginFlags';
 import {Vector3} from './Vector3';
@@ -69,8 +68,6 @@ export class LoginResponse
         const json = str.replace(/[\[\]']/g, '\"');
         const parsed = JSON.parse(json);
 
-        console.log(parsed);
-
         if (parsed['region_handle'])
         {
             const coords = parsed['region_handle'].replace(/r/g, '').split(', ');
@@ -217,10 +214,10 @@ export class LoginResponse
                     });
                     break;
                 case 'sim_port':
-                    this.region.port = parseInt(val, 10);
+                    this.region.circuit.port = parseInt(val, 10);
                     break;
                 case 'sim_ip':
-                    this.region.ipAddress = String(val);
+                    this.region.circuit.ipAddress = String(val);
                     break;
                 case 'agent_appearance_service':
                     this.agent.agentAppearanceService = val;

lib/classes/MessageBase.ts

@@ -0,0 +1,13 @@
+import {MessageFlags} from '../enums/MessageFlags';
+import {Message} from '../enums/Message';
+
+export interface MessageBase
+{
+    name: string;
+    messageFlags: MessageFlags;
+    id: Message;
+
+    getSize(): number;
+    writeToBuffer(buf: Buffer, pos: number): number;
+    readFromBuffer(buf: Buffer, pos: number): number;
+}

lib/classes/MessageDecoder.ts

@@ -1,14 +0,0 @@
-import {Packet} from './Packet';
-import {Message} from '../enums/Message';
-import * as MessageClass from './MessageClasses';
-import {nameFromID} from './MessageClasses';
-
-export class MessageDecoder
-{
-    constructor()
-    {
-        //let pk: Packet = new Messages['UseCircuitCode']() as Packet;
-        let pk: Packet = new (<any>MessageClass)[nameFromID(Message.UseCircuitCode)]() as Packet;
-        console.log(pk.name);
-    }
-}

lib/classes/Packet.ts

@@ -1,12 +1,147 @@
+import {PacketFlags} from '../enums/PacketFlags';
+import {MessageBase} from './MessageBase';
+import {Zerocoder} from './Zerocoder';
+import {nameFromID} from './MessageClasses';
 import {MessageFlags} from '../enums/MessageFlags';
+import * as MessageClass from './MessageClasses';
 
-export interface Packet
+export class Packet
 {
-    name: string;
-    flags: MessageFlags;
-    id: number;
+    packetFlags: PacketFlags = 0;
+    sequenceNumber = 0;
+    extraHeader: Buffer = Buffer.allocUnsafe(0);
+    message: MessageBase;
 
-    getSize(): number;
-    writeToBuffer(buf: Buffer, pos: number): number;
-    readFromBuffer(buf: Buffer, pos: number): number;
+    getSize(): number
+    {
+        let idSize = 4;
+        if (this.message.messageFlags & MessageFlags.FrequencyHigh)
+        {
+            idSize = 1;
+        }
+        else if (this.message.messageFlags & MessageFlags.FrequencyMedium)
+        {
+            idSize = 2;
+        }
+        return 1 + 4 + 1 + this.extraHeader.length + idSize + this.message.getSize();
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): Buffer
+    {
+        if (this.message.messageFlags & MessageFlags.Zerocoded)
+        {
+            this.packetFlags = this.packetFlags | PacketFlags.Zerocoded;
+        }
+        buf.writeUInt8(this.packetFlags, pos++);
+        buf.writeUInt32BE(this.sequenceNumber, pos);
+        pos = pos + 4;
+        buf.writeUInt8(this.extraHeader.length, pos++);
+        if (this.extraHeader.length > 0)
+        {
+            this.extraHeader.copy(buf, pos, 0, this.extraHeader.length - 1);
+            pos += this.extraHeader.length;
+        }
+        const bodyStart = pos;
+
+        if (this.message.messageFlags & MessageFlags.FrequencyHigh)
+        {
+            buf.writeUInt8(this.message.id, pos++);
+        }
+        else if (this.message.messageFlags & MessageFlags.FrequencyMedium)
+        {
+            buf.writeUInt16BE(this.message.id, pos);
+            pos += 2;
+        }
+        else
+        {
+            buf.writeUInt32BE(this.message.id, pos);
+            pos += 4;
+        }
+
+        const expectedLength = this.message.getSize();
+        const actualLength = this.message.writeToBuffer(buf, pos);
+        if (actualLength !== expectedLength)
+        {
+            console.error('WARNING: Bytes written does not match expected message data length')
+        }
+        pos += actualLength;
+        if (pos < buf.length)
+        {
+            console.error('WARNING: BUFFER UNDERFLOW: Finished writing but we are not at the end of the buffer');
+        }
+        if (this.packetFlags & PacketFlags.Zerocoded)
+        {
+            buf = Zerocoder.Encode(buf, bodyStart, pos);
+        }
+        return buf;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number, ackReceived: (sequenceID: number) => void, sendAck: (sequenceID: number) => void)
+    {
+        this.packetFlags = buf.readUInt8(pos++);
+        this.sequenceNumber = buf.readUInt32BE(pos);
+        if (this.packetFlags & PacketFlags.Reliable)
+        {
+            sendAck(this.sequenceNumber);
+        }
+        pos = pos + 4;
+        const extraBytes = buf.readUInt8(pos++);
+        if (extraBytes > 0)
+        {
+            this.extraHeader = buf.slice(pos, pos + extraBytes);
+            pos += extraBytes;
+        }
+        else
+        {
+            this.extraHeader = Buffer.allocUnsafe(0);
+        }
+
+        if (this.packetFlags & PacketFlags.Zerocoded)
+        {
+            buf = Zerocoder.Decode(buf, pos, buf.length - 1);
+        }
+
+        let messageID = buf.readUInt8(pos);
+        if (messageID === 0xFF)
+        {
+            messageID = buf.readUInt16BE(pos);
+            if (messageID === 0xFFFF)
+            {
+                messageID = buf.readUInt32BE(pos);
+                pos += 4;
+            }
+            else
+            {
+                pos += 2;
+            }
+        }
+        else
+        {
+            pos++;
+        }
+
+        this.message = new (<any>MessageClass)[nameFromID(messageID)]() as MessageBase;
+
+        const readLength = this.message.readFromBuffer(buf, pos);
+        pos += readLength;
+
+
+        if (this.packetFlags & PacketFlags.Ack)
+        {
+            // Final byte in the packet contains the number of Acks
+            const numAcks = buf.readUInt8(buf.length - 1);
+            for (let i = 0; i < numAcks; i++)
+            {
+                const ackID = buf.readUInt32LE(pos);
+                ackReceived(ackID);
+                pos += 4;
+            }
+            // Account for the final byte
+            pos++;
+        }
+        if (pos < buf.length)
+        {
+            console.error('WARNING: Finished reading but we\'re not at the end of the packet');
+        }
+    }
 }

lib/classes/Region.ts

@@ -4,13 +4,10 @@ export class Region
 {
     xCoordinate: number;
     yCoordinate: number;
-    port: number;
-    ipAddress: string;
     circuit: Circuit;
 
     constructor()
     {
-        console.log("Creating circuit");
         this.circuit = new Circuit();
     }
 }

lib/classes/UUID.ts

@@ -20,7 +20,13 @@ export class UUID
             }
             else if (pos !== undefined)
             {
-                this.mUUID = uuid.unparse(buf, pos);
+                const uuidBuf: Buffer = buf.slice(pos, pos + 16);
+                const hexString = uuidBuf.toString('hex');
+                this.setUUID(hexString.substr(0, 8) + '-'
+                    + hexString.substr(8, 4) + '-'
+                    + hexString.substr(12, 4) + '-'
+                    + hexString.substr(16, 4) + '-'
+                    + hexString.substr(20, 12));
             }
         }
     }
@@ -42,6 +48,8 @@ export class UUID
 
     writeToBuffer(buf: Buffer, pos: number)
     {
-        uuid.parse(this.mUUID, buf, pos);
+        const shortened = this.mUUID.substr(0, 8) + this.mUUID.substr(9, 4) + this.mUUID.substr(14, 4) + this.mUUID.substr(19, 4) + this.mUUID.substr(24, 12);
+        const binary = Buffer.from(shortened, 'hex');
+        binary.copy(buf, pos, 0);
     }
 }

lib/classes/Zerocoder.ts

@@ -0,0 +1,101 @@
+export class Zerocoder
+{
+    static Encode(buf: Buffer, start: number, end: number): Buffer
+    {
+        // First, run through the data and calculate how many bytes we will save
+        let bytes = 0;
+        let zero = 0;
+        for (let i = start; i <= end; i++)
+        {
+            if (buf[i] === 0)
+            {
+                zero++;
+            }
+            else
+            {
+                if (zero > 0)
+                {
+                    bytes += (zero - 2);
+                    zero = 0;
+                }
+            }
+        }
+        if (zero > 0)
+        {
+            bytes += (zero - 2);
+        }
+
+        const newBuf = Buffer.allocUnsafe((end + 1) - bytes);
+        buf.copy(newBuf, 0, 0, start - 1);
+        let newBufIndex = start;
+        zero = 0;
+        for (let i = start; i <= end; i++)
+        {
+            if (buf[i] === 0)
+            {
+                zero++;
+            }
+            else
+            {
+                if (zero > 0)
+                {
+                    newBuf[newBufIndex++] = 0;
+                    newBuf.writeUInt8(zero, newBufIndex++);
+                    zero = 0;
+                }
+                newBuf[newBufIndex++] = buf[i];
+            }
+        }
+        if (zero > 0)
+        {
+            newBuf[newBufIndex++] = 0;
+            newBuf.writeUInt8(zero, newBufIndex);
+        }
+        return newBuf;
+    }
+    static Decode(buf: Buffer, start: number, end: number): Buffer
+    {
+        // First, run through the data and calculate how many bytes have been compressed
+        let bytes = 0;
+        let zero = false;
+        for (let i = start; i <= end; i++)
+        {
+            if (zero === true)
+            {
+                zero = false;
+                // Minus two bytes for the overhead
+                bytes += buf.readUInt8(i) - 2;
+            }
+            else if (buf[i] === 0)
+            {
+                zero = true;
+            }
+        }
+
+        const newBuf = Buffer.allocUnsafe((end + 1) + bytes);
+        buf.copy(newBuf, 0, 0, start - 1);
+        let newBufIndex = start;
+        zero = false;
+        for (let i = start; i <= end; i++)
+        {
+            if (zero === true)
+            {
+                zero = false;
+                const zeroCount = buf.readUInt8(i);
+                for (let x = 0; x < zeroCount; x++)
+                {
+                    newBuf[newBufIndex++] = 0;
+                }
+            }
+            else if (buf[i] === 0)
+            {
+                zero = true;
+            }
+            else
+            {
+                newBuf[newBufIndex++] = buf[i];
+            }
+        }
+        return newBuf;
+    }
+}

lib/classes/messages/AbortXfer.ts

@@ -0,0 +1,55 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AbortXferMessage implements MessageBase
+{
+    name = 'AbortXfer';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AbortXfer;
+
+    XferID: {
+        ID: Long;
+        Result: number;
+    };
+
+    getSize(): number
+    {
+        return 12;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeInt32LE(this.XferID['ID'].low, pos);
+        pos += 4;
+        buf.writeInt32LE(this.XferID['ID'].high, pos);
+        pos += 4;
+        buf.writeInt32LE(this.XferID['Result'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjXferID: {
+            ID: Long,
+            Result: number
+        } = {
+            ID: Long.ZERO,
+            Result: 0
+        };
+        newObjXferID['ID'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+        pos += 8;
+        newObjXferID['Result'] = buf.readInt32LE(pos);
+        pos += 4;
+        this.XferID = newObjXferID;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AcceptCallingCard.ts

@@ -0,0 +1,89 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AcceptCallingCardMessage implements MessageBase
+{
+    name = 'AcceptCallingCard';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AcceptCallingCard;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    TransactionBlock: {
+        TransactionID: UUID;
+    };
+    FolderData: {
+        FolderID: UUID;
+    }[];
+
+    getSize(): number
+    {
+        return ((16) * this.FolderData.length) + 49;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.TransactionBlock['TransactionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.FolderData.length;
+        buf.writeUInt8(this.FolderData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.FolderData[i]['FolderID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjTransactionBlock: {
+            TransactionID: UUID
+        } = {
+            TransactionID: UUID.zero()
+        };
+        newObjTransactionBlock['TransactionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.TransactionBlock = newObjTransactionBlock;
+        const count = buf.readUInt8(pos++);
+        this.FolderData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjFolderData: {
+                FolderID: UUID
+            } = {
+                FolderID: UUID.zero()
+            };
+            newObjFolderData['FolderID'] = new UUID(buf, pos);
+            pos += 16;
+            this.FolderData.push(newObjFolderData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AcceptFriendship.ts

@@ -0,0 +1,89 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AcceptFriendshipMessage implements MessageBase
+{
+    name = 'AcceptFriendship';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AcceptFriendship;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    TransactionBlock: {
+        TransactionID: UUID;
+    };
+    FolderData: {
+        FolderID: UUID;
+    }[];
+
+    getSize(): number
+    {
+        return ((16) * this.FolderData.length) + 49;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.TransactionBlock['TransactionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.FolderData.length;
+        buf.writeUInt8(this.FolderData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.FolderData[i]['FolderID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjTransactionBlock: {
+            TransactionID: UUID
+        } = {
+            TransactionID: UUID.zero()
+        };
+        newObjTransactionBlock['TransactionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.TransactionBlock = newObjTransactionBlock;
+        const count = buf.readUInt8(pos++);
+        this.FolderData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjFolderData: {
+                FolderID: UUID
+            } = {
+                FolderID: UUID.zero()
+            };
+            newObjFolderData['FolderID'] = new UUID(buf, pos);
+            pos += 16;
+            this.FolderData.push(newObjFolderData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ActivateGestures.ts

@@ -0,0 +1,97 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ActivateGesturesMessage implements MessageBase
+{
+    name = 'ActivateGestures';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.ActivateGestures;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        Flags: number;
+    };
+    Data: {
+        ItemID: UUID;
+        AssetID: UUID;
+        GestureFlags: number;
+    }[];
+
+    getSize(): number
+    {
+        return ((36) * this.Data.length) + 37;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['Flags'], pos);
+        pos += 4;
+        const count = this.Data.length;
+        buf.writeUInt8(this.Data.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.Data[i]['ItemID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.Data[i]['AssetID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt32LE(this.Data[i]['GestureFlags'], pos);
+            pos += 4;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            Flags: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            Flags: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['Flags'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.Data = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjData: {
+                ItemID: UUID,
+                AssetID: UUID,
+                GestureFlags: number
+            } = {
+                ItemID: UUID.zero(),
+                AssetID: UUID.zero(),
+                GestureFlags: 0
+            };
+            newObjData['ItemID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjData['AssetID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjData['GestureFlags'] = buf.readUInt32LE(pos);
+            pos += 4;
+            this.Data.push(newObjData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ActivateGroup.ts

@@ -0,0 +1,60 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ActivateGroupMessage implements MessageBase
+{
+    name = 'ActivateGroup';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.ActivateGroup;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        GroupID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 48;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['GroupID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            GroupID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            GroupID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['GroupID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AddCircuitCode.ts

@@ -0,0 +1,60 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AddCircuitCodeMessage implements MessageBase
+{
+    name = 'AddCircuitCode';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AddCircuitCode;
+
+    CircuitCode: {
+        Code: number;
+        SessionID: UUID;
+        AgentID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 36;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeUInt32LE(this.CircuitCode['Code'], pos);
+        pos += 4;
+        this.CircuitCode['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.CircuitCode['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjCircuitCode: {
+            Code: number,
+            SessionID: UUID,
+            AgentID: UUID
+        } = {
+            Code: 0,
+            SessionID: UUID.zero(),
+            AgentID: UUID.zero()
+        };
+        newObjCircuitCode['Code'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjCircuitCode['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjCircuitCode['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        this.CircuitCode = newObjCircuitCode;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentAlertMessage.ts

@@ -0,0 +1,66 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentAlertMessageMessage implements MessageBase
+{
+    name = 'AgentAlertMessage';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AgentAlertMessage;
+
+    AgentData: {
+        AgentID: UUID;
+    };
+    AlertData: {
+        Modal: boolean;
+        Message: string;
+    };
+
+    getSize(): number
+    {
+        return (this.AlertData['Message'].length + 1) + 17;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8((this.AlertData['Modal']) ? 1 : 0, pos++);
+        buf.writeUInt8(this.AlertData['Message'].length, pos++);
+        buf.write(this.AlertData['Message'], pos);
+        pos += this.AlertData['Message'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID
+        } = {
+            AgentID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjAlertData: {
+            Modal: boolean,
+            Message: string
+        } = {
+            Modal: false,
+            Message: ''
+        };
+        newObjAlertData['Modal'] = (buf.readUInt8(pos++) === 1);
+        varLength = buf.readUInt8(pos++);
+        newObjAlertData['Message'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.AlertData = newObjAlertData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentAnimation.ts

@@ -0,0 +1,116 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentAnimationMessage implements MessageBase
+{
+    name = 'AgentAnimation';
+    messageFlags = MessageFlags.FrequencyHigh;
+    id = Message.AgentAnimation;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    AnimationList: {
+        AnimID: UUID;
+        StartAnim: boolean;
+    }[];
+    PhysicalAvatarEventList: {
+        TypeData: string;
+    }[];
+
+    getSize(): number
+    {
+        return ((17) * this.AnimationList.length) + ((this.calculateVarVarSize(this.PhysicalAvatarEventList, 'TypeData', 1)) * this.PhysicalAvatarEventList.length) + 34;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        let count = this.AnimationList.length;
+        buf.writeUInt8(this.AnimationList.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.AnimationList[i]['AnimID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8((this.AnimationList[i]['StartAnim']) ? 1 : 0, pos++);
+        }
+        count = this.PhysicalAvatarEventList.length;
+        buf.writeUInt8(this.PhysicalAvatarEventList.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.PhysicalAvatarEventList[i]['TypeData'].length, pos++);
+            buf.write(this.PhysicalAvatarEventList[i]['TypeData'], pos);
+            pos += this.PhysicalAvatarEventList[i]['TypeData'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        let count = buf.readUInt8(pos++);
+        this.AnimationList = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAnimationList: {
+                AnimID: UUID,
+                StartAnim: boolean
+            } = {
+                AnimID: UUID.zero(),
+                StartAnim: false
+            };
+            newObjAnimationList['AnimID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjAnimationList['StartAnim'] = (buf.readUInt8(pos++) === 1);
+            this.AnimationList.push(newObjAnimationList);
+        }
+        count = buf.readUInt8(pos++);
+        this.PhysicalAvatarEventList = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjPhysicalAvatarEventList: {
+                TypeData: string
+            } = {
+                TypeData: ''
+            };
+            varLength = buf.readUInt8(pos++);
+            newObjPhysicalAvatarEventList['TypeData'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.PhysicalAvatarEventList.push(newObjPhysicalAvatarEventList);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentCachedTexture.ts

@@ -0,0 +1,88 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentCachedTextureMessage implements MessageBase
+{
+    name = 'AgentCachedTexture';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentCachedTexture;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        SerialNum: number;
+    };
+    WearableData: {
+        ID: UUID;
+        TextureIndex: number;
+    }[];
+
+    getSize(): number
+    {
+        return ((17) * this.WearableData.length) + 37;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt32LE(this.AgentData['SerialNum'], pos);
+        pos += 4;
+        const count = this.WearableData.length;
+        buf.writeUInt8(this.WearableData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.WearableData[i]['ID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.WearableData[i]['TextureIndex'], pos++);
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            SerialNum: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            SerialNum: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SerialNum'] = buf.readInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.WearableData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjWearableData: {
+                ID: UUID,
+                TextureIndex: number
+            } = {
+                ID: UUID.zero(),
+                TextureIndex: 0
+            };
+            newObjWearableData['ID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjWearableData['TextureIndex'] = buf.readUInt8(pos++);
+            this.WearableData.push(newObjWearableData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentCachedTextureResponse.ts

@@ -0,0 +1,107 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentCachedTextureResponseMessage implements MessageBase
+{
+    name = 'AgentCachedTextureResponse';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AgentCachedTextureResponse;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        SerialNum: number;
+    };
+    WearableData: {
+        TextureID: UUID;
+        TextureIndex: number;
+        HostName: string;
+    }[];
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.WearableData, 'HostName', 1) + 17) * this.WearableData.length) + 37;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt32LE(this.AgentData['SerialNum'], pos);
+        pos += 4;
+        const count = this.WearableData.length;
+        buf.writeUInt8(this.WearableData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.WearableData[i]['TextureID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.WearableData[i]['TextureIndex'], pos++);
+            buf.writeUInt8(this.WearableData[i]['HostName'].length, pos++);
+            buf.write(this.WearableData[i]['HostName'], pos);
+            pos += this.WearableData[i]['HostName'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            SerialNum: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            SerialNum: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SerialNum'] = buf.readInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.WearableData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjWearableData: {
+                TextureID: UUID,
+                TextureIndex: number,
+                HostName: string
+            } = {
+                TextureID: UUID.zero(),
+                TextureIndex: 0,
+                HostName: ''
+            };
+            newObjWearableData['TextureID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjWearableData['TextureIndex'] = buf.readUInt8(pos++);
+            varLength = buf.readUInt8(pos++);
+            newObjWearableData['HostName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.WearableData.push(newObjWearableData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentDataUpdate.ts

@@ -0,0 +1,99 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentDataUpdateMessage implements MessageBase
+{
+    name = 'AgentDataUpdate';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AgentDataUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+        FirstName: string;
+        LastName: string;
+        GroupTitle: string;
+        ActiveGroupID: UUID;
+        GroupPowers: Long;
+        GroupName: string;
+    };
+
+    getSize(): number
+    {
+        return (this.AgentData['FirstName'].length + 1 + this.AgentData['LastName'].length + 1 + this.AgentData['GroupTitle'].length + 1 + this.AgentData['GroupName'].length + 1) + 40;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.AgentData['FirstName'].length, pos++);
+        buf.write(this.AgentData['FirstName'], pos);
+        pos += this.AgentData['FirstName'].length;
+        buf.writeUInt8(this.AgentData['LastName'].length, pos++);
+        buf.write(this.AgentData['LastName'], pos);
+        pos += this.AgentData['LastName'].length;
+        buf.writeUInt8(this.AgentData['GroupTitle'].length, pos++);
+        buf.write(this.AgentData['GroupTitle'], pos);
+        pos += this.AgentData['GroupTitle'].length;
+        this.AgentData['ActiveGroupID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt32LE(this.AgentData['GroupPowers'].low, pos);
+        pos += 4;
+        buf.writeInt32LE(this.AgentData['GroupPowers'].high, pos);
+        pos += 4;
+        buf.writeUInt8(this.AgentData['GroupName'].length, pos++);
+        buf.write(this.AgentData['GroupName'], pos);
+        pos += this.AgentData['GroupName'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            FirstName: string,
+            LastName: string,
+            GroupTitle: string,
+            ActiveGroupID: UUID,
+            GroupPowers: Long,
+            GroupName: string
+        } = {
+            AgentID: UUID.zero(),
+            FirstName: '',
+            LastName: '',
+            GroupTitle: '',
+            ActiveGroupID: UUID.zero(),
+            GroupPowers: Long.ZERO,
+            GroupName: ''
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        varLength = buf.readUInt8(pos++);
+        newObjAgentData['FirstName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjAgentData['LastName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjAgentData['GroupTitle'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjAgentData['ActiveGroupID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['GroupPowers'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+        pos += 8;
+        varLength = buf.readUInt8(pos++);
+        newObjAgentData['GroupName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentDataUpdateRequest.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentDataUpdateRequestMessage implements MessageBase
+{
+    name = 'AgentDataUpdateRequest';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentDataUpdateRequest;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 32;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentDropGroup.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentDropGroupMessage implements MessageBase
+{
+    name = 'AgentDropGroup';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.Deprecated | MessageFlags.FrequencyLow;
+    id = Message.AgentDropGroup;
+
+    AgentData: {
+        AgentID: UUID;
+        GroupID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 32;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['GroupID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            GroupID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            GroupID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['GroupID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentFOV.ts

@@ -0,0 +1,80 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentFOVMessage implements MessageBase
+{
+    name = 'AgentFOV';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentFOV;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        CircuitCode: number;
+    };
+    FOVBlock: {
+        GenCounter: number;
+        VerticalAngle: number;
+    };
+
+    getSize(): number
+    {
+        return 44;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['CircuitCode'], pos);
+        pos += 4;
+        buf.writeUInt32LE(this.FOVBlock['GenCounter'], pos);
+        pos += 4;
+        buf.writeFloatLE(this.FOVBlock['VerticalAngle'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            CircuitCode: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            CircuitCode: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['CircuitCode'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        const newObjFOVBlock: {
+            GenCounter: number,
+            VerticalAngle: number
+        } = {
+            GenCounter: 0,
+            VerticalAngle: 0
+        };
+        newObjFOVBlock['GenCounter'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjFOVBlock['VerticalAngle'] = buf.readFloatLE(pos);
+        pos += 4;
+        this.FOVBlock = newObjFOVBlock;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentGroupDataUpdate.ts

@@ -0,0 +1,117 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentGroupDataUpdateMessage implements MessageBase
+{
+    name = 'AgentGroupDataUpdate';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.Deprecated | MessageFlags.FrequencyLow;
+    id = Message.AgentGroupDataUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+    };
+    GroupData: {
+        GroupID: UUID;
+        GroupPowers: Long;
+        AcceptNotices: boolean;
+        GroupInsigniaID: UUID;
+        Contribution: number;
+        GroupName: string;
+    }[];
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.GroupData, 'GroupName', 1) + 45) * this.GroupData.length) + 17;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.GroupData.length;
+        buf.writeUInt8(this.GroupData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.GroupData[i]['GroupID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeInt32LE(this.GroupData[i]['GroupPowers'].low, pos);
+            pos += 4;
+            buf.writeInt32LE(this.GroupData[i]['GroupPowers'].high, pos);
+            pos += 4;
+            buf.writeUInt8((this.GroupData[i]['AcceptNotices']) ? 1 : 0, pos++);
+            this.GroupData[i]['GroupInsigniaID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeInt32LE(this.GroupData[i]['Contribution'], pos);
+            pos += 4;
+            buf.writeUInt8(this.GroupData[i]['GroupName'].length, pos++);
+            buf.write(this.GroupData[i]['GroupName'], pos);
+            pos += this.GroupData[i]['GroupName'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID
+        } = {
+            AgentID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.GroupData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjGroupData: {
+                GroupID: UUID,
+                GroupPowers: Long,
+                AcceptNotices: boolean,
+                GroupInsigniaID: UUID,
+                Contribution: number,
+                GroupName: string
+            } = {
+                GroupID: UUID.zero(),
+                GroupPowers: Long.ZERO,
+                AcceptNotices: false,
+                GroupInsigniaID: UUID.zero(),
+                Contribution: 0,
+                GroupName: ''
+            };
+            newObjGroupData['GroupID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjGroupData['GroupPowers'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+            pos += 8;
+            newObjGroupData['AcceptNotices'] = (buf.readUInt8(pos++) === 1);
+            newObjGroupData['GroupInsigniaID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjGroupData['Contribution'] = buf.readInt32LE(pos);
+            pos += 4;
+            varLength = buf.readUInt8(pos++);
+            newObjGroupData['GroupName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.GroupData.push(newObjGroupData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentHeightWidth.ts

@@ -0,0 +1,87 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentHeightWidthMessage implements MessageBase
+{
+    name = 'AgentHeightWidth';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentHeightWidth;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        CircuitCode: number;
+    };
+    HeightWidthBlock: {
+        GenCounter: number;
+        Height: number;
+        Width: number;
+    };
+
+    getSize(): number
+    {
+        return 44;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['CircuitCode'], pos);
+        pos += 4;
+        buf.writeUInt32LE(this.HeightWidthBlock['GenCounter'], pos);
+        pos += 4;
+        buf.writeUInt16LE(this.HeightWidthBlock['Height'], pos);
+        pos += 2;
+        buf.writeUInt16LE(this.HeightWidthBlock['Width'], pos);
+        pos += 2;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            CircuitCode: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            CircuitCode: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['CircuitCode'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        const newObjHeightWidthBlock: {
+            GenCounter: number,
+            Height: number,
+            Width: number
+        } = {
+            GenCounter: 0,
+            Height: 0,
+            Width: 0
+        };
+        newObjHeightWidthBlock['GenCounter'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjHeightWidthBlock['Height'] = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjHeightWidthBlock['Width'] = buf.readUInt16LE(pos);
+        pos += 2;
+        this.HeightWidthBlock = newObjHeightWidthBlock;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentIsNowWearing.ts

@@ -0,0 +1,81 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentIsNowWearingMessage implements MessageBase
+{
+    name = 'AgentIsNowWearing';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AgentIsNowWearing;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    WearableData: {
+        ItemID: UUID;
+        WearableType: number;
+    }[];
+
+    getSize(): number
+    {
+        return ((17) * this.WearableData.length) + 33;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.WearableData.length;
+        buf.writeUInt8(this.WearableData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.WearableData[i]['ItemID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.WearableData[i]['WearableType'], pos++);
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.WearableData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjWearableData: {
+                ItemID: UUID,
+                WearableType: number
+            } = {
+                ItemID: UUID.zero(),
+                WearableType: 0
+            };
+            newObjWearableData['ItemID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjWearableData['WearableType'] = buf.readUInt8(pos++);
+            this.WearableData.push(newObjWearableData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentMovementComplete.ts

@@ -0,0 +1,108 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentMovementCompleteMessage implements MessageBase
+{
+    name = 'AgentMovementComplete';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentMovementComplete;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    Data: {
+        Position: Vector3;
+        LookAt: Vector3;
+        RegionHandle: Long;
+        Timestamp: number;
+    };
+    SimData: {
+        ChannelVersion: string;
+    };
+
+    getSize(): number
+    {
+        return (this.SimData['ChannelVersion'].length + 2) + 68;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['Position'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.Data['LookAt'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        buf.writeInt32LE(this.Data['RegionHandle'].low, pos);
+        pos += 4;
+        buf.writeInt32LE(this.Data['RegionHandle'].high, pos);
+        pos += 4;
+        buf.writeUInt32LE(this.Data['Timestamp'], pos);
+        pos += 4;
+        buf.writeUInt16LE(this.SimData['ChannelVersion'].length, pos);
+        pos += 2;
+        buf.write(this.SimData['ChannelVersion'], pos);
+        pos += this.SimData['ChannelVersion'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            Position: Vector3,
+            LookAt: Vector3,
+            RegionHandle: Long,
+            Timestamp: number
+        } = {
+            Position: Vector3.getZero(),
+            LookAt: Vector3.getZero(),
+            RegionHandle: Long.ZERO,
+            Timestamp: 0
+        };
+        newObjData['Position'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjData['LookAt'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjData['RegionHandle'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+        pos += 8;
+        newObjData['Timestamp'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.Data = newObjData;
+        const newObjSimData: {
+            ChannelVersion: string
+        } = {
+            ChannelVersion: ''
+        };
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjSimData['ChannelVersion'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.SimData = newObjSimData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentPause.ts

@@ -0,0 +1,60 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentPauseMessage implements MessageBase
+{
+    name = 'AgentPause';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentPause;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        SerialNum: number;
+    };
+
+    getSize(): number
+    {
+        return 36;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['SerialNum'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            SerialNum: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            SerialNum: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SerialNum'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentQuitCopy.ts

@@ -0,0 +1,66 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentQuitCopyMessage implements MessageBase
+{
+    name = 'AgentQuitCopy';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentQuitCopy;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    FuseBlock: {
+        ViewerCircuitCode: number;
+    };
+
+    getSize(): number
+    {
+        return 36;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.FuseBlock['ViewerCircuitCode'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjFuseBlock: {
+            ViewerCircuitCode: number
+        } = {
+            ViewerCircuitCode: 0
+        };
+        newObjFuseBlock['ViewerCircuitCode'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.FuseBlock = newObjFuseBlock;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentRequestSit.ts

@@ -0,0 +1,74 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentRequestSitMessage implements MessageBase
+{
+    name = 'AgentRequestSit';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyHigh;
+    id = Message.AgentRequestSit;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    TargetObject: {
+        TargetID: UUID;
+        Offset: Vector3;
+    };
+
+    getSize(): number
+    {
+        return 60;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.TargetObject['TargetID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.TargetObject['Offset'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjTargetObject: {
+            TargetID: UUID,
+            Offset: Vector3
+        } = {
+            TargetID: UUID.zero(),
+            Offset: Vector3.getZero()
+        };
+        newObjTargetObject['TargetID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjTargetObject['Offset'] = new Vector3(buf, pos, false);
+        pos += 12;
+        this.TargetObject = newObjTargetObject;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentResume.ts

@@ -0,0 +1,60 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentResumeMessage implements MessageBase
+{
+    name = 'AgentResume';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentResume;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        SerialNum: number;
+    };
+
+    getSize(): number
+    {
+        return 36;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['SerialNum'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            SerialNum: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            SerialNum: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SerialNum'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentSetAppearance.ts

@@ -0,0 +1,134 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentSetAppearanceMessage implements MessageBase
+{
+    name = 'AgentSetAppearance';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AgentSetAppearance;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        SerialNum: number;
+        Size: Vector3;
+    };
+    WearableData: {
+        CacheID: UUID;
+        TextureIndex: number;
+    }[];
+    ObjectData: {
+        TextureEntry: string;
+    };
+    VisualParam: {
+        ParamValue: number;
+    }[];
+
+    getSize(): number
+    {
+        return ((17) * this.WearableData.length) + (this.ObjectData['TextureEntry'].length + 2) + ((1) * this.VisualParam.length) + 50;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['SerialNum'], pos);
+        pos += 4;
+        this.AgentData['Size'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        let count = this.WearableData.length;
+        buf.writeUInt8(this.WearableData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.WearableData[i]['CacheID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.WearableData[i]['TextureIndex'], pos++);
+        }
+        buf.writeUInt16LE(this.ObjectData['TextureEntry'].length, pos);
+        pos += 2;
+        buf.write(this.ObjectData['TextureEntry'], pos);
+        pos += this.ObjectData['TextureEntry'].length;
+        count = this.VisualParam.length;
+        buf.writeUInt8(this.VisualParam.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.VisualParam[i]['ParamValue'], pos++);
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            SerialNum: number,
+            Size: Vector3
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            SerialNum: 0,
+            Size: Vector3.getZero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SerialNum'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjAgentData['Size'] = new Vector3(buf, pos, false);
+        pos += 12;
+        this.AgentData = newObjAgentData;
+        let count = buf.readUInt8(pos++);
+        this.WearableData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjWearableData: {
+                CacheID: UUID,
+                TextureIndex: number
+            } = {
+                CacheID: UUID.zero(),
+                TextureIndex: 0
+            };
+            newObjWearableData['CacheID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjWearableData['TextureIndex'] = buf.readUInt8(pos++);
+            this.WearableData.push(newObjWearableData);
+        }
+        const newObjObjectData: {
+            TextureEntry: string
+        } = {
+            TextureEntry: ''
+        };
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjObjectData['TextureEntry'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.ObjectData = newObjObjectData;
+        count = buf.readUInt8(pos++);
+        this.VisualParam = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjVisualParam: {
+                ParamValue: number
+            } = {
+                ParamValue: 0
+            };
+            newObjVisualParam['ParamValue'] = buf.readUInt8(pos++);
+            this.VisualParam.push(newObjVisualParam);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentSit.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentSitMessage implements MessageBase
+{
+    name = 'AgentSit';
+    messageFlags = MessageFlags.FrequencyHigh;
+    id = Message.AgentSit;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 32;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentThrottle.ts

@@ -0,0 +1,82 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentThrottleMessage implements MessageBase
+{
+    name = 'AgentThrottle';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AgentThrottle;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        CircuitCode: number;
+    };
+    Throttle: {
+        GenCounter: number;
+        Throttles: string;
+    };
+
+    getSize(): number
+    {
+        return (this.Throttle['Throttles'].length + 1) + 40;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['CircuitCode'], pos);
+        pos += 4;
+        buf.writeUInt32LE(this.Throttle['GenCounter'], pos);
+        pos += 4;
+        buf.writeUInt8(this.Throttle['Throttles'].length, pos++);
+        buf.write(this.Throttle['Throttles'], pos);
+        pos += this.Throttle['Throttles'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            CircuitCode: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            CircuitCode: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['CircuitCode'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        const newObjThrottle: {
+            GenCounter: number,
+            Throttles: string
+        } = {
+            GenCounter: 0,
+            Throttles: ''
+        };
+        newObjThrottle['GenCounter'] = buf.readUInt32LE(pos);
+        pos += 4;
+        varLength = buf.readUInt8(pos++);
+        newObjThrottle['Throttles'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.Throttle = newObjThrottle;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentUpdate.ts

@@ -0,0 +1,121 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {Quaternion} from '../Quaternion';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentUpdateMessage implements MessageBase
+{
+    name = 'AgentUpdate';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyHigh;
+    id = Message.AgentUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        BodyRotation: Quaternion;
+        HeadRotation: Quaternion;
+        State: number;
+        CameraCenter: Vector3;
+        CameraAtAxis: Vector3;
+        CameraLeftAxis: Vector3;
+        CameraUpAxis: Vector3;
+        Far: number;
+        ControlFlags: number;
+        Flags: number;
+    };
+
+    getSize(): number
+    {
+        return 114;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['BodyRotation'].writeToBuffer(buf, pos);
+        pos += 12;
+        this.AgentData['HeadRotation'].writeToBuffer(buf, pos);
+        pos += 12;
+        buf.writeUInt8(this.AgentData['State'], pos++);
+        this.AgentData['CameraCenter'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['CameraAtAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['CameraLeftAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['CameraUpAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        buf.writeFloatLE(this.AgentData['Far'], pos);
+        pos += 4;
+        buf.writeUInt32LE(this.AgentData['ControlFlags'], pos);
+        pos += 4;
+        buf.writeUInt8(this.AgentData['Flags'], pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            BodyRotation: Quaternion,
+            HeadRotation: Quaternion,
+            State: number,
+            CameraCenter: Vector3,
+            CameraAtAxis: Vector3,
+            CameraLeftAxis: Vector3,
+            CameraUpAxis: Vector3,
+            Far: number,
+            ControlFlags: number,
+            Flags: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            BodyRotation: Quaternion.getIdentity(),
+            HeadRotation: Quaternion.getIdentity(),
+            State: 0,
+            CameraCenter: Vector3.getZero(),
+            CameraAtAxis: Vector3.getZero(),
+            CameraLeftAxis: Vector3.getZero(),
+            CameraUpAxis: Vector3.getZero(),
+            Far: 0,
+            ControlFlags: 0,
+            Flags: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['BodyRotation'] = new Quaternion(buf, pos);
+        pos += 12;
+        newObjAgentData['HeadRotation'] = new Quaternion(buf, pos);
+        pos += 12;
+        newObjAgentData['State'] = buf.readUInt8(pos++);
+        newObjAgentData['CameraCenter'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['CameraAtAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['CameraLeftAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['CameraUpAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['Far'] = buf.readFloatLE(pos);
+        pos += 4;
+        newObjAgentData['ControlFlags'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjAgentData['Flags'] = buf.readUInt8(pos++);
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentWearablesRequest.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentWearablesRequestMessage implements MessageBase
+{
+    name = 'AgentWearablesRequest';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AgentWearablesRequest;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 32;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AgentWearablesUpdate.ts

@@ -0,0 +1,95 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AgentWearablesUpdateMessage implements MessageBase
+{
+    name = 'AgentWearablesUpdate';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AgentWearablesUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        SerialNum: number;
+    };
+    WearableData: {
+        ItemID: UUID;
+        AssetID: UUID;
+        WearableType: number;
+    }[];
+
+    getSize(): number
+    {
+        return ((33) * this.WearableData.length) + 37;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['SerialNum'], pos);
+        pos += 4;
+        const count = this.WearableData.length;
+        buf.writeUInt8(this.WearableData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.WearableData[i]['ItemID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.WearableData[i]['AssetID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.WearableData[i]['WearableType'], pos++);
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            SerialNum: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            SerialNum: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SerialNum'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.WearableData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjWearableData: {
+                ItemID: UUID,
+                AssetID: UUID,
+                WearableType: number
+            } = {
+                ItemID: UUID.zero(),
+                AssetID: UUID.zero(),
+                WearableType: 0
+            };
+            newObjWearableData['ItemID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjWearableData['AssetID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjWearableData['WearableType'] = buf.readUInt8(pos++);
+            this.WearableData.push(newObjWearableData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AlertMessage.ts

@@ -0,0 +1,115 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AlertMessageMessage implements MessageBase
+{
+    name = 'AlertMessage';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AlertMessage;
+
+    AlertData: {
+        Message: string;
+    };
+    AlertInfo: {
+        Message: string;
+        ExtraParams: string;
+    }[];
+    AgentInfo: {
+        AgentID: UUID;
+    }[];
+
+    getSize(): number
+    {
+        return (this.AlertData['Message'].length + 1) + ((this.calculateVarVarSize(this.AlertInfo, 'Message', 1) + this.calculateVarVarSize(this.AlertInfo, 'ExtraParams', 1)) * this.AlertInfo.length) + ((16) * this.AgentInfo.length) + 2;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeUInt8(this.AlertData['Message'].length, pos++);
+        buf.write(this.AlertData['Message'], pos);
+        pos += this.AlertData['Message'].length;
+        let count = this.AlertInfo.length;
+        buf.writeUInt8(this.AlertInfo.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.AlertInfo[i]['Message'].length, pos++);
+            buf.write(this.AlertInfo[i]['Message'], pos);
+            pos += this.AlertInfo[i]['Message'].length;
+            buf.writeUInt8(this.AlertInfo[i]['ExtraParams'].length, pos++);
+            buf.write(this.AlertInfo[i]['ExtraParams'], pos);
+            pos += this.AlertInfo[i]['ExtraParams'].length;
+        }
+        count = this.AgentInfo.length;
+        buf.writeUInt8(this.AgentInfo.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.AgentInfo[i]['AgentID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAlertData: {
+            Message: string
+        } = {
+            Message: ''
+        };
+        varLength = buf.readUInt8(pos++);
+        newObjAlertData['Message'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.AlertData = newObjAlertData;
+        let count = buf.readUInt8(pos++);
+        this.AlertInfo = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAlertInfo: {
+                Message: string,
+                ExtraParams: string
+            } = {
+                Message: '',
+                ExtraParams: ''
+            };
+            varLength = buf.readUInt8(pos++);
+            newObjAlertInfo['Message'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            varLength = buf.readUInt8(pos++);
+            newObjAlertInfo['ExtraParams'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.AlertInfo.push(newObjAlertInfo);
+        }
+        count = buf.readUInt8(pos++);
+        this.AgentInfo = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAgentInfo: {
+                AgentID: UUID
+            } = {
+                AgentID: UUID.zero()
+            };
+            newObjAgentInfo['AgentID'] = new UUID(buf, pos);
+            pos += 16;
+            this.AgentInfo.push(newObjAgentInfo);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AssetUploadComplete.ts

@@ -0,0 +1,56 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AssetUploadCompleteMessage implements MessageBase
+{
+    name = 'AssetUploadComplete';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AssetUploadComplete;
+
+    AssetBlock: {
+        UUID: UUID;
+        Type: number;
+        Success: boolean;
+    };
+
+    getSize(): number
+    {
+        return 18;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AssetBlock['UUID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt8(this.AssetBlock['Type'], pos++);
+        buf.writeUInt8((this.AssetBlock['Success']) ? 1 : 0, pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAssetBlock: {
+            UUID: UUID,
+            Type: number,
+            Success: boolean
+        } = {
+            UUID: UUID.zero(),
+            Type: 0,
+            Success: false
+        };
+        newObjAssetBlock['UUID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAssetBlock['Type'] = buf.readInt8(pos++);
+        newObjAssetBlock['Success'] = (buf.readUInt8(pos++) === 1);
+        this.AssetBlock = newObjAssetBlock;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AssetUploadRequest.ts

@@ -0,0 +1,72 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AssetUploadRequestMessage implements MessageBase
+{
+    name = 'AssetUploadRequest';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AssetUploadRequest;
+
+    AssetBlock: {
+        TransactionID: UUID;
+        Type: number;
+        Tempfile: boolean;
+        StoreLocal: boolean;
+        AssetData: string;
+    };
+
+    getSize(): number
+    {
+        return (this.AssetBlock['AssetData'].length + 2) + 19;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AssetBlock['TransactionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt8(this.AssetBlock['Type'], pos++);
+        buf.writeUInt8((this.AssetBlock['Tempfile']) ? 1 : 0, pos++);
+        buf.writeUInt8((this.AssetBlock['StoreLocal']) ? 1 : 0, pos++);
+        buf.writeUInt16LE(this.AssetBlock['AssetData'].length, pos);
+        pos += 2;
+        buf.write(this.AssetBlock['AssetData'], pos);
+        pos += this.AssetBlock['AssetData'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAssetBlock: {
+            TransactionID: UUID,
+            Type: number,
+            Tempfile: boolean,
+            StoreLocal: boolean,
+            AssetData: string
+        } = {
+            TransactionID: UUID.zero(),
+            Type: 0,
+            Tempfile: false,
+            StoreLocal: false,
+            AssetData: ''
+        };
+        newObjAssetBlock['TransactionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAssetBlock['Type'] = buf.readInt8(pos++);
+        newObjAssetBlock['Tempfile'] = (buf.readUInt8(pos++) === 1);
+        newObjAssetBlock['StoreLocal'] = (buf.readUInt8(pos++) === 1);
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjAssetBlock['AssetData'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.AssetBlock = newObjAssetBlock;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AtomicPassObject.ts

@@ -0,0 +1,51 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AtomicPassObjectMessage implements MessageBase
+{
+    name = 'AtomicPassObject';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyHigh;
+    id = Message.AtomicPassObject;
+
+    TaskData: {
+        TaskID: UUID;
+        AttachmentNeedsSave: boolean;
+    };
+
+    getSize(): number
+    {
+        return 17;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.TaskData['TaskID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8((this.TaskData['AttachmentNeedsSave']) ? 1 : 0, pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjTaskData: {
+            TaskID: UUID,
+            AttachmentNeedsSave: boolean
+        } = {
+            TaskID: UUID.zero(),
+            AttachmentNeedsSave: false
+        };
+        newObjTaskData['TaskID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjTaskData['AttachmentNeedsSave'] = (buf.readUInt8(pos++) === 1);
+        this.TaskData = newObjTaskData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AttachedSound.ts

@@ -0,0 +1,72 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AttachedSoundMessage implements MessageBase
+{
+    name = 'AttachedSound';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyMedium;
+    id = Message.AttachedSound;
+
+    DataBlock: {
+        SoundID: UUID;
+        ObjectID: UUID;
+        OwnerID: UUID;
+        Gain: number;
+        Flags: number;
+    };
+
+    getSize(): number
+    {
+        return 53;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.DataBlock['SoundID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.DataBlock['ObjectID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.DataBlock['OwnerID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeFloatLE(this.DataBlock['Gain'], pos);
+        pos += 4;
+        buf.writeUInt8(this.DataBlock['Flags'], pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjDataBlock: {
+            SoundID: UUID,
+            ObjectID: UUID,
+            OwnerID: UUID,
+            Gain: number,
+            Flags: number
+        } = {
+            SoundID: UUID.zero(),
+            ObjectID: UUID.zero(),
+            OwnerID: UUID.zero(),
+            Gain: 0,
+            Flags: 0
+        };
+        newObjDataBlock['SoundID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjDataBlock['ObjectID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjDataBlock['OwnerID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjDataBlock['Gain'] = buf.readFloatLE(pos);
+        pos += 4;
+        newObjDataBlock['Flags'] = buf.readUInt8(pos++);
+        this.DataBlock = newObjDataBlock;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AttachedSoundGainChange.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AttachedSoundGainChangeMessage implements MessageBase
+{
+    name = 'AttachedSoundGainChange';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyMedium;
+    id = Message.AttachedSoundGainChange;
+
+    DataBlock: {
+        ObjectID: UUID;
+        Gain: number;
+    };
+
+    getSize(): number
+    {
+        return 20;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.DataBlock['ObjectID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeFloatLE(this.DataBlock['Gain'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjDataBlock: {
+            ObjectID: UUID,
+            Gain: number
+        } = {
+            ObjectID: UUID.zero(),
+            Gain: 0
+        };
+        newObjDataBlock['ObjectID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjDataBlock['Gain'] = buf.readFloatLE(pos);
+        pos += 4;
+        this.DataBlock = newObjDataBlock;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarAnimation.ts

@@ -0,0 +1,134 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarAnimationMessage implements MessageBase
+{
+    name = 'AvatarAnimation';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyHigh;
+    id = Message.AvatarAnimation;
+
+    Sender: {
+        ID: UUID;
+    };
+    AnimationList: {
+        AnimID: UUID;
+        AnimSequenceID: number;
+    }[];
+    AnimationSourceList: {
+        ObjectID: UUID;
+    }[];
+    PhysicalAvatarEventList: {
+        TypeData: string;
+    }[];
+
+    getSize(): number
+    {
+        return ((20) * this.AnimationList.length) + ((16) * this.AnimationSourceList.length) + ((this.calculateVarVarSize(this.PhysicalAvatarEventList, 'TypeData', 1)) * this.PhysicalAvatarEventList.length) + 19;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.Sender['ID'].writeToBuffer(buf, pos);
+        pos += 16;
+        let count = this.AnimationList.length;
+        buf.writeUInt8(this.AnimationList.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.AnimationList[i]['AnimID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeInt32LE(this.AnimationList[i]['AnimSequenceID'], pos);
+            pos += 4;
+        }
+        count = this.AnimationSourceList.length;
+        buf.writeUInt8(this.AnimationSourceList.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.AnimationSourceList[i]['ObjectID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        count = this.PhysicalAvatarEventList.length;
+        buf.writeUInt8(this.PhysicalAvatarEventList.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.PhysicalAvatarEventList[i]['TypeData'].length, pos++);
+            buf.write(this.PhysicalAvatarEventList[i]['TypeData'], pos);
+            pos += this.PhysicalAvatarEventList[i]['TypeData'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjSender: {
+            ID: UUID
+        } = {
+            ID: UUID.zero()
+        };
+        newObjSender['ID'] = new UUID(buf, pos);
+        pos += 16;
+        this.Sender = newObjSender;
+        let count = buf.readUInt8(pos++);
+        this.AnimationList = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAnimationList: {
+                AnimID: UUID,
+                AnimSequenceID: number
+            } = {
+                AnimID: UUID.zero(),
+                AnimSequenceID: 0
+            };
+            newObjAnimationList['AnimID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjAnimationList['AnimSequenceID'] = buf.readInt32LE(pos);
+            pos += 4;
+            this.AnimationList.push(newObjAnimationList);
+        }
+        count = buf.readUInt8(pos++);
+        this.AnimationSourceList = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAnimationSourceList: {
+                ObjectID: UUID
+            } = {
+                ObjectID: UUID.zero()
+            };
+            newObjAnimationSourceList['ObjectID'] = new UUID(buf, pos);
+            pos += 16;
+            this.AnimationSourceList.push(newObjAnimationSourceList);
+        }
+        count = buf.readUInt8(pos++);
+        this.PhysicalAvatarEventList = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjPhysicalAvatarEventList: {
+                TypeData: string
+            } = {
+                TypeData: ''
+            };
+            varLength = buf.readUInt8(pos++);
+            newObjPhysicalAvatarEventList['TypeData'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.PhysicalAvatarEventList.push(newObjPhysicalAvatarEventList);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarAppearance.ts

@@ -0,0 +1,148 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarAppearanceMessage implements MessageBase
+{
+    name = 'AvatarAppearance';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AvatarAppearance;
+
+    Sender: {
+        ID: UUID;
+        IsTrial: boolean;
+    };
+    ObjectData: {
+        TextureEntry: string;
+    };
+    VisualParam: {
+        ParamValue: number;
+    }[];
+    AppearanceData: {
+        AppearanceVersion: number;
+        CofVersion: number;
+        Flags: number;
+    }[];
+    AppearanceHover: {
+        HoverHeight: Vector3;
+    }[];
+
+    getSize(): number
+    {
+        return (this.ObjectData['TextureEntry'].length + 2) + ((1) * this.VisualParam.length) + ((9) * this.AppearanceData.length) + ((12) * this.AppearanceHover.length) + 20;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.Sender['ID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8((this.Sender['IsTrial']) ? 1 : 0, pos++);
+        buf.writeUInt16LE(this.ObjectData['TextureEntry'].length, pos);
+        pos += 2;
+        buf.write(this.ObjectData['TextureEntry'], pos);
+        pos += this.ObjectData['TextureEntry'].length;
+        let count = this.VisualParam.length;
+        buf.writeUInt8(this.VisualParam.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.VisualParam[i]['ParamValue'], pos++);
+        }
+        count = this.AppearanceData.length;
+        buf.writeUInt8(this.AppearanceData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.AppearanceData[i]['AppearanceVersion'], pos++);
+            buf.writeInt32LE(this.AppearanceData[i]['CofVersion'], pos);
+            pos += 4;
+            buf.writeUInt32LE(this.AppearanceData[i]['Flags'], pos);
+            pos += 4;
+        }
+        count = this.AppearanceHover.length;
+        buf.writeUInt8(this.AppearanceHover.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.AppearanceHover[i]['HoverHeight'].writeToBuffer(buf, pos, false);
+            pos += 12;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjSender: {
+            ID: UUID,
+            IsTrial: boolean
+        } = {
+            ID: UUID.zero(),
+            IsTrial: false
+        };
+        newObjSender['ID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjSender['IsTrial'] = (buf.readUInt8(pos++) === 1);
+        this.Sender = newObjSender;
+        const newObjObjectData: {
+            TextureEntry: string
+        } = {
+            TextureEntry: ''
+        };
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjObjectData['TextureEntry'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.ObjectData = newObjObjectData;
+        let count = buf.readUInt8(pos++);
+        this.VisualParam = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjVisualParam: {
+                ParamValue: number
+            } = {
+                ParamValue: 0
+            };
+            newObjVisualParam['ParamValue'] = buf.readUInt8(pos++);
+            this.VisualParam.push(newObjVisualParam);
+        }
+        count = buf.readUInt8(pos++);
+        this.AppearanceData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAppearanceData: {
+                AppearanceVersion: number,
+                CofVersion: number,
+                Flags: number
+            } = {
+                AppearanceVersion: 0,
+                CofVersion: 0,
+                Flags: 0
+            };
+            newObjAppearanceData['AppearanceVersion'] = buf.readUInt8(pos++);
+            newObjAppearanceData['CofVersion'] = buf.readInt32LE(pos);
+            pos += 4;
+            newObjAppearanceData['Flags'] = buf.readUInt32LE(pos);
+            pos += 4;
+            this.AppearanceData.push(newObjAppearanceData);
+        }
+        count = buf.readUInt8(pos++);
+        this.AppearanceHover = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAppearanceHover: {
+                HoverHeight: Vector3
+            } = {
+                HoverHeight: Vector3.getZero()
+            };
+            newObjAppearanceHover['HoverHeight'] = new Vector3(buf, pos, false);
+            pos += 12;
+            this.AppearanceHover.push(newObjAppearanceHover);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarClassifiedReply.ts

@@ -0,0 +1,95 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarClassifiedReplyMessage implements MessageBase
+{
+    name = 'AvatarClassifiedReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AvatarClassifiedReply;
+
+    AgentData: {
+        AgentID: UUID;
+        TargetID: UUID;
+    };
+    Data: {
+        ClassifiedID: UUID;
+        Name: string;
+    }[];
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.Data, 'Name', 1) + 16) * this.Data.length) + 33;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['TargetID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.Data.length;
+        buf.writeUInt8(this.Data.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.Data[i]['ClassifiedID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.Data[i]['Name'].length, pos++);
+            buf.write(this.Data[i]['Name'], pos);
+            pos += this.Data[i]['Name'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            TargetID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            TargetID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['TargetID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.Data = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjData: {
+                ClassifiedID: UUID,
+                Name: string
+            } = {
+                ClassifiedID: UUID.zero(),
+                Name: ''
+            };
+            newObjData['ClassifiedID'] = new UUID(buf, pos);
+            pos += 16;
+            varLength = buf.readUInt8(pos++);
+            newObjData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.Data.push(newObjData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarGroupsReply.ts

@@ -0,0 +1,137 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarGroupsReplyMessage implements MessageBase
+{
+    name = 'AvatarGroupsReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AvatarGroupsReply;
+
+    AgentData: {
+        AgentID: UUID;
+        AvatarID: UUID;
+    };
+    GroupData: {
+        GroupPowers: Long;
+        AcceptNotices: boolean;
+        GroupTitle: string;
+        GroupID: UUID;
+        GroupName: string;
+        GroupInsigniaID: UUID;
+    }[];
+    NewGroupData: {
+        ListInProfile: boolean;
+    };
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.GroupData, 'GroupTitle', 1) + this.calculateVarVarSize(this.GroupData, 'GroupName', 1) + 41) * this.GroupData.length) + 34;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['AvatarID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.GroupData.length;
+        buf.writeUInt8(this.GroupData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeInt32LE(this.GroupData[i]['GroupPowers'].low, pos);
+            pos += 4;
+            buf.writeInt32LE(this.GroupData[i]['GroupPowers'].high, pos);
+            pos += 4;
+            buf.writeUInt8((this.GroupData[i]['AcceptNotices']) ? 1 : 0, pos++);
+            buf.writeUInt8(this.GroupData[i]['GroupTitle'].length, pos++);
+            buf.write(this.GroupData[i]['GroupTitle'], pos);
+            pos += this.GroupData[i]['GroupTitle'].length;
+            this.GroupData[i]['GroupID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.GroupData[i]['GroupName'].length, pos++);
+            buf.write(this.GroupData[i]['GroupName'], pos);
+            pos += this.GroupData[i]['GroupName'].length;
+            this.GroupData[i]['GroupInsigniaID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        buf.writeUInt8((this.NewGroupData['ListInProfile']) ? 1 : 0, pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            AvatarID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            AvatarID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['AvatarID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.GroupData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjGroupData: {
+                GroupPowers: Long,
+                AcceptNotices: boolean,
+                GroupTitle: string,
+                GroupID: UUID,
+                GroupName: string,
+                GroupInsigniaID: UUID
+            } = {
+                GroupPowers: Long.ZERO,
+                AcceptNotices: false,
+                GroupTitle: '',
+                GroupID: UUID.zero(),
+                GroupName: '',
+                GroupInsigniaID: UUID.zero()
+            };
+            newObjGroupData['GroupPowers'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+            pos += 8;
+            newObjGroupData['AcceptNotices'] = (buf.readUInt8(pos++) === 1);
+            varLength = buf.readUInt8(pos++);
+            newObjGroupData['GroupTitle'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            newObjGroupData['GroupID'] = new UUID(buf, pos);
+            pos += 16;
+            varLength = buf.readUInt8(pos++);
+            newObjGroupData['GroupName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            newObjGroupData['GroupInsigniaID'] = new UUID(buf, pos);
+            pos += 16;
+            this.GroupData.push(newObjGroupData);
+        }
+        const newObjNewGroupData: {
+            ListInProfile: boolean
+        } = {
+            ListInProfile: false
+        };
+        newObjNewGroupData['ListInProfile'] = (buf.readUInt8(pos++) === 1);
+        this.NewGroupData = newObjNewGroupData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarInterestsReply.ts

@@ -0,0 +1,100 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarInterestsReplyMessage implements MessageBase
+{
+    name = 'AvatarInterestsReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AvatarInterestsReply;
+
+    AgentData: {
+        AgentID: UUID;
+        AvatarID: UUID;
+    };
+    PropertiesData: {
+        WantToMask: number;
+        WantToText: string;
+        SkillsMask: number;
+        SkillsText: string;
+        LanguagesText: string;
+    };
+
+    getSize(): number
+    {
+        return (this.PropertiesData['WantToText'].length + 1 + this.PropertiesData['SkillsText'].length + 1 + this.PropertiesData['LanguagesText'].length + 1) + 40;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['AvatarID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.PropertiesData['WantToMask'], pos);
+        pos += 4;
+        buf.writeUInt8(this.PropertiesData['WantToText'].length, pos++);
+        buf.write(this.PropertiesData['WantToText'], pos);
+        pos += this.PropertiesData['WantToText'].length;
+        buf.writeUInt32LE(this.PropertiesData['SkillsMask'], pos);
+        pos += 4;
+        buf.writeUInt8(this.PropertiesData['SkillsText'].length, pos++);
+        buf.write(this.PropertiesData['SkillsText'], pos);
+        pos += this.PropertiesData['SkillsText'].length;
+        buf.writeUInt8(this.PropertiesData['LanguagesText'].length, pos++);
+        buf.write(this.PropertiesData['LanguagesText'], pos);
+        pos += this.PropertiesData['LanguagesText'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            AvatarID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            AvatarID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['AvatarID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjPropertiesData: {
+            WantToMask: number,
+            WantToText: string,
+            SkillsMask: number,
+            SkillsText: string,
+            LanguagesText: string
+        } = {
+            WantToMask: 0,
+            WantToText: '',
+            SkillsMask: 0,
+            SkillsText: '',
+            LanguagesText: ''
+        };
+        newObjPropertiesData['WantToMask'] = buf.readUInt32LE(pos);
+        pos += 4;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['WantToText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjPropertiesData['SkillsMask'] = buf.readUInt32LE(pos);
+        pos += 4;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['SkillsText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['LanguagesText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.PropertiesData = newObjPropertiesData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarInterestsUpdate.ts

@@ -0,0 +1,100 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarInterestsUpdateMessage implements MessageBase
+{
+    name = 'AvatarInterestsUpdate';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AvatarInterestsUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    PropertiesData: {
+        WantToMask: number;
+        WantToText: string;
+        SkillsMask: number;
+        SkillsText: string;
+        LanguagesText: string;
+    };
+
+    getSize(): number
+    {
+        return (this.PropertiesData['WantToText'].length + 1 + this.PropertiesData['SkillsText'].length + 1 + this.PropertiesData['LanguagesText'].length + 1) + 40;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.PropertiesData['WantToMask'], pos);
+        pos += 4;
+        buf.writeUInt8(this.PropertiesData['WantToText'].length, pos++);
+        buf.write(this.PropertiesData['WantToText'], pos);
+        pos += this.PropertiesData['WantToText'].length;
+        buf.writeUInt32LE(this.PropertiesData['SkillsMask'], pos);
+        pos += 4;
+        buf.writeUInt8(this.PropertiesData['SkillsText'].length, pos++);
+        buf.write(this.PropertiesData['SkillsText'], pos);
+        pos += this.PropertiesData['SkillsText'].length;
+        buf.writeUInt8(this.PropertiesData['LanguagesText'].length, pos++);
+        buf.write(this.PropertiesData['LanguagesText'], pos);
+        pos += this.PropertiesData['LanguagesText'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjPropertiesData: {
+            WantToMask: number,
+            WantToText: string,
+            SkillsMask: number,
+            SkillsText: string,
+            LanguagesText: string
+        } = {
+            WantToMask: 0,
+            WantToText: '',
+            SkillsMask: 0,
+            SkillsText: '',
+            LanguagesText: ''
+        };
+        newObjPropertiesData['WantToMask'] = buf.readUInt32LE(pos);
+        pos += 4;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['WantToText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjPropertiesData['SkillsMask'] = buf.readUInt32LE(pos);
+        pos += 4;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['SkillsText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['LanguagesText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.PropertiesData = newObjPropertiesData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarNotesReply.ts

@@ -0,0 +1,70 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarNotesReplyMessage implements MessageBase
+{
+    name = 'AvatarNotesReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AvatarNotesReply;
+
+    AgentData: {
+        AgentID: UUID;
+    };
+    Data: {
+        TargetID: UUID;
+        Notes: string;
+    };
+
+    getSize(): number
+    {
+        return (this.Data['Notes'].length + 2) + 32;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['TargetID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt16LE(this.Data['Notes'].length, pos);
+        pos += 2;
+        buf.write(this.Data['Notes'], pos);
+        pos += this.Data['Notes'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID
+        } = {
+            AgentID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            TargetID: UUID,
+            Notes: string
+        } = {
+            TargetID: UUID.zero(),
+            Notes: ''
+        };
+        newObjData['TargetID'] = new UUID(buf, pos);
+        pos += 16;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjData['Notes'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarNotesUpdate.ts

@@ -0,0 +1,77 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarNotesUpdateMessage implements MessageBase
+{
+    name = 'AvatarNotesUpdate';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AvatarNotesUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    Data: {
+        TargetID: UUID;
+        Notes: string;
+    };
+
+    getSize(): number
+    {
+        return (this.Data['Notes'].length + 2) + 48;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['TargetID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt16LE(this.Data['Notes'].length, pos);
+        pos += 2;
+        buf.write(this.Data['Notes'], pos);
+        pos += this.Data['Notes'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            TargetID: UUID,
+            Notes: string
+        } = {
+            TargetID: UUID.zero(),
+            Notes: ''
+        };
+        newObjData['TargetID'] = new UUID(buf, pos);
+        pos += 16;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjData['Notes'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarPickerReply.ts

@@ -0,0 +1,104 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarPickerReplyMessage implements MessageBase
+{
+    name = 'AvatarPickerReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AvatarPickerReply;
+
+    AgentData: {
+        AgentID: UUID;
+        QueryID: UUID;
+    };
+    Data: {
+        AvatarID: UUID;
+        FirstName: string;
+        LastName: string;
+    }[];
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.Data, 'FirstName', 1) + this.calculateVarVarSize(this.Data, 'LastName', 1) + 16) * this.Data.length) + 33;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['QueryID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.Data.length;
+        buf.writeUInt8(this.Data.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.Data[i]['AvatarID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.Data[i]['FirstName'].length, pos++);
+            buf.write(this.Data[i]['FirstName'], pos);
+            pos += this.Data[i]['FirstName'].length;
+            buf.writeUInt8(this.Data[i]['LastName'].length, pos++);
+            buf.write(this.Data[i]['LastName'], pos);
+            pos += this.Data[i]['LastName'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            QueryID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            QueryID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['QueryID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.Data = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjData: {
+                AvatarID: UUID,
+                FirstName: string,
+                LastName: string
+            } = {
+                AvatarID: UUID.zero(),
+                FirstName: '',
+                LastName: ''
+            };
+            newObjData['AvatarID'] = new UUID(buf, pos);
+            pos += 16;
+            varLength = buf.readUInt8(pos++);
+            newObjData['FirstName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            varLength = buf.readUInt8(pos++);
+            newObjData['LastName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.Data.push(newObjData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarPickerRequest.ts

@@ -0,0 +1,75 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarPickerRequestMessage implements MessageBase
+{
+    name = 'AvatarPickerRequest';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AvatarPickerRequest;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        QueryID: UUID;
+    };
+    Data: {
+        Name: string;
+    };
+
+    getSize(): number
+    {
+        return (this.Data['Name'].length + 1) + 48;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['QueryID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.Data['Name'].length, pos++);
+        buf.write(this.Data['Name'], pos);
+        pos += this.Data['Name'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            QueryID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            QueryID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['QueryID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            Name: string
+        } = {
+            Name: ''
+        };
+        varLength = buf.readUInt8(pos++);
+        newObjData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarPickerRequestBackend.ts

@@ -0,0 +1,80 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarPickerRequestBackendMessage implements MessageBase
+{
+    name = 'AvatarPickerRequestBackend';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AvatarPickerRequestBackend;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        QueryID: UUID;
+        GodLevel: number;
+    };
+    Data: {
+        Name: string;
+    };
+
+    getSize(): number
+    {
+        return (this.Data['Name'].length + 1) + 49;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['QueryID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.AgentData['GodLevel'], pos++);
+        buf.writeUInt8(this.Data['Name'].length, pos++);
+        buf.write(this.Data['Name'], pos);
+        pos += this.Data['Name'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            QueryID: UUID,
+            GodLevel: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            QueryID: UUID.zero(),
+            GodLevel: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['QueryID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['GodLevel'] = buf.readUInt8(pos++);
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            Name: string
+        } = {
+            Name: ''
+        };
+        varLength = buf.readUInt8(pos++);
+        newObjData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarPicksReply.ts

@@ -0,0 +1,95 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarPicksReplyMessage implements MessageBase
+{
+    name = 'AvatarPicksReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AvatarPicksReply;
+
+    AgentData: {
+        AgentID: UUID;
+        TargetID: UUID;
+    };
+    Data: {
+        PickID: UUID;
+        PickName: string;
+    }[];
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.Data, 'PickName', 1) + 16) * this.Data.length) + 33;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['TargetID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.Data.length;
+        buf.writeUInt8(this.Data.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.Data[i]['PickID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.Data[i]['PickName'].length, pos++);
+            buf.write(this.Data[i]['PickName'], pos);
+            pos += this.Data[i]['PickName'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            TargetID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            TargetID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['TargetID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.Data = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjData: {
+                PickID: UUID,
+                PickName: string
+            } = {
+                PickID: UUID.zero(),
+                PickName: ''
+            };
+            newObjData['PickID'] = new UUID(buf, pos);
+            pos += 16;
+            varLength = buf.readUInt8(pos++);
+            newObjData['PickName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.Data.push(newObjData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarPropertiesReply.ts

@@ -0,0 +1,134 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarPropertiesReplyMessage implements MessageBase
+{
+    name = 'AvatarPropertiesReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AvatarPropertiesReply;
+
+    AgentData: {
+        AgentID: UUID;
+        AvatarID: UUID;
+    };
+    PropertiesData: {
+        ImageID: UUID;
+        FLImageID: UUID;
+        PartnerID: UUID;
+        AboutText: string;
+        FLAboutText: string;
+        BornOn: string;
+        ProfileURL: string;
+        CharterMember: string;
+        Flags: number;
+    };
+
+    getSize(): number
+    {
+        return (this.PropertiesData['AboutText'].length + 2 + this.PropertiesData['FLAboutText'].length + 1 + this.PropertiesData['BornOn'].length + 1 + this.PropertiesData['ProfileURL'].length + 1 + this.PropertiesData['CharterMember'].length + 1) + 84;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['AvatarID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.PropertiesData['ImageID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.PropertiesData['FLImageID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.PropertiesData['PartnerID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt16LE(this.PropertiesData['AboutText'].length, pos);
+        pos += 2;
+        buf.write(this.PropertiesData['AboutText'], pos);
+        pos += this.PropertiesData['AboutText'].length;
+        buf.writeUInt8(this.PropertiesData['FLAboutText'].length, pos++);
+        buf.write(this.PropertiesData['FLAboutText'], pos);
+        pos += this.PropertiesData['FLAboutText'].length;
+        buf.writeUInt8(this.PropertiesData['BornOn'].length, pos++);
+        buf.write(this.PropertiesData['BornOn'], pos);
+        pos += this.PropertiesData['BornOn'].length;
+        buf.writeUInt8(this.PropertiesData['ProfileURL'].length, pos++);
+        buf.write(this.PropertiesData['ProfileURL'], pos);
+        pos += this.PropertiesData['ProfileURL'].length;
+        buf.writeUInt8(this.PropertiesData['CharterMember'].length, pos++);
+        buf.write(this.PropertiesData['CharterMember'], pos);
+        pos += this.PropertiesData['CharterMember'].length;
+        buf.writeUInt32LE(this.PropertiesData['Flags'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            AvatarID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            AvatarID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['AvatarID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjPropertiesData: {
+            ImageID: UUID,
+            FLImageID: UUID,
+            PartnerID: UUID,
+            AboutText: string,
+            FLAboutText: string,
+            BornOn: string,
+            ProfileURL: string,
+            CharterMember: string,
+            Flags: number
+        } = {
+            ImageID: UUID.zero(),
+            FLImageID: UUID.zero(),
+            PartnerID: UUID.zero(),
+            AboutText: '',
+            FLAboutText: '',
+            BornOn: '',
+            ProfileURL: '',
+            CharterMember: '',
+            Flags: 0
+        };
+        newObjPropertiesData['ImageID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjPropertiesData['FLImageID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjPropertiesData['PartnerID'] = new UUID(buf, pos);
+        pos += 16;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjPropertiesData['AboutText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['FLAboutText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['BornOn'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['ProfileURL'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['CharterMember'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjPropertiesData['Flags'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.PropertiesData = newObjPropertiesData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarPropertiesRequest.ts

@@ -0,0 +1,60 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarPropertiesRequestMessage implements MessageBase
+{
+    name = 'AvatarPropertiesRequest';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.AvatarPropertiesRequest;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        AvatarID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 48;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['AvatarID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            AvatarID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            AvatarID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['AvatarID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarPropertiesRequestBackend.ts

@@ -0,0 +1,63 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarPropertiesRequestBackendMessage implements MessageBase
+{
+    name = 'AvatarPropertiesRequestBackend';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.AvatarPropertiesRequestBackend;
+
+    AgentData: {
+        AgentID: UUID;
+        AvatarID: UUID;
+        GodLevel: number;
+        WebProfilesDisabled: boolean;
+    };
+
+    getSize(): number
+    {
+        return 34;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['AvatarID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.AgentData['GodLevel'], pos++);
+        buf.writeUInt8((this.AgentData['WebProfilesDisabled']) ? 1 : 0, pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            AvatarID: UUID,
+            GodLevel: number,
+            WebProfilesDisabled: boolean
+        } = {
+            AgentID: UUID.zero(),
+            AvatarID: UUID.zero(),
+            GodLevel: 0,
+            WebProfilesDisabled: false
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['AvatarID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['GodLevel'] = buf.readUInt8(pos++);
+        newObjAgentData['WebProfilesDisabled'] = (buf.readUInt8(pos++) === 1);
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarPropertiesUpdate.ts

@@ -0,0 +1,112 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarPropertiesUpdateMessage implements MessageBase
+{
+    name = 'AvatarPropertiesUpdate';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AvatarPropertiesUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    PropertiesData: {
+        ImageID: UUID;
+        FLImageID: UUID;
+        AboutText: string;
+        FLAboutText: string;
+        AllowPublish: boolean;
+        MaturePublish: boolean;
+        ProfileURL: string;
+    };
+
+    getSize(): number
+    {
+        return (this.PropertiesData['AboutText'].length + 2 + this.PropertiesData['FLAboutText'].length + 1 + this.PropertiesData['ProfileURL'].length + 1) + 66;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.PropertiesData['ImageID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.PropertiesData['FLImageID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt16LE(this.PropertiesData['AboutText'].length, pos);
+        pos += 2;
+        buf.write(this.PropertiesData['AboutText'], pos);
+        pos += this.PropertiesData['AboutText'].length;
+        buf.writeUInt8(this.PropertiesData['FLAboutText'].length, pos++);
+        buf.write(this.PropertiesData['FLAboutText'], pos);
+        pos += this.PropertiesData['FLAboutText'].length;
+        buf.writeUInt8((this.PropertiesData['AllowPublish']) ? 1 : 0, pos++);
+        buf.writeUInt8((this.PropertiesData['MaturePublish']) ? 1 : 0, pos++);
+        buf.writeUInt8(this.PropertiesData['ProfileURL'].length, pos++);
+        buf.write(this.PropertiesData['ProfileURL'], pos);
+        pos += this.PropertiesData['ProfileURL'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjPropertiesData: {
+            ImageID: UUID,
+            FLImageID: UUID,
+            AboutText: string,
+            FLAboutText: string,
+            AllowPublish: boolean,
+            MaturePublish: boolean,
+            ProfileURL: string
+        } = {
+            ImageID: UUID.zero(),
+            FLImageID: UUID.zero(),
+            AboutText: '',
+            FLAboutText: '',
+            AllowPublish: false,
+            MaturePublish: false,
+            ProfileURL: ''
+        };
+        newObjPropertiesData['ImageID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjPropertiesData['FLImageID'] = new UUID(buf, pos);
+        pos += 16;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjPropertiesData['AboutText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['FLAboutText'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjPropertiesData['AllowPublish'] = (buf.readUInt8(pos++) === 1);
+        newObjPropertiesData['MaturePublish'] = (buf.readUInt8(pos++) === 1);
+        varLength = buf.readUInt8(pos++);
+        newObjPropertiesData['ProfileURL'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.PropertiesData = newObjPropertiesData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarSitResponse.ts

@@ -0,0 +1,92 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {Quaternion} from '../Quaternion';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarSitResponseMessage implements MessageBase
+{
+    name = 'AvatarSitResponse';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyHigh;
+    id = Message.AvatarSitResponse;
+
+    SitObject: {
+        ID: UUID;
+    };
+    SitTransform: {
+        AutoPilot: boolean;
+        SitPosition: Vector3;
+        SitRotation: Quaternion;
+        CameraEyeOffset: Vector3;
+        CameraAtOffset: Vector3;
+        ForceMouselook: boolean;
+    };
+
+    getSize(): number
+    {
+        return 66;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.SitObject['ID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8((this.SitTransform['AutoPilot']) ? 1 : 0, pos++);
+        this.SitTransform['SitPosition'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.SitTransform['SitRotation'].writeToBuffer(buf, pos);
+        pos += 12;
+        this.SitTransform['CameraEyeOffset'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.SitTransform['CameraAtOffset'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        buf.writeUInt8((this.SitTransform['ForceMouselook']) ? 1 : 0, pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjSitObject: {
+            ID: UUID
+        } = {
+            ID: UUID.zero()
+        };
+        newObjSitObject['ID'] = new UUID(buf, pos);
+        pos += 16;
+        this.SitObject = newObjSitObject;
+        const newObjSitTransform: {
+            AutoPilot: boolean,
+            SitPosition: Vector3,
+            SitRotation: Quaternion,
+            CameraEyeOffset: Vector3,
+            CameraAtOffset: Vector3,
+            ForceMouselook: boolean
+        } = {
+            AutoPilot: false,
+            SitPosition: Vector3.getZero(),
+            SitRotation: Quaternion.getIdentity(),
+            CameraEyeOffset: Vector3.getZero(),
+            CameraAtOffset: Vector3.getZero(),
+            ForceMouselook: false
+        };
+        newObjSitTransform['AutoPilot'] = (buf.readUInt8(pos++) === 1);
+        newObjSitTransform['SitPosition'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjSitTransform['SitRotation'] = new Quaternion(buf, pos);
+        pos += 12;
+        newObjSitTransform['CameraEyeOffset'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjSitTransform['CameraAtOffset'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjSitTransform['ForceMouselook'] = (buf.readUInt8(pos++) === 1);
+        this.SitTransform = newObjSitTransform;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/AvatarTextureUpdate.ts

@@ -0,0 +1,121 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class AvatarTextureUpdateMessage implements MessageBase
+{
+    name = 'AvatarTextureUpdate';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.AvatarTextureUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+        TexturesChanged: boolean;
+    };
+    WearableData: {
+        CacheID: UUID;
+        TextureIndex: number;
+        HostName: string;
+    }[];
+    TextureData: {
+        TextureID: UUID;
+    }[];
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.WearableData, 'HostName', 1) + 17) * this.WearableData.length) + ((16) * this.TextureData.length) + 19;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8((this.AgentData['TexturesChanged']) ? 1 : 0, pos++);
+        let count = this.WearableData.length;
+        buf.writeUInt8(this.WearableData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.WearableData[i]['CacheID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.WearableData[i]['TextureIndex'], pos++);
+            buf.writeUInt8(this.WearableData[i]['HostName'].length, pos++);
+            buf.write(this.WearableData[i]['HostName'], pos);
+            pos += this.WearableData[i]['HostName'].length;
+        }
+        count = this.TextureData.length;
+        buf.writeUInt8(this.TextureData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.TextureData[i]['TextureID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            TexturesChanged: boolean
+        } = {
+            AgentID: UUID.zero(),
+            TexturesChanged: false
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['TexturesChanged'] = (buf.readUInt8(pos++) === 1);
+        this.AgentData = newObjAgentData;
+        let count = buf.readUInt8(pos++);
+        this.WearableData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjWearableData: {
+                CacheID: UUID,
+                TextureIndex: number,
+                HostName: string
+            } = {
+                CacheID: UUID.zero(),
+                TextureIndex: 0,
+                HostName: ''
+            };
+            newObjWearableData['CacheID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjWearableData['TextureIndex'] = buf.readUInt8(pos++);
+            varLength = buf.readUInt8(pos++);
+            newObjWearableData['HostName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.WearableData.push(newObjWearableData);
+        }
+        count = buf.readUInt8(pos++);
+        this.TextureData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjTextureData: {
+                TextureID: UUID
+            } = {
+                TextureID: UUID.zero()
+            };
+            newObjTextureData['TextureID'] = new UUID(buf, pos);
+            pos += 16;
+            this.TextureData.push(newObjTextureData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/BulkUpdateInventory.ts

@@ -0,0 +1,273 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class BulkUpdateInventoryMessage implements MessageBase
+{
+    name = 'BulkUpdateInventory';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.BulkUpdateInventory;
+
+    AgentData: {
+        AgentID: UUID;
+        TransactionID: UUID;
+    };
+    FolderData: {
+        FolderID: UUID;
+        ParentID: UUID;
+        Type: number;
+        Name: string;
+    }[];
+    ItemData: {
+        ItemID: UUID;
+        CallbackID: number;
+        FolderID: UUID;
+        CreatorID: UUID;
+        OwnerID: UUID;
+        GroupID: UUID;
+        BaseMask: number;
+        OwnerMask: number;
+        GroupMask: number;
+        EveryoneMask: number;
+        NextOwnerMask: number;
+        GroupOwned: boolean;
+        AssetID: UUID;
+        Type: number;
+        InvType: number;
+        Flags: number;
+        SaleType: number;
+        SalePrice: number;
+        Name: string;
+        Description: string;
+        CreationDate: number;
+        CRC: number;
+    }[];
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.FolderData, 'Name', 1) + 33) * this.FolderData.length) + ((this.calculateVarVarSize(this.ItemData, 'Name', 1) + this.calculateVarVarSize(this.ItemData, 'Description', 1) + 140) * this.ItemData.length) + 34;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['TransactionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        let count = this.FolderData.length;
+        buf.writeUInt8(this.FolderData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.FolderData[i]['FolderID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.FolderData[i]['ParentID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeInt8(this.FolderData[i]['Type'], pos++);
+            buf.writeUInt8(this.FolderData[i]['Name'].length, pos++);
+            buf.write(this.FolderData[i]['Name'], pos);
+            pos += this.FolderData[i]['Name'].length;
+        }
+        count = this.ItemData.length;
+        buf.writeUInt8(this.ItemData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.ItemData[i]['ItemID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt32LE(this.ItemData[i]['CallbackID'], pos);
+            pos += 4;
+            this.ItemData[i]['FolderID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.ItemData[i]['CreatorID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.ItemData[i]['OwnerID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.ItemData[i]['GroupID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt32LE(this.ItemData[i]['BaseMask'], pos);
+            pos += 4;
+            buf.writeUInt32LE(this.ItemData[i]['OwnerMask'], pos);
+            pos += 4;
+            buf.writeUInt32LE(this.ItemData[i]['GroupMask'], pos);
+            pos += 4;
+            buf.writeUInt32LE(this.ItemData[i]['EveryoneMask'], pos);
+            pos += 4;
+            buf.writeUInt32LE(this.ItemData[i]['NextOwnerMask'], pos);
+            pos += 4;
+            buf.writeUInt8((this.ItemData[i]['GroupOwned']) ? 1 : 0, pos++);
+            this.ItemData[i]['AssetID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeInt8(this.ItemData[i]['Type'], pos++);
+            buf.writeInt8(this.ItemData[i]['InvType'], pos++);
+            buf.writeUInt32LE(this.ItemData[i]['Flags'], pos);
+            pos += 4;
+            buf.writeUInt8(this.ItemData[i]['SaleType'], pos++);
+            buf.writeInt32LE(this.ItemData[i]['SalePrice'], pos);
+            pos += 4;
+            buf.writeUInt8(this.ItemData[i]['Name'].length, pos++);
+            buf.write(this.ItemData[i]['Name'], pos);
+            pos += this.ItemData[i]['Name'].length;
+            buf.writeUInt8(this.ItemData[i]['Description'].length, pos++);
+            buf.write(this.ItemData[i]['Description'], pos);
+            pos += this.ItemData[i]['Description'].length;
+            buf.writeInt32LE(this.ItemData[i]['CreationDate'], pos);
+            pos += 4;
+            buf.writeUInt32LE(this.ItemData[i]['CRC'], pos);
+            pos += 4;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            TransactionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            TransactionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['TransactionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        let count = buf.readUInt8(pos++);
+        this.FolderData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjFolderData: {
+                FolderID: UUID,
+                ParentID: UUID,
+                Type: number,
+                Name: string
+            } = {
+                FolderID: UUID.zero(),
+                ParentID: UUID.zero(),
+                Type: 0,
+                Name: ''
+            };
+            newObjFolderData['FolderID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjFolderData['ParentID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjFolderData['Type'] = buf.readInt8(pos++);
+            varLength = buf.readUInt8(pos++);
+            newObjFolderData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.FolderData.push(newObjFolderData);
+        }
+        count = buf.readUInt8(pos++);
+        this.ItemData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjItemData: {
+                ItemID: UUID,
+                CallbackID: number,
+                FolderID: UUID,
+                CreatorID: UUID,
+                OwnerID: UUID,
+                GroupID: UUID,
+                BaseMask: number,
+                OwnerMask: number,
+                GroupMask: number,
+                EveryoneMask: number,
+                NextOwnerMask: number,
+                GroupOwned: boolean,
+                AssetID: UUID,
+                Type: number,
+                InvType: number,
+                Flags: number,
+                SaleType: number,
+                SalePrice: number,
+                Name: string,
+                Description: string,
+                CreationDate: number,
+                CRC: number
+            } = {
+                ItemID: UUID.zero(),
+                CallbackID: 0,
+                FolderID: UUID.zero(),
+                CreatorID: UUID.zero(),
+                OwnerID: UUID.zero(),
+                GroupID: UUID.zero(),
+                BaseMask: 0,
+                OwnerMask: 0,
+                GroupMask: 0,
+                EveryoneMask: 0,
+                NextOwnerMask: 0,
+                GroupOwned: false,
+                AssetID: UUID.zero(),
+                Type: 0,
+                InvType: 0,
+                Flags: 0,
+                SaleType: 0,
+                SalePrice: 0,
+                Name: '',
+                Description: '',
+                CreationDate: 0,
+                CRC: 0
+            };
+            newObjItemData['ItemID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjItemData['CallbackID'] = buf.readUInt32LE(pos);
+            pos += 4;
+            newObjItemData['FolderID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjItemData['CreatorID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjItemData['OwnerID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjItemData['GroupID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjItemData['BaseMask'] = buf.readUInt32LE(pos);
+            pos += 4;
+            newObjItemData['OwnerMask'] = buf.readUInt32LE(pos);
+            pos += 4;
+            newObjItemData['GroupMask'] = buf.readUInt32LE(pos);
+            pos += 4;
+            newObjItemData['EveryoneMask'] = buf.readUInt32LE(pos);
+            pos += 4;
+            newObjItemData['NextOwnerMask'] = buf.readUInt32LE(pos);
+            pos += 4;
+            newObjItemData['GroupOwned'] = (buf.readUInt8(pos++) === 1);
+            newObjItemData['AssetID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjItemData['Type'] = buf.readInt8(pos++);
+            newObjItemData['InvType'] = buf.readInt8(pos++);
+            newObjItemData['Flags'] = buf.readUInt32LE(pos);
+            pos += 4;
+            newObjItemData['SaleType'] = buf.readUInt8(pos++);
+            newObjItemData['SalePrice'] = buf.readInt32LE(pos);
+            pos += 4;
+            varLength = buf.readUInt8(pos++);
+            newObjItemData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            varLength = buf.readUInt8(pos++);
+            newObjItemData['Description'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            newObjItemData['CreationDate'] = buf.readInt32LE(pos);
+            pos += 4;
+            newObjItemData['CRC'] = buf.readUInt32LE(pos);
+            pos += 4;
+            this.ItemData.push(newObjItemData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/BuyObjectInventory.ts

@@ -0,0 +1,80 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class BuyObjectInventoryMessage implements MessageBase
+{
+    name = 'BuyObjectInventory';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.BuyObjectInventory;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    Data: {
+        ObjectID: UUID;
+        ItemID: UUID;
+        FolderID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 80;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['ObjectID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['ItemID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['FolderID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            ObjectID: UUID,
+            ItemID: UUID,
+            FolderID: UUID
+        } = {
+            ObjectID: UUID.zero(),
+            ItemID: UUID.zero(),
+            FolderID: UUID.zero()
+        };
+        newObjData['ObjectID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['ItemID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['FolderID'] = new UUID(buf, pos);
+        pos += 16;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CameraConstraint.ts

@@ -0,0 +1,46 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {Vector4} from '../Vector4';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CameraConstraintMessage implements MessageBase
+{
+    name = 'CameraConstraint';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyHigh;
+    id = Message.CameraConstraint;
+
+    CameraCollidePlane: {
+        Plane: Vector4;
+    };
+
+    getSize(): number
+    {
+        return 16;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.CameraCollidePlane['Plane'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjCameraCollidePlane: {
+            Plane: Vector4
+        } = {
+            Plane: Vector4.getZero()
+        };
+        newObjCameraCollidePlane['Plane'] = new Vector4(buf, pos);
+        pos += 16;
+        this.CameraCollidePlane = newObjCameraCollidePlane;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CancelAuction.ts

@@ -0,0 +1,56 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CancelAuctionMessage implements MessageBase
+{
+    name = 'CancelAuction';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.CancelAuction;
+
+    ParcelData: {
+        ParcelID: UUID;
+    }[];
+
+    getSize(): number
+    {
+        return ((16) * this.ParcelData.length) + 1;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        const count = this.ParcelData.length;
+        buf.writeUInt8(this.ParcelData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.ParcelData[i]['ParcelID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const count = buf.readUInt8(pos++);
+        this.ParcelData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjParcelData: {
+                ParcelID: UUID
+            } = {
+                ParcelID: UUID.zero()
+            };
+            newObjParcelData['ParcelID'] = new UUID(buf, pos);
+            pos += 16;
+            this.ParcelData.push(newObjParcelData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChangeInventoryItemFlags.ts

@@ -0,0 +1,83 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChangeInventoryItemFlagsMessage implements MessageBase
+{
+    name = 'ChangeInventoryItemFlags';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.ChangeInventoryItemFlags;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    InventoryData: {
+        ItemID: UUID;
+        Flags: number;
+    }[];
+
+    getSize(): number
+    {
+        return ((20) * this.InventoryData.length) + 33;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.InventoryData.length;
+        buf.writeUInt8(this.InventoryData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.InventoryData[i]['ItemID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt32LE(this.InventoryData[i]['Flags'], pos);
+            pos += 4;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.InventoryData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjInventoryData: {
+                ItemID: UUID,
+                Flags: number
+            } = {
+                ItemID: UUID.zero(),
+                Flags: 0
+            };
+            newObjInventoryData['ItemID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjInventoryData['Flags'] = buf.readUInt32LE(pos);
+            pos += 4;
+            this.InventoryData.push(newObjInventoryData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChangeUserRights.ts

@@ -0,0 +1,76 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChangeUserRightsMessage implements MessageBase
+{
+    name = 'ChangeUserRights';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.ChangeUserRights;
+
+    AgentData: {
+        AgentID: UUID;
+    };
+    Rights: {
+        AgentRelated: UUID;
+        RelatedRights: number;
+    }[];
+
+    getSize(): number
+    {
+        return ((20) * this.Rights.length) + 17;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.Rights.length;
+        buf.writeUInt8(this.Rights.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.Rights[i]['AgentRelated'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeInt32LE(this.Rights[i]['RelatedRights'], pos);
+            pos += 4;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID
+        } = {
+            AgentID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.Rights = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjRights: {
+                AgentRelated: UUID,
+                RelatedRights: number
+            } = {
+                AgentRelated: UUID.zero(),
+                RelatedRights: 0
+            };
+            newObjRights['AgentRelated'] = new UUID(buf, pos);
+            pos += 16;
+            newObjRights['RelatedRights'] = buf.readInt32LE(pos);
+            pos += 4;
+            this.Rights.push(newObjRights);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChatFromSimulator.ts

@@ -0,0 +1,96 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChatFromSimulatorMessage implements MessageBase
+{
+    name = 'ChatFromSimulator';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.ChatFromSimulator;
+
+    ChatData: {
+        FromName: string;
+        SourceID: UUID;
+        OwnerID: UUID;
+        SourceType: number;
+        ChatType: number;
+        Audible: number;
+        Position: Vector3;
+        Message: string;
+    };
+
+    getSize(): number
+    {
+        return (this.ChatData['FromName'].length + 1 + this.ChatData['Message'].length + 2) + 47;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeUInt8(this.ChatData['FromName'].length, pos++);
+        buf.write(this.ChatData['FromName'], pos);
+        pos += this.ChatData['FromName'].length;
+        this.ChatData['SourceID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.ChatData['OwnerID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.ChatData['SourceType'], pos++);
+        buf.writeUInt8(this.ChatData['ChatType'], pos++);
+        buf.writeUInt8(this.ChatData['Audible'], pos++);
+        this.ChatData['Position'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        buf.writeUInt16LE(this.ChatData['Message'].length, pos);
+        pos += 2;
+        buf.write(this.ChatData['Message'], pos);
+        pos += this.ChatData['Message'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjChatData: {
+            FromName: string,
+            SourceID: UUID,
+            OwnerID: UUID,
+            SourceType: number,
+            ChatType: number,
+            Audible: number,
+            Position: Vector3,
+            Message: string
+        } = {
+            FromName: '',
+            SourceID: UUID.zero(),
+            OwnerID: UUID.zero(),
+            SourceType: 0,
+            ChatType: 0,
+            Audible: 0,
+            Position: Vector3.getZero(),
+            Message: ''
+        };
+        varLength = buf.readUInt8(pos++);
+        newObjChatData['FromName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjChatData['SourceID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjChatData['OwnerID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjChatData['SourceType'] = buf.readUInt8(pos++);
+        newObjChatData['ChatType'] = buf.readUInt8(pos++);
+        newObjChatData['Audible'] = buf.readUInt8(pos++);
+        newObjChatData['Position'] = new Vector3(buf, pos, false);
+        pos += 12;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjChatData['Message'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.ChatData = newObjChatData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChatFromViewer.ts

@@ -0,0 +1,82 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChatFromViewerMessage implements MessageBase
+{
+    name = 'ChatFromViewer';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.ChatFromViewer;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    ChatData: {
+        Message: string;
+        Type: number;
+        Channel: number;
+    };
+
+    getSize(): number
+    {
+        return (this.ChatData['Message'].length + 2) + 37;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt16LE(this.ChatData['Message'].length, pos);
+        pos += 2;
+        buf.write(this.ChatData['Message'], pos);
+        pos += this.ChatData['Message'].length;
+        buf.writeUInt8(this.ChatData['Type'], pos++);
+        buf.writeInt32LE(this.ChatData['Channel'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjChatData: {
+            Message: string,
+            Type: number,
+            Channel: number
+        } = {
+            Message: '',
+            Type: 0,
+            Channel: 0
+        };
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjChatData['Message'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjChatData['Type'] = buf.readUInt8(pos++);
+        newObjChatData['Channel'] = buf.readInt32LE(pos);
+        pos += 4;
+        this.ChatData = newObjChatData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChatPass.ts

@@ -0,0 +1,110 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChatPassMessage implements MessageBase
+{
+    name = 'ChatPass';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.ChatPass;
+
+    ChatData: {
+        Channel: number;
+        Position: Vector3;
+        ID: UUID;
+        OwnerID: UUID;
+        Name: string;
+        SourceType: number;
+        Type: number;
+        Radius: number;
+        SimAccess: number;
+        Message: string;
+    };
+
+    getSize(): number
+    {
+        return (this.ChatData['Name'].length + 1 + this.ChatData['Message'].length + 2) + 55;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeInt32LE(this.ChatData['Channel'], pos);
+        pos += 4;
+        this.ChatData['Position'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.ChatData['ID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.ChatData['OwnerID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.ChatData['Name'].length, pos++);
+        buf.write(this.ChatData['Name'], pos);
+        pos += this.ChatData['Name'].length;
+        buf.writeUInt8(this.ChatData['SourceType'], pos++);
+        buf.writeUInt8(this.ChatData['Type'], pos++);
+        buf.writeFloatLE(this.ChatData['Radius'], pos);
+        pos += 4;
+        buf.writeUInt8(this.ChatData['SimAccess'], pos++);
+        buf.writeUInt16LE(this.ChatData['Message'].length, pos);
+        pos += 2;
+        buf.write(this.ChatData['Message'], pos);
+        pos += this.ChatData['Message'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjChatData: {
+            Channel: number,
+            Position: Vector3,
+            ID: UUID,
+            OwnerID: UUID,
+            Name: string,
+            SourceType: number,
+            Type: number,
+            Radius: number,
+            SimAccess: number,
+            Message: string
+        } = {
+            Channel: 0,
+            Position: Vector3.getZero(),
+            ID: UUID.zero(),
+            OwnerID: UUID.zero(),
+            Name: '',
+            SourceType: 0,
+            Type: 0,
+            Radius: 0,
+            SimAccess: 0,
+            Message: ''
+        };
+        newObjChatData['Channel'] = buf.readInt32LE(pos);
+        pos += 4;
+        newObjChatData['Position'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjChatData['ID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjChatData['OwnerID'] = new UUID(buf, pos);
+        pos += 16;
+        varLength = buf.readUInt8(pos++);
+        newObjChatData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjChatData['SourceType'] = buf.readUInt8(pos++);
+        newObjChatData['Type'] = buf.readUInt8(pos++);
+        newObjChatData['Radius'] = buf.readFloatLE(pos);
+        pos += 4;
+        newObjChatData['SimAccess'] = buf.readUInt8(pos++);
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjChatData['Message'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.ChatData = newObjChatData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CheckParcelAuctions.ts

@@ -0,0 +1,58 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CheckParcelAuctionsMessage implements MessageBase
+{
+    name = 'CheckParcelAuctions';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.CheckParcelAuctions;
+
+    RegionData: {
+        RegionHandle: Long;
+    }[];
+
+    getSize(): number
+    {
+        return ((8) * this.RegionData.length) + 1;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        const count = this.RegionData.length;
+        buf.writeUInt8(this.RegionData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeInt32LE(this.RegionData[i]['RegionHandle'].low, pos);
+            pos += 4;
+            buf.writeInt32LE(this.RegionData[i]['RegionHandle'].high, pos);
+            pos += 4;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const count = buf.readUInt8(pos++);
+        this.RegionData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjRegionData: {
+                RegionHandle: Long
+            } = {
+                RegionHandle: Long.ZERO
+            };
+            newObjRegionData['RegionHandle'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+            pos += 8;
+            this.RegionData.push(newObjRegionData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CheckParcelSales.ts

@@ -0,0 +1,58 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CheckParcelSalesMessage implements MessageBase
+{
+    name = 'CheckParcelSales';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.CheckParcelSales;
+
+    RegionData: {
+        RegionHandle: Long;
+    }[];
+
+    getSize(): number
+    {
+        return ((8) * this.RegionData.length) + 1;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        const count = this.RegionData.length;
+        buf.writeUInt8(this.RegionData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeInt32LE(this.RegionData[i]['RegionHandle'].low, pos);
+            pos += 4;
+            buf.writeInt32LE(this.RegionData[i]['RegionHandle'].high, pos);
+            pos += 4;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const count = buf.readUInt8(pos++);
+        this.RegionData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjRegionData: {
+                RegionHandle: Long
+            } = {
+                RegionHandle: Long.ZERO
+            };
+            newObjRegionData['RegionHandle'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+            pos += 8;
+            this.RegionData.push(newObjRegionData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChildAgentAlive.ts

@@ -0,0 +1,70 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChildAgentAliveMessage implements MessageBase
+{
+    name = 'ChildAgentAlive';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyHigh;
+    id = Message.ChildAgentAlive;
+
+    AgentData: {
+        RegionHandle: Long;
+        ViewerCircuitCode: number;
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 44;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeInt32LE(this.AgentData['RegionHandle'].low, pos);
+        pos += 4;
+        buf.writeInt32LE(this.AgentData['RegionHandle'].high, pos);
+        pos += 4;
+        buf.writeUInt32LE(this.AgentData['ViewerCircuitCode'], pos);
+        pos += 4;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            RegionHandle: Long,
+            ViewerCircuitCode: number,
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            RegionHandle: Long.ZERO,
+            ViewerCircuitCode: 0,
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['RegionHandle'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+        pos += 8;
+        newObjAgentData['ViewerCircuitCode'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChildAgentDying.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChildAgentDyingMessage implements MessageBase
+{
+    name = 'ChildAgentDying';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.ChildAgentDying;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 32;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChildAgentPositionUpdate.ts

@@ -0,0 +1,125 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChildAgentPositionUpdateMessage implements MessageBase
+{
+    name = 'ChildAgentPositionUpdate';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyHigh;
+    id = Message.ChildAgentPositionUpdate;
+
+    AgentData: {
+        RegionHandle: Long;
+        ViewerCircuitCode: number;
+        AgentID: UUID;
+        SessionID: UUID;
+        AgentPos: Vector3;
+        AgentVel: Vector3;
+        Center: Vector3;
+        Size: Vector3;
+        AtAxis: Vector3;
+        LeftAxis: Vector3;
+        UpAxis: Vector3;
+        ChangedGrid: boolean;
+    };
+
+    getSize(): number
+    {
+        return 129;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeInt32LE(this.AgentData['RegionHandle'].low, pos);
+        pos += 4;
+        buf.writeInt32LE(this.AgentData['RegionHandle'].high, pos);
+        pos += 4;
+        buf.writeUInt32LE(this.AgentData['ViewerCircuitCode'], pos);
+        pos += 4;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['AgentPos'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['AgentVel'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['Center'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['Size'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['AtAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['LeftAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['UpAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        buf.writeUInt8((this.AgentData['ChangedGrid']) ? 1 : 0, pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            RegionHandle: Long,
+            ViewerCircuitCode: number,
+            AgentID: UUID,
+            SessionID: UUID,
+            AgentPos: Vector3,
+            AgentVel: Vector3,
+            Center: Vector3,
+            Size: Vector3,
+            AtAxis: Vector3,
+            LeftAxis: Vector3,
+            UpAxis: Vector3,
+            ChangedGrid: boolean
+        } = {
+            RegionHandle: Long.ZERO,
+            ViewerCircuitCode: 0,
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            AgentPos: Vector3.getZero(),
+            AgentVel: Vector3.getZero(),
+            Center: Vector3.getZero(),
+            Size: Vector3.getZero(),
+            AtAxis: Vector3.getZero(),
+            LeftAxis: Vector3.getZero(),
+            UpAxis: Vector3.getZero(),
+            ChangedGrid: false
+        };
+        newObjAgentData['RegionHandle'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+        pos += 8;
+        newObjAgentData['ViewerCircuitCode'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['AgentPos'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['AgentVel'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['Center'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['Size'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['AtAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['LeftAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['UpAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['ChangedGrid'] = (buf.readUInt8(pos++) === 1);
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChildAgentUnknown.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChildAgentUnknownMessage implements MessageBase
+{
+    name = 'ChildAgentUnknown';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.ChildAgentUnknown;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 32;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ChildAgentUpdate.ts

@@ -0,0 +1,446 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import Long = require('long');
+import {Quaternion} from '../Quaternion';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ChildAgentUpdateMessage implements MessageBase
+{
+    name = 'ChildAgentUpdate';
+    messageFlags = MessageFlags.Trusted | MessageFlags.Zerocoded | MessageFlags.FrequencyHigh;
+    id = Message.ChildAgentUpdate;
+
+    AgentData: {
+        RegionHandle: Long;
+        ViewerCircuitCode: number;
+        AgentID: UUID;
+        SessionID: UUID;
+        AgentPos: Vector3;
+        AgentVel: Vector3;
+        Center: Vector3;
+        Size: Vector3;
+        AtAxis: Vector3;
+        LeftAxis: Vector3;
+        UpAxis: Vector3;
+        ChangedGrid: boolean;
+        Far: number;
+        Aspect: number;
+        Throttles: string;
+        LocomotionState: number;
+        HeadRotation: Quaternion;
+        BodyRotation: Quaternion;
+        ControlFlags: number;
+        EnergyLevel: number;
+        GodLevel: number;
+        AlwaysRun: boolean;
+        PreyAgent: UUID;
+        AgentAccess: number;
+        AgentTextures: string;
+        ActiveGroupID: UUID;
+    };
+    GroupData: {
+        GroupID: UUID;
+        GroupPowers: Long;
+        AcceptNotices: boolean;
+    }[];
+    AnimationData: {
+        Animation: UUID;
+        ObjectID: UUID;
+    }[];
+    GranterBlock: {
+        GranterID: UUID;
+    }[];
+    NVPairData: {
+        NVPairs: string;
+    }[];
+    VisualParam: {
+        ParamValue: number;
+    }[];
+    AgentAccess: {
+        AgentLegacyAccess: number;
+        AgentMaxAccess: number;
+    }[];
+    AgentInfo: {
+        Flags: number;
+    }[];
+    AgentInventoryHost: {
+        InventoryHost: string;
+    }[];
+
+    getSize(): number
+    {
+        return (this.AgentData['Throttles'].length + 1 + this.AgentData['AgentTextures'].length + 2) + ((25) * this.GroupData.length) + ((32) * this.AnimationData.length) + ((16) * this.GranterBlock.length) + ((this.calculateVarVarSize(this.NVPairData, 'NVPairs', 2)) * this.NVPairData.length) + ((1) * this.VisualParam.length) + ((2) * this.AgentAccess.length) + ((4) * this.AgentInfo.length) + ((this.calculateVarVarSize(this.AgentInventoryHost, 'InventoryHost', 1)) * this.AgentInventoryHost.length) + 216;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeInt32LE(this.AgentData['RegionHandle'].low, pos);
+        pos += 4;
+        buf.writeInt32LE(this.AgentData['RegionHandle'].high, pos);
+        pos += 4;
+        buf.writeUInt32LE(this.AgentData['ViewerCircuitCode'], pos);
+        pos += 4;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['AgentPos'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['AgentVel'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['Center'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['Size'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['AtAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['LeftAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        this.AgentData['UpAxis'].writeToBuffer(buf, pos, false);
+        pos += 12;
+        buf.writeUInt8((this.AgentData['ChangedGrid']) ? 1 : 0, pos++);
+        buf.writeFloatLE(this.AgentData['Far'], pos);
+        pos += 4;
+        buf.writeFloatLE(this.AgentData['Aspect'], pos);
+        pos += 4;
+        buf.writeUInt8(this.AgentData['Throttles'].length, pos++);
+        buf.write(this.AgentData['Throttles'], pos);
+        pos += this.AgentData['Throttles'].length;
+        buf.writeUInt32LE(this.AgentData['LocomotionState'], pos);
+        pos += 4;
+        this.AgentData['HeadRotation'].writeToBuffer(buf, pos);
+        pos += 12;
+        this.AgentData['BodyRotation'].writeToBuffer(buf, pos);
+        pos += 12;
+        buf.writeUInt32LE(this.AgentData['ControlFlags'], pos);
+        pos += 4;
+        buf.writeFloatLE(this.AgentData['EnergyLevel'], pos);
+        pos += 4;
+        buf.writeUInt8(this.AgentData['GodLevel'], pos++);
+        buf.writeUInt8((this.AgentData['AlwaysRun']) ? 1 : 0, pos++);
+        this.AgentData['PreyAgent'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.AgentData['AgentAccess'], pos++);
+        buf.writeUInt16LE(this.AgentData['AgentTextures'].length, pos);
+        pos += 2;
+        buf.write(this.AgentData['AgentTextures'], pos);
+        pos += this.AgentData['AgentTextures'].length;
+        this.AgentData['ActiveGroupID'].writeToBuffer(buf, pos);
+        pos += 16;
+        let count = this.GroupData.length;
+        buf.writeUInt8(this.GroupData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.GroupData[i]['GroupID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeInt32LE(this.GroupData[i]['GroupPowers'].low, pos);
+            pos += 4;
+            buf.writeInt32LE(this.GroupData[i]['GroupPowers'].high, pos);
+            pos += 4;
+            buf.writeUInt8((this.GroupData[i]['AcceptNotices']) ? 1 : 0, pos++);
+        }
+        count = this.AnimationData.length;
+        buf.writeUInt8(this.AnimationData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.AnimationData[i]['Animation'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.AnimationData[i]['ObjectID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        count = this.GranterBlock.length;
+        buf.writeUInt8(this.GranterBlock.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.GranterBlock[i]['GranterID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        count = this.NVPairData.length;
+        buf.writeUInt8(this.NVPairData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt16LE(this.NVPairData[i]['NVPairs'].length, pos);
+            pos += 2;
+            buf.write(this.NVPairData[i]['NVPairs'], pos);
+            pos += this.NVPairData[i]['NVPairs'].length;
+        }
+        count = this.VisualParam.length;
+        buf.writeUInt8(this.VisualParam.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.VisualParam[i]['ParamValue'], pos++);
+        }
+        count = this.AgentAccess.length;
+        buf.writeUInt8(this.AgentAccess.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.AgentAccess[i]['AgentLegacyAccess'], pos++);
+            buf.writeUInt8(this.AgentAccess[i]['AgentMaxAccess'], pos++);
+        }
+        count = this.AgentInfo.length;
+        buf.writeUInt8(this.AgentInfo.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt32LE(this.AgentInfo[i]['Flags'], pos);
+            pos += 4;
+        }
+        count = this.AgentInventoryHost.length;
+        buf.writeUInt8(this.AgentInventoryHost.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.AgentInventoryHost[i]['InventoryHost'].length, pos++);
+            buf.write(this.AgentInventoryHost[i]['InventoryHost'], pos);
+            pos += this.AgentInventoryHost[i]['InventoryHost'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            RegionHandle: Long,
+            ViewerCircuitCode: number,
+            AgentID: UUID,
+            SessionID: UUID,
+            AgentPos: Vector3,
+            AgentVel: Vector3,
+            Center: Vector3,
+            Size: Vector3,
+            AtAxis: Vector3,
+            LeftAxis: Vector3,
+            UpAxis: Vector3,
+            ChangedGrid: boolean,
+            Far: number,
+            Aspect: number,
+            Throttles: string,
+            LocomotionState: number,
+            HeadRotation: Quaternion,
+            BodyRotation: Quaternion,
+            ControlFlags: number,
+            EnergyLevel: number,
+            GodLevel: number,
+            AlwaysRun: boolean,
+            PreyAgent: UUID,
+            AgentAccess: number,
+            AgentTextures: string,
+            ActiveGroupID: UUID
+        } = {
+            RegionHandle: Long.ZERO,
+            ViewerCircuitCode: 0,
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            AgentPos: Vector3.getZero(),
+            AgentVel: Vector3.getZero(),
+            Center: Vector3.getZero(),
+            Size: Vector3.getZero(),
+            AtAxis: Vector3.getZero(),
+            LeftAxis: Vector3.getZero(),
+            UpAxis: Vector3.getZero(),
+            ChangedGrid: false,
+            Far: 0,
+            Aspect: 0,
+            Throttles: '',
+            LocomotionState: 0,
+            HeadRotation: Quaternion.getIdentity(),
+            BodyRotation: Quaternion.getIdentity(),
+            ControlFlags: 0,
+            EnergyLevel: 0,
+            GodLevel: 0,
+            AlwaysRun: false,
+            PreyAgent: UUID.zero(),
+            AgentAccess: 0,
+            AgentTextures: '',
+            ActiveGroupID: UUID.zero()
+        };
+        newObjAgentData['RegionHandle'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+        pos += 8;
+        newObjAgentData['ViewerCircuitCode'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['AgentPos'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['AgentVel'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['Center'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['Size'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['AtAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['LeftAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['UpAxis'] = new Vector3(buf, pos, false);
+        pos += 12;
+        newObjAgentData['ChangedGrid'] = (buf.readUInt8(pos++) === 1);
+        newObjAgentData['Far'] = buf.readFloatLE(pos);
+        pos += 4;
+        newObjAgentData['Aspect'] = buf.readFloatLE(pos);
+        pos += 4;
+        varLength = buf.readUInt8(pos++);
+        newObjAgentData['Throttles'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjAgentData['LocomotionState'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjAgentData['HeadRotation'] = new Quaternion(buf, pos);
+        pos += 12;
+        newObjAgentData['BodyRotation'] = new Quaternion(buf, pos);
+        pos += 12;
+        newObjAgentData['ControlFlags'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjAgentData['EnergyLevel'] = buf.readFloatLE(pos);
+        pos += 4;
+        newObjAgentData['GodLevel'] = buf.readUInt8(pos++);
+        newObjAgentData['AlwaysRun'] = (buf.readUInt8(pos++) === 1);
+        newObjAgentData['PreyAgent'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['AgentAccess'] = buf.readUInt8(pos++);
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjAgentData['AgentTextures'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjAgentData['ActiveGroupID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        let count = buf.readUInt8(pos++);
+        this.GroupData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjGroupData: {
+                GroupID: UUID,
+                GroupPowers: Long,
+                AcceptNotices: boolean
+            } = {
+                GroupID: UUID.zero(),
+                GroupPowers: Long.ZERO,
+                AcceptNotices: false
+            };
+            newObjGroupData['GroupID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjGroupData['GroupPowers'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+            pos += 8;
+            newObjGroupData['AcceptNotices'] = (buf.readUInt8(pos++) === 1);
+            this.GroupData.push(newObjGroupData);
+        }
+        count = buf.readUInt8(pos++);
+        this.AnimationData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAnimationData: {
+                Animation: UUID,
+                ObjectID: UUID
+            } = {
+                Animation: UUID.zero(),
+                ObjectID: UUID.zero()
+            };
+            newObjAnimationData['Animation'] = new UUID(buf, pos);
+            pos += 16;
+            newObjAnimationData['ObjectID'] = new UUID(buf, pos);
+            pos += 16;
+            this.AnimationData.push(newObjAnimationData);
+        }
+        count = buf.readUInt8(pos++);
+        this.GranterBlock = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjGranterBlock: {
+                GranterID: UUID
+            } = {
+                GranterID: UUID.zero()
+            };
+            newObjGranterBlock['GranterID'] = new UUID(buf, pos);
+            pos += 16;
+            this.GranterBlock.push(newObjGranterBlock);
+        }
+        count = buf.readUInt8(pos++);
+        this.NVPairData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjNVPairData: {
+                NVPairs: string
+            } = {
+                NVPairs: ''
+            };
+            varLength = buf.readUInt16LE(pos);
+            pos += 2;
+            newObjNVPairData['NVPairs'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.NVPairData.push(newObjNVPairData);
+        }
+        count = buf.readUInt8(pos++);
+        this.VisualParam = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjVisualParam: {
+                ParamValue: number
+            } = {
+                ParamValue: 0
+            };
+            newObjVisualParam['ParamValue'] = buf.readUInt8(pos++);
+            this.VisualParam.push(newObjVisualParam);
+        }
+        count = buf.readUInt8(pos++);
+        this.AgentAccess = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAgentAccess: {
+                AgentLegacyAccess: number,
+                AgentMaxAccess: number
+            } = {
+                AgentLegacyAccess: 0,
+                AgentMaxAccess: 0
+            };
+            newObjAgentAccess['AgentLegacyAccess'] = buf.readUInt8(pos++);
+            newObjAgentAccess['AgentMaxAccess'] = buf.readUInt8(pos++);
+            this.AgentAccess.push(newObjAgentAccess);
+        }
+        count = buf.readUInt8(pos++);
+        this.AgentInfo = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAgentInfo: {
+                Flags: number
+            } = {
+                Flags: 0
+            };
+            newObjAgentInfo['Flags'] = buf.readUInt32LE(pos);
+            pos += 4;
+            this.AgentInfo.push(newObjAgentInfo);
+        }
+        count = buf.readUInt8(pos++);
+        this.AgentInventoryHost = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAgentInventoryHost: {
+                InventoryHost: string
+            } = {
+                InventoryHost: ''
+            };
+            varLength = buf.readUInt8(pos++);
+            newObjAgentInventoryHost['InventoryHost'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.AgentInventoryHost.push(newObjAgentInventoryHost);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ClassifiedDelete.ts

@@ -0,0 +1,66 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ClassifiedDeleteMessage implements MessageBase
+{
+    name = 'ClassifiedDelete';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.ClassifiedDelete;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    Data: {
+        ClassifiedID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 48;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['ClassifiedID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            ClassifiedID: UUID
+        } = {
+            ClassifiedID: UUID.zero()
+        };
+        newObjData['ClassifiedID'] = new UUID(buf, pos);
+        pos += 16;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ClassifiedGodDelete.ts

@@ -0,0 +1,73 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ClassifiedGodDeleteMessage implements MessageBase
+{
+    name = 'ClassifiedGodDelete';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.ClassifiedGodDelete;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    Data: {
+        ClassifiedID: UUID;
+        QueryID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 64;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['ClassifiedID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['QueryID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            ClassifiedID: UUID,
+            QueryID: UUID
+        } = {
+            ClassifiedID: UUID.zero(),
+            QueryID: UUID.zero()
+        };
+        newObjData['ClassifiedID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['QueryID'] = new UUID(buf, pos);
+        pos += 16;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ClassifiedInfoReply.ts

@@ -0,0 +1,166 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ClassifiedInfoReplyMessage implements MessageBase
+{
+    name = 'ClassifiedInfoReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.ClassifiedInfoReply;
+
+    AgentData: {
+        AgentID: UUID;
+    };
+    Data: {
+        ClassifiedID: UUID;
+        CreatorID: UUID;
+        CreationDate: number;
+        ExpirationDate: number;
+        Category: number;
+        Name: string;
+        Desc: string;
+        ParcelID: UUID;
+        ParentEstate: number;
+        SnapshotID: UUID;
+        SimName: string;
+        PosGlobal: Vector3;
+        ParcelName: string;
+        ClassifiedFlags: number;
+        PriceForListing: number;
+    };
+
+    getSize(): number
+    {
+        return (this.Data['Name'].length + 1 + this.Data['Desc'].length + 2 + this.Data['SimName'].length + 1 + this.Data['ParcelName'].length + 1) + 125;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['ClassifiedID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['CreatorID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.Data['CreationDate'], pos);
+        pos += 4;
+        buf.writeUInt32LE(this.Data['ExpirationDate'], pos);
+        pos += 4;
+        buf.writeUInt32LE(this.Data['Category'], pos);
+        pos += 4;
+        buf.writeUInt8(this.Data['Name'].length, pos++);
+        buf.write(this.Data['Name'], pos);
+        pos += this.Data['Name'].length;
+        buf.writeUInt16LE(this.Data['Desc'].length, pos);
+        pos += 2;
+        buf.write(this.Data['Desc'], pos);
+        pos += this.Data['Desc'].length;
+        this.Data['ParcelID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.Data['ParentEstate'], pos);
+        pos += 4;
+        this.Data['SnapshotID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.Data['SimName'].length, pos++);
+        buf.write(this.Data['SimName'], pos);
+        pos += this.Data['SimName'].length;
+        this.Data['PosGlobal'].writeToBuffer(buf, pos, true);
+        pos += 24;
+        buf.writeUInt8(this.Data['ParcelName'].length, pos++);
+        buf.write(this.Data['ParcelName'], pos);
+        pos += this.Data['ParcelName'].length;
+        buf.writeUInt8(this.Data['ClassifiedFlags'], pos++);
+        buf.writeInt32LE(this.Data['PriceForListing'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID
+        } = {
+            AgentID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            ClassifiedID: UUID,
+            CreatorID: UUID,
+            CreationDate: number,
+            ExpirationDate: number,
+            Category: number,
+            Name: string,
+            Desc: string,
+            ParcelID: UUID,
+            ParentEstate: number,
+            SnapshotID: UUID,
+            SimName: string,
+            PosGlobal: Vector3,
+            ParcelName: string,
+            ClassifiedFlags: number,
+            PriceForListing: number
+        } = {
+            ClassifiedID: UUID.zero(),
+            CreatorID: UUID.zero(),
+            CreationDate: 0,
+            ExpirationDate: 0,
+            Category: 0,
+            Name: '',
+            Desc: '',
+            ParcelID: UUID.zero(),
+            ParentEstate: 0,
+            SnapshotID: UUID.zero(),
+            SimName: '',
+            PosGlobal: Vector3.getZero(),
+            ParcelName: '',
+            ClassifiedFlags: 0,
+            PriceForListing: 0
+        };
+        newObjData['ClassifiedID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['CreatorID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['CreationDate'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjData['ExpirationDate'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjData['Category'] = buf.readUInt32LE(pos);
+        pos += 4;
+        varLength = buf.readUInt8(pos++);
+        newObjData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjData['Desc'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjData['ParcelID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['ParentEstate'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjData['SnapshotID'] = new UUID(buf, pos);
+        pos += 16;
+        varLength = buf.readUInt8(pos++);
+        newObjData['SimName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjData['PosGlobal'] = new Vector3(buf, pos, true);
+        pos += 24;
+        varLength = buf.readUInt8(pos++);
+        newObjData['ParcelName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjData['ClassifiedFlags'] = buf.readUInt8(pos++);
+        newObjData['PriceForListing'] = buf.readInt32LE(pos);
+        pos += 4;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ClassifiedInfoRequest.ts

@@ -0,0 +1,66 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ClassifiedInfoRequestMessage implements MessageBase
+{
+    name = 'ClassifiedInfoRequest';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.ClassifiedInfoRequest;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    Data: {
+        ClassifiedID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 48;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['ClassifiedID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            ClassifiedID: UUID
+        } = {
+            ClassifiedID: UUID.zero()
+        };
+        newObjData['ClassifiedID'] = new UUID(buf, pos);
+        pos += 16;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ClassifiedInfoUpdate.ts

@@ -0,0 +1,134 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {Vector3} from '../Vector3';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ClassifiedInfoUpdateMessage implements MessageBase
+{
+    name = 'ClassifiedInfoUpdate';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.ClassifiedInfoUpdate;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    Data: {
+        ClassifiedID: UUID;
+        Category: number;
+        Name: string;
+        Desc: string;
+        ParcelID: UUID;
+        ParentEstate: number;
+        SnapshotID: UUID;
+        PosGlobal: Vector3;
+        ClassifiedFlags: number;
+        PriceForListing: number;
+    };
+
+    getSize(): number
+    {
+        return (this.Data['Name'].length + 1 + this.Data['Desc'].length + 2) + 117;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['ClassifiedID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.Data['Category'], pos);
+        pos += 4;
+        buf.writeUInt8(this.Data['Name'].length, pos++);
+        buf.write(this.Data['Name'], pos);
+        pos += this.Data['Name'].length;
+        buf.writeUInt16LE(this.Data['Desc'].length, pos);
+        pos += 2;
+        buf.write(this.Data['Desc'], pos);
+        pos += this.Data['Desc'].length;
+        this.Data['ParcelID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.Data['ParentEstate'], pos);
+        pos += 4;
+        this.Data['SnapshotID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.Data['PosGlobal'].writeToBuffer(buf, pos, true);
+        pos += 24;
+        buf.writeUInt8(this.Data['ClassifiedFlags'], pos++);
+        buf.writeInt32LE(this.Data['PriceForListing'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjData: {
+            ClassifiedID: UUID,
+            Category: number,
+            Name: string,
+            Desc: string,
+            ParcelID: UUID,
+            ParentEstate: number,
+            SnapshotID: UUID,
+            PosGlobal: Vector3,
+            ClassifiedFlags: number,
+            PriceForListing: number
+        } = {
+            ClassifiedID: UUID.zero(),
+            Category: 0,
+            Name: '',
+            Desc: '',
+            ParcelID: UUID.zero(),
+            ParentEstate: 0,
+            SnapshotID: UUID.zero(),
+            PosGlobal: Vector3.getZero(),
+            ClassifiedFlags: 0,
+            PriceForListing: 0
+        };
+        newObjData['ClassifiedID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['Category'] = buf.readUInt32LE(pos);
+        pos += 4;
+        varLength = buf.readUInt8(pos++);
+        newObjData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjData['Desc'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjData['ParcelID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['ParentEstate'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjData['SnapshotID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjData['PosGlobal'] = new Vector3(buf, pos, true);
+        pos += 24;
+        newObjData['ClassifiedFlags'] = buf.readUInt8(pos++);
+        newObjData['PriceForListing'] = buf.readInt32LE(pos);
+        pos += 4;
+        this.Data = newObjData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ClearFollowCamProperties.ts

@@ -0,0 +1,46 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ClearFollowCamPropertiesMessage implements MessageBase
+{
+    name = 'ClearFollowCamProperties';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.ClearFollowCamProperties;
+
+    ObjectData: {
+        ObjectID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 16;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.ObjectData['ObjectID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjObjectData: {
+            ObjectID: UUID
+        } = {
+            ObjectID: UUID.zero()
+        };
+        newObjObjectData['ObjectID'] = new UUID(buf, pos);
+        pos += 16;
+        this.ObjectData = newObjObjectData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CloseCircuit.ts

@@ -0,0 +1,29 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CloseCircuitMessage implements MessageBase
+{
+    name = 'CloseCircuit';
+    messageFlags = MessageFlags.FrequencyFixed;
+    id = Message.CloseCircuit;
+
+
+    getSize(): number
+    {
+        return 0;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        return 0;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        return 0;
+    }
+}
+

lib/classes/messages/CoarseLocationUpdate.ts

@@ -0,0 +1,107 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CoarseLocationUpdateMessage implements MessageBase
+{
+    name = 'CoarseLocationUpdate';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyMedium;
+    id = Message.CoarseLocationUpdate;
+
+    Location: {
+        X: number;
+        Y: number;
+        Z: number;
+    }[];
+    Index: {
+        You: number;
+        Prey: number;
+    };
+    AgentData: {
+        AgentID: UUID;
+    }[];
+
+    getSize(): number
+    {
+        return ((3) * this.Location.length) + ((16) * this.AgentData.length) + 6;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let count = this.Location.length;
+        buf.writeUInt8(this.Location.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt8(this.Location[i]['X'], pos++);
+            buf.writeUInt8(this.Location[i]['Y'], pos++);
+            buf.writeUInt8(this.Location[i]['Z'], pos++);
+        }
+        buf.writeInt16LE(this.Index['You'], pos);
+        pos += 2;
+        buf.writeInt16LE(this.Index['Prey'], pos);
+        pos += 2;
+        count = this.AgentData.length;
+        buf.writeUInt8(this.AgentData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.AgentData[i]['AgentID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        let count = buf.readUInt8(pos++);
+        this.Location = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjLocation: {
+                X: number,
+                Y: number,
+                Z: number
+            } = {
+                X: 0,
+                Y: 0,
+                Z: 0
+            };
+            newObjLocation['X'] = buf.readUInt8(pos++);
+            newObjLocation['Y'] = buf.readUInt8(pos++);
+            newObjLocation['Z'] = buf.readUInt8(pos++);
+            this.Location.push(newObjLocation);
+        }
+        const newObjIndex: {
+            You: number,
+            Prey: number
+        } = {
+            You: 0,
+            Prey: 0
+        };
+        newObjIndex['You'] = buf.readInt16LE(pos);
+        pos += 2;
+        newObjIndex['Prey'] = buf.readInt16LE(pos);
+        pos += 2;
+        this.Index = newObjIndex;
+        count = buf.readUInt8(pos++);
+        this.AgentData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjAgentData: {
+                AgentID: UUID
+            } = {
+                AgentID: UUID.zero()
+            };
+            newObjAgentData['AgentID'] = new UUID(buf, pos);
+            pos += 16;
+            this.AgentData.push(newObjAgentData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CompleteAgentMovement.ts

@@ -0,0 +1,60 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CompleteAgentMovementMessage implements MessageBase
+{
+    name = 'CompleteAgentMovement';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.CompleteAgentMovement;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        CircuitCode: number;
+    };
+
+    getSize(): number
+    {
+        return 36;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AgentData['CircuitCode'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            CircuitCode: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            CircuitCode: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['CircuitCode'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CompleteAuction.ts

@@ -0,0 +1,56 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CompleteAuctionMessage implements MessageBase
+{
+    name = 'CompleteAuction';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.CompleteAuction;
+
+    ParcelData: {
+        ParcelID: UUID;
+    }[];
+
+    getSize(): number
+    {
+        return ((16) * this.ParcelData.length) + 1;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        const count = this.ParcelData.length;
+        buf.writeUInt8(this.ParcelData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.ParcelData[i]['ParcelID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const count = buf.readUInt8(pos++);
+        this.ParcelData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjParcelData: {
+                ParcelID: UUID
+            } = {
+                ParcelID: UUID.zero()
+            };
+            newObjParcelData['ParcelID'] = new UUID(buf, pos);
+            pos += 16;
+            this.ParcelData.push(newObjParcelData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CompletePingCheck.ts

@@ -0,0 +1,43 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CompletePingCheckMessage implements MessageBase
+{
+    name = 'CompletePingCheck';
+    messageFlags = MessageFlags.FrequencyHigh;
+    id = Message.CompletePingCheck;
+
+    PingID: {
+        PingID: number;
+    };
+
+    getSize(): number
+    {
+        return 1;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeUInt8(this.PingID['PingID'], pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjPingID: {
+            PingID: number
+        } = {
+            PingID: 0
+        };
+        newObjPingID['PingID'] = buf.readUInt8(pos++);
+        this.PingID = newObjPingID;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ConfirmAuctionStart.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ConfirmAuctionStartMessage implements MessageBase
+{
+    name = 'ConfirmAuctionStart';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.ConfirmAuctionStart;
+
+    AuctionData: {
+        ParcelID: UUID;
+        AuctionID: number;
+    };
+
+    getSize(): number
+    {
+        return 20;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AuctionData['ParcelID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.AuctionData['AuctionID'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAuctionData: {
+            ParcelID: UUID,
+            AuctionID: number
+        } = {
+            ParcelID: UUID.zero(),
+            AuctionID: 0
+        };
+        newObjAuctionData['ParcelID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAuctionData['AuctionID'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.AuctionData = newObjAuctionData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ConfirmEnableSimulator.ts

@@ -0,0 +1,53 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ConfirmEnableSimulatorMessage implements MessageBase
+{
+    name = 'ConfirmEnableSimulator';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyMedium;
+    id = Message.ConfirmEnableSimulator;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+
+    getSize(): number
+    {
+        return 32;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/ConfirmXferPacket.ts

@@ -0,0 +1,55 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import Long = require('long');
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class ConfirmXferPacketMessage implements MessageBase
+{
+    name = 'ConfirmXferPacket';
+    messageFlags = MessageFlags.FrequencyHigh;
+    id = Message.ConfirmXferPacket;
+
+    XferID: {
+        ID: Long;
+        Packet: number;
+    };
+
+    getSize(): number
+    {
+        return 12;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        buf.writeInt32LE(this.XferID['ID'].low, pos);
+        pos += 4;
+        buf.writeInt32LE(this.XferID['ID'].high, pos);
+        pos += 4;
+        buf.writeUInt32LE(this.XferID['Packet'], pos);
+        pos += 4;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjXferID: {
+            ID: Long,
+            Packet: number
+        } = {
+            ID: Long.ZERO,
+            Packet: 0
+        };
+        newObjXferID['ID'] = new Long(buf.readInt32LE(pos), buf.readInt32LE(pos+4));
+        pos += 8;
+        newObjXferID['Packet'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.XferID = newObjXferID;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CopyInventoryFromNotecard.ts

@@ -0,0 +1,103 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CopyInventoryFromNotecardMessage implements MessageBase
+{
+    name = 'CopyInventoryFromNotecard';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.Deprecated | MessageFlags.FrequencyLow;
+    id = Message.CopyInventoryFromNotecard;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    NotecardData: {
+        NotecardItemID: UUID;
+        ObjectID: UUID;
+    };
+    InventoryData: {
+        ItemID: UUID;
+        FolderID: UUID;
+    }[];
+
+    getSize(): number
+    {
+        return ((32) * this.InventoryData.length) + 65;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.NotecardData['NotecardItemID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.NotecardData['ObjectID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.InventoryData.length;
+        buf.writeUInt8(this.InventoryData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            this.InventoryData[i]['ItemID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.InventoryData[i]['FolderID'].writeToBuffer(buf, pos);
+            pos += 16;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjNotecardData: {
+            NotecardItemID: UUID,
+            ObjectID: UUID
+        } = {
+            NotecardItemID: UUID.zero(),
+            ObjectID: UUID.zero()
+        };
+        newObjNotecardData['NotecardItemID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjNotecardData['ObjectID'] = new UUID(buf, pos);
+        pos += 16;
+        this.NotecardData = newObjNotecardData;
+        const count = buf.readUInt8(pos++);
+        this.InventoryData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjInventoryData: {
+                ItemID: UUID,
+                FolderID: UUID
+            } = {
+                ItemID: UUID.zero(),
+                FolderID: UUID.zero()
+            };
+            newObjInventoryData['ItemID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjInventoryData['FolderID'] = new UUID(buf, pos);
+            pos += 16;
+            this.InventoryData.push(newObjInventoryData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CopyInventoryItem.ts

@@ -0,0 +1,116 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CopyInventoryItemMessage implements MessageBase
+{
+    name = 'CopyInventoryItem';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.CopyInventoryItem;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    InventoryData: {
+        CallbackID: number;
+        OldAgentID: UUID;
+        OldItemID: UUID;
+        NewFolderID: UUID;
+        NewName: string;
+    }[];
+
+    getSize(): number
+    {
+        return ((this.calculateVarVarSize(this.InventoryData, 'NewName', 1) + 52) * this.InventoryData.length) + 33;
+    }
+
+    calculateVarVarSize(block: object[], paramName: string, extraPerVar: number): number
+    {
+        let size = 0;
+        block.forEach((bl: any) =>
+        {
+            size += bl[paramName].length + extraPerVar;
+        });
+        return size;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        const count = this.InventoryData.length;
+        buf.writeUInt8(this.InventoryData.length, pos++);
+        for (let i = 0; i < count; i++)
+        {
+            buf.writeUInt32LE(this.InventoryData[i]['CallbackID'], pos);
+            pos += 4;
+            this.InventoryData[i]['OldAgentID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.InventoryData[i]['OldItemID'].writeToBuffer(buf, pos);
+            pos += 16;
+            this.InventoryData[i]['NewFolderID'].writeToBuffer(buf, pos);
+            pos += 16;
+            buf.writeUInt8(this.InventoryData[i]['NewName'].length, pos++);
+            buf.write(this.InventoryData[i]['NewName'], pos);
+            pos += this.InventoryData[i]['NewName'].length;
+        }
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const count = buf.readUInt8(pos++);
+        this.InventoryData = [];
+        for (let i = 0; i < count; i++)
+        {
+            const newObjInventoryData: {
+                CallbackID: number,
+                OldAgentID: UUID,
+                OldItemID: UUID,
+                NewFolderID: UUID,
+                NewName: string
+            } = {
+                CallbackID: 0,
+                OldAgentID: UUID.zero(),
+                OldItemID: UUID.zero(),
+                NewFolderID: UUID.zero(),
+                NewName: ''
+            };
+            newObjInventoryData['CallbackID'] = buf.readUInt32LE(pos);
+            pos += 4;
+            newObjInventoryData['OldAgentID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjInventoryData['OldItemID'] = new UUID(buf, pos);
+            pos += 16;
+            newObjInventoryData['NewFolderID'] = new UUID(buf, pos);
+            pos += 16;
+            varLength = buf.readUInt8(pos++);
+            newObjInventoryData['NewName'] = buf.toString('utf8', pos, pos + (varLength - 1));
+            pos += varLength;
+            this.InventoryData.push(newObjInventoryData);
+        }
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CreateGroupReply.ts

@@ -0,0 +1,73 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CreateGroupReplyMessage implements MessageBase
+{
+    name = 'CreateGroupReply';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.CreateGroupReply;
+
+    AgentData: {
+        AgentID: UUID;
+    };
+    ReplyData: {
+        GroupID: UUID;
+        Success: boolean;
+        Message: string;
+    };
+
+    getSize(): number
+    {
+        return (this.ReplyData['Message'].length + 1) + 33;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.ReplyData['GroupID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8((this.ReplyData['Success']) ? 1 : 0, pos++);
+        buf.writeUInt8(this.ReplyData['Message'].length, pos++);
+        buf.write(this.ReplyData['Message'], pos);
+        pos += this.ReplyData['Message'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID
+        } = {
+            AgentID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjReplyData: {
+            GroupID: UUID,
+            Success: boolean,
+            Message: string
+        } = {
+            GroupID: UUID.zero(),
+            Success: false,
+            Message: ''
+        };
+        newObjReplyData['GroupID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjReplyData['Success'] = (buf.readUInt8(pos++) === 1);
+        varLength = buf.readUInt8(pos++);
+        newObjReplyData['Message'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.ReplyData = newObjReplyData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CreateGroupRequest.ts

@@ -0,0 +1,113 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CreateGroupRequestMessage implements MessageBase
+{
+    name = 'CreateGroupRequest';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.CreateGroupRequest;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    GroupData: {
+        Name: string;
+        Charter: string;
+        ShowInList: boolean;
+        InsigniaID: UUID;
+        MembershipFee: number;
+        OpenEnrollment: boolean;
+        AllowPublish: boolean;
+        MaturePublish: boolean;
+    };
+
+    getSize(): number
+    {
+        return (this.GroupData['Name'].length + 1 + this.GroupData['Charter'].length + 2) + 56;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.GroupData['Name'].length, pos++);
+        buf.write(this.GroupData['Name'], pos);
+        pos += this.GroupData['Name'].length;
+        buf.writeUInt16LE(this.GroupData['Charter'].length, pos);
+        pos += 2;
+        buf.write(this.GroupData['Charter'], pos);
+        pos += this.GroupData['Charter'].length;
+        buf.writeUInt8((this.GroupData['ShowInList']) ? 1 : 0, pos++);
+        this.GroupData['InsigniaID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt32LE(this.GroupData['MembershipFee'], pos);
+        pos += 4;
+        buf.writeUInt8((this.GroupData['OpenEnrollment']) ? 1 : 0, pos++);
+        buf.writeUInt8((this.GroupData['AllowPublish']) ? 1 : 0, pos++);
+        buf.writeUInt8((this.GroupData['MaturePublish']) ? 1 : 0, pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjGroupData: {
+            Name: string,
+            Charter: string,
+            ShowInList: boolean,
+            InsigniaID: UUID,
+            MembershipFee: number,
+            OpenEnrollment: boolean,
+            AllowPublish: boolean,
+            MaturePublish: boolean
+        } = {
+            Name: '',
+            Charter: '',
+            ShowInList: false,
+            InsigniaID: UUID.zero(),
+            MembershipFee: 0,
+            OpenEnrollment: false,
+            AllowPublish: false,
+            MaturePublish: false
+        };
+        varLength = buf.readUInt8(pos++);
+        newObjGroupData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjGroupData['Charter'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjGroupData['ShowInList'] = (buf.readUInt8(pos++) === 1);
+        newObjGroupData['InsigniaID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjGroupData['MembershipFee'] = buf.readInt32LE(pos);
+        pos += 4;
+        newObjGroupData['OpenEnrollment'] = (buf.readUInt8(pos++) === 1);
+        newObjGroupData['AllowPublish'] = (buf.readUInt8(pos++) === 1);
+        newObjGroupData['MaturePublish'] = (buf.readUInt8(pos++) === 1);
+        this.GroupData = newObjGroupData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CreateGroupRequestExtended.ts

@@ -0,0 +1,120 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CreateGroupRequestExtendedMessage implements MessageBase
+{
+    name = 'CreateGroupRequestExtended';
+    messageFlags = MessageFlags.Trusted | MessageFlags.FrequencyLow;
+    id = Message.CreateGroupRequestExtended;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+        GroupLimit: number;
+    };
+    GroupData: {
+        Name: string;
+        Charter: string;
+        ShowInList: boolean;
+        InsigniaID: UUID;
+        MembershipFee: number;
+        OpenEnrollment: boolean;
+        AllowPublish: boolean;
+        MaturePublish: boolean;
+    };
+
+    getSize(): number
+    {
+        return (this.GroupData['Name'].length + 1 + this.GroupData['Charter'].length + 2) + 60;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt32LE(this.AgentData['GroupLimit'], pos);
+        pos += 4;
+        buf.writeUInt8(this.GroupData['Name'].length, pos++);
+        buf.write(this.GroupData['Name'], pos);
+        pos += this.GroupData['Name'].length;
+        buf.writeUInt16LE(this.GroupData['Charter'].length, pos);
+        pos += 2;
+        buf.write(this.GroupData['Charter'], pos);
+        pos += this.GroupData['Charter'].length;
+        buf.writeUInt8((this.GroupData['ShowInList']) ? 1 : 0, pos++);
+        this.GroupData['InsigniaID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt32LE(this.GroupData['MembershipFee'], pos);
+        pos += 4;
+        buf.writeUInt8((this.GroupData['OpenEnrollment']) ? 1 : 0, pos++);
+        buf.writeUInt8((this.GroupData['AllowPublish']) ? 1 : 0, pos++);
+        buf.writeUInt8((this.GroupData['MaturePublish']) ? 1 : 0, pos++);
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID,
+            GroupLimit: number
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero(),
+            GroupLimit: 0
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['GroupLimit'] = buf.readInt32LE(pos);
+        pos += 4;
+        this.AgentData = newObjAgentData;
+        const newObjGroupData: {
+            Name: string,
+            Charter: string,
+            ShowInList: boolean,
+            InsigniaID: UUID,
+            MembershipFee: number,
+            OpenEnrollment: boolean,
+            AllowPublish: boolean,
+            MaturePublish: boolean
+        } = {
+            Name: '',
+            Charter: '',
+            ShowInList: false,
+            InsigniaID: UUID.zero(),
+            MembershipFee: 0,
+            OpenEnrollment: false,
+            AllowPublish: false,
+            MaturePublish: false
+        };
+        varLength = buf.readUInt8(pos++);
+        newObjGroupData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt16LE(pos);
+        pos += 2;
+        newObjGroupData['Charter'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        newObjGroupData['ShowInList'] = (buf.readUInt8(pos++) === 1);
+        newObjGroupData['InsigniaID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjGroupData['MembershipFee'] = buf.readInt32LE(pos);
+        pos += 4;
+        newObjGroupData['OpenEnrollment'] = (buf.readUInt8(pos++) === 1);
+        newObjGroupData['AllowPublish'] = (buf.readUInt8(pos++) === 1);
+        newObjGroupData['MaturePublish'] = (buf.readUInt8(pos++) === 1);
+        this.GroupData = newObjGroupData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CreateInventoryFolder.ts

@@ -0,0 +1,87 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CreateInventoryFolderMessage implements MessageBase
+{
+    name = 'CreateInventoryFolder';
+    messageFlags = MessageFlags.FrequencyLow;
+    id = Message.CreateInventoryFolder;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    FolderData: {
+        FolderID: UUID;
+        ParentID: UUID;
+        Type: number;
+        Name: string;
+    };
+
+    getSize(): number
+    {
+        return (this.FolderData['Name'].length + 1) + 65;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.FolderData['FolderID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.FolderData['ParentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeInt8(this.FolderData['Type'], pos++);
+        buf.writeUInt8(this.FolderData['Name'].length, pos++);
+        buf.write(this.FolderData['Name'], pos);
+        pos += this.FolderData['Name'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjFolderData: {
+            FolderID: UUID,
+            ParentID: UUID,
+            Type: number,
+            Name: string
+        } = {
+            FolderID: UUID.zero(),
+            ParentID: UUID.zero(),
+            Type: 0,
+            Name: ''
+        };
+        newObjFolderData['FolderID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjFolderData['ParentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjFolderData['Type'] = buf.readInt8(pos++);
+        varLength = buf.readUInt8(pos++);
+        newObjFolderData['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.FolderData = newObjFolderData;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CreateInventoryItem.ts

@@ -0,0 +1,120 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CreateInventoryItemMessage implements MessageBase
+{
+    name = 'CreateInventoryItem';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.CreateInventoryItem;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    InventoryBlock: {
+        CallbackID: number;
+        FolderID: UUID;
+        TransactionID: UUID;
+        NextOwnerMask: number;
+        Type: number;
+        InvType: number;
+        WearableType: number;
+        Name: string;
+        Description: string;
+    };
+
+    getSize(): number
+    {
+        return (this.InventoryBlock['Name'].length + 1 + this.InventoryBlock['Description'].length + 1) + 75;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.InventoryBlock['CallbackID'], pos);
+        pos += 4;
+        this.InventoryBlock['FolderID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.InventoryBlock['TransactionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.InventoryBlock['NextOwnerMask'], pos);
+        pos += 4;
+        buf.writeInt8(this.InventoryBlock['Type'], pos++);
+        buf.writeInt8(this.InventoryBlock['InvType'], pos++);
+        buf.writeUInt8(this.InventoryBlock['WearableType'], pos++);
+        buf.writeUInt8(this.InventoryBlock['Name'].length, pos++);
+        buf.write(this.InventoryBlock['Name'], pos);
+        pos += this.InventoryBlock['Name'].length;
+        buf.writeUInt8(this.InventoryBlock['Description'].length, pos++);
+        buf.write(this.InventoryBlock['Description'], pos);
+        pos += this.InventoryBlock['Description'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjInventoryBlock: {
+            CallbackID: number,
+            FolderID: UUID,
+            TransactionID: UUID,
+            NextOwnerMask: number,
+            Type: number,
+            InvType: number,
+            WearableType: number,
+            Name: string,
+            Description: string
+        } = {
+            CallbackID: 0,
+            FolderID: UUID.zero(),
+            TransactionID: UUID.zero(),
+            NextOwnerMask: 0,
+            Type: 0,
+            InvType: 0,
+            WearableType: 0,
+            Name: '',
+            Description: ''
+        };
+        newObjInventoryBlock['CallbackID'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjInventoryBlock['FolderID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjInventoryBlock['TransactionID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjInventoryBlock['NextOwnerMask'] = buf.readUInt32LE(pos);
+        pos += 4;
+        newObjInventoryBlock['Type'] = buf.readInt8(pos++);
+        newObjInventoryBlock['InvType'] = buf.readInt8(pos++);
+        newObjInventoryBlock['WearableType'] = buf.readUInt8(pos++);
+        varLength = buf.readUInt8(pos++);
+        newObjInventoryBlock['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        varLength = buf.readUInt8(pos++);
+        newObjInventoryBlock['Description'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.InventoryBlock = newObjInventoryBlock;
+        return pos - startPos;
+    }
+}
+

lib/classes/messages/CreateLandmarkForEvent.ts

@@ -0,0 +1,88 @@
+// This file has been automatically generated by writeMessageClasses.js
+
+import {UUID} from '../UUID';
+import {MessageFlags} from '../../enums/MessageFlags';
+import {MessageBase} from '../MessageBase';
+import {Message} from '../../enums/Message';
+
+export class CreateLandmarkForEventMessage implements MessageBase
+{
+    name = 'CreateLandmarkForEvent';
+    messageFlags = MessageFlags.Zerocoded | MessageFlags.FrequencyLow;
+    id = Message.CreateLandmarkForEvent;
+
+    AgentData: {
+        AgentID: UUID;
+        SessionID: UUID;
+    };
+    EventData: {
+        EventID: number;
+    };
+    InventoryBlock: {
+        FolderID: UUID;
+        Name: string;
+    };
+
+    getSize(): number
+    {
+        return (this.InventoryBlock['Name'].length + 1) + 52;
+    }
+
+    writeToBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        this.AgentData['AgentID'].writeToBuffer(buf, pos);
+        pos += 16;
+        this.AgentData['SessionID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt32LE(this.EventData['EventID'], pos);
+        pos += 4;
+        this.InventoryBlock['FolderID'].writeToBuffer(buf, pos);
+        pos += 16;
+        buf.writeUInt8(this.InventoryBlock['Name'].length, pos++);
+        buf.write(this.InventoryBlock['Name'], pos);
+        pos += this.InventoryBlock['Name'].length;
+        return pos - startPos;
+    }
+
+    readFromBuffer(buf: Buffer, pos: number): number
+    {
+        const startPos = pos;
+        let varLength = 0;
+        const newObjAgentData: {
+            AgentID: UUID,
+            SessionID: UUID
+        } = {
+            AgentID: UUID.zero(),
+            SessionID: UUID.zero()
+        };
+        newObjAgentData['AgentID'] = new UUID(buf, pos);
+        pos += 16;
+        newObjAgentData['SessionID'] = new UUID(buf, pos);
+        pos += 16;
+        this.AgentData = newObjAgentData;
+        const newObjEventData: {
+            EventID: number
+        } = {
+            EventID: 0
+        };
+        newObjEventData['EventID'] = buf.readUInt32LE(pos);
+        pos += 4;
+        this.EventData = newObjEventData;
+        const newObjInventoryBlock: {
+            FolderID: UUID,
+            Name: string
+        } = {
+            FolderID: UUID.zero(),
+            Name: ''
+        };
+        newObjInventoryBlock['FolderID'] = new UUID(buf, pos);
+        pos += 16;
+        varLength = buf.readUInt8(pos++);
+        newObjInventoryBlock['Name'] = buf.toString('utf8', pos, pos + (varLength - 1));
+        pos += varLength;
+        this.InventoryBlock = newObjInventoryBlock;
+        return pos - startPos;
+    }
+}
+