@colyseus/schema 5.0.21 → 5.0.23

package/build/codegen/cli.cjs

@@ -1029,8 +1029,8 @@ function getDecorators(node) {
     return node.modifiers?.filter(ts__namespace.isDecorator);
 }
 
-const name$9 = "Unity/C#";
-const typeMaps$9 = {
+const name$a = "Unity/C#";
+const typeMaps$a = {
     "string": "string",
     "number": "float",
     "boolean": "bool",
@@ -1045,7 +1045,7 @@ const typeMaps$9 = {
     "float32": "float",
     "float64": "double",
 };
-const COMMON_IMPORTS$6 = `using Colyseus.Schema;
+const COMMON_IMPORTS$7 = `using Colyseus.Schema;
 #if UNITY_5_3_OR_NEWER
 using UnityEngine.Scripting;
 #endif`;
@@ -1060,10 +1060,10 @@ const capitalize$1 = (s) => {
 /**
  * Generate individual files for each class/interface/enum
  */
-function generate$a(context, options) {
+function generate$b(context, options) {
     // enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps$9[structure.name] = structure.name;
+        typeMaps$a[structure.name] = structure.name;
     });
     return [
         ...context.classes.map(structure => ({
@@ -1083,23 +1083,23 @@ function generate$a(context, options) {
 /**
  * Generate a single bundled file containing all classes, interfaces, and enums
  */
-function renderBundle$9(context, options) {
+function renderBundle$a(context, options) {
     const fileName = options.namespace ? `${options.namespace}.cs` : "Schema.cs";
     const indent = options.namespace ? "\t" : "";
     // enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps$9[structure.name] = structure.name;
+        typeMaps$a[structure.name] = structure.name;
     });
     // Collect all bodies
-    const classBodies = context.classes.map(klass => generateClassBody$9(klass, indent));
-    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody$2(iface, indent));
+    const classBodies = context.classes.map(klass => generateClassBody$a(klass, indent));
+    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody$3(iface, indent));
     const enumBodies = context.enums
         .filter(structure => structure.name !== 'OPERATION')
-        .map(e => generateEnumBody$2(e, indent));
+        .map(e => generateEnumBody$3(e, indent));
     const allBodies = [...classBodies, ...interfaceBodies, ...enumBodies].join("\n\n");
     const content = `${getCommentHeader()}
 
-${COMMON_IMPORTS$6}
+${COMMON_IMPORTS$7}
 ${options.namespace ? `\nnamespace ${options.namespace} {\n` : ""}
 ${allBodies}
 ${options.namespace ? "}" : ""}`;
@@ -1108,13 +1108,13 @@ ${options.namespace ? "}" : ""}`;
 /**
  * Generate just the class body (without imports/namespace) for bundling
  */
-function generateClassBody$9(klass, indent = "") {
+function generateClassBody$a(klass, indent = "") {
     return `${indent}public partial class ${klass.name} : ${klass.extends} {
 #if UNITY_5_3_OR_NEWER
 [Preserve]
 #endif
 public ${klass.name}() { }
-${klass.properties.map((prop) => generateProperty$4(prop, indent)).join("\n\n")}
+${klass.properties.map((prop) => generateProperty$5(prop, indent)).join("\n\n")}
 ${indent}}`;
 }
 /**
@@ -1124,9 +1124,9 @@ function generateClass$9(klass, namespace) {
     const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
 
-${COMMON_IMPORTS$6}
+${COMMON_IMPORTS$7}
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${generateClassBody$9(klass, indent)}
+${generateClassBody$a(klass, indent)}
 ${namespace ? "}" : ""}
 `;
 }
@@ -1145,7 +1145,7 @@ function canUseNativeEnum(_enum) {
 /**
  * Generate just the enum body (without imports/namespace) for bundling
  */
-function generateEnumBody$2(_enum, indent = "") {
+function generateEnumBody$3(_enum, indent = "") {
     if (canUseNativeEnum(_enum)) {
         const members = _enum.properties
             .map((prop, i) => {
@@ -1188,10 +1188,10 @@ function generateEnum$2(_enum, namespace) {
     const indent = namespace ? "\t" : "";
     return `${getCommentHeader()}
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${generateEnumBody$2(_enum, indent)}
+${generateEnumBody$3(_enum, indent)}
 ${namespace ? "}" : ""}`;
 }
-function generateProperty$4(prop, indent = "") {
+function generateProperty$5(prop, indent = "") {
     let typeArgs = `"${prop.type}"`;
     let property = "public";
     let langType;
@@ -1223,7 +1223,7 @@ function generateProperty$4(prop, indent = "") {
 /**
  * Generate just the interface body (without imports/namespace) for bundling
  */
-function generateInterfaceBody$2(struct, indent = "") {
+function generateInterfaceBody$3(struct, indent = "") {
     return `${indent}public class ${struct.name} {
 ${struct.properties.map(prop => `\t${indent}public ${getType(prop)} ${prop.name};`).join("\n")}
 ${indent}}`;
@@ -1237,12 +1237,12 @@ function generateInterface$2(struct, namespace) {
 
 using Colyseus.Schema;
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${generateInterfaceBody$2(struct, indent)}
+${generateInterfaceBody$3(struct, indent)}
 ${namespace ? "}" : ""}
 `;
 }
 function getChildType(prop) {
-    return typeMaps$9[prop.childType];
+    return typeMaps$a[prop.childType];
 }
 function getType(prop) {
     if (prop.childType) {
@@ -1263,20 +1263,20 @@ function getType(prop) {
     }
     else {
         return (prop.type === "array")
-            ? `${typeMaps$9[prop.childType] || prop.childType}[]`
-            : typeMaps$9[prop.type];
+            ? `${typeMaps$a[prop.childType] || prop.childType}[]`
+            : typeMaps$a[prop.type];
     }
 }
 
 var csharp = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$a,
-    name: name$9,
-    renderBundle: renderBundle$9
+    generate: generate$b,
+    name: name$a,
+    renderBundle: renderBundle$a
 });
 
-const name$8 = "C++";
-const typeMaps$8 = {
+const name$9 = "C++";
+const typeMaps$9 = {
     "string": "string",
     "number": "varint_t",
     "boolean": "bool",
@@ -1323,7 +1323,7 @@ const distinct$6 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class
  */
-function generate$9(context, options) {
+function generate$a(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".hpp",
         content: generateClass$8(klass, options.namespace, context.classes)
@@ -1332,10 +1332,10 @@ function generate$9(context, options) {
 /**
  * Generate a single bundled header file containing all classes
  */
-function renderBundle$8(context, options) {
+function renderBundle$9(context, options) {
     const fileName = options.namespace ? `${options.namespace}.hpp` : "schema.hpp";
     const guardName = `__SCHEMA_CODEGEN_${(options.namespace || "SCHEMA").toUpperCase()}_H__`;
-    const classBodies = context.classes.map(klass => generateClassBody$8(klass, context.classes, options.namespace));
+    const classBodies = context.classes.map(klass => generateClassBody$9(klass, context.classes, options.namespace));
     const content = `${getCommentHeader()}
 #ifndef ${guardName}
 #define ${guardName} 1
@@ -1353,7 +1353,7 @@ ${options.namespace ? "}" : ""}
 /**
  * Generate just the class body (without includes/guards) for bundling
  */
-function generateClassBody$8(klass, allClasses, namespace) {
+function generateClassBody$9(klass, allClasses, namespace) {
     const propertiesPerType = {};
     const allRefs = [];
     klass.properties.forEach(property => {
@@ -1370,12 +1370,12 @@ function generateClassBody$8(klass, allClasses, namespace) {
     const allProperties = getAllProperties$1(klass, allClasses);
     const createInstanceMethod = (allRefs.length === 0) ? "" :
         `\tinline Schema* createInstance(std::type_index type) {
-\t\t${generateFieldIfElseChain(allRefs, (property) => `type == typeid(${property.childType})`, (property) => `return new ${property.childType}();`, (property) => typeMaps$8[property.childType] === undefined)}
+\t\t${generateFieldIfElseChain(allRefs, (property) => `type == typeid(${property.childType})`, (property) => `return new ${property.childType}();`, (property) => typeMaps$9[property.childType] === undefined)}
 \t\treturn ${klass.extends}::createInstance(type);
 \t}`;
     return `class ${klass.name} : public ${klass.extends} {
 public:
-${klass.properties.map(prop => generateProperty$3(prop)).join("\n")}
+${klass.properties.map(prop => generateProperty$4(prop)).join("\n")}
 
 \t${klass.name}() {
 \t\tthis->_indexes = ${generateAllIndexes(allProperties)};
@@ -1408,7 +1408,7 @@ function generateClass$8(klass, namespace, allClasses) {
         }
     });
     const localIncludes = allRefs.
-        filter(ref => ref.childType && typeMaps$8[ref.childType] === undefined).
+        filter(ref => ref.childType && typeMaps$9[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
         filter(distinct$6).
@@ -1422,13 +1422,13 @@ ${COMMON_INCLUDES$1}
 ${localIncludes}
 
 ${namespace ? `namespace ${namespace} {` : ""}
-${generateClassBody$8(klass, allClasses)}
+${generateClassBody$9(klass, allClasses)}
 ${namespace ? "}" : ""}
 
 #endif
 `;
 }
-function generateProperty$3(prop) {
+function generateProperty$4(prop) {
     let property = "";
     let langType;
     let initializer = "";
@@ -1442,26 +1442,26 @@ function generateProperty$3(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}*>`
-                : `ArraySchema<${typeMaps$8[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$9[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}*>`
-                : `MapSchema<${typeMaps$8[prop.childType]}>`;
+                : `MapSchema<${typeMaps$9[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         isPropPointer = "*";
     }
     else {
-        langType = typeMaps$8[prop.type];
+        langType = typeMaps$9[prop.type];
         initializer = typeInitializer$2[prop.type];
     }
     property += ` ${langType} ${isPropPointer}${prop.name}`;
     return `\t${property} = ${initializer};`;
 }
 function generateGettersAndSetters(klass, type, properties) {
-    let langType = typeMaps$8[type];
+    let langType = typeMaps$9[type];
     let typeCast = "";
     const getMethodName = `get${capitalize(type)}`;
     const setMethodName = `set${capitalize(type)}`;
@@ -1485,7 +1485,7 @@ function generateGettersAndSetters(klass, type, properties) {
 \tinline void ${setMethodName}(const string &field, ${langType} value)
 \t{
 \t\t${generateFieldIfElseChain(properties, (property) => `field == "${property.name}"`, (property) => {
-        const isSchemaType = (typeMaps$8[property.childType] === undefined);
+        const isSchemaType = (typeMaps$9[property.childType] === undefined);
         if (type === "ref") {
             langType = `${property.childType}*`;
             typeCast = (isSchemaType)
@@ -1495,12 +1495,12 @@ function generateGettersAndSetters(klass, type, properties) {
         else if (type === "array") {
             typeCast = (isSchemaType)
                 ? `(ArraySchema<${property.childType}*> *)`
-                : `(ArraySchema<${typeMaps$8[property.childType]}> *)`;
+                : `(ArraySchema<${typeMaps$9[property.childType]}> *)`;
         }
         else if (type === "map") {
             typeCast = (isSchemaType)
                 ? `(MapSchema<${property.childType}*> *)`
-                : `(MapSchema<${typeMaps$8[property.childType]}> *)`;
+                : `(MapSchema<${typeMaps$9[property.childType]}> *)`;
         }
         return `this->${property.name} = ${typeCast}value;\n\t\t\treturn;`;
     })}
@@ -1539,7 +1539,7 @@ function generateAllTypes(properties) {
 }
 function generateAllChildSchemaTypes(properties) {
     return `{${properties.map((property, i) => {
-        if (property.childType && typeMaps$8[property.childType] === undefined) {
+        if (property.childType && typeMaps$9[property.childType] === undefined) {
             return `{${i}, typeid(${property.childType})}`;
         }
         else {
@@ -1549,7 +1549,7 @@ function generateAllChildSchemaTypes(properties) {
 }
 function generateAllChildPrimitiveTypes(properties) {
     return `{${properties.map((property, i) => {
-        if (typeMaps$8[property.childType] !== undefined) {
+        if (typeMaps$9[property.childType] !== undefined) {
             return `{${i}, "${property.childType}"}`;
         }
         else {
@@ -1577,13 +1577,13 @@ function getAllProperties$1(klass, allClasses) {
 
 var cpp = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$9,
-    name: name$8,
-    renderBundle: renderBundle$8
+    generate: generate$a,
+    name: name$9,
+    renderBundle: renderBundle$9
 });
 
-const name$7 = "Haxe";
-const typeMaps$7 = {
+const name$8 = "Haxe";
+const typeMaps$8 = {
     "string": "String",
     "number": "Dynamic",
     "boolean": "Bool",
@@ -1613,12 +1613,12 @@ const typeInitializer$1 = {
     "float32": "0",
     "float64": "0",
 };
-const COMMON_IMPORTS$5 = `import io.colyseus.serializer.schema.Schema;
+const COMMON_IMPORTS$6 = `import io.colyseus.serializer.schema.Schema;
 import io.colyseus.serializer.schema.types.*;`;
 /**
  * Generate individual files for each class
  */
-function generate$8(context, options) {
+function generate$9(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".hx",
         content: generateClass$7(klass, options.namespace, context.classes)
@@ -1627,13 +1627,13 @@ function generate$8(context, options) {
 /**
  * Generate a single bundled file containing all classes
  */
-function renderBundle$7(context, options) {
+function renderBundle$8(context, options) {
     const fileName = options.namespace ? `${options.namespace}.hx` : "Schema.hx";
-    const classBodies = context.classes.map(klass => generateClassBody$7(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$8(klass));
     const content = `${getCommentHeader()}
 
 ${options.namespace ? `package ${options.namespace};` : ""}
-${COMMON_IMPORTS$5}
+${COMMON_IMPORTS$6}
 
 ${classBodies.join("\n\n")}
 `;
@@ -1642,9 +1642,9 @@ ${classBodies.join("\n\n")}
 /**
  * Generate just the class body (without package/imports) for bundling
  */
-function generateClassBody$7(klass) {
+function generateClassBody$8(klass) {
     return `class ${klass.name} extends ${klass.extends} {
-${klass.properties.map(prop => generateProperty$2(prop)).join("\n")}
+${klass.properties.map(prop => generateProperty$3(prop)).join("\n")}
 }`;
 }
 /**
@@ -1654,12 +1654,12 @@ function generateClass$7(klass, namespace, allClasses) {
     return `${getCommentHeader()}
 
 ${namespace ? `package ${namespace};` : ""}
-${COMMON_IMPORTS$5}
+${COMMON_IMPORTS$6}
 
-${generateClassBody$7(klass)}
+${generateClassBody$8(klass)}
 `;
 }
-function generateProperty$2(prop) {
+function generateProperty$3(prop) {
     let langType;
     let initializer = "";
     let typeArgs = `"${prop.type}"`;
@@ -1684,18 +1684,18 @@ function generateProperty$2(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}>`
-                : `ArraySchema<${typeMaps$7[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$8[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}>`
-                : `MapSchema<${typeMaps$7[prop.childType]}>`;
+                : `MapSchema<${typeMaps$8[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
     }
     else {
-        langType = typeMaps$7[prop.type];
+        langType = typeMaps$8[prop.type];
         initializer = typeInitializer$1[prop.type];
     }
     // TODO: remove initializer. The callbacks at the Haxe decoder side have a
@@ -1706,13 +1706,13 @@ function generateProperty$2(prop) {
 
 var haxe = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$8,
-    name: name$7,
-    renderBundle: renderBundle$7
+    generate: generate$9,
+    name: name$8,
+    renderBundle: renderBundle$8
 });
 
-const name$6 = "TypeScript";
-const typeMaps$6 = {
+const name$7 = "TypeScript";
+const typeMaps$7 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -1727,12 +1727,12 @@ const typeMaps$6 = {
     "float32": "number",
     "float64": "number",
 };
-const COMMON_IMPORTS$4 = `import { Schema, type, ArraySchema, MapSchema, SetSchema, DataChange } from '@colyseus/schema';`;
+const COMMON_IMPORTS$5 = `import { Schema, type, ArraySchema, MapSchema, SetSchema, DataChange } from '@colyseus/schema';`;
 const distinct$5 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class/interface
  */
-function generate$7(context, options) {
+function generate$8(context, options) {
     return [
         ...context.classes.map(structure => ({
             name: structure.name + ".ts",
@@ -1747,15 +1747,15 @@ function generate$7(context, options) {
 /**
  * Generate a single bundled file containing all classes and interfaces
  */
-function renderBundle$6(context, options) {
+function renderBundle$7(context, options) {
     const fileName = options.namespace ? `${options.namespace}.ts` : "schema.ts";
     // Collect all class bodies
-    const classBodies = context.classes.map(klass => generateClassBody$6(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$7(klass));
     // Collect all interface bodies
-    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody$1(iface));
+    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody$2(iface));
     const content = `${getCommentHeader()}
 
-${COMMON_IMPORTS$4}
+${COMMON_IMPORTS$5}
 
 ${classBodies.join("\n\n")}
 ${interfaceBodies.length > 0 ? "\n" + interfaceBodies.join("\n\n") : ""}`;
@@ -1764,15 +1764,15 @@ ${interfaceBodies.length > 0 ? "\n" + interfaceBodies.join("\n\n") : ""}`;
 /**
  * Generate just the class body (without imports) for bundling
  */
-function generateClassBody$6(klass) {
+function generateClassBody$7(klass) {
     return `export class ${klass.name} extends ${klass.extends} {
-${klass.properties.map(prop => `    ${generateProperty$1(prop)}`).join("\n")}
+${klass.properties.map(prop => `    ${generateProperty$2(prop)}`).join("\n")}
 }`;
 }
 /**
  * Generate just the interface body (without imports) for bundling
  */
-function generateInterfaceBody$1(iface) {
+function generateInterfaceBody$2(iface) {
     return `export interface ${iface.name} {
 ${iface.properties.map(prop => `    ${prop.name}: ${prop.type};`).join("\n")}
 }`;
@@ -1790,7 +1790,7 @@ function generateClass$6(klass, namespace, allClasses) {
         }
     });
     const localImports = allRefs.
-        filter(ref => ref.childType && typeMaps$6[ref.childType] === undefined).
+        filter(ref => ref.childType && typeMaps$7[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
         filter(distinct$5).
@@ -1798,13 +1798,13 @@ function generateClass$6(klass, namespace, allClasses) {
         join("\n");
     return `${getCommentHeader()}
 
-${COMMON_IMPORTS$4}
+${COMMON_IMPORTS$5}
 ${localImports}
 
-${generateClassBody$6(klass)}
+${generateClassBody$7(klass)}
 `;
 }
-function generateProperty$1(prop) {
+function generateProperty$2(prop) {
     let langType;
     let initializer = "";
     let typeArgs;
@@ -1824,7 +1824,7 @@ function generateProperty$1(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}>`
-                : `ArraySchema<${typeMaps$6[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$7[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `[ ${prop.childType} ]`
@@ -1833,7 +1833,7 @@ function generateProperty$1(prop) {
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}>`
-                : `MapSchema<${typeMaps$6[prop.childType]}>`;
+                : `MapSchema<${typeMaps$7[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `{ map: ${prop.childType} }`
@@ -1842,7 +1842,7 @@ function generateProperty$1(prop) {
         else if (prop.type === "set") {
             langType = (isUpcaseFirst)
                 ? `SetSchema<${prop.childType}>`
-                : `SetSchema<${typeMaps$6[prop.childType]}>`;
+                : `SetSchema<${typeMaps$7[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `{ set: ${prop.childType} }`
@@ -1855,7 +1855,7 @@ function generateProperty$1(prop) {
         typeArgs = `{ quantized: { min: ${q.min}, max: ${q.max}, bits: ${q.bits}${q.wrap ? `, mode: "wrap"` : ""} } }`;
     }
     else {
-        langType = typeMaps$6[prop.type];
+        langType = typeMaps$7[prop.type];
         typeArgs = `"${prop.type}"`;
     }
     // TS1263: "Declarations with initializers cannot also have definite assignment assertions"
@@ -1868,19 +1868,19 @@ function generateProperty$1(prop) {
 function generateInterface$1(structure, namespace, allClasses) {
     return `${getCommentHeader()}
 
-${generateInterfaceBody$1(structure)}
+${generateInterfaceBody$2(structure)}
 `;
 }
 
 var ts = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$7,
-    name: name$6,
-    renderBundle: renderBundle$6
+    generate: generate$8,
+    name: name$7,
+    renderBundle: renderBundle$7
 });
 
-const name$5 = "JavaScript";
-const typeMaps$5 = {
+const name$6 = "JavaScript";
+const typeMaps$6 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -1895,14 +1895,14 @@ const typeMaps$5 = {
     "float32": "number",
     "float64": "number",
 };
-const COMMON_IMPORTS$3 = `const schema = require("@colyseus/schema");
+const COMMON_IMPORTS$4 = `const schema = require("@colyseus/schema");
 const Schema = schema.Schema;
 const type = schema.type;`;
 const distinct$4 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class
  */
-function generate$6(context, options) {
+function generate$7(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".js",
         content: generateClass$5(klass, options.namespace, context.classes)
@@ -1911,13 +1911,13 @@ function generate$6(context, options) {
 /**
  * Generate a single bundled file containing all classes
  */
-function renderBundle$5(context, options) {
+function renderBundle$6(context, options) {
     const fileName = options.namespace ? `${options.namespace}.js` : "schema.js";
-    const classBodies = context.classes.map(klass => generateClassBody$5(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$6(klass));
     const classExports = context.classes.map(klass => `    ${klass.name},`).join("\n");
     const content = `${getCommentHeader()}
 
-${COMMON_IMPORTS$3}
+${COMMON_IMPORTS$4}
 
 ${classBodies.join("\n\n")}
 
@@ -1930,7 +1930,7 @@ ${classExports}
 /**
  * Generate just the class body (without imports) for bundling
  */
-function generateClassBody$5(klass) {
+function generateClassBody$6(klass) {
     return `class ${klass.name} extends ${klass.extends} {
     constructor () {
         super();
@@ -1954,7 +1954,7 @@ function generateClass$5(klass, namespace, allClasses) {
         }
     });
     const localImports = allRefs.
-        filter(ref => ref.childType && typeMaps$5[ref.childType] === undefined).
+        filter(ref => ref.childType && typeMaps$6[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
         filter(distinct$4).
@@ -1962,10 +1962,10 @@ function generateClass$5(klass, namespace, allClasses) {
         join("\n");
     return `${getCommentHeader()}
 
-${COMMON_IMPORTS$3}
+${COMMON_IMPORTS$4}
 ${localImports}
 
-${generateClassBody$5(klass)}
+${generateClassBody$6(klass)}
 
 export default ${klass.name};
 `;
@@ -2015,13 +2015,13 @@ function generatePropertyInitializer(prop) {
 
 var js = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$6,
-    name: name$5,
-    renderBundle: renderBundle$5
+    generate: generate$7,
+    name: name$6,
+    renderBundle: renderBundle$6
 });
 
-const name$4 = "Java";
-const typeMaps$4 = {
+const name$5 = "Java";
+const typeMaps$5 = {
     "string": "String",
     "number": "float",
     "boolean": "boolean",
@@ -2051,7 +2051,7 @@ const typeInitializer = {
     "float32": "0",
     "float64": "0",
 };
-const COMMON_IMPORTS$2 = `import io.colyseus.serializer.schema.Schema;
+const COMMON_IMPORTS$3 = `import io.colyseus.serializer.schema.Schema;
 import io.colyseus.serializer.schema.annotations.SchemaClass;
 import io.colyseus.serializer.schema.annotations.SchemaField;`;
 /**
@@ -2060,7 +2060,7 @@ import io.colyseus.serializer.schema.annotations.SchemaField;`;
 /**
  * Generate individual files for each class
  */
-function generate$5(context, options) {
+function generate$6(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".java",
         content: generateClass$4(klass, options.namespace)
@@ -2071,13 +2071,13 @@ function generate$5(context, options) {
  * Note: Java typically requires one public class per file, so bundled mode
  * generates all classes in a single file with package-private visibility
  */
-function renderBundle$4(context, options) {
+function renderBundle$5(context, options) {
     const fileName = options.namespace ? `Schema.java` : "Schema.java";
-    const classBodies = context.classes.map(klass => generateClassBody$4(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$5(klass));
     const content = `${getCommentHeader()}
 ${options.namespace ? `\npackage ${options.namespace};` : ""}
 
-${COMMON_IMPORTS$2}
+${COMMON_IMPORTS$3}
 
 ${classBodies.join("\n\n")}
 `;
@@ -2086,10 +2086,10 @@ ${classBodies.join("\n\n")}
 /**
  * Generate just the class body (without package/imports) for bundling
  */
-function generateClassBody$4(klass) {
+function generateClassBody$5(klass) {
     return `@SchemaClass
 class ${klass.name} extends ${klass.extends} {
-${klass.properties.map(prop => generateProperty(prop, "")).join("\n\n")}
+${klass.properties.map(prop => generateProperty$1(prop, "")).join("\n\n")}
 }`;
 }
 /**
@@ -2100,16 +2100,16 @@ function generateClass$4(klass, namespace) {
     return `${getCommentHeader()}
 ${namespace ? `\npackage ${namespace};` : ""}
 
-${COMMON_IMPORTS$2}
+${COMMON_IMPORTS$3}
 
 @SchemaClass
 ${indent}public class ${klass.name} extends ${klass.extends} {
-${klass.properties.map(prop => generateProperty(prop, indent)).join("\n\n")}
+${klass.properties.map(prop => generateProperty$1(prop, indent)).join("\n\n")}
 ${indent}}
 ${namespace ? "}" : ""}
 `;
 }
-function generateProperty(prop, indent = "") {
+function generateProperty$1(prop, indent = "") {
     let typeArgs = `${prop.index}/${prop.type}`;
     let property = "public";
     let langType;
@@ -2123,7 +2123,7 @@ function generateProperty(prop, indent = "") {
         if (prop.type === "ref") {
             langType = (isUpcaseFirst)
                 ? prop.childType
-                : typeMaps$4[prop.childType];
+                : typeMaps$5[prop.childType];
             initializer = `new ${langType}${(prop.type !== "ref" && isUpcaseFirst) ? "<>" : ""}(${ctorArgs})`;
         }
         else if (prop.type === "array") {
@@ -2145,7 +2145,7 @@ function generateProperty(prop, indent = "") {
         }
     }
     else {
-        langType = typeMaps$4[prop.type];
+        langType = typeMaps$5[prop.type];
         initializer = typeInitializer[prop.type];
     }
     property += ` ${langType} ${prop.name}`;
@@ -2155,18 +2155,18 @@ function generateProperty(prop, indent = "") {
 
 var java = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$5,
-    name: name$4,
-    renderBundle: renderBundle$4
+    generate: generate$6,
+    name: name$5,
+    renderBundle: renderBundle$5
 });
 
-const name$3 = "LUA";
+const name$4 = "LUA";
 /**
     TODO:
     - Support inheritance
     - Support importing Schema dependencies
 */
-const typeMaps$3 = {
+const typeMaps$4 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -2181,14 +2181,14 @@ const typeMaps$3 = {
     "float32": "number",
     "float64": "number",
 };
-const COMMON_IMPORTS$1 = `local schema = require 'colyseus.serializer.schema.schema'`;
+const COMMON_IMPORTS$2 = `local schema = require 'colyseus.serializer.schema.schema'`;
 const QUANTIZE_IMPORT = `local quantize = require 'colyseus.serializer.schema.quantize'`;
 const distinct$3 = (value, index, self) => self.indexOf(value) === index;
 const hasQuantized = (classes) => classes.some(klass => klass.properties.some(prop => prop.quantized));
 /**
  * Generate individual files for each class
  */
-function generate$4(context, options) {
+function generate$5(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".lua",
         content: generateClass$3(klass, options.namespace, context.classes)
@@ -2197,13 +2197,13 @@ function generate$4(context, options) {
 /**
  * Generate a single bundled file containing all classes
  */
-function renderBundle$3(context, options) {
+function renderBundle$4(context, options) {
     const fileName = options.namespace ? `${options.namespace}.lua` : "schema.lua";
-    const classBodies = context.classes.map(klass => generateClassBody$3(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$4(klass));
     const classNames = context.classes.map(klass => `    ${klass.name} = ${klass.name},`).join("\n");
     const content = `${getCommentHeader().replace(/\/\//mg, "--")}
 
-${COMMON_IMPORTS$1}${hasQuantized(context.classes) ? `\n${QUANTIZE_IMPORT}` : ""}
+${COMMON_IMPORTS$2}${hasQuantized(context.classes) ? `\n${QUANTIZE_IMPORT}` : ""}
 
 ${classBodies.join("\n\n")}
 
@@ -2216,7 +2216,7 @@ ${classNames}
 /**
  * Generate just the class body (without requires) for bundling
  */
-function generateClassBody$3(klass) {
+function generateClassBody$4(klass) {
     // Inheritance support
     const inherits = (klass.extends !== "Schema")
         ? `, ${klass.extends}`
@@ -2241,7 +2241,7 @@ function generateClass$3(klass, namespace, allClasses) {
         }
     });
     const localRequires = allRefs.
-        filter(ref => ref.childType && typeMaps$3[ref.childType] === undefined).
+        filter(ref => ref.childType && typeMaps$4[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
         filter(distinct$3).
@@ -2249,10 +2249,10 @@ function generateClass$3(klass, namespace, allClasses) {
         join("\n");
     return `${getCommentHeader().replace(/\/\//mg, "--")}
 
-${COMMON_IMPORTS$1}${hasQuantized([klass]) ? `\n${QUANTIZE_IMPORT}` : ""}
+${COMMON_IMPORTS$2}${hasQuantized([klass]) ? `\n${QUANTIZE_IMPORT}` : ""}
 ${localRequires}
 
-${generateClassBody$3(klass)}
+${generateClassBody$4(klass)}
 
 return ${klass.name}
 `;
@@ -2302,22 +2302,22 @@ function getLUATypeAnnotation(prop) {
         return "MapSchema";
     }
     else {
-        return typeMaps$3[prop.type];
+        return typeMaps$4[prop.type];
     }
 }
 
 var lua = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$4,
-    name: name$3,
-    renderBundle: renderBundle$3
+    generate: generate$5,
+    name: name$4,
+    renderBundle: renderBundle$4
 });
 
-const name$2 = "C";
+const name$3 = "C";
 /**
  * Type mappings for C
  */
-const typeMaps$2 = {
+const typeMaps$3 = {
     "string": "char*",
     "number": "double",
     "boolean": "bool",
@@ -2370,7 +2370,7 @@ const distinct$2 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class
  */
-function generate$3(context, options) {
+function generate$4(context, options) {
     return context.classes.map(klass => ({
         name: toSnakeCase(klass.name) + ".h",
         content: generateClass$2(klass, options.namespace, context.classes)
@@ -2379,10 +2379,10 @@ function generate$3(context, options) {
 /**
  * Generate a single bundled header file containing all classes
  */
-function renderBundle$2(context, options) {
+function renderBundle$3(context, options) {
     const fileName = options.namespace ? `${toSnakeCase(options.namespace)}.h` : "schema.h";
     const guardName = `__SCHEMA_CODEGEN_${(options.namespace || "SCHEMA").toUpperCase()}_H__`;
-    const classBodies = context.classes.map(klass => generateClassBody$2(klass, context.classes)).join("\n\n");
+    const classBodies = context.classes.map(klass => generateClassBody$3(klass, context.classes)).join("\n\n");
     const content = `${getCommentHeader()}
 #ifndef ${guardName}
 #define ${guardName} 1
@@ -2398,7 +2398,7 @@ ${classBodies}
 /**
  * Generate just the class body (without guards/includes) for bundling
  */
-function generateClassBody$2(klass, allClasses) {
+function generateClassBody$3(klass, allClasses) {
     const snakeName = toSnakeCase(klass.name);
     const typeName = `${snakeName}_t`;
     const allProperties = getAllProperties(klass, allClasses);
@@ -2426,7 +2426,7 @@ function generateClass$2(klass, namespace, allClasses) {
     });
     // Generate includes for referenced schema types
     const refIncludes = allRefs
-        .filter(ref => ref.childType && typeMaps$2[ref.childType] === undefined)
+        .filter(ref => ref.childType && typeMaps$3[ref.childType] === undefined)
         .map(ref => ref.childType)
         .concat(getInheritanceTree(klass, allClasses, false).map(k => k.name))
         .filter(distinct$2)
@@ -2438,7 +2438,7 @@ function generateClass$2(klass, namespace, allClasses) {
 
 ${COMMON_INCLUDES}
 ${refIncludes ? `\n${refIncludes}\n` : ""}
-${generateClassBody$2(klass, allClasses)}
+${generateClassBody$3(klass, allClasses)}
 
 #endif
 `;
@@ -2459,7 +2459,7 @@ function getCType(prop) {
         return `${toSnakeCase(prop.childType)}_t*`;
     }
     else if (prop.type === "array") {
-        if (typeMaps$2[prop.childType]) {
+        if (typeMaps$3[prop.childType]) {
             return `colyseus_array_schema_t*`;
         }
         else {
@@ -2467,7 +2467,7 @@ function getCType(prop) {
         }
     }
     else if (prop.type === "map") {
-        if (typeMaps$2[prop.childType]) {
+        if (typeMaps$3[prop.childType]) {
             return `colyseus_map_schema_t*`;
         }
         else {
@@ -2475,7 +2475,7 @@ function getCType(prop) {
         }
     }
     else {
-        return typeMaps$2[prop.type] || `${toSnakeCase(prop.type)}_t*`;
+        return typeMaps$3[prop.type] || `${toSnakeCase(prop.type)}_t*`;
     }
 }
 function getFieldType(prop) {
@@ -2503,11 +2503,11 @@ function generateFieldsArray(klass, typeName, snakeName, allProperties) {
         let vtableRef = "NULL";
         let childPrimitiveRef = "NULL";
         let quantizedRef = "NULL";
-        if (prop.type === "ref" && prop.childType && !typeMaps$2[prop.childType]) {
+        if (prop.type === "ref" && prop.childType && !typeMaps$3[prop.childType]) {
             const childSnake = toSnakeCase(prop.childType);
             vtableRef = `&${childSnake}_vtable`;
         }
-        else if ((prop.type === "array" || prop.type === "map") && prop.childType && !typeMaps$2[prop.childType]) {
+        else if ((prop.type === "array" || prop.type === "map") && prop.childType && !typeMaps$3[prop.childType]) {
             const childSnake = toSnakeCase(prop.childType);
             vtableRef = `&${childSnake}_vtable`;
         }
@@ -2537,7 +2537,7 @@ function generateDestroyFunction(klass, snakeName, typeName, allProperties) {
             freeStatements.push(`    if (instance->${prop.name}) free(instance->${prop.name});`);
         }
         else if (prop.type === "ref") {
-            if (typeMaps$2[prop.childType]) {
+            if (typeMaps$3[prop.childType]) {
                 freeStatements.push(`    if (instance->${prop.name}) free(instance->${prop.name});`);
             }
             else {
@@ -2574,16 +2574,16 @@ function getAllProperties(klass, allClasses) {
 
 var c = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$3,
-    name: name$2,
-    renderBundle: renderBundle$2
+    generate: generate$4,
+    name: name$3,
+    renderBundle: renderBundle$3
 });
 
-const name$1 = "GDScript";
+const name$2 = "GDScript";
 /**
  * Type mappings from schema types to GDScript Colyseus.Schema type constants
  */
-const typeMaps$1 = {
+const typeMaps$2 = {
     "string": "Colyseus.Schema.STRING",
     "number": "Colyseus.Schema.NUMBER",
     "boolean": "Colyseus.Schema.BOOLEAN",
@@ -2610,10 +2610,10 @@ const distinct$1 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class
  */
-function generate$2(context, options) {
+function generate$3(context, options) {
     // Enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps$1[structure.name] = structure.name;
+        typeMaps$2[structure.name] = structure.name;
     });
     return [
         ...context.classes.map(klass => ({
@@ -2629,16 +2629,16 @@ function generate$2(context, options) {
 /**
  * Generate a single bundled file containing all classes and enums
  */
-function renderBundle$1(context, options) {
+function renderBundle$2(context, options) {
     const fileName = options.namespace ? `${options.namespace}.gd` : "schema.gd";
     // Enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps$1[structure.name] = structure.name;
+        typeMaps$2[structure.name] = structure.name;
     });
     const enumBodies = context.enums
         .filter(structure => structure.name !== 'OPERATION')
-        .map(e => generateEnumBody$1(e));
-    const classBodies = context.classes.map(klass => generateClassBody$1(klass));
+        .map(e => generateEnumBody$2(e));
+    const classBodies = context.classes.map(klass => generateClassBody$2(klass));
     const content = `${getCommentHeader("#")}
 
 ${enumBodies.length > 0 ? enumBodies.join("\n\n") + "\n\n" : ""}${classBodies.join("\n\n")}
@@ -2648,7 +2648,7 @@ ${enumBodies.length > 0 ? enumBodies.join("\n\n") + "\n\n" : ""}${classBodies.jo
 /**
  * Generate just the class body (without preload) for bundling
  */
-function generateClassBody$1(klass) {
+function generateClassBody$2(klass) {
     // Determine parent class
     const parentClass = (klass.extends !== "Schema")
         ? klass.extends
@@ -2693,7 +2693,7 @@ function generateClass$1(klass, namespace, allClasses) {
     });
     // Get required preloads for referenced types
     const preloads = allRefs
-        .filter(ref => ref.childType && typeMaps$1[ref.childType] === undefined)
+        .filter(ref => ref.childType && typeMaps$2[ref.childType] === undefined)
         .map(ref => ref.childType)
         .concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name))
         .filter(distinct$1)
@@ -2701,7 +2701,7 @@ function generateClass$1(klass, namespace, allClasses) {
         .join("\n");
     return `${getCommentHeader("#")}
 
-${preloads ? preloads + "\n\n" : ""}${generateClassBody$1(klass)}
+${preloads ? preloads + "\n\n" : ""}${generateClassBody$2(klass)}
 `;
 }
 /**
@@ -2713,12 +2713,12 @@ function generateFieldDefinition(prop) {
         const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
         // Array or Map container
         const containerType = containerMaps[prop.type];
-        const childTypeRef = isUpcaseFirst ? prop.childType : typeMaps$1[prop.childType] || `"${prop.childType}"`;
+        const childTypeRef = isUpcaseFirst ? prop.childType : typeMaps$2[prop.childType] || `"${prop.childType}"`;
         args = [`"${prop.name}"`, containerType, childTypeRef];
     }
     else {
         // Primitive type
-        const typeRef = typeMaps$1[prop.type] || `"${prop.type}"`;
+        const typeRef = typeMaps$2[prop.type] || `"${prop.type}"`;
         args = [`"${prop.name}"`, typeRef];
     }
     return `\t\t\tColyseus.Schema.Field.new(${args.join(", ")})`;
@@ -2726,7 +2726,7 @@ function generateFieldDefinition(prop) {
 /**
  * Generate just the enum body for bundling
  */
-function generateEnumBody$1(_enum) {
+function generateEnumBody$2(_enum) {
     const enumValues = _enum.properties.map((prop, index) => {
         let value;
         if (prop.type) {
@@ -2752,24 +2752,24 @@ ${enumValues}
 function generateEnum$1(_enum, _namespace) {
     return `${getCommentHeader("#")}
 
-${generateEnumBody$1(_enum)}
+${generateEnumBody$2(_enum)}
 `;
 }
 
 var gdscript = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$2,
-    name: name$1,
-    renderBundle: renderBundle$1
+    generate: generate$3,
+    name: name$2,
+    renderBundle: renderBundle$2
 });
 
-const name = "Dart/Flutter";
+const name$1 = "Dart/Flutter";
 /**
  * Dart types for interface (plain message) properties. Schema scalar getters
  * don't use this table: the `colyseus` package reads every numeric field as
  * `double` through `SchemaView`, so all numeric schema types collapse there.
  */
-const typeMaps = {
+const typeMaps$1 = {
     "string": "String",
     "number": "double",
     "boolean": "bool",
@@ -2784,12 +2784,12 @@ const typeMaps = {
     "float32": "double",
     "float64": "double",
 };
-const enumNames = new Set();
-const COMMON_IMPORTS = `import 'package:colyseus/colyseus.dart';`;
+const enumNames$1 = new Set();
+const COMMON_IMPORTS$1 = `import 'package:colyseus/colyseus.dart';`;
 // Field names come from the server schema and may not be lowerCamelCase.
 const LINT_HEADER = `// ignore_for_file: non_constant_identifier_names, constant_identifier_names`;
 const distinct = (value, index, self) => self.indexOf(value) === index;
-const isSchemaType = (childType) => childType !== undefined && /^[A-Z]/.test(childType) && !enumNames.has(childType);
+const isSchemaType$1 = (childType) => childType !== undefined && /^[A-Z]/.test(childType) && !enumNames$1.has(childType);
 /**
  * Dart Code Generator
  *
@@ -2802,8 +2802,8 @@ const isSchemaType = (childType) => childType !== undefined && /^[A-Z]/.test(chi
 /**
  * Generate individual files for each class/interface/enum
  */
-function generate$1(context, options) {
-    context.enums.forEach((structure) => enumNames.add(structure.name));
+function generate$2(context, options) {
+    context.enums.forEach((structure) => enumNames$1.add(structure.name));
     return [
         ...context.classes.map(klass => ({
             name: `${klass.name}.dart`,
@@ -2822,20 +2822,20 @@ function generate$1(context, options) {
 /**
  * Generate a single bundled file containing all classes, interfaces, and enums
  */
-function renderBundle(context, options) {
+function renderBundle$1(context, options) {
     const fileName = options.namespace ? `${options.namespace}.dart` : "schema.dart";
-    context.enums.forEach((structure) => enumNames.add(structure.name));
+    context.enums.forEach((structure) => enumNames$1.add(structure.name));
     const bodies = [
-        ...context.classes.map(klass => generateClassBody(klass, context.classes)),
-        ...context.interfaces.map(iface => generateInterfaceBody(iface)),
+        ...context.classes.map(klass => generateClassBody$1(klass, context.classes)),
+        ...context.interfaces.map(iface => generateInterfaceBody$1(iface)),
         ...context.enums
             .filter(structure => structure.name !== 'OPERATION')
-            .map(e => generateEnumBody(e)),
+            .map(e => generateEnumBody$1(e)),
     ].join("\n\n");
     const content = `${getCommentHeader()}
 ${LINT_HEADER}
 
-${COMMON_IMPORTS}
+${COMMON_IMPORTS$1}
 
 ${bodies}
 `;
@@ -2844,7 +2844,7 @@ ${bodies}
 /**
  * Generate just the class body (without imports) for bundling
  */
-function generateClassBody(klass, allClasses) {
+function generateClassBody$1(klass, allClasses) {
     // `SchemaRef` is a `base` class, so subclasses carry a modifier: `base`
     // when the class is itself extended (extendable from any file), `final`
     // otherwise.
@@ -2866,7 +2866,7 @@ ${getters}
  */
 function generateClass(klass, allClasses) {
     const localRefs = klass.properties
-        .filter(prop => isSchemaType(prop.childType))
+        .filter(prop => isSchemaType$1(prop.childType))
         .map(prop => prop.childType)
         .concat(klass.extends !== "Schema" ? [klass.extends] : [])
         .filter(distinct)
@@ -2876,9 +2876,9 @@ function generateClass(klass, allClasses) {
     return `${getCommentHeader()}
 ${LINT_HEADER}
 
-${COMMON_IMPORTS}
+${COMMON_IMPORTS$1}
 ${localRefs ? localRefs + "\n" : ""}
-${generateClassBody(klass, allClasses)}
+${generateClassBody$1(klass, allClasses)}
 `;
 }
 /**
@@ -2892,7 +2892,7 @@ function scalarDartType(type) {
     if (type === "boolean") {
         return "bool";
     }
-    if (typeMaps[type] === "double" || type === "quantized" || type === "number") {
+    if (typeMaps$1[type] === "double" || type === "quantized" || type === "number") {
         return "double";
     }
     return undefined;
@@ -2902,7 +2902,7 @@ function generateGetter(prop) {
         ? `  @Deprecated("field '${prop.name}' is deprecated.")\n`
         : '';
     let body;
-    if (prop.childType && isSchemaType(prop.childType)) {
+    if (prop.childType && isSchemaType$1(prop.childType)) {
         if (prop.type === "ref") {
             body = `  ${prop.childType}? get ${prop.name} => refOf('${prop.name}', ${prop.childType}.new);`;
         }
@@ -2914,7 +2914,7 @@ function generateGetter(prop) {
         }
     }
     else if (prop.childType) {
-        const child = typeMaps[prop.childType] ?? "dynamic";
+        const child = typeMaps$1[prop.childType] ?? "dynamic";
         if (prop.type === "map") {
             body = `  MapSchema<${child}> get ${prop.name} => primitiveMapOf('${prop.name}');`;
         }
@@ -2947,9 +2947,9 @@ function generateGetter(prop) {
 /**
  * Generate just the interface body for bundling
  */
-function generateInterfaceBody(struct) {
+function generateInterfaceBody$1(struct) {
     const fields = struct.properties
-        .map(prop => `  ${getInterfaceType(prop)}? ${prop.name};`)
+        .map(prop => `  ${getInterfaceType$1(prop)}? ${prop.name};`)
         .join("\n");
     return `class ${struct.name} {
 ${fields}
@@ -2960,7 +2960,7 @@ ${fields}
  */
 function generateInterface(struct) {
     const localRefs = struct.properties
-        .filter(prop => isSchemaType(prop.childType ?? (typeMaps[prop.type] ? undefined : prop.type)))
+        .filter(prop => isSchemaType$1(prop.childType ?? (typeMaps$1[prop.type] ? undefined : prop.type)))
         .map(prop => prop.childType ?? prop.type)
         .filter(distinct)
         .map(ref => `import '${ref}.dart';`)
@@ -2968,20 +2968,20 @@ function generateInterface(struct) {
     return `${getCommentHeader()}
 ${LINT_HEADER}
 ${localRefs ? "\n" + localRefs + "\n" : ""}
-${generateInterfaceBody(struct)}
+${generateInterfaceBody$1(struct)}
 `;
 }
-function getInterfaceType(prop) {
+function getInterfaceType$1(prop) {
     if (prop.type === "array") {
-        return `List<${typeMaps[prop.childType] ?? prop.childType ?? "dynamic"}>`;
+        return `List<${typeMaps$1[prop.childType] ?? prop.childType ?? "dynamic"}>`;
     }
-    return typeMaps[prop.type] ?? prop.type ?? "dynamic";
+    return typeMaps$1[prop.type] ?? prop.type ?? "dynamic";
 }
 /**
  * Generate just the enum body for bundling: a namespace of consts, since
  * Colyseus enums may carry string or float values Dart enums can't.
  */
-function generateEnumBody(_enum) {
+function generateEnumBody$1(_enum) {
     const members = _enum.properties
         .map((prop, i) => {
         let value;
@@ -3005,18 +3005,265 @@ function generateEnum(_enum) {
     return `${getCommentHeader()}
 ${LINT_HEADER}
 
-${generateEnumBody(_enum)}
+${generateEnumBody$1(_enum)}
 `;
 }
 
 var dart = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$2,
+    name: name$1,
+    renderBundle: renderBundle$1
+});
+
+const name = "Swift";
+/**
+ * Swift types for interface (plain message) properties. Schema getters do not
+ * use this table: the `Colyseus` package reads every numeric field as `Double`
+ * through `SchemaView`, so all numeric schema types collapse there.
+ */
+const typeMaps = {
+    "string": "String",
+    "number": "Double",
+    "boolean": "Bool",
+    "int8": "Int",
+    "uint8": "Int",
+    "int16": "Int",
+    "uint16": "Int",
+    "int32": "Int",
+    "uint32": "Int",
+    "int64": "Int",
+    "uint64": "Int",
+    "float32": "Double",
+    "float64": "Double",
+};
+const enumNames = new Set();
+const COMMON_IMPORTS = `import Colyseus`;
+const isSchemaType = (childType) => childType !== undefined && /^[A-Z]/.test(childType) && !enumNames.has(childType);
+/**
+ * Swift Code Generator
+ *
+ * Emits typed façades over the `Colyseus` package's runtime: one `SchemaRef`
+ * subclass per schema, whose properties read through the shared handle on the
+ * instance the core decoded. Nothing is copied and nothing is stored, so a
+ * generated class stays correct as patches arrive.
+ *
+ * Collection properties return `MapSchema<T>` / `ArraySchema<T>`, which carry
+ * the field they came from — that is what `callbacks.onAdd(state.players, …)`
+ * registers against.
+ */
+/**
+ * Generate individual files for each class/interface/enum
+ */
+function generate$1(context, options) {
+    context.enums.forEach((structure) => enumNames.add(structure.name));
+    return [
+        ...context.classes.map(klass => ({
+            name: `${klass.name}.swift`,
+            content: generateFile(generateClassBody(klass, context.classes, !!options.namespace), options)
+        })),
+        ...context.interfaces.map(structure => ({
+            name: `${structure.name}.swift`,
+            content: generateFile(generateInterfaceBody(structure), options),
+        })),
+        ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
+            name: `${structure.name}.swift`,
+            content: generateFile(generateEnumBody(structure), options),
+        })),
+    ];
+}
+/**
+ * Generate a single bundled file containing all classes, interfaces, and enums
+ */
+function renderBundle(context, options) {
+    const fileName = options.namespace ? `${options.namespace}.swift` : "Schema.swift";
+    context.enums.forEach((structure) => enumNames.add(structure.name));
+    const bodies = [
+        ...context.classes.map(klass => generateClassBody(klass, context.classes, !!options.namespace)),
+        ...context.interfaces.map(iface => generateInterfaceBody(iface)),
+        ...context.enums
+            .filter(structure => structure.name !== 'OPERATION')
+            .map(e => generateEnumBody(e)),
+    ].join("\n\n");
+    return { name: fileName, content: generateFile(bodies, options) };
+}
+/**
+ * Swift has no namespaces, so one stands in as a caseless enum. Declarations
+ * go inside it through an extension, which works the same whether they are
+ * bundled into one file or split across many.
+ */
+function generateFile(body, options) {
+    const header = `${getCommentHeader()}
+
+${COMMON_IMPORTS}
+`;
+    if (!options.namespace) {
+        return `${header}
+${body}
+`;
+    }
+    return `${header}
+public enum ${options.namespace} {}
+
+extension ${options.namespace} {
+${indent(body)}
+}
+`;
+}
+function indent(text) {
+    return text
+        .split("\n")
+        .map(line => (line.length > 0 ? `    ${line}` : line))
+        .join("\n");
+}
+function generateClassBody(klass, allClasses, namespaced) {
+    // A class nobody extends is final. One that is extended stays open so a
+    // consumer in another module can subclass it — except inside a namespace,
+    // where `open` conflicts with the extension's own access level and the
+    // subclass is generated alongside it anyway.
+    const isExtended = allClasses.some(other => other.extends === klass.name);
+    const modifier = isExtended ? (namespaced ? "public" : "open") : "public final";
+    const parent = (klass.extends === "Schema") ? "SchemaRef" : klass.extends;
+    const properties = klass.properties
+        .map(prop => generateProperty(prop))
+        .filter(Boolean)
+        .join("\n");
+    // Swift does not carry an `@unchecked Sendable` conformance across module
+    // boundaries, so every subclass has to restate it. What it asserts is the
+    // SDK's own contract: decoded state is read where it is pumped.
+    return `${modifier} class ${klass.name}: ${parent}, @unchecked Sendable {
+${properties}
+}`;
+}
+/**
+ * The Swift type a scalar schema field reads as, or undefined when the field
+ * can only be read dynamically (enum-typed and unknown types).
+ */
+function scalarSwiftType(type) {
+    if (type === "string") {
+        return "String";
+    }
+    if (type === "boolean") {
+        return "Bool";
+    }
+    if (typeMaps[type] === "Double" || typeMaps[type] === "Int" || type === "quantized" || type === "number") {
+        return "Double";
+    }
+    return undefined;
+}
+function generateProperty(prop) {
+    const deprecation = (prop.deprecated)
+        ? `    @available(*, deprecated, message: "field '${prop.name}' is deprecated.")\n`
+        : '';
+    const escaped = escapeName(prop.name);
+    let body;
+    if (prop.childType && isSchemaType(prop.childType)) {
+        if (prop.type === "ref") {
+            body = `    public var ${escaped}: ${prop.childType}? { refOf("${prop.name}") }`;
+        }
+        else if (prop.type === "map") {
+            body = `    public var ${escaped}: MapSchema<${prop.childType}> { mapOf("${prop.name}") }`;
+        }
+        else {
+            body = `    public var ${escaped}: ArraySchema<${prop.childType}> { arrayOf("${prop.name}") }`;
+        }
+    }
+    else if (prop.childType) {
+        // A collection of primitives. Everything numeric reads as Double, the
+        // same collapse the scalar getters make.
+        const child = typeMaps[prop.childType] === "String" ? "String" : "Double";
+        if (prop.type === "map") {
+            body = `    public var ${escaped}: MapSchema<${child}> { mapOf("${prop.name}") }`;
+        }
+        else if (prop.type === "array") {
+            body = `    public var ${escaped}: ArraySchema<${child}> { arrayOf("${prop.name}") }`;
+        }
+        else {
+            // A "ref" with a primitive child has no typed shape to offer.
+            body = `    public var ${escaped}: Double { view["${prop.name}"] }`;
+        }
+    }
+    else {
+        const swiftType = scalarSwiftType(prop.type);
+        if (swiftType === "String") {
+            body = `    public var ${escaped}: String { view.string("${prop.name}") ?? "" }`;
+        }
+        else if (swiftType === "Bool") {
+            body = `    public var ${escaped}: Bool { view.bool("${prop.name}") }`;
+        }
+        else if (swiftType === "Double") {
+            body = `    public var ${escaped}: Double { view["${prop.name}"] }`;
+        }
+        else {
+            // Enum-typed or unknown: read as the number the wire carries.
+            body = `    public var ${escaped}: Double { view["${prop.name}"] }`;
+        }
+    }
+    return deprecation + body;
+}
+/**
+ * Message payloads are plain structs rather than façades: they arrive as
+ * msgpack, not as decoded schema state.
+ */
+function generateInterfaceBody(struct) {
+    const fields = struct.properties
+        .map(prop => `    public var ${escapeName(prop.name)}: ${getInterfaceType(prop)}?`)
+        .join("\n");
+    return `public struct ${struct.name}: Codable {
+${fields}
+
+    public init() {}
+}`;
+}
+function getInterfaceType(prop) {
+    if (prop.type === "array") {
+        return `[${typeMaps[prop.childType] ?? prop.childType ?? "Double"}]`;
+    }
+    return typeMaps[prop.type] ?? prop.type ?? "Double";
+}
+/**
+ * A namespace of constants rather than a Swift enum: Colyseus enums may carry
+ * string or floating-point values, and a Swift enum's raw type has to be one
+ * or the other.
+ */
+function generateEnumBody(_enum) {
+    const members = _enum.properties
+        .map((prop, i) => {
+        let value;
+        if (prop.type) {
+            value = isNaN(Number(prop.type)) ? `"${prop.type}"` : `${Number(prop.type)}`;
+        }
+        else {
+            value = `${i}`;
+        }
+        return `    public static let ${escapeName(prop.name)} = ${value}`;
+    })
+        .join("\n");
+    return `public enum ${_enum.name} {
+${members}
+}`;
+}
+/** Field names come from the server schema and may collide with a keyword. */
+const SWIFT_KEYWORDS = new Set([
+    "associatedtype", "class", "deinit", "enum", "extension", "fileprivate", "func", "import",
+    "init", "inout", "internal", "let", "open", "operator", "private", "precedencegroup",
+    "protocol", "public", "rethrows", "static", "struct", "subscript", "typealias", "var",
+    "break", "case", "catch", "continue", "default", "defer", "do", "else", "fallthrough",
+    "for", "guard", "if", "in", "repeat", "return", "throw", "switch", "where", "while",
+    "Any", "as", "await", "false", "is", "nil", "self", "Self", "super", "throws", "true", "try",
+]);
+function escapeName(name) {
+    return SWIFT_KEYWORDS.has(name) ? `\`${name}\`` : name;
+}
+
+var swift = /*#__PURE__*/Object.freeze({
     __proto__: null,
     generate: generate$1,
     name: name,
     renderBundle: renderBundle
 });
 
-const generators = { csharp, cpp, haxe, ts, js, java, lua, c, gdscript, dart, };
+const generators = { csharp, cpp, haxe, ts, js, java, lua, c, gdscript, dart, swift, };
 function generate(targetId, options) {
     const generator = generators[targetId];
     if (!generator) {