[dart] Fix remaining dart-writer issues, apply dart fix at the end of generation to clean up superfluos imports in generated files.

spine-flutter/codegen/src/dart-writer.ts

@@ -1,40 +1,38 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import type { CClassOrStruct, CEnum, CMethod, CParameter } from '../../../spine-c/codegen/src/c-types.js';
 import { toSnakeCase } from '../../../spine-c/codegen/src/types.js';
 
-const LICENSE_HEADER = `// ******************************************************************************
-// Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
-//
-// Copyright (c) 2013-2023, Esoteric Software LLC
-//
-// Integration of the Spine Runtimes into software or otherwise creating
-// derivative works of the Spine Runtimes is permitted under the terms and
-// conditions of Section 2 of the Spine Editor License Agreement:
-// http://esotericsoftware.com/spine-editor-license
-//
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
-// "Products"), provided that each user of the Products must obtain their own
-// Spine Editor license and redistribution of the Products in any form must
-// include this license and copyright notice.
-//
-// THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
-// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
-// BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
-// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/`;
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LICENSE_HEADER = fs.readFileSync(path.join(__dirname, '../../../spine-cpp/src/spine/Skeleton.cpp'), 'utf8')
+    .split('\n')
+    .slice(0, 28)
+    .map((line, index, array) => {
+        // Convert C++ block comment format to Dart line comment format
+        if (index === 0 && line.startsWith('/****')) {
+            // First line: remove asterisks
+            return '//' + line.substring(4).replace(/\*+/g, '');
+        } else if (index === array.length - 1 && (line.startsWith(' ****') || line.trim() === '*/')) {
+            // Last line: remove asterisks, use // not ///
+            return '//' + line.substring(line.indexOf('*') + 1).replace(/\*+/g, '').replace(/\//g, '');
+        } else if (line.startsWith(' ****') || line.trim() === '*/') {
+            return '// ' + line.substring(4);
+        } else if (line.startsWith(' * ')) {
+            return '// ' + line.substring(3);
+        } else if (line.startsWith(' *')) {
+            return '//' + line.substring(2);
+        } else {
+            return line;
+        }
+    })
+    .join('\n');
 
 /** Generates Dart wrapper files from C intermediate representation */
 export class DartWriter {
     private enumNames = new Set<string>();
+    private inheritanceMap = new Map<string, string>(); // child -> parent
+    private classMap = new Map<string, CClassOrStruct>(); // name -> class
 
     constructor(private outputDir: string) {
         this.cleanOutputDirectory();
@@ -48,19 +46,143 @@ export class DartWriter {
         fs.mkdirSync(this.outputDir, { recursive: true });
     }
 
+    /** Build inheritance relationships and class mapping */
+    private buildInheritanceInfo(cTypes: CClassOrStruct[]): void {
+        // Build class map
+        for (const cType of cTypes) {
+            this.classMap.set(cType.name, cType);
+        }
+
+        // Build inheritance map (child -> immediate parent)
+        for (const cType of cTypes) {
+            if (cType.cppType.superTypes && cType.cppType.superTypes.length > 0) {
+                // Find the immediate parent (most specific supertype)
+                let immediateParent: string | null = null;
+                
+                for (const superType of cType.cppType.superTypes) {
+                    const parentCName = `spine_${toSnakeCase(superType)}`;
+                    // Check if this parent exists in our class list
+                    if (this.classMap.has(parentCName)) {
+                        // Use the first valid supertype as immediate parent
+                        // (In most cases there's only one direct parent)
+                        if (!immediateParent) {
+                            immediateParent = parentCName;
+                        }
+                    }
+                }
+                
+                if (immediateParent) {
+                    this.inheritanceMap.set(cType.name, immediateParent);
+                }
+            }
+        }
+    }
+
+    /** Sort classes by inheritance dependency (base classes first) */
+    private sortByInheritance(cTypes: CClassOrStruct[]): CClassOrStruct[] {
+        const sorted: CClassOrStruct[] = [];
+        const processed = new Set<string>();
+        
+        const processClass = (cType: CClassOrStruct) => {
+            if (processed.has(cType.name)) {
+                return;
+            }
+            
+            // Process parent first
+            const parentName = this.inheritanceMap.get(cType.name);
+            if (parentName) {
+                const parent = this.classMap.get(parentName);
+                if (parent) {
+                    processClass(parent);
+                }
+            }
+            
+            // Then process this class
+            sorted.push(cType);
+            processed.add(cType.name);
+        };
+        
+        // Process all classes
+        for (const cType of cTypes) {
+            processClass(cType);
+        }
+        
+        return sorted;
+    }
+
+    /** Check if a class is abstract */
+    private isAbstract(cType: CClassOrStruct): boolean {
+        return cType.cppType.isAbstract === true;
+    }
+
+    /** Get parent class name for inheritance */
+    private getParentClass(cType: CClassOrStruct): string | null {
+        return this.inheritanceMap.get(cType.name) || null;
+    }
+
+    /** Get root parent class name (for accessing static bindings) */
+    private getRootParent(cType: CClassOrStruct): string {
+        let current = cType.name;
+        while (this.inheritanceMap.has(current)) {
+            current = this.inheritanceMap.get(current)!;
+        }
+        return current;
+    }
+
+    /** Check if a method is inherited from a parent class */
+    private isMethodInherited(method: CMethod, cType: CClassOrStruct): boolean {
+        // Find if this method exists in any parent class
+        const parentName = this.getParentClass(cType);
+        if (!parentName) {
+            return false;
+        }
+        
+        const parent = this.classMap.get(parentName);
+        if (!parent) {
+            return false;
+        }
+        
+        // Check if parent has this method (by looking at the method name pattern)
+        const methodSuffix = this.getMethodSuffix(method.name, cType.name);
+        const parentMethodName = `${parentName}_${methodSuffix}`;
+        
+        const hasInParent = parent.methods.some(m => m.name === parentMethodName);
+        if (hasInParent) {
+            return true;
+        }
+        
+        // Recursively check parent's parents
+        return this.isMethodInherited(method, parent);
+    }
+
+    /** Extract method suffix from full method name */
+    private getMethodSuffix(methodName: string, typeName: string): string {
+        const prefix = `${typeName}_`;
+        if (methodName.startsWith(prefix)) {
+            return methodName.slice(prefix.length);
+        }
+        return methodName;
+    }
+
     async writeAll(cTypes: CClassOrStruct[], cEnums: CEnum[], cArrayTypes: CClassOrStruct[]): Promise<void> {
         // Collect enum names first
         for (const cEnum of cEnums) {
             this.enumNames.add(cEnum.name);
         }
 
+        // Build inheritance information
+        this.buildInheritanceInfo(cTypes);
+
+        // Sort classes by inheritance dependency (base classes first)
+        const sortedTypes = this.sortByInheritance(cTypes);
+
         // Write enums
         for (const cEnum of cEnums) {
             await this.writeEnum(cEnum);
         }
 
-        // Write wrapper classes
-        for (const cType of cTypes) {
+        // Write wrapper classes in dependency order
+        for (const cType of sortedTypes) {
             await this.writeClass(cType);
         }
 
@@ -69,6 +191,9 @@ export class DartWriter {
 
         // Write main export file
         await this.writeExportFile(cTypes, cEnums, cArrayTypes);
+
+        // Run dart fix to clean up generated code
+        await this.runDartFix();
     }
 
 
@@ -130,6 +255,7 @@ export class DartWriter {
         }
         
         lines.push("import 'spine_flutter_bindings_generated.dart';");
+        lines.push("import '../spine_bindings.dart';");
 
         // Check if this class has an rtti method
         const hasRttiMethod = cType.methods.some(m => m.name === `${cType.name}_rtti` && m.parameters.length === 0);
@@ -137,6 +263,13 @@ export class DartWriter {
             lines.push("import 'rtti.dart';");
         }
 
+        // Add parent class import if needed
+        const parentName = this.getParentClass(cType);
+        if (parentName) {
+            const parentDartName = this.toDartTypeName(parentName);
+            lines.push(`import '${toSnakeCase(parentDartName)}.dart';`);
+        }
+
         // Collect all imports needed (arrays, enums, and other types)
         const allImports = this.collectAllImports(cType);
         for (const importFile of allImports) {
@@ -144,40 +277,70 @@ export class DartWriter {
             if (importFile === 'rtti.dart' && hasRttiMethod) {
                 continue;
             }
+            // Skip parent class import if we already added it above
+            if (parentName) {
+                const parentDartName = this.toDartTypeName(parentName);
+                if (importFile === `${toSnakeCase(parentDartName)}.dart`) {
+                    continue;
+                }
+            }
             lines.push(`import '${importFile}';`);
         }
 
         lines.push('');
         lines.push(`/// ${dartClassName} wrapper`);
-        lines.push(`class ${dartClassName} implements Finalizable {`);
-        lines.push('  static late SpineFlutterBindings _bindings;');
+        
+        // Build class declaration with inheritance
+        let classDeclaration = `class ${dartClassName}`;
+        if (this.isAbstract(cType)) {
+            classDeclaration = `abstract ${classDeclaration}`;
+        }
+        
+        if (parentName) {
+            const parentDartName = this.toDartTypeName(parentName);
+            classDeclaration += ` extends ${parentDartName}`;
+        } else {
+            classDeclaration += ` implements Finalizable`;
+        }
+        
+        lines.push(`${classDeclaration} {`);
+        
+        // Every class has its own typed pointer field
         lines.push(`  final Pointer<${cType.name}_wrapper> _ptr;`);
         lines.push('');
-        lines.push('  /// Initialize the bindings for all spine-flutter classes');
-        lines.push('  static void init(SpineFlutterBindings bindings) {');
-        lines.push('    _bindings = bindings;');
-        lines.push('  }');
-        lines.push('');
 
         // Constructor from pointer
-        lines.push(`  ${dartClassName}.fromPointer(this._ptr);`);
+        if (parentName) {
+            // Derived class - initialize own pointer and call super constructor with cast
+            lines.push(`  ${dartClassName}.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());`);
+        } else {
+            // Base class - set the pointer directly  
+            lines.push(`  ${dartClassName}.fromPointer(this._ptr);`);
+        }
+        
         lines.push('');
         lines.push('  /// Get the native pointer for FFI calls');
-        lines.push('  Pointer get nativePtr => _ptr;');
+        lines.push(`  Pointer get nativePtr => _ptr;`);
         lines.push('');
 
-        // Write constructors
-        for (const constr of cType.constructors) {
-            lines.push(this.writeConstructor(dartClassName, constr, cType));
-            lines.push('');
+        // Write constructors (only for concrete classes)
+        if (!this.isAbstract(cType)) {
+            for (const constr of cType.constructors) {
+                lines.push(this.writeConstructor(dartClassName, constr, cType));
+                lines.push('');
+            }
         }
 
-        // Filter out methods with raw pointer parameters
+        // Filter out methods with raw pointer parameters and inherited methods
         const validMethods = cType.methods.filter(method => {
             if (this.hasRawPointerParameters(method)) {
                 console.log(`  Skipping method ${cType.name}::${method.name}: has raw pointer parameters`);
                 return false;
             }
+            if (this.isMethodInherited(method, cType)) {
+                console.log(`  Skipping method ${cType.name}::${method.name}: inherited from parent`);
+                return false;
+            }
             return true;
         });
 
@@ -204,7 +367,7 @@ export class DartWriter {
         // Write dispose method if destructor exists
         if (cType.destructor) {
             lines.push('  void dispose() {');
-            lines.push(`    _bindings.${cType.destructor.name}(_ptr);`);
+            lines.push(`    SpineBindings.bindings.${cType.destructor.name}(_ptr);`);
             lines.push('  }');
         }
 
@@ -223,7 +386,9 @@ export class DartWriter {
         lines.push('// AUTO GENERATED FILE, DO NOT EDIT.');
         lines.push('');
         lines.push("import 'dart:ffi';");
+        lines.push("import 'package:ffi/ffi.dart';");
         lines.push("import 'spine_flutter_bindings_generated.dart';");
+        lines.push("import '../spine_bindings.dart';");
         lines.push("import '../native_array.dart';");
         
         // Collect all imports needed for all array types
@@ -232,6 +397,17 @@ export class DartWriter {
             const elementType = this.extractArrayElementType(arrayType.name);
             if (!this.isPrimitive(elementType) && !['int', 'float', 'bool', 'unsigned_short', 'property_id'].includes(elementType.toLowerCase())) {
                 imports.add(`import '${toSnakeCase(elementType)}.dart';`);
+                
+                // If this element type is abstract, we need to import all its concrete subclasses too
+                const cElementType = `spine_${toSnakeCase(elementType)}`;
+                const cClass = this.classMap.get(cElementType);
+                if (cClass && this.isAbstract(cClass)) {
+                    const concreteSubclasses = this.getConcreteSubclasses(cElementType);
+                    for (const subclass of concreteSubclasses) {
+                        const dartSubclass = this.toDartTypeName(subclass);
+                        imports.add(`import '${toSnakeCase(dartSubclass)}.dart';`);
+                    }
+                }
             }
         }
         
@@ -258,13 +434,6 @@ export class DartWriter {
 
         lines.push(`/// Array of ${elementType} elements`);
         lines.push(`class ${dartClassName} extends NativeArray<${this.toDartElementType(elementType)}> {`);
-        lines.push('  static late SpineFlutterBindings _bindings;');
-        lines.push('');
-        lines.push('  /// Initialize the bindings for all spine-flutter classes');
-        lines.push('  static void init(SpineFlutterBindings bindings) {');
-        lines.push('    _bindings = bindings;');
-        lines.push('  }');
-        lines.push('');
         // Generate typed constructor - arrays use the array wrapper type
         const arrayWrapperType = `${arrayType.name}_wrapper`;
         lines.push(`  ${dartClassName}.fromPointer(Pointer<${arrayWrapperType}> super.ptr);`);
@@ -278,7 +447,7 @@ export class DartWriter {
         if (sizeMethod) {
             lines.push('  @override');
             lines.push('  int get length {');
-            lines.push(`    return _bindings.${sizeMethod.name}(nativePtr.cast());`);
+            lines.push(`    return SpineBindings.bindings.${sizeMethod.name}(nativePtr.cast());`);
             lines.push('  }');
             lines.push('');
         }
@@ -290,7 +459,7 @@ export class DartWriter {
             lines.push('      throw RangeError.index(index, this, \'index\');');
             lines.push('    }');
             
-            lines.push(`    final buffer = _bindings.${bufferMethod.name}(nativePtr.cast());`);
+            lines.push(`    final buffer = SpineBindings.bindings.${bufferMethod.name}(nativePtr.cast());`);
 
             // Handle different element types
             if (elementType === 'int') {
@@ -309,7 +478,16 @@ export class DartWriter {
             } else {
                 // For object types, the buffer contains pointers
                 const dartElementType = this.toDartTypeName(`spine_${toSnakeCase(elementType)}`);
-                lines.push(`    return ${dartElementType}.fromPointer(buffer[index]);`);
+                const cElementType = `spine_${toSnakeCase(elementType)}`;
+                const cClass = this.classMap.get(cElementType);
+                
+                if (cClass && this.isAbstract(cClass)) {
+                    // Use RTTI to determine concrete type for abstract classes
+                    const rttiCode = this.generateRttiBasedInstantiation(dartElementType, 'buffer[index]', cClass);
+                    lines.push(`    ${rttiCode}`);
+                } else {
+                    lines.push(`    return ${dartElementType}.fromPointer(buffer[index]);`);
+                }
             }
 
             lines.push('  }');
@@ -327,7 +505,7 @@ export class DartWriter {
             // Convert value to C type
             const param = setMethod.parameters[2]; // The value parameter
             const convertedValue = this.convertDartToC('value', param);
-            lines.push(`    _bindings.${setMethod.name}(nativePtr.cast(), index, ${convertedValue});`);
+            lines.push(`    SpineBindings.bindings.${setMethod.name}(nativePtr.cast(), index, ${convertedValue});`);
             lines.push('  }');
         }
 
@@ -427,7 +605,7 @@ export class DartWriter {
         const factoryName = constructorName ? `.${constructorName}` : '';
 
         lines.push(`  factory ${dartClassName}${factoryName}(${params}) {`);
-        lines.push(`    final ptr = _bindings.${constr.name}(${args});`);
+        lines.push(`    final ptr = SpineBindings.bindings.${constr.name}(${args});`);
         lines.push(`    return ${dartClassName}.fromPointer(ptr);`);
         lines.push('  }');
 
@@ -472,14 +650,14 @@ export class DartWriter {
 
         lines.push(`${methodSignature}(${params}) {`);
 
-        // Always use the static _bindings
-        const bindingsRef = '_bindings';
+        // Always use the global bindings
+        const bindingsRef = 'SpineBindings.bindings';
 
         if (method.returnType === 'void') {
             lines.push(`    ${bindingsRef}.${method.name}(${args});`);
         } else {
             lines.push(`    final result = ${bindingsRef}.${method.name}(${args});`);
-            lines.push(`    ${this.generateReturnConversion(method.returnType, 'result', bindingsRef)}`);
+            lines.push(`    ${this.generateReturnConversion(method.returnType, 'result')}`);
         }
 
         lines.push('  }');
@@ -491,10 +669,9 @@ export class DartWriter {
         const lines: string[] = [];
         const propertyName = renamedMethod || this.extractPropertyName(method.name, cType.name);
         const dartReturnType = this.toDartReturnType(method.returnType);
-
         lines.push(`  ${dartReturnType} get ${propertyName} {`);
-        lines.push(`    final result = _bindings.${method.name}(_ptr);`);
-        lines.push(`    ${this.generateReturnConversion(method.returnType, 'result', '_bindings')}`);
+        lines.push(`    final result = SpineBindings.bindings.${method.name}(_ptr);`);
+        lines.push(`    ${this.generateReturnConversion(method.returnType, 'result')}`);
         lines.push('  }');
 
         return lines.join('\n');
@@ -517,7 +694,7 @@ export class DartWriter {
         }
 
         lines.push(`  set ${propertyName}(${dartType} value) {`);
-        lines.push(`    _bindings.${method.name}(_ptr, ${this.convertDartToC('value', param)});`);
+        lines.push(`    SpineBindings.bindings.${method.name}(_ptr, ${this.convertDartToC('value', param)});`);
         lines.push('  }');
 
         return lines.join('\n');
@@ -730,7 +907,7 @@ export class DartWriter {
         return dartValue;
     }
 
-    private generateReturnConversion(cReturnType: string, resultVar: string, bindingsRef: string = '_bindings'): string {
+    private generateReturnConversion(cReturnType: string, resultVar: string): string {
         // Handle char* with or without spaces
         if (cReturnType === 'char*' || cReturnType === 'char *' || cReturnType === 'const char*' || cReturnType === 'const char *') {
             return `return ${resultVar}.cast<Utf8>().toDartString();`;
@@ -749,12 +926,63 @@ export class DartWriter {
 
         if (cReturnType.startsWith('spine_')) {
             const dartType = this.toDartTypeName(cReturnType);
+            const cClass = this.classMap.get(cReturnType);
+            if (cClass && this.isAbstract(cClass)) {
+                // Use RTTI to determine concrete type and instantiate correctly
+                return this.generateRttiBasedInstantiation(dartType, resultVar, cClass);
+            }
             return `return ${dartType}.fromPointer(${resultVar});`;
         }
 
         return `return ${resultVar};`;
     }
 
+    private generateRttiBasedInstantiation(abstractType: string, resultVar: string, abstractClass: CClassOrStruct): string {
+        const lines: string[] = [];
+        
+        // Get concrete subclasses for this abstract class
+        const concreteSubclasses = this.getConcreteSubclasses(abstractClass.name);
+        
+        if (concreteSubclasses.length === 0) {
+            return `throw UnsupportedError('Cannot instantiate abstract class ${abstractType} from pointer - no concrete subclasses found');`;
+        }
+        
+        lines.push(`final rtti = SpineBindings.bindings.${abstractClass.name}_get_rtti(${resultVar});`);
+        lines.push(`final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();`);
+        lines.push(`switch (className) {`);
+        
+        for (const subclass of concreteSubclasses) {
+            const dartSubclass = this.toDartTypeName(subclass);
+            lines.push(`  case '${subclass}':`);
+            lines.push(`    return ${dartSubclass}.fromPointer(${resultVar}.cast());`);
+        }
+        
+        lines.push(`  default:`);
+        lines.push(`    throw UnsupportedError('Unknown concrete type: \$className for abstract class ${abstractType}');`);
+        lines.push(`}`);
+        
+        return lines.join('\n    ');
+    }
+
+    private getConcreteSubclasses(abstractClassName: string): string[] {
+        const concreteSubclasses: string[] = [];
+        
+        // Find all classes that inherit from this abstract class
+        for (const [childName, parentName] of this.inheritanceMap.entries()) {
+            if (parentName === abstractClassName) {
+                const childClass = this.classMap.get(childName);
+                if (childClass && !this.isAbstract(childClass)) {
+                    concreteSubclasses.push(childName);
+                } else {
+                    // Recursively check for concrete subclasses
+                    concreteSubclasses.push(...this.getConcreteSubclasses(childName));
+                }
+            }
+        }
+        
+        return concreteSubclasses;
+    }
+
     private collectAllImports(cType: CClassOrStruct): Set<string> {
         const imports = new Set<string>();
         const currentTypeName = this.toDartTypeName(cType.name);
@@ -782,6 +1010,19 @@ export class DartWriter {
                     if (fileName !== currentFileName) {
                         imports.add(fileName);
                     }
+                    
+                    // If this return type is abstract, we need to import all its concrete subclasses too
+                    const returnClass = this.classMap.get(cleanType);
+                    if (returnClass && this.isAbstract(returnClass)) {
+                        const concreteSubclasses = this.getConcreteSubclasses(cleanType);
+                        for (const subclass of concreteSubclasses) {
+                            const dartSubclass = this.toDartTypeName(subclass);
+                            const subclassFileName = `${toSnakeCase(dartSubclass)}.dart`;
+                            if (subclassFileName !== currentFileName) {
+                                imports.add(subclassFileName);
+                            }
+                        }
+                    }
                 }
             }
 
@@ -983,6 +1224,15 @@ export class DartWriter {
                     return true;
                 }
             }
+            
+            // Check if method returns abstract types (which use RTTI and need Utf8)
+            if (method.returnType.startsWith('spine_')) {
+                const cleanType = method.returnType.replace('*', '').trim();
+                const returnClass = this.classMap.get(cleanType);
+                if (returnClass && this.isAbstract(returnClass)) {
+                    return true; // RTTI switch uses Utf8 conversion
+                }
+            }
         }
 
         // Check constructors
@@ -997,4 +1247,31 @@ export class DartWriter {
 
         return false;
     }
+
+    private async runDartFix(): Promise<void> {
+        const { spawn } = await import('node:child_process');
+        
+        return new Promise((resolve, reject) => {
+            console.log('Running dart fix --apply on generated code...');
+            
+            const dartFix = spawn('dart', ['fix', '--apply', this.outputDir], {
+                stdio: 'inherit'
+            });
+            
+            dartFix.on('close', (code) => {
+                if (code === 0) {
+                    console.log('✓ Dart fix completed successfully');
+                    resolve();
+                } else {
+                    console.warn(`⚠ Dart fix exited with code ${code}`);
+                    resolve(); // Don't fail the build if dart fix fails
+                }
+            });
+            
+            dartFix.on('error', (error) => {
+                console.warn(`⚠ Failed to run dart fix: ${error.message}`);
+                resolve(); // Don't fail the build if dart fix fails
+            });
+        });
+    }
 }

spine-flutter/lib/generated/alpha_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,43 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline1.dart';
 
 /// AlphaTimeline wrapper
-class AlphaTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class AlphaTimeline extends CurveTimeline1 {
   final Pointer<spine_alpha_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  AlphaTimeline.fromPointer(this._ptr);
+  AlphaTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory AlphaTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = _bindings.spine_alpha_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings.spine_alpha_timeline_create(frameCount, bezierCount, slotIndex);
     return AlphaTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_alpha_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_alpha_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_alpha_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_alpha_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_alpha_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_alpha_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_alpha_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_alpha_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_alpha_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_alpha_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_alpha_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_alpha_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_alpha_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_alpha_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_alpha_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_alpha_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
   int get slotIndex {
-    final result = _bindings.spine_alpha_timeline_get_slot_index(_ptr);
+    final result = SpineBindings.bindings.spine_alpha_timeline_get_slot_index(_ptr);
     return result;
   }
 
   set slotIndex(int value) {
-    _bindings.spine_alpha_timeline_set_slot_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_alpha_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_alpha_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_alpha_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
+    SpineBindings.bindings.spine_alpha_timeline_set_slot_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_alpha_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_alpha_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/animation.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,15 +23,16 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'skeleton.dart';
 import 'mix_blend.dart';
 import 'mix_direction.dart';
@@ -39,72 +40,66 @@ import 'arrays.dart';
 
 /// Animation wrapper
 class Animation implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_animation_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Animation.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory Animation(String name, ArrayTimeline timelines, double duration) {
-    final ptr = _bindings.spine_animation_create(name.toNativeUtf8().cast<Char>(), timelines.nativePtr.cast(), duration);
+    final ptr = SpineBindings.bindings.spine_animation_create(name.toNativeUtf8().cast<Char>(), timelines.nativePtr.cast(), duration);
     return Animation.fromPointer(ptr);
   }
 
   ArrayTimeline get timelines {
-    final result = _bindings.spine_animation_get_timelines(_ptr);
+    final result = SpineBindings.bindings.spine_animation_get_timelines(_ptr);
     return ArrayTimeline.fromPointer(result);
   }
 
   set timelines(ArrayTimeline value) {
-    _bindings.spine_animation_set_timelines(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_animation_set_timelines(_ptr, value.nativePtr.cast());
   }
 
   bool hasTimeline(ArrayPropertyId ids) {
-    final result = _bindings.spine_animation_has_timeline(_ptr, ids.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_animation_has_timeline(_ptr, ids.nativePtr.cast());
     return result;
   }
 
   double get duration {
-    final result = _bindings.spine_animation_get_duration(_ptr);
+    final result = SpineBindings.bindings.spine_animation_get_duration(_ptr);
     return result;
   }
 
   set duration(double value) {
-    _bindings.spine_animation_set_duration(_ptr, value);
+    SpineBindings.bindings.spine_animation_set_duration(_ptr, value);
   }
 
   void apply(Skeleton skeleton, double lastTime, double time, bool loop, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_animation_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, loop, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
+    SpineBindings.bindings.spine_animation_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, loop, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
   }
 
   String get name {
-    final result = _bindings.spine_animation_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_animation_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   ArrayInt get bones {
-    final result = _bindings.spine_animation_get_bones(_ptr);
+    final result = SpineBindings.bindings.spine_animation_get_bones(_ptr);
     return ArrayInt.fromPointer(result);
   }
 
   static int search1(ArrayFloat values, double target) {
-    final result = _bindings.spine_animation_search_1(values.nativePtr.cast(), target);
+    final result = SpineBindings.bindings.spine_animation_search_1(values.nativePtr.cast(), target);
     return result;
   }
 
   static int search2(ArrayFloat values, double target, int step) {
-    final result = _bindings.spine_animation_search_2(values.nativePtr.cast(), target, step);
+    final result = SpineBindings.bindings.spine_animation_search_2(values.nativePtr.cast(), target, step);
     return result;
   }
 
   void dispose() {
-    _bindings.spine_animation_dispose(_ptr);
+    SpineBindings.bindings.spine_animation_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/animation_state.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,15 +23,16 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'skeleton.dart';
 import 'track_entry.dart';
 import 'animation.dart';
@@ -40,121 +41,115 @@ import 'arrays.dart';
 
 /// AnimationState wrapper
 class AnimationState implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_animation_state_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   AnimationState.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory AnimationState(AnimationStateData data) {
-    final ptr = _bindings.spine_animation_state_create(data.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_animation_state_create(data.nativePtr.cast());
     return AnimationState.fromPointer(ptr);
   }
 
   void update(double delta) {
-    _bindings.spine_animation_state_update(_ptr, delta);
+    SpineBindings.bindings.spine_animation_state_update(_ptr, delta);
   }
 
   bool apply(Skeleton skeleton) {
-    final result = _bindings.spine_animation_state_apply(_ptr, skeleton.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_animation_state_apply(_ptr, skeleton.nativePtr.cast());
     return result;
   }
 
   void clearTracks() {
-    _bindings.spine_animation_state_clear_tracks(_ptr);
+    SpineBindings.bindings.spine_animation_state_clear_tracks(_ptr);
   }
 
   void clearTrack(int trackIndex) {
-    _bindings.spine_animation_state_clear_track(_ptr, trackIndex);
+    SpineBindings.bindings.spine_animation_state_clear_track(_ptr, trackIndex);
   }
 
   TrackEntry setEmptyAnimation(int trackIndex, double mixDuration) {
-    final result = _bindings.spine_animation_state_set_empty_animation(_ptr, trackIndex, mixDuration);
+    final result = SpineBindings.bindings.spine_animation_state_set_empty_animation(_ptr, trackIndex, mixDuration);
     return TrackEntry.fromPointer(result);
   }
 
   TrackEntry addEmptyAnimation(int trackIndex, double mixDuration, double delay) {
-    final result = _bindings.spine_animation_state_add_empty_animation(_ptr, trackIndex, mixDuration, delay);
+    final result = SpineBindings.bindings.spine_animation_state_add_empty_animation(_ptr, trackIndex, mixDuration, delay);
     return TrackEntry.fromPointer(result);
   }
 
   set emptyAnimations(double value) {
-    _bindings.spine_animation_state_set_empty_animations(_ptr, value);
+    SpineBindings.bindings.spine_animation_state_set_empty_animations(_ptr, value);
   }
 
   TrackEntry getCurrent(int trackIndex) {
-    final result = _bindings.spine_animation_state_get_current(_ptr, trackIndex);
+    final result = SpineBindings.bindings.spine_animation_state_get_current(_ptr, trackIndex);
     return TrackEntry.fromPointer(result);
   }
 
   AnimationStateData get data {
-    final result = _bindings.spine_animation_state_get_data(_ptr);
+    final result = SpineBindings.bindings.spine_animation_state_get_data(_ptr);
     return AnimationStateData.fromPointer(result);
   }
 
   ArrayTrackEntry get tracks {
-    final result = _bindings.spine_animation_state_get_tracks(_ptr);
+    final result = SpineBindings.bindings.spine_animation_state_get_tracks(_ptr);
     return ArrayTrackEntry.fromPointer(result);
   }
 
   double get timeScale {
-    final result = _bindings.spine_animation_state_get_time_scale(_ptr);
+    final result = SpineBindings.bindings.spine_animation_state_get_time_scale(_ptr);
     return result;
   }
 
   set timeScale(double value) {
-    _bindings.spine_animation_state_set_time_scale(_ptr, value);
+    SpineBindings.bindings.spine_animation_state_set_time_scale(_ptr, value);
   }
 
   void disableQueue() {
-    _bindings.spine_animation_state_disable_queue(_ptr);
+    SpineBindings.bindings.spine_animation_state_disable_queue(_ptr);
   }
 
   void enableQueue() {
-    _bindings.spine_animation_state_enable_queue(_ptr);
+    SpineBindings.bindings.spine_animation_state_enable_queue(_ptr);
   }
 
   set manualTrackEntryDisposal(bool value) {
-    _bindings.spine_animation_state_set_manual_track_entry_disposal(_ptr, value);
+    SpineBindings.bindings.spine_animation_state_set_manual_track_entry_disposal(_ptr, value);
   }
 
   bool get manualTrackEntryDisposal {
-    final result = _bindings.spine_animation_state_get_manual_track_entry_disposal(_ptr);
+    final result = SpineBindings.bindings.spine_animation_state_get_manual_track_entry_disposal(_ptr);
     return result;
   }
 
   void disposeTrackEntry(TrackEntry entry) {
-    _bindings.spine_animation_state_dispose_track_entry(_ptr, entry.nativePtr.cast());
+    SpineBindings.bindings.spine_animation_state_dispose_track_entry(_ptr, entry.nativePtr.cast());
   }
 
   TrackEntry setAnimation1(int trackIndex, String animationName, bool loop) {
-    final result = _bindings.spine_animation_state_set_animation_1(_ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop);
+    final result = SpineBindings.bindings.spine_animation_state_set_animation_1(_ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop);
     return TrackEntry.fromPointer(result);
   }
 
   TrackEntry setAnimation2(int trackIndex, Animation animation, bool loop) {
-    final result = _bindings.spine_animation_state_set_animation_2(_ptr, trackIndex, animation.nativePtr.cast(), loop);
+    final result = SpineBindings.bindings.spine_animation_state_set_animation_2(_ptr, trackIndex, animation.nativePtr.cast(), loop);
     return TrackEntry.fromPointer(result);
   }
 
   TrackEntry addAnimation1(int trackIndex, String animationName, bool loop, double delay) {
-    final result = _bindings.spine_animation_state_add_animation_1(_ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop, delay);
+    final result = SpineBindings.bindings.spine_animation_state_add_animation_1(_ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop, delay);
     return TrackEntry.fromPointer(result);
   }
 
   TrackEntry addAnimation2(int trackIndex, Animation animation, bool loop, double delay) {
-    final result = _bindings.spine_animation_state_add_animation_2(_ptr, trackIndex, animation.nativePtr.cast(), loop, delay);
+    final result = SpineBindings.bindings.spine_animation_state_add_animation_2(_ptr, trackIndex, animation.nativePtr.cast(), loop, delay);
     return TrackEntry.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_animation_state_dispose(_ptr);
+    SpineBindings.bindings.spine_animation_state_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/animation_state_data.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,70 +23,65 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'skeleton_data.dart';
 import 'animation.dart';
 
 /// AnimationStateData wrapper
 class AnimationStateData implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_animation_state_data_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   AnimationStateData.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory AnimationStateData(SkeletonData skeletonData) {
-    final ptr = _bindings.spine_animation_state_data_create(skeletonData.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_animation_state_data_create(skeletonData.nativePtr.cast());
     return AnimationStateData.fromPointer(ptr);
   }
 
   SkeletonData get skeletonData {
-    final result = _bindings.spine_animation_state_data_get_skeleton_data(_ptr);
+    final result = SpineBindings.bindings.spine_animation_state_data_get_skeleton_data(_ptr);
     return SkeletonData.fromPointer(result);
   }
 
   double get defaultMix {
-    final result = _bindings.spine_animation_state_data_get_default_mix(_ptr);
+    final result = SpineBindings.bindings.spine_animation_state_data_get_default_mix(_ptr);
     return result;
   }
 
   set defaultMix(double value) {
-    _bindings.spine_animation_state_data_set_default_mix(_ptr, value);
+    SpineBindings.bindings.spine_animation_state_data_set_default_mix(_ptr, value);
   }
 
   double getMix(Animation from, Animation to) {
-    final result = _bindings.spine_animation_state_data_get_mix(_ptr, from.nativePtr.cast(), to.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_animation_state_data_get_mix(_ptr, from.nativePtr.cast(), to.nativePtr.cast());
     return result;
   }
 
   void clear() {
-    _bindings.spine_animation_state_data_clear(_ptr);
+    SpineBindings.bindings.spine_animation_state_data_clear(_ptr);
   }
 
   void setMix1(String fromName, String toName, double duration) {
-    _bindings.spine_animation_state_data_set_mix_1(_ptr, fromName.toNativeUtf8().cast<Char>(), toName.toNativeUtf8().cast<Char>(), duration);
+    SpineBindings.bindings.spine_animation_state_data_set_mix_1(_ptr, fromName.toNativeUtf8().cast<Char>(), toName.toNativeUtf8().cast<Char>(), duration);
   }
 
   void setMix2(Animation from, Animation to, double duration) {
-    _bindings.spine_animation_state_data_set_mix_2(_ptr, from.nativePtr.cast(), to.nativePtr.cast(), duration);
+    SpineBindings.bindings.spine_animation_state_data_set_mix_2(_ptr, from.nativePtr.cast(), to.nativePtr.cast(), duration);
   }
 
   void dispose() {
-    _bindings.spine_animation_state_data_dispose(_ptr);
+    SpineBindings.bindings.spine_animation_state_data_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/atlas.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,49 +23,44 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'atlas_region.dart';
 import 'arrays.dart';
 
 /// Atlas wrapper
 class Atlas implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_atlas_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Atlas.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   void flipV() {
-    _bindings.spine_atlas_flip_v(_ptr);
+    SpineBindings.bindings.spine_atlas_flip_v(_ptr);
   }
 
   AtlasRegion findRegion(String name) {
-    final result = _bindings.spine_atlas_find_region(_ptr, name.toNativeUtf8().cast<Char>());
+    final result = SpineBindings.bindings.spine_atlas_find_region(_ptr, name.toNativeUtf8().cast<Char>());
     return AtlasRegion.fromPointer(result);
   }
 
   ArrayAtlasPage get pages {
-    final result = _bindings.spine_atlas_get_pages(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_get_pages(_ptr);
     return ArrayAtlasPage.fromPointer(result);
   }
 
   ArrayAtlasRegion get regions {
-    final result = _bindings.spine_atlas_get_regions(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_get_regions(_ptr);
     return ArrayAtlasRegion.fromPointer(result);
   }
 

spine-flutter/lib/generated/atlas_attachment_loader.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,82 +23,42 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'region_attachment.dart';
-import 'skin.dart';
-import 'sequence.dart';
-import 'mesh_attachment.dart';
-import 'bounding_box_attachment.dart';
-import 'path_attachment.dart';
-import 'point_attachment.dart';
-import 'clipping_attachment.dart';
+import '../spine_bindings.dart';
+import 'attachment_loader.dart';
 import 'atlas_region.dart';
 import 'atlas.dart';
 
 /// AtlasAttachmentLoader wrapper
-class AtlasAttachmentLoader implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class AtlasAttachmentLoader extends AttachmentLoader {
   final Pointer<spine_atlas_attachment_loader_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  AtlasAttachmentLoader.fromPointer(this._ptr);
+  AtlasAttachmentLoader.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory AtlasAttachmentLoader(Atlas atlas) {
-    final ptr = _bindings.spine_atlas_attachment_loader_create(atlas.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_atlas_attachment_loader_create(atlas.nativePtr.cast());
     return AtlasAttachmentLoader.fromPointer(ptr);
   }
 
-  RegionAttachment newRegionAttachment(Skin skin, String name, String path, Sequence sequence) {
-    final result = _bindings.spine_atlas_attachment_loader_new_region_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
-    return RegionAttachment.fromPointer(result);
-  }
-
-  MeshAttachment newMeshAttachment(Skin skin, String name, String path, Sequence sequence) {
-    final result = _bindings.spine_atlas_attachment_loader_new_mesh_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
-    return MeshAttachment.fromPointer(result);
-  }
-
-  BoundingBoxAttachment newBoundingBoxAttachment(Skin skin, String name) {
-    final result = _bindings.spine_atlas_attachment_loader_new_bounding_box_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-    return BoundingBoxAttachment.fromPointer(result);
-  }
-
-  PathAttachment newPathAttachment(Skin skin, String name) {
-    final result = _bindings.spine_atlas_attachment_loader_new_path_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-    return PathAttachment.fromPointer(result);
-  }
-
-  PointAttachment newPointAttachment(Skin skin, String name) {
-    final result = _bindings.spine_atlas_attachment_loader_new_point_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-    return PointAttachment.fromPointer(result);
-  }
-
-  ClippingAttachment newClippingAttachment(Skin skin, String name) {
-    final result = _bindings.spine_atlas_attachment_loader_new_clipping_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-    return ClippingAttachment.fromPointer(result);
-  }
-
   AtlasRegion findRegion(String name) {
-    final result = _bindings.spine_atlas_attachment_loader_find_region(_ptr, name.toNativeUtf8().cast<Char>());
+    final result = SpineBindings.bindings.spine_atlas_attachment_loader_find_region(_ptr, name.toNativeUtf8().cast<Char>());
     return AtlasRegion.fromPointer(result);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_atlas_attachment_loader_dispose(_ptr);
+    SpineBindings.bindings.spine_atlas_attachment_loader_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/atlas_page.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,139 +23,134 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'format.dart';
 import 'texture_filter.dart';
 import 'texture_wrap.dart';
 
 /// AtlasPage wrapper
 class AtlasPage implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_atlas_page_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   AtlasPage.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory AtlasPage(String inName) {
-    final ptr = _bindings.spine_atlas_page_create(inName.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_atlas_page_create(inName.toNativeUtf8().cast<Char>());
     return AtlasPage.fromPointer(ptr);
   }
 
   String get name {
-    final result = _bindings.spine_atlas_page_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set name(String value) {
-    _bindings.spine_atlas_page_set_name(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_atlas_page_set_name(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get texturePath {
-    final result = _bindings.spine_atlas_page_get_texture_path(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_texture_path(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set texturePath(String value) {
-    _bindings.spine_atlas_page_set_texture_path(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_atlas_page_set_texture_path(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   Format get format {
-    final result = _bindings.spine_atlas_page_get_format(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_format(_ptr);
     return Format.fromValue(result);
   }
 
   set format(Format value) {
-    _bindings.spine_atlas_page_set_format(_ptr, value.value);
+    SpineBindings.bindings.spine_atlas_page_set_format(_ptr, value.value);
   }
 
   TextureFilter get minFilter {
-    final result = _bindings.spine_atlas_page_get_min_filter(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_min_filter(_ptr);
     return TextureFilter.fromValue(result);
   }
 
   set minFilter(TextureFilter value) {
-    _bindings.spine_atlas_page_set_min_filter(_ptr, value.value);
+    SpineBindings.bindings.spine_atlas_page_set_min_filter(_ptr, value.value);
   }
 
   TextureFilter get magFilter {
-    final result = _bindings.spine_atlas_page_get_mag_filter(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_mag_filter(_ptr);
     return TextureFilter.fromValue(result);
   }
 
   set magFilter(TextureFilter value) {
-    _bindings.spine_atlas_page_set_mag_filter(_ptr, value.value);
+    SpineBindings.bindings.spine_atlas_page_set_mag_filter(_ptr, value.value);
   }
 
   TextureWrap get uWrap {
-    final result = _bindings.spine_atlas_page_get_u_wrap(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_u_wrap(_ptr);
     return TextureWrap.fromValue(result);
   }
 
   set uWrap(TextureWrap value) {
-    _bindings.spine_atlas_page_set_u_wrap(_ptr, value.value);
+    SpineBindings.bindings.spine_atlas_page_set_u_wrap(_ptr, value.value);
   }
 
   TextureWrap get vWrap {
-    final result = _bindings.spine_atlas_page_get_v_wrap(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_v_wrap(_ptr);
     return TextureWrap.fromValue(result);
   }
 
   set vWrap(TextureWrap value) {
-    _bindings.spine_atlas_page_set_v_wrap(_ptr, value.value);
+    SpineBindings.bindings.spine_atlas_page_set_v_wrap(_ptr, value.value);
   }
 
   int get width {
-    final result = _bindings.spine_atlas_page_get_width(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_width(_ptr);
     return result;
   }
 
   set width(int value) {
-    _bindings.spine_atlas_page_set_width(_ptr, value);
+    SpineBindings.bindings.spine_atlas_page_set_width(_ptr, value);
   }
 
   int get height {
-    final result = _bindings.spine_atlas_page_get_height(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_height(_ptr);
     return result;
   }
 
   set height(int value) {
-    _bindings.spine_atlas_page_set_height(_ptr, value);
+    SpineBindings.bindings.spine_atlas_page_set_height(_ptr, value);
   }
 
   bool get pma {
-    final result = _bindings.spine_atlas_page_get_pma(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_pma(_ptr);
     return result;
   }
 
   set pma(bool value) {
-    _bindings.spine_atlas_page_set_pma(_ptr, value);
+    SpineBindings.bindings.spine_atlas_page_set_pma(_ptr, value);
   }
 
   int get index {
-    final result = _bindings.spine_atlas_page_get_index(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_page_get_index(_ptr);
     return result;
   }
 
   set index(int value) {
-    _bindings.spine_atlas_page_set_index(_ptr, value);
+    SpineBindings.bindings.spine_atlas_page_set_index(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_atlas_page_dispose(_ptr);
+    SpineBindings.bindings.spine_atlas_page_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/atlas_region.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,243 +23,176 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'texture_region.dart';
 import 'atlas_page.dart';
 import 'arrays.dart';
 
 /// AtlasRegion wrapper
-class AtlasRegion implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class AtlasRegion extends TextureRegion {
   final Pointer<spine_atlas_region_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  AtlasRegion.fromPointer(this._ptr);
+  AtlasRegion.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory AtlasRegion() {
-    final ptr = _bindings.spine_atlas_region_create();
+    final ptr = SpineBindings.bindings.spine_atlas_region_create();
     return AtlasRegion.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_atlas_region_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   AtlasPage get page {
-    final result = _bindings.spine_atlas_region_get_page(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_page(_ptr);
     return AtlasPage.fromPointer(result);
   }
 
   int get index {
-    final result = _bindings.spine_atlas_region_get_index(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_index(_ptr);
     return result;
   }
 
   int get x {
-    final result = _bindings.spine_atlas_region_get_x(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_x(_ptr);
     return result;
   }
 
   int get y {
-    final result = _bindings.spine_atlas_region_get_y(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_y(_ptr);
     return result;
   }
 
   double get offsetX {
-    final result = _bindings.spine_atlas_region_get_offset_x(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_offset_x(_ptr);
     return result;
   }
 
   double get offsetY {
-    final result = _bindings.spine_atlas_region_get_offset_y(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_offset_y(_ptr);
     return result;
   }
 
   int get packedWidth {
-    final result = _bindings.spine_atlas_region_get_packed_width(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_packed_width(_ptr);
     return result;
   }
 
   int get packedHeight {
-    final result = _bindings.spine_atlas_region_get_packed_height(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_packed_height(_ptr);
     return result;
   }
 
   int get originalWidth {
-    final result = _bindings.spine_atlas_region_get_original_width(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_original_width(_ptr);
     return result;
   }
 
   int get originalHeight {
-    final result = _bindings.spine_atlas_region_get_original_height(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_original_height(_ptr);
     return result;
   }
 
   bool get rotate {
-    final result = _bindings.spine_atlas_region_get_rotate(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_rotate(_ptr);
     return result;
   }
 
   int get degrees {
-    final result = _bindings.spine_atlas_region_get_degrees(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_degrees(_ptr);
     return result;
   }
 
   ArrayInt get splits {
-    final result = _bindings.spine_atlas_region_get_splits(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_splits(_ptr);
     return ArrayInt.fromPointer(result);
   }
 
   ArrayInt get pads {
-    final result = _bindings.spine_atlas_region_get_pads(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_pads(_ptr);
     return ArrayInt.fromPointer(result);
   }
 
   ArrayFloat get values {
-    final result = _bindings.spine_atlas_region_get_values(_ptr);
+    final result = SpineBindings.bindings.spine_atlas_region_get_values(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   set page(AtlasPage value) {
-    _bindings.spine_atlas_region_set_page(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_atlas_region_set_page(_ptr, value.nativePtr.cast());
   }
 
   set name(String value) {
-    _bindings.spine_atlas_region_set_name(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_atlas_region_set_name(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   set index(int value) {
-    _bindings.spine_atlas_region_set_index(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_index(_ptr, value);
   }
 
   set x(int value) {
-    _bindings.spine_atlas_region_set_x(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_x(_ptr, value);
   }
 
   set y(int value) {
-    _bindings.spine_atlas_region_set_y(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_y(_ptr, value);
   }
 
   set offsetX(double value) {
-    _bindings.spine_atlas_region_set_offset_x(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_offset_x(_ptr, value);
   }
 
   set offsetY(double value) {
-    _bindings.spine_atlas_region_set_offset_y(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_offset_y(_ptr, value);
   }
 
   set packedWidth(int value) {
-    _bindings.spine_atlas_region_set_packed_width(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_packed_width(_ptr, value);
   }
 
   set packedHeight(int value) {
-    _bindings.spine_atlas_region_set_packed_height(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_packed_height(_ptr, value);
   }
 
   set originalWidth(int value) {
-    _bindings.spine_atlas_region_set_original_width(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_original_width(_ptr, value);
   }
 
   set originalHeight(int value) {
-    _bindings.spine_atlas_region_set_original_height(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_original_height(_ptr, value);
   }
 
   set rotate(bool value) {
-    _bindings.spine_atlas_region_set_rotate(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_rotate(_ptr, value);
   }
 
   set degrees(int value) {
-    _bindings.spine_atlas_region_set_degrees(_ptr, value);
+    SpineBindings.bindings.spine_atlas_region_set_degrees(_ptr, value);
   }
 
   set splits(ArrayInt value) {
-    _bindings.spine_atlas_region_set_splits(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_atlas_region_set_splits(_ptr, value.nativePtr.cast());
   }
 
   set pads(ArrayInt value) {
-    _bindings.spine_atlas_region_set_pads(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_atlas_region_set_pads(_ptr, value.nativePtr.cast());
   }
 
   set values(ArrayFloat value) {
-    _bindings.spine_atlas_region_set_values(_ptr, value.nativePtr.cast());
-  }
-
-  double get u {
-    final result = _bindings.spine_atlas_region_get_u(_ptr);
-    return result;
-  }
-
-  set u(double value) {
-    _bindings.spine_atlas_region_set_u(_ptr, value);
-  }
-
-  double get v {
-    final result = _bindings.spine_atlas_region_get_v(_ptr);
-    return result;
-  }
-
-  set v(double value) {
-    _bindings.spine_atlas_region_set_v(_ptr, value);
-  }
-
-  double get u2 {
-    final result = _bindings.spine_atlas_region_get_u2(_ptr);
-    return result;
-  }
-
-  set u2(double value) {
-    _bindings.spine_atlas_region_set_u2(_ptr, value);
-  }
-
-  double get v2 {
-    final result = _bindings.spine_atlas_region_get_v2(_ptr);
-    return result;
-  }
-
-  set v2(double value) {
-    _bindings.spine_atlas_region_set_v2(_ptr, value);
-  }
-
-  int get regionWidth {
-    final result = _bindings.spine_atlas_region_get_region_width(_ptr);
-    return result;
-  }
-
-  set regionWidth(int value) {
-    _bindings.spine_atlas_region_set_region_width(_ptr, value);
-  }
-
-  int get regionHeight {
-    final result = _bindings.spine_atlas_region_get_region_height(_ptr);
-    return result;
-  }
-
-  set regionHeight(int value) {
-    _bindings.spine_atlas_region_set_region_height(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_atlas_region_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_atlas_region_set_values(_ptr, value.nativePtr.cast());
   }
 
+  @override
   void dispose() {
-    _bindings.spine_atlas_region_dispose(_ptr);
+    SpineBindings.bindings.spine_atlas_region_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/attachment.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,66 +23,84 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
+import 'point_attachment.dart';
+import 'region_attachment.dart';
+import 'bounding_box_attachment.dart';
+import 'clipping_attachment.dart';
+import 'mesh_attachment.dart';
+import 'path_attachment.dart';
 
 /// Attachment wrapper
-class Attachment implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class Attachment implements Finalizable {
   final Pointer<spine_attachment_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Attachment.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   Rtti get rtti {
-    final result = _bindings.spine_attachment_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_attachment_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   String get name {
-    final result = _bindings.spine_attachment_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_attachment_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   Attachment copy() {
-    final result = _bindings.spine_attachment_copy(_ptr);
-    return Attachment.fromPointer(result);
+    final result = SpineBindings.bindings.spine_attachment_copy(_ptr);
+    final rtti = SpineBindings.bindings.spine_attachment_get_rtti(result);
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    switch (className) {
+      case 'spine_point_attachment':
+        return PointAttachment.fromPointer(result.cast());
+      case 'spine_region_attachment':
+        return RegionAttachment.fromPointer(result.cast());
+      case 'spine_bounding_box_attachment':
+        return BoundingBoxAttachment.fromPointer(result.cast());
+      case 'spine_clipping_attachment':
+        return ClippingAttachment.fromPointer(result.cast());
+      case 'spine_mesh_attachment':
+        return MeshAttachment.fromPointer(result.cast());
+      case 'spine_path_attachment':
+        return PathAttachment.fromPointer(result.cast());
+      default:
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
+    }
   }
 
   int get refCount {
-    final result = _bindings.spine_attachment_get_ref_count(_ptr);
+    final result = SpineBindings.bindings.spine_attachment_get_ref_count(_ptr);
     return result;
   }
 
   void reference() {
-    _bindings.spine_attachment_reference(_ptr);
+    SpineBindings.bindings.spine_attachment_reference(_ptr);
   }
 
   void dereference() {
-    _bindings.spine_attachment_dereference(_ptr);
+    SpineBindings.bindings.spine_attachment_dereference(_ptr);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_attachment_rtti();
+    final result = SpineBindings.bindings.spine_attachment_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_attachment_dispose(_ptr);
+    SpineBindings.bindings.spine_attachment_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/attachment_loader.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,15 +23,16 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'region_attachment.dart';
 import 'skin.dart';
 import 'sequence.dart';
@@ -42,51 +43,45 @@ import 'point_attachment.dart';
 import 'clipping_attachment.dart';
 
 /// AttachmentLoader wrapper
-class AttachmentLoader implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class AttachmentLoader implements Finalizable {
   final Pointer<spine_attachment_loader_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   AttachmentLoader.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   RegionAttachment newRegionAttachment(Skin skin, String name, String path, Sequence sequence) {
-    final result = _bindings.spine_attachment_loader_new_region_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_attachment_loader_new_region_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
     return RegionAttachment.fromPointer(result);
   }
 
   MeshAttachment newMeshAttachment(Skin skin, String name, String path, Sequence sequence) {
-    final result = _bindings.spine_attachment_loader_new_mesh_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_attachment_loader_new_mesh_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
     return MeshAttachment.fromPointer(result);
   }
 
   BoundingBoxAttachment newBoundingBoxAttachment(Skin skin, String name) {
-    final result = _bindings.spine_attachment_loader_new_bounding_box_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
+    final result = SpineBindings.bindings.spine_attachment_loader_new_bounding_box_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
     return BoundingBoxAttachment.fromPointer(result);
   }
 
   PathAttachment newPathAttachment(Skin skin, String name) {
-    final result = _bindings.spine_attachment_loader_new_path_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
+    final result = SpineBindings.bindings.spine_attachment_loader_new_path_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
     return PathAttachment.fromPointer(result);
   }
 
   PointAttachment newPointAttachment(Skin skin, String name) {
-    final result = _bindings.spine_attachment_loader_new_point_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
+    final result = SpineBindings.bindings.spine_attachment_loader_new_point_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
     return PointAttachment.fromPointer(result);
   }
 
   ClippingAttachment newClippingAttachment(Skin skin, String name) {
-    final result = _bindings.spine_attachment_loader_new_clipping_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
+    final result = SpineBindings.bindings.spine_attachment_loader_new_clipping_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
     return ClippingAttachment.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_attachment_loader_dispose(_ptr);
+    SpineBindings.bindings.spine_attachment_loader_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/attachment_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,94 +23,48 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'timeline.dart';
 
 /// AttachmentTimeline wrapper
-class AttachmentTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class AttachmentTimeline extends Timeline {
   final Pointer<spine_attachment_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  AttachmentTimeline.fromPointer(this._ptr);
+  AttachmentTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory AttachmentTimeline(int frameCount, int slotIndex) {
-    final ptr = _bindings.spine_attachment_timeline_create(frameCount, slotIndex);
+    final ptr = SpineBindings.bindings.spine_attachment_timeline_create(frameCount, slotIndex);
     return AttachmentTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_attachment_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_attachment_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
   void setFrame(int frame, double time, String attachmentName) {
-    _bindings.spine_attachment_timeline_set_frame(_ptr, frame, time, attachmentName.toNativeUtf8().cast<Char>());
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_attachment_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_attachment_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_attachment_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_attachment_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_attachment_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
+    SpineBindings.bindings.spine_attachment_timeline_set_frame(_ptr, frame, time, attachmentName.toNativeUtf8().cast<Char>());
   }
 
   int get slotIndex {
-    final result = _bindings.spine_attachment_timeline_get_slot_index(_ptr);
+    final result = SpineBindings.bindings.spine_attachment_timeline_get_slot_index(_ptr);
     return result;
   }
 
   set slotIndex(int value) {
-    _bindings.spine_attachment_timeline_set_slot_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_attachment_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_attachment_timeline_set_slot_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_attachment_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_attachment_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/attachment_type.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/blend_mode.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/bone.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,15 +23,17 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
+import 'posed_active.dart';
 import 'skeleton.dart';
 import 'physics.dart';
 import 'bone_data.dart';
@@ -40,101 +42,88 @@ import 'bone_pose.dart';
 import 'arrays.dart';
 
 /// Bone wrapper
-class Bone implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class Bone extends PosedActive {
   final Pointer<spine_bone_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  Bone.fromPointer(this._ptr);
+  Bone.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory Bone(BoneData data, Bone parent) {
-    final ptr = _bindings.spine_bone_create(data.nativePtr.cast(), parent.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_bone_create(data.nativePtr.cast(), parent.nativePtr.cast());
     return Bone.fromPointer(ptr);
   }
 
   factory Bone.from(Bone bone, Bone parent) {
-    final ptr = _bindings.spine_bone_create2(bone.nativePtr.cast(), parent.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_bone_create2(bone.nativePtr.cast(), parent.nativePtr.cast());
     return Bone.fromPointer(ptr);
   }
 
   Rtti get rtti {
-    final result = _bindings.spine_bone_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_bone_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   Bone get parent {
-    final result = _bindings.spine_bone_get_parent(_ptr);
+    final result = SpineBindings.bindings.spine_bone_get_parent(_ptr);
     return Bone.fromPointer(result);
   }
 
   ArrayBone get children {
-    final result = _bindings.spine_bone_get_children(_ptr);
+    final result = SpineBindings.bindings.spine_bone_get_children(_ptr);
     return ArrayBone.fromPointer(result);
   }
 
   static bool isYDown() {
-    final result = _bindings.spine_bone_is_y_down();
+    final result = SpineBindings.bindings.spine_bone_is_y_down();
     return result;
   }
 
   static void setYDown(bool value) {
-    _bindings.spine_bone_set_y_down(value);
+    SpineBindings.bindings.spine_bone_set_y_down(value);
   }
 
   void update(Skeleton skeleton, Physics physics) {
-    _bindings.spine_bone_update(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings.spine_bone_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   BoneData get data {
-    final result = _bindings.spine_bone_get_data(_ptr);
+    final result = SpineBindings.bindings.spine_bone_get_data(_ptr);
     return BoneData.fromPointer(result);
   }
 
   BoneLocal get pose {
-    final result = _bindings.spine_bone_get_pose(_ptr);
+    final result = SpineBindings.bindings.spine_bone_get_pose(_ptr);
     return BoneLocal.fromPointer(result);
   }
 
   BonePose get appliedPose {
-    final result = _bindings.spine_bone_get_applied_pose(_ptr);
+    final result = SpineBindings.bindings.spine_bone_get_applied_pose(_ptr);
     return BonePose.fromPointer(result);
   }
 
   void resetConstrained() {
-    _bindings.spine_bone_reset_constrained(_ptr);
+    SpineBindings.bindings.spine_bone_reset_constrained(_ptr);
   }
 
   void constrained() {
-    _bindings.spine_bone_constrained(_ptr);
+    SpineBindings.bindings.spine_bone_constrained(_ptr);
   }
 
   bool get isPoseEqualToApplied {
-    final result = _bindings.spine_bone_is_pose_equal_to_applied(_ptr);
+    final result = SpineBindings.bindings.spine_bone_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
-  bool get isActive {
-    final result = _bindings.spine_bone_is_active(_ptr);
-    return result;
-  }
-
-  set active(bool value) {
-    _bindings.spine_bone_set_active(_ptr, value);
-  }
-
   static Rtti rttiStatic() {
-    final result = _bindings.spine_bone_rtti();
+    final result = SpineBindings.bindings.spine_bone_rtti();
     return Rtti.fromPointer(result);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_bone_dispose(_ptr);
+    SpineBindings.bindings.spine_bone_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/bone_data.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,100 +23,95 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'color.dart';
 import 'bone_local.dart';
 
 /// BoneData wrapper
 class BoneData implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_bone_data_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   BoneData.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory BoneData(int index, String name, BoneData parent) {
-    final ptr = _bindings.spine_bone_data_create(index, name.toNativeUtf8().cast<Char>(), parent.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_bone_data_create(index, name.toNativeUtf8().cast<Char>(), parent.nativePtr.cast());
     return BoneData.fromPointer(ptr);
   }
 
   int get index {
-    final result = _bindings.spine_bone_data_get_index(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_index(_ptr);
     return result;
   }
 
   BoneData get parent {
-    final result = _bindings.spine_bone_data_get_parent(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_parent(_ptr);
     return BoneData.fromPointer(result);
   }
 
   double get length {
-    final result = _bindings.spine_bone_data_get_length(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_length(_ptr);
     return result;
   }
 
   set length(double value) {
-    _bindings.spine_bone_data_set_length(_ptr, value);
+    SpineBindings.bindings.spine_bone_data_set_length(_ptr, value);
   }
 
   Color get color {
-    final result = _bindings.spine_bone_data_get_color(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
   String get icon {
-    final result = _bindings.spine_bone_data_get_icon(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_icon(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set icon(String value) {
-    _bindings.spine_bone_data_set_icon(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_bone_data_set_icon(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   bool get visible {
-    final result = _bindings.spine_bone_data_get_visible(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_visible(_ptr);
     return result;
   }
 
   set visible(bool value) {
-    _bindings.spine_bone_data_set_visible(_ptr, value);
+    SpineBindings.bindings.spine_bone_data_set_visible(_ptr, value);
   }
 
   BoneLocal get setupPose {
-    final result = _bindings.spine_bone_data_get_setup_pose(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_setup_pose(_ptr);
     return BoneLocal.fromPointer(result);
   }
 
   String get name {
-    final result = _bindings.spine_bone_data_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   bool get skinRequired {
-    final result = _bindings.spine_bone_data_get_skin_required(_ptr);
+    final result = SpineBindings.bindings.spine_bone_data_get_skin_required(_ptr);
     return result;
   }
 
   set skinRequired(bool value) {
-    _bindings.spine_bone_data_set_skin_required(_ptr, value);
+    SpineBindings.bindings.spine_bone_data_set_skin_required(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_bone_data_dispose(_ptr);
+    SpineBindings.bindings.spine_bone_data_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/bone_local.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,125 +23,120 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'inherit.dart';
 
 /// BoneLocal wrapper
 class BoneLocal implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_bone_local_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   BoneLocal.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory BoneLocal() {
-    final ptr = _bindings.spine_bone_local_create();
+    final ptr = SpineBindings.bindings.spine_bone_local_create();
     return BoneLocal.fromPointer(ptr);
   }
 
   void set(BoneLocal pose) {
-    _bindings.spine_bone_local_set(_ptr, pose.nativePtr.cast());
+    SpineBindings.bindings.spine_bone_local_set(_ptr, pose.nativePtr.cast());
   }
 
   double get x {
-    final result = _bindings.spine_bone_local_get_x(_ptr);
+    final result = SpineBindings.bindings.spine_bone_local_get_x(_ptr);
     return result;
   }
 
   set x(double value) {
-    _bindings.spine_bone_local_set_x(_ptr, value);
+    SpineBindings.bindings.spine_bone_local_set_x(_ptr, value);
   }
 
   double get y {
-    final result = _bindings.spine_bone_local_get_y(_ptr);
+    final result = SpineBindings.bindings.spine_bone_local_get_y(_ptr);
     return result;
   }
 
   set y(double value) {
-    _bindings.spine_bone_local_set_y(_ptr, value);
+    SpineBindings.bindings.spine_bone_local_set_y(_ptr, value);
   }
 
   void setPosition(double x, double y) {
-    _bindings.spine_bone_local_set_position(_ptr, x, y);
+    SpineBindings.bindings.spine_bone_local_set_position(_ptr, x, y);
   }
 
   double get rotation {
-    final result = _bindings.spine_bone_local_get_rotation(_ptr);
+    final result = SpineBindings.bindings.spine_bone_local_get_rotation(_ptr);
     return result;
   }
 
   set rotation(double value) {
-    _bindings.spine_bone_local_set_rotation(_ptr, value);
+    SpineBindings.bindings.spine_bone_local_set_rotation(_ptr, value);
   }
 
   double get scaleX {
-    final result = _bindings.spine_bone_local_get_scale_x(_ptr);
+    final result = SpineBindings.bindings.spine_bone_local_get_scale_x(_ptr);
     return result;
   }
 
   set scaleX(double value) {
-    _bindings.spine_bone_local_set_scale_x(_ptr, value);
+    SpineBindings.bindings.spine_bone_local_set_scale_x(_ptr, value);
   }
 
   double get scaleY {
-    final result = _bindings.spine_bone_local_get_scale_y(_ptr);
+    final result = SpineBindings.bindings.spine_bone_local_get_scale_y(_ptr);
     return result;
   }
 
   set scaleY(double value) {
-    _bindings.spine_bone_local_set_scale_y(_ptr, value);
+    SpineBindings.bindings.spine_bone_local_set_scale_y(_ptr, value);
   }
 
   double get shearX {
-    final result = _bindings.spine_bone_local_get_shear_x(_ptr);
+    final result = SpineBindings.bindings.spine_bone_local_get_shear_x(_ptr);
     return result;
   }
 
   set shearX(double value) {
-    _bindings.spine_bone_local_set_shear_x(_ptr, value);
+    SpineBindings.bindings.spine_bone_local_set_shear_x(_ptr, value);
   }
 
   double get shearY {
-    final result = _bindings.spine_bone_local_get_shear_y(_ptr);
+    final result = SpineBindings.bindings.spine_bone_local_get_shear_y(_ptr);
     return result;
   }
 
   set shearY(double value) {
-    _bindings.spine_bone_local_set_shear_y(_ptr, value);
+    SpineBindings.bindings.spine_bone_local_set_shear_y(_ptr, value);
   }
 
   Inherit get inherit {
-    final result = _bindings.spine_bone_local_get_inherit(_ptr);
+    final result = SpineBindings.bindings.spine_bone_local_get_inherit(_ptr);
     return Inherit.fromValue(result);
   }
 
   set inherit(Inherit value) {
-    _bindings.spine_bone_local_set_inherit(_ptr, value.value);
+    SpineBindings.bindings.spine_bone_local_set_inherit(_ptr, value.value);
   }
 
   void setScale1(double scaleX, double scaleY) {
-    _bindings.spine_bone_local_set_scale_1(_ptr, scaleX, scaleY);
+    SpineBindings.bindings.spine_bone_local_set_scale_1(_ptr, scaleX, scaleY);
   }
 
   set scale2(double value) {
-    _bindings.spine_bone_local_set_scale_2(_ptr, value);
+    SpineBindings.bindings.spine_bone_local_set_scale_2(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_bone_local_dispose(_ptr);
+    SpineBindings.bindings.spine_bone_local_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/bone_pose.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,255 +23,163 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
+import 'bone_local.dart';
 import 'skeleton.dart';
 import 'physics.dart';
-import 'bone_local.dart';
-import 'inherit.dart';
 
 /// BonePose wrapper
-class BonePose implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class BonePose extends BoneLocal {
   final Pointer<spine_bone_pose_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  BonePose.fromPointer(this._ptr);
+  BonePose.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory BonePose() {
-    final ptr = _bindings.spine_bone_pose_create();
+    final ptr = SpineBindings.bindings.spine_bone_pose_create();
     return BonePose.fromPointer(ptr);
   }
 
   Rtti get rtti {
-    final result = _bindings.spine_bone_pose_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   void update(Skeleton skeleton, Physics physics) {
-    _bindings.spine_bone_pose_update(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings.spine_bone_pose_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   void updateWorldTransform(Skeleton skeleton) {
-    _bindings.spine_bone_pose_update_world_transform(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_bone_pose_update_world_transform(_ptr, skeleton.nativePtr.cast());
   }
 
   void updateLocalTransform(Skeleton skeleton) {
-    _bindings.spine_bone_pose_update_local_transform(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_bone_pose_update_local_transform(_ptr, skeleton.nativePtr.cast());
   }
 
   void validateLocalTransform(Skeleton skeleton) {
-    _bindings.spine_bone_pose_validate_local_transform(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_bone_pose_validate_local_transform(_ptr, skeleton.nativePtr.cast());
   }
 
   void modifyLocal(Skeleton skeleton) {
-    _bindings.spine_bone_pose_modify_local(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_bone_pose_modify_local(_ptr, skeleton.nativePtr.cast());
   }
 
   void modifyWorld(int update) {
-    _bindings.spine_bone_pose_modify_world(_ptr, update);
+    SpineBindings.bindings.spine_bone_pose_modify_world(_ptr, update);
   }
 
   void resetWorld(int update) {
-    _bindings.spine_bone_pose_reset_world(_ptr, update);
+    SpineBindings.bindings.spine_bone_pose_reset_world(_ptr, update);
   }
 
   double get a {
-    final result = _bindings.spine_bone_pose_get_a(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_a(_ptr);
     return result;
   }
 
   set a(double value) {
-    _bindings.spine_bone_pose_set_a(_ptr, value);
+    SpineBindings.bindings.spine_bone_pose_set_a(_ptr, value);
   }
 
   double get b {
-    final result = _bindings.spine_bone_pose_get_b(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_b(_ptr);
     return result;
   }
 
   set b(double value) {
-    _bindings.spine_bone_pose_set_b(_ptr, value);
+    SpineBindings.bindings.spine_bone_pose_set_b(_ptr, value);
   }
 
   double get c {
-    final result = _bindings.spine_bone_pose_get_c(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_c(_ptr);
     return result;
   }
 
   set c(double value) {
-    _bindings.spine_bone_pose_set_c(_ptr, value);
+    SpineBindings.bindings.spine_bone_pose_set_c(_ptr, value);
   }
 
   double get d {
-    final result = _bindings.spine_bone_pose_get_d(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_d(_ptr);
     return result;
   }
 
   set d(double value) {
-    _bindings.spine_bone_pose_set_d(_ptr, value);
+    SpineBindings.bindings.spine_bone_pose_set_d(_ptr, value);
   }
 
   double get worldX {
-    final result = _bindings.spine_bone_pose_get_world_x(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_x(_ptr);
     return result;
   }
 
   set worldX(double value) {
-    _bindings.spine_bone_pose_set_world_x(_ptr, value);
+    SpineBindings.bindings.spine_bone_pose_set_world_x(_ptr, value);
   }
 
   double get worldY {
-    final result = _bindings.spine_bone_pose_get_world_y(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_y(_ptr);
     return result;
   }
 
   set worldY(double value) {
-    _bindings.spine_bone_pose_set_world_y(_ptr, value);
+    SpineBindings.bindings.spine_bone_pose_set_world_y(_ptr, value);
   }
 
   double get worldRotationX {
-    final result = _bindings.spine_bone_pose_get_world_rotation_x(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_rotation_x(_ptr);
     return result;
   }
 
   double get worldRotationY {
-    final result = _bindings.spine_bone_pose_get_world_rotation_y(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_rotation_y(_ptr);
     return result;
   }
 
   double get worldScaleX {
-    final result = _bindings.spine_bone_pose_get_world_scale_x(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_scale_x(_ptr);
     return result;
   }
 
   double get worldScaleY {
-    final result = _bindings.spine_bone_pose_get_world_scale_y(_ptr);
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_scale_y(_ptr);
     return result;
   }
 
   double worldToLocalRotation(double worldRotation) {
-    final result = _bindings.spine_bone_pose_world_to_local_rotation(_ptr, worldRotation);
+    final result = SpineBindings.bindings.spine_bone_pose_world_to_local_rotation(_ptr, worldRotation);
     return result;
   }
 
   double localToWorldRotation(double localRotation) {
-    final result = _bindings.spine_bone_pose_local_to_world_rotation(_ptr, localRotation);
+    final result = SpineBindings.bindings.spine_bone_pose_local_to_world_rotation(_ptr, localRotation);
     return result;
   }
 
   void rotateWorld(double degrees) {
-    _bindings.spine_bone_pose_rotate_world(_ptr, degrees);
-  }
-
-  void set(BoneLocal pose) {
-    _bindings.spine_bone_pose_set(_ptr, pose.nativePtr.cast());
-  }
-
-  double get x {
-    final result = _bindings.spine_bone_pose_get_x(_ptr);
-    return result;
-  }
-
-  set x(double value) {
-    _bindings.spine_bone_pose_set_x(_ptr, value);
-  }
-
-  double get y {
-    final result = _bindings.spine_bone_pose_get_y(_ptr);
-    return result;
-  }
-
-  set y(double value) {
-    _bindings.spine_bone_pose_set_y(_ptr, value);
-  }
-
-  void setPosition(double x, double y) {
-    _bindings.spine_bone_pose_set_position(_ptr, x, y);
-  }
-
-  double get rotation {
-    final result = _bindings.spine_bone_pose_get_rotation(_ptr);
-    return result;
-  }
-
-  set rotation(double value) {
-    _bindings.spine_bone_pose_set_rotation(_ptr, value);
-  }
-
-  double get scaleX {
-    final result = _bindings.spine_bone_pose_get_scale_x(_ptr);
-    return result;
-  }
-
-  set scaleX(double value) {
-    _bindings.spine_bone_pose_set_scale_x(_ptr, value);
-  }
-
-  double get scaleY {
-    final result = _bindings.spine_bone_pose_get_scale_y(_ptr);
-    return result;
-  }
-
-  set scaleY(double value) {
-    _bindings.spine_bone_pose_set_scale_y(_ptr, value);
-  }
-
-  double get shearX {
-    final result = _bindings.spine_bone_pose_get_shear_x(_ptr);
-    return result;
-  }
-
-  set shearX(double value) {
-    _bindings.spine_bone_pose_set_shear_x(_ptr, value);
-  }
-
-  double get shearY {
-    final result = _bindings.spine_bone_pose_get_shear_y(_ptr);
-    return result;
-  }
-
-  set shearY(double value) {
-    _bindings.spine_bone_pose_set_shear_y(_ptr, value);
-  }
-
-  Inherit get inherit {
-    final result = _bindings.spine_bone_pose_get_inherit(_ptr);
-    return Inherit.fromValue(result);
-  }
-
-  set inherit(Inherit value) {
-    _bindings.spine_bone_pose_set_inherit(_ptr, value.value);
+    SpineBindings.bindings.spine_bone_pose_rotate_world(_ptr, degrees);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_bone_pose_rtti();
+    final result = SpineBindings.bindings.spine_bone_pose_rtti();
     return Rtti.fromPointer(result);
   }
 
-  void setScale1(double scaleX, double scaleY) {
-    _bindings.spine_bone_pose_set_scale_1(_ptr, scaleX, scaleY);
-  }
-
-  set scale2(double value) {
-    _bindings.spine_bone_pose_set_scale_2(_ptr, value);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_bone_pose_dispose(_ptr);
+    SpineBindings.bindings.spine_bone_pose_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/bone_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,51 +23,46 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 
 /// BoneTimeline wrapper
 class BoneTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_bone_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   BoneTimeline.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   Rtti get rtti {
-    final result = _bindings.spine_bone_timeline_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_bone_timeline_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   int get boneIndex {
-    final result = _bindings.spine_bone_timeline_get_bone_index(_ptr);
+    final result = SpineBindings.bindings.spine_bone_timeline_get_bone_index(_ptr);
     return result;
   }
 
   set boneIndex(int value) {
-    _bindings.spine_bone_timeline_set_bone_index(_ptr, value);
+    SpineBindings.bindings.spine_bone_timeline_set_bone_index(_ptr, value);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_bone_timeline_rtti();
+    final result = SpineBindings.bindings.spine_bone_timeline_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_bone_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_bone_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/bone_timeline1.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,135 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline1.dart';
 
 /// BoneTimeline1 wrapper
-class BoneTimeline1 implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class BoneTimeline1 extends CurveTimeline1 {
   final Pointer<spine_bone_timeline1_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  BoneTimeline1.fromPointer(this._ptr);
+  BoneTimeline1.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
-  Rtti get rtti {
-    final result = _bindings.spine_bone_timeline1_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_bone_timeline1_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_bone_timeline1_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_bone_timeline1_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_bone_timeline1_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_bone_timeline1_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_bone_timeline1_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_bone_timeline1_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_bone_timeline1_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_bone_timeline1_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_bone_timeline1_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_bone_timeline1_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_bone_timeline1_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_bone_timeline1_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_bone_timeline1_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_bone_timeline1_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
   int get boneIndex {
-    final result = _bindings.spine_bone_timeline1_get_bone_index(_ptr);
+    final result = SpineBindings.bindings.spine_bone_timeline1_get_bone_index(_ptr);
     return result;
   }
 
   set boneIndex(int value) {
-    _bindings.spine_bone_timeline1_set_bone_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_bone_timeline1_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_bone_timeline1_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_bone_timeline1_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
+    SpineBindings.bindings.spine_bone_timeline1_set_bone_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_bone_timeline1_dispose(_ptr);
+    SpineBindings.bindings.spine_bone_timeline1_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/bone_timeline2.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,115 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline2.dart';
 
 /// BoneTimeline2 wrapper
-class BoneTimeline2 implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class BoneTimeline2 extends CurveTimeline2 {
   final Pointer<spine_bone_timeline2_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  BoneTimeline2.fromPointer(this._ptr);
+  BoneTimeline2.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
-  Rtti get rtti {
-    final result = _bindings.spine_bone_timeline2_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_bone_timeline2_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value1, double value2) {
-    _bindings.spine_bone_timeline2_set_frame(_ptr, frame, time, value1, value2);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_bone_timeline2_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_bone_timeline2_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_bone_timeline2_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_bone_timeline2_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_bone_timeline2_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_bone_timeline2_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_bone_timeline2_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_bone_timeline2_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_bone_timeline2_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_bone_timeline2_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_bone_timeline2_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
   int get boneIndex {
-    final result = _bindings.spine_bone_timeline2_get_bone_index(_ptr);
+    final result = SpineBindings.bindings.spine_bone_timeline2_get_bone_index(_ptr);
     return result;
   }
 
   set boneIndex(int value) {
-    _bindings.spine_bone_timeline2_set_bone_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_bone_timeline2_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_bone_timeline2_set_bone_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_bone_timeline2_dispose(_ptr);
+    SpineBindings.bindings.spine_bone_timeline2_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/bounding_box_attachment.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,131 +23,41 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'color.dart';
-import 'attachment.dart';
-import 'skeleton.dart';
-import 'slot.dart';
+import '../spine_bindings.dart';
 import 'vertex_attachment.dart';
-import 'arrays.dart';
+import 'color.dart';
 
 /// BoundingBoxAttachment wrapper
-class BoundingBoxAttachment implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class BoundingBoxAttachment extends VertexAttachment {
   final Pointer<spine_bounding_box_attachment_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  BoundingBoxAttachment.fromPointer(this._ptr);
+  BoundingBoxAttachment.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory BoundingBoxAttachment(String name) {
-    final ptr = _bindings.spine_bounding_box_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_bounding_box_attachment_create(name.toNativeUtf8().cast<Char>());
     return BoundingBoxAttachment.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_bounding_box_attachment_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   Color get color {
-    final result = _bindings.spine_bounding_box_attachment_get_color(_ptr);
+    final result = SpineBindings.bindings.spine_bounding_box_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
-  Attachment copy() {
-    final result = _bindings.spine_bounding_box_attachment_copy(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  int get id {
-    final result = _bindings.spine_bounding_box_attachment_get_id(_ptr);
-    return result;
-  }
-
-  ArrayInt get bones {
-    final result = _bindings.spine_bounding_box_attachment_get_bones(_ptr);
-    return ArrayInt.fromPointer(result);
-  }
-
-  set bones(ArrayInt value) {
-    _bindings.spine_bounding_box_attachment_set_bones(_ptr, value.nativePtr.cast());
-  }
-
-  ArrayFloat get vertices {
-    final result = _bindings.spine_bounding_box_attachment_get_vertices(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  set vertices(ArrayFloat value) {
-    _bindings.spine_bounding_box_attachment_set_vertices(_ptr, value.nativePtr.cast());
-  }
-
-  int get worldVerticesLength {
-    final result = _bindings.spine_bounding_box_attachment_get_world_vertices_length(_ptr);
-    return result;
-  }
-
-  set worldVerticesLength(int value) {
-    _bindings.spine_bounding_box_attachment_set_world_vertices_length(_ptr, value);
-  }
-
-  Attachment get timelineAttachment {
-    final result = _bindings.spine_bounding_box_attachment_get_timeline_attachment(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  set timelineAttachment(Attachment value) {
-    _bindings.spine_bounding_box_attachment_set_timeline_attachment(_ptr, value.nativePtr.cast());
-  }
-
-  void copyTo(VertexAttachment other) {
-    _bindings.spine_bounding_box_attachment_copy_to(_ptr, other.nativePtr.cast());
-  }
-
-  String get name {
-    final result = _bindings.spine_bounding_box_attachment_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  int get refCount {
-    final result = _bindings.spine_bounding_box_attachment_get_ref_count(_ptr);
-    return result;
-  }
-
-  void reference() {
-    _bindings.spine_bounding_box_attachment_reference(_ptr);
-  }
-
-  void dereference() {
-    _bindings.spine_bounding_box_attachment_dereference(_ptr);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_bounding_box_attachment_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  void computeWorldVertices(Skeleton skeleton, Slot slot, int start, int count, ArrayFloat worldVertices, int offset, int stride) {
-    _bindings.spine_bounding_box_attachment_compute_world_vertices_2(_ptr, skeleton.nativePtr.cast(), slot.nativePtr.cast(), start, count, worldVertices.nativePtr.cast(), offset, stride);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_bounding_box_attachment_dispose(_ptr);
+    SpineBindings.bindings.spine_bounding_box_attachment_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/clipping_attachment.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,141 +23,51 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'vertex_attachment.dart';
 import 'slot_data.dart';
 import 'color.dart';
-import 'attachment.dart';
-import 'skeleton.dart';
-import 'slot.dart';
-import 'vertex_attachment.dart';
-import 'arrays.dart';
 
 /// ClippingAttachment wrapper
-class ClippingAttachment implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class ClippingAttachment extends VertexAttachment {
   final Pointer<spine_clipping_attachment_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  ClippingAttachment.fromPointer(this._ptr);
+  ClippingAttachment.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory ClippingAttachment(String name) {
-    final ptr = _bindings.spine_clipping_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_clipping_attachment_create(name.toNativeUtf8().cast<Char>());
     return ClippingAttachment.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_clipping_attachment_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   SlotData get endSlot {
-    final result = _bindings.spine_clipping_attachment_get_end_slot(_ptr);
+    final result = SpineBindings.bindings.spine_clipping_attachment_get_end_slot(_ptr);
     return SlotData.fromPointer(result);
   }
 
   set endSlot(SlotData value) {
-    _bindings.spine_clipping_attachment_set_end_slot(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_clipping_attachment_set_end_slot(_ptr, value.nativePtr.cast());
   }
 
   Color get color {
-    final result = _bindings.spine_clipping_attachment_get_color(_ptr);
+    final result = SpineBindings.bindings.spine_clipping_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
-  Attachment copy() {
-    final result = _bindings.spine_clipping_attachment_copy(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  int get id {
-    final result = _bindings.spine_clipping_attachment_get_id(_ptr);
-    return result;
-  }
-
-  ArrayInt get bones {
-    final result = _bindings.spine_clipping_attachment_get_bones(_ptr);
-    return ArrayInt.fromPointer(result);
-  }
-
-  set bones(ArrayInt value) {
-    _bindings.spine_clipping_attachment_set_bones(_ptr, value.nativePtr.cast());
-  }
-
-  ArrayFloat get vertices {
-    final result = _bindings.spine_clipping_attachment_get_vertices(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  set vertices(ArrayFloat value) {
-    _bindings.spine_clipping_attachment_set_vertices(_ptr, value.nativePtr.cast());
-  }
-
-  int get worldVerticesLength {
-    final result = _bindings.spine_clipping_attachment_get_world_vertices_length(_ptr);
-    return result;
-  }
-
-  set worldVerticesLength(int value) {
-    _bindings.spine_clipping_attachment_set_world_vertices_length(_ptr, value);
-  }
-
-  Attachment get timelineAttachment {
-    final result = _bindings.spine_clipping_attachment_get_timeline_attachment(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  set timelineAttachment(Attachment value) {
-    _bindings.spine_clipping_attachment_set_timeline_attachment(_ptr, value.nativePtr.cast());
-  }
-
-  void copyTo(VertexAttachment other) {
-    _bindings.spine_clipping_attachment_copy_to(_ptr, other.nativePtr.cast());
-  }
-
-  String get name {
-    final result = _bindings.spine_clipping_attachment_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  int get refCount {
-    final result = _bindings.spine_clipping_attachment_get_ref_count(_ptr);
-    return result;
-  }
-
-  void reference() {
-    _bindings.spine_clipping_attachment_reference(_ptr);
-  }
-
-  void dereference() {
-    _bindings.spine_clipping_attachment_dereference(_ptr);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_clipping_attachment_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  void computeWorldVertices(Skeleton skeleton, Slot slot, int start, int count, ArrayFloat worldVertices, int offset, int stride) {
-    _bindings.spine_clipping_attachment_compute_world_vertices_2(_ptr, skeleton.nativePtr.cast(), slot.nativePtr.cast(), start, count, worldVertices.nativePtr.cast(), offset, stride);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_clipping_attachment_dispose(_ptr);
+    SpineBindings.bindings.spine_clipping_attachment_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/color.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,126 +23,121 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// Color wrapper
 class Color implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_color_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Color.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory Color() {
-    final ptr = _bindings.spine_color_create();
+    final ptr = SpineBindings.bindings.spine_color_create();
     return Color.fromPointer(ptr);
   }
 
   factory Color.fromRGBA(double r, double g, double b, double a) {
-    final ptr = _bindings.spine_color_create2(r, g, b, a);
+    final ptr = SpineBindings.bindings.spine_color_create2(r, g, b, a);
     return Color.fromPointer(ptr);
   }
 
   Color clamp() {
-    final result = _bindings.spine_color_clamp(_ptr);
+    final result = SpineBindings.bindings.spine_color_clamp(_ptr);
     return Color.fromPointer(result);
   }
 
   static double parseHex(String value, int index) {
-    final result = _bindings.spine_color_parse_hex(value.toNativeUtf8().cast<Char>(), index);
+    final result = SpineBindings.bindings.spine_color_parse_hex(value.toNativeUtf8().cast<Char>(), index);
     return result;
   }
 
   void rgba8888ToColor(int value) {
-    _bindings.spine_color_rgba8888_to_color(_ptr, value);
+    SpineBindings.bindings.spine_color_rgba8888_to_color(_ptr, value);
   }
 
   void rgb888ToColor(int value) {
-    _bindings.spine_color_rgb888_to_color(_ptr, value);
+    SpineBindings.bindings.spine_color_rgb888_to_color(_ptr, value);
   }
 
   double get r {
-    final result = _bindings.spine_color_get_r(_ptr);
+    final result = SpineBindings.bindings.spine_color_get_r(_ptr);
     return result;
   }
 
   set r(double value) {
-    _bindings.spine_color_set_r(_ptr, value);
+    SpineBindings.bindings.spine_color_set_r(_ptr, value);
   }
 
   double get g {
-    final result = _bindings.spine_color_get_g(_ptr);
+    final result = SpineBindings.bindings.spine_color_get_g(_ptr);
     return result;
   }
 
   set g(double value) {
-    _bindings.spine_color_set_g(_ptr, value);
+    SpineBindings.bindings.spine_color_set_g(_ptr, value);
   }
 
   double get b {
-    final result = _bindings.spine_color_get_b(_ptr);
+    final result = SpineBindings.bindings.spine_color_get_b(_ptr);
     return result;
   }
 
   set b(double value) {
-    _bindings.spine_color_set_b(_ptr, value);
+    SpineBindings.bindings.spine_color_set_b(_ptr, value);
   }
 
   double get a {
-    final result = _bindings.spine_color_get_a(_ptr);
+    final result = SpineBindings.bindings.spine_color_get_a(_ptr);
     return result;
   }
 
   set a(double value) {
-    _bindings.spine_color_set_a(_ptr, value);
+    SpineBindings.bindings.spine_color_set_a(_ptr, value);
   }
 
-  Color set1(double _r, double _g, double _b, double _a) {
-    final result = _bindings.spine_color_set_1(_ptr, _r, _g, _b, _a);
+  Color set1(double r, double g, double b, double a) {
+    final result = SpineBindings.bindings.spine_color_set_1(_ptr, r, g, b, a);
     return Color.fromPointer(result);
   }
 
-  Color set2(double _r, double _g, double _b) {
-    final result = _bindings.spine_color_set_2(_ptr, _r, _g, _b);
+  Color set2(double r, double g, double b) {
+    final result = SpineBindings.bindings.spine_color_set_2(_ptr, r, g, b);
     return Color.fromPointer(result);
   }
 
   Color set3(Color other) {
-    final result = _bindings.spine_color_set_3(_ptr, other.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_color_set_3(_ptr, other.nativePtr.cast());
     return Color.fromPointer(result);
   }
 
-  Color add1(double _r, double _g, double _b, double _a) {
-    final result = _bindings.spine_color_add_1(_ptr, _r, _g, _b, _a);
+  Color add1(double r, double g, double b, double a) {
+    final result = SpineBindings.bindings.spine_color_add_1(_ptr, r, g, b, a);
     return Color.fromPointer(result);
   }
 
-  Color add2(double _r, double _g, double _b) {
-    final result = _bindings.spine_color_add_2(_ptr, _r, _g, _b);
+  Color add2(double r, double g, double b) {
+    final result = SpineBindings.bindings.spine_color_add_2(_ptr, r, g, b);
     return Color.fromPointer(result);
   }
 
   Color add3(Color other) {
-    final result = _bindings.spine_color_add_3(_ptr, other.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_color_add_3(_ptr, other.nativePtr.cast());
     return Color.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_color_dispose(_ptr);
+    SpineBindings.bindings.spine_color_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/constraint.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,63 +23,45 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'update.dart';
 import 'constraint_data.dart';
 import 'skeleton.dart';
-import 'physics.dart';
 
 /// Constraint wrapper
-class Constraint implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class Constraint extends Update {
   final Pointer<spine_constraint_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  Constraint.fromPointer(this._ptr);
+  Constraint.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
-  Rtti get rtti {
-    final result = _bindings.spine_constraint_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   ConstraintData get data {
-    final result = _bindings.spine_constraint_get_data(_ptr);
-    return ConstraintData.fromPointer(result);
+    final result = SpineBindings.bindings.spine_constraint_get_data(_ptr);
+    throw UnsupportedError('Cannot instantiate abstract class ConstraintData from pointer - no concrete subclasses found');
   }
 
   void sort(Skeleton skeleton) {
-    _bindings.spine_constraint_sort(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
   bool get isSourceActive {
-    final result = _bindings.spine_constraint_is_source_active(_ptr);
+    final result = SpineBindings.bindings.spine_constraint_is_source_active(_ptr);
     return result;
   }
 
-  void update(Skeleton skeleton, Physics physics) {
-    _bindings.spine_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_constraint_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_constraint_dispose(_ptr);
+    SpineBindings.bindings.spine_constraint_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/constraint_data.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,60 +23,55 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'constraint.dart';
 import 'skeleton.dart';
 
 /// ConstraintData wrapper
-class ConstraintData implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class ConstraintData implements Finalizable {
   final Pointer<spine_constraint_data_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   ConstraintData.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   Rtti get rtti {
-    final result = _bindings.spine_constraint_data_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   Constraint createMethod(Skeleton skeleton) {
-    final result = _bindings.spine_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-    return Constraint.fromPointer(result);
+    final result = SpineBindings.bindings.spine_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
+    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
   }
 
   String get name {
-    final result = _bindings.spine_constraint_data_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_constraint_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   bool get skinRequired {
-    final result = _bindings.spine_constraint_data_get_skin_required(_ptr);
+    final result = SpineBindings.bindings.spine_constraint_data_get_skin_required(_ptr);
     return result;
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_constraint_data_rtti();
+    final result = SpineBindings.bindings.spine_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_constraint_data_dispose(_ptr);
+    SpineBindings.bindings.spine_constraint_data_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/constraint_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,51 +23,46 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 
 /// ConstraintTimeline wrapper
 class ConstraintTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_constraint_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   ConstraintTimeline.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   Rtti get rtti {
-    final result = _bindings.spine_constraint_timeline_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_constraint_timeline_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   int get constraintIndex {
-    final result = _bindings.spine_constraint_timeline_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings.spine_constraint_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   set constraintIndex(int value) {
-    _bindings.spine_constraint_timeline_set_constraint_index(_ptr, value);
+    SpineBindings.bindings.spine_constraint_timeline_set_constraint_index(_ptr, value);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_constraint_timeline_rtti();
+    final result = SpineBindings.bindings.spine_constraint_timeline_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_constraint_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_constraint_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/constraint_timeline1.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,135 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'skeleton.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline1.dart';
 
 /// ConstraintTimeline1 wrapper
-class ConstraintTimeline1 implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class ConstraintTimeline1 extends CurveTimeline1 {
   final Pointer<spine_constraint_timeline1_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  ConstraintTimeline1.fromPointer(this._ptr);
+  ConstraintTimeline1.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
-  Rtti get rtti {
-    final result = _bindings.spine_constraint_timeline1_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_constraint_timeline1_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_constraint_timeline1_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_constraint_timeline1_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_constraint_timeline1_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_constraint_timeline1_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_constraint_timeline1_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_constraint_timeline1_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_constraint_timeline1_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_constraint_timeline1_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_constraint_timeline1_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_constraint_timeline1_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_constraint_timeline1_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_constraint_timeline1_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_constraint_timeline1_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_constraint_timeline1_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
   int get constraintIndex {
-    final result = _bindings.spine_constraint_timeline1_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings.spine_constraint_timeline1_get_constraint_index(_ptr);
     return result;
   }
 
   set constraintIndex(int value) {
-    _bindings.spine_constraint_timeline1_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_constraint_timeline1_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_constraint_timeline1_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_constraint_timeline1_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
+    SpineBindings.bindings.spine_constraint_timeline1_set_constraint_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_constraint_timeline1_dispose(_ptr);
+    SpineBindings.bindings.spine_constraint_timeline1_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/curve_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,97 +23,52 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
+import '../spine_bindings.dart';
+import 'timeline.dart';
 import 'arrays.dart';
 
 /// CurveTimeline wrapper
-class CurveTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class CurveTimeline extends Timeline {
   final Pointer<spine_curve_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  CurveTimeline.fromPointer(this._ptr);
+  CurveTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
-  Rtti get rtti {
-    final result = _bindings.spine_curve_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   set linear(int value) {
-    _bindings.spine_curve_timeline_set_linear(_ptr, value);
+    SpineBindings.bindings.spine_curve_timeline_set_linear(_ptr, value);
   }
 
   set stepped(int value) {
-    _bindings.spine_curve_timeline_set_stepped(_ptr, value);
+    SpineBindings.bindings.spine_curve_timeline_set_stepped(_ptr, value);
   }
 
   void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_curve_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+    SpineBindings.bindings.spine_curve_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
   }
 
   double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_curve_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
+    final result = SpineBindings.bindings.spine_curve_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
     return result;
   }
 
   ArrayFloat get curves {
-    final result = _bindings.spine_curve_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_curve_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_curve_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_curve_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_curve_timeline_get_frames(_ptr);
+    final result = SpineBindings.bindings.spine_curve_timeline_get_curves(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
-  double get duration {
-    final result = _bindings.spine_curve_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_curve_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_curve_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_curve_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_curve_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/curve_timeline1.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,126 +23,60 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline.dart';
 import 'mix_blend.dart';
 import 'mix_direction.dart';
-import 'skeleton.dart';
-import 'arrays.dart';
 
 /// CurveTimeline1 wrapper
-class CurveTimeline1 implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class CurveTimeline1 extends CurveTimeline {
   final Pointer<spine_curve_timeline1_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  CurveTimeline1.fromPointer(this._ptr);
+  CurveTimeline1.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
-  Rtti get rtti {
-    final result = _bindings.spine_curve_timeline1_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void setFrame(int frame, double time, double value) {
-    _bindings.spine_curve_timeline1_set_frame(_ptr, frame, time, value);
+    SpineBindings.bindings.spine_curve_timeline1_set_frame(_ptr, frame, time, value);
   }
 
   double getCurveValue(double time) {
-    final result = _bindings.spine_curve_timeline1_get_curve_value(_ptr, time);
+    final result = SpineBindings.bindings.spine_curve_timeline1_get_curve_value(_ptr, time);
     return result;
   }
 
   double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_curve_timeline1_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
+    final result = SpineBindings.bindings.spine_curve_timeline1_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
     return result;
   }
 
   double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_curve_timeline1_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_curve_timeline1_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_curve_timeline1_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_curve_timeline1_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_curve_timeline1_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_curve_timeline1_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_curve_timeline1_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_curve_timeline1_get_frame_entries(_ptr);
+    final result = SpineBindings.bindings.spine_curve_timeline1_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
     return result;
   }
 
-  int get frameCount {
-    final result = _bindings.spine_curve_timeline1_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_curve_timeline1_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_curve_timeline1_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_curve_timeline1_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_curve_timeline1_rtti();
-    return Rtti.fromPointer(result);
-  }
-
   double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_curve_timeline1_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
+    final result = SpineBindings.bindings.spine_curve_timeline1_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
     return result;
   }
 
   double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_curve_timeline1_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
+    final result = SpineBindings.bindings.spine_curve_timeline1_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
     return result;
   }
 
+  @override
   void dispose() {
-    _bindings.spine_curve_timeline1_dispose(_ptr);
+    SpineBindings.bindings.spine_curve_timeline1_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/curve_timeline2.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,106 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline.dart';
 
 /// CurveTimeline2 wrapper
-class CurveTimeline2 implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class CurveTimeline2 extends CurveTimeline {
   final Pointer<spine_curve_timeline2_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  CurveTimeline2.fromPointer(this._ptr);
+  CurveTimeline2.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
-  Rtti get rtti {
-    final result = _bindings.spine_curve_timeline2_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void setFrame(int frame, double time, double value1, double value2) {
-    _bindings.spine_curve_timeline2_set_frame(_ptr, frame, time, value1, value2);
+    SpineBindings.bindings.spine_curve_timeline2_set_frame(_ptr, frame, time, value1, value2);
   }
 
   double getCurveValue(double time) {
-    final result = _bindings.spine_curve_timeline2_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_curve_timeline2_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_curve_timeline2_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_curve_timeline2_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_curve_timeline2_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_curve_timeline2_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_curve_timeline2_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_curve_timeline2_get_frame_entries(_ptr);
+    final result = SpineBindings.bindings.spine_curve_timeline2_get_curve_value(_ptr, time);
     return result;
   }
 
-  int get frameCount {
-    final result = _bindings.spine_curve_timeline2_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_curve_timeline2_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_curve_timeline2_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_curve_timeline2_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_curve_timeline2_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_curve_timeline2_dispose(_ptr);
+    SpineBindings.bindings.spine_curve_timeline2_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/deform_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,130 +23,72 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
+import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'slot_curve_timeline.dart';
 import 'vertex_attachment.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
+import 'bounding_box_attachment.dart';
+import 'clipping_attachment.dart';
+import 'mesh_attachment.dart';
+import 'path_attachment.dart';
 import 'arrays.dart';
 
 /// DeformTimeline wrapper
-class DeformTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class DeformTimeline extends SlotCurveTimeline {
   final Pointer<spine_deform_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  DeformTimeline.fromPointer(this._ptr);
+  DeformTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory DeformTimeline(int frameCount, int bezierCount, int slotIndex, VertexAttachment attachment) {
-    final ptr = _bindings.spine_deform_timeline_create(frameCount, bezierCount, slotIndex, attachment.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_deform_timeline_create(frameCount, bezierCount, slotIndex, attachment.nativePtr.cast());
     return DeformTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_deform_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void setFrame(int frameIndex, double time, ArrayFloat vertices) {
-    _bindings.spine_deform_timeline_set_frame(_ptr, frameIndex, time, vertices.nativePtr.cast());
+    SpineBindings.bindings.spine_deform_timeline_set_frame(_ptr, frameIndex, time, vertices.nativePtr.cast());
   }
 
   VertexAttachment get attachment {
-    final result = _bindings.spine_deform_timeline_get_attachment(_ptr);
-    return VertexAttachment.fromPointer(result);
+    final result = SpineBindings.bindings.spine_deform_timeline_get_attachment(_ptr);
+    final rtti = SpineBindings.bindings.spine_vertex_attachment_get_rtti(result);
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    switch (className) {
+      case 'spine_bounding_box_attachment':
+        return BoundingBoxAttachment.fromPointer(result.cast());
+      case 'spine_clipping_attachment':
+        return ClippingAttachment.fromPointer(result.cast());
+      case 'spine_mesh_attachment':
+        return MeshAttachment.fromPointer(result.cast());
+      case 'spine_path_attachment':
+        return PathAttachment.fromPointer(result.cast());
+      default:
+        throw UnsupportedError('Unknown concrete type: $className for abstract class VertexAttachment');
+    }
   }
 
   set attachment(VertexAttachment value) {
-    _bindings.spine_deform_timeline_set_attachment(_ptr, value.nativePtr.cast());
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_deform_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+    SpineBindings.bindings.spine_deform_timeline_set_attachment(_ptr, value.nativePtr.cast());
   }
 
   double getCurvePercent(double time, int frame) {
-    final result = _bindings.spine_deform_timeline_get_curve_percent(_ptr, time, frame);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_deform_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_deform_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  set linear(int value) {
-    _bindings.spine_deform_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_deform_timeline_set_stepped(_ptr, value);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_deform_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
+    final result = SpineBindings.bindings.spine_deform_timeline_get_curve_percent(_ptr, time, frame);
     return result;
   }
 
-  ArrayFloat get curves {
-    final result = _bindings.spine_deform_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_deform_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_deform_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_deform_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_deform_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get slotIndex {
-    final result = _bindings.spine_deform_timeline_get_slot_index(_ptr);
-    return result;
-  }
-
-  set slotIndex(int value) {
-    _bindings.spine_deform_timeline_set_slot_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_deform_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_deform_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_deform_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/draw_order_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,84 +23,39 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
+import '../spine_bindings.dart';
+import 'timeline.dart';
 import 'arrays.dart';
 
 /// DrawOrderTimeline wrapper
-class DrawOrderTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class DrawOrderTimeline extends Timeline {
   final Pointer<spine_draw_order_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  DrawOrderTimeline.fromPointer(this._ptr);
+  DrawOrderTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory DrawOrderTimeline(int frameCount) {
-    final ptr = _bindings.spine_draw_order_timeline_create(frameCount);
+    final ptr = SpineBindings.bindings.spine_draw_order_timeline_create(frameCount);
     return DrawOrderTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_draw_order_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_draw_order_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_draw_order_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
   void setFrame(int frame, double time, ArrayInt drawOrder) {
-    _bindings.spine_draw_order_timeline_set_frame(_ptr, frame, time, drawOrder.nativePtr.cast());
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_draw_order_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_draw_order_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_draw_order_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_draw_order_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_draw_order_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_draw_order_timeline_set_frame(_ptr, frame, time, drawOrder.nativePtr.cast());
   }
 
+  @override
   void dispose() {
-    _bindings.spine_draw_order_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_draw_order_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/event.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,93 +23,88 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'event_data.dart';
 
 /// Event wrapper
 class Event implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_event_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Event.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory Event(double time, EventData data) {
-    final ptr = _bindings.spine_event_create(time, data.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_event_create(time, data.nativePtr.cast());
     return Event.fromPointer(ptr);
   }
 
   EventData get data {
-    final result = _bindings.spine_event_get_data(_ptr);
+    final result = SpineBindings.bindings.spine_event_get_data(_ptr);
     return EventData.fromPointer(result);
   }
 
   double get time {
-    final result = _bindings.spine_event_get_time(_ptr);
+    final result = SpineBindings.bindings.spine_event_get_time(_ptr);
     return result;
   }
 
   int get intValue {
-    final result = _bindings.spine_event_get_int(_ptr);
+    final result = SpineBindings.bindings.spine_event_get_int(_ptr);
     return result;
   }
 
   set intValue(int value) {
-    _bindings.spine_event_set_int(_ptr, value);
+    SpineBindings.bindings.spine_event_set_int(_ptr, value);
   }
 
   double get floatValue {
-    final result = _bindings.spine_event_get_float(_ptr);
+    final result = SpineBindings.bindings.spine_event_get_float(_ptr);
     return result;
   }
 
   set floatValue(double value) {
-    _bindings.spine_event_set_float(_ptr, value);
+    SpineBindings.bindings.spine_event_set_float(_ptr, value);
   }
 
   String get stringValue {
-    final result = _bindings.spine_event_get_string(_ptr);
+    final result = SpineBindings.bindings.spine_event_get_string(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set stringValue(String value) {
-    _bindings.spine_event_set_string(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_event_set_string(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   double get volume {
-    final result = _bindings.spine_event_get_volume(_ptr);
+    final result = SpineBindings.bindings.spine_event_get_volume(_ptr);
     return result;
   }
 
   set volume(double value) {
-    _bindings.spine_event_set_volume(_ptr, value);
+    SpineBindings.bindings.spine_event_set_volume(_ptr, value);
   }
 
   double get balance {
-    final result = _bindings.spine_event_get_balance(_ptr);
+    final result = SpineBindings.bindings.spine_event_get_balance(_ptr);
     return result;
   }
 
   set balance(double value) {
-    _bindings.spine_event_set_balance(_ptr, value);
+    SpineBindings.bindings.spine_event_set_balance(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_event_dispose(_ptr);
+    SpineBindings.bindings.spine_event_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/event_data.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,96 +23,91 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// EventData wrapper
 class EventData implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_event_data_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   EventData.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory EventData(String name) {
-    final ptr = _bindings.spine_event_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_event_data_create(name.toNativeUtf8().cast<Char>());
     return EventData.fromPointer(ptr);
   }
 
   String get name {
-    final result = _bindings.spine_event_data_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_event_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   int get intValue {
-    final result = _bindings.spine_event_data_get_int(_ptr);
+    final result = SpineBindings.bindings.spine_event_data_get_int(_ptr);
     return result;
   }
 
   set intValue(int value) {
-    _bindings.spine_event_data_set_int(_ptr, value);
+    SpineBindings.bindings.spine_event_data_set_int(_ptr, value);
   }
 
   double get floatValue {
-    final result = _bindings.spine_event_data_get_float(_ptr);
+    final result = SpineBindings.bindings.spine_event_data_get_float(_ptr);
     return result;
   }
 
   set floatValue(double value) {
-    _bindings.spine_event_data_set_float(_ptr, value);
+    SpineBindings.bindings.spine_event_data_set_float(_ptr, value);
   }
 
   String get stringValue {
-    final result = _bindings.spine_event_data_get_string(_ptr);
+    final result = SpineBindings.bindings.spine_event_data_get_string(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set stringValue(String value) {
-    _bindings.spine_event_data_set_string(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_event_data_set_string(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get audioPath {
-    final result = _bindings.spine_event_data_get_audio_path(_ptr);
+    final result = SpineBindings.bindings.spine_event_data_get_audio_path(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set audioPath(String value) {
-    _bindings.spine_event_data_set_audio_path(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_event_data_set_audio_path(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   double get volume {
-    final result = _bindings.spine_event_data_get_volume(_ptr);
+    final result = SpineBindings.bindings.spine_event_data_get_volume(_ptr);
     return result;
   }
 
   set volume(double value) {
-    _bindings.spine_event_data_set_volume(_ptr, value);
+    SpineBindings.bindings.spine_event_data_set_volume(_ptr, value);
   }
 
   double get balance {
-    final result = _bindings.spine_event_data_get_balance(_ptr);
+    final result = SpineBindings.bindings.spine_event_data_get_balance(_ptr);
     return result;
   }
 
   set balance(double value) {
-    _bindings.spine_event_data_set_balance(_ptr, value);
+    SpineBindings.bindings.spine_event_data_set_balance(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_event_data_dispose(_ptr);
+    SpineBindings.bindings.spine_event_data_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/event_queue_entry.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,66 +23,61 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'event_type.dart';
 import 'track_entry.dart';
 import 'event.dart';
 
 /// EventQueueEntry wrapper
 class EventQueueEntry implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_event_queue_entry_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   EventQueueEntry.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory EventQueueEntry(EventType eventType, TrackEntry trackEntry, Event event) {
-    final ptr = _bindings.spine_event_queue_entry_create(eventType.value, trackEntry.nativePtr.cast(), event.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_event_queue_entry_create(eventType.value, trackEntry.nativePtr.cast(), event.nativePtr.cast());
     return EventQueueEntry.fromPointer(ptr);
   }
 
   EventType get type {
-    final result = _bindings.spine_event_queue_entry_get__type(_ptr);
+    final result = SpineBindings.bindings.spine_event_queue_entry_get__type(_ptr);
     return EventType.fromValue(result);
   }
 
   set type(EventType value) {
-    _bindings.spine_event_queue_entry_set__type(_ptr, value.value);
+    SpineBindings.bindings.spine_event_queue_entry_set__type(_ptr, value.value);
   }
 
   TrackEntry get entry {
-    final result = _bindings.spine_event_queue_entry_get__entry(_ptr);
+    final result = SpineBindings.bindings.spine_event_queue_entry_get__entry(_ptr);
     return TrackEntry.fromPointer(result);
   }
 
   set entry(TrackEntry value) {
-    _bindings.spine_event_queue_entry_set__entry(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_event_queue_entry_set__entry(_ptr, value.nativePtr.cast());
   }
 
   Event get event {
-    final result = _bindings.spine_event_queue_entry_get__event(_ptr);
+    final result = SpineBindings.bindings.spine_event_queue_entry_get__event(_ptr);
     return Event.fromPointer(result);
   }
 
   set event(Event value) {
-    _bindings.spine_event_queue_entry_set__event(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_event_queue_entry_set__event(_ptr, value.nativePtr.cast());
   }
 
   void dispose() {
-    _bindings.spine_event_queue_entry_dispose(_ptr);
+    SpineBindings.bindings.spine_event_queue_entry_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/event_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,90 +23,45 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
+import '../spine_bindings.dart';
+import 'timeline.dart';
 import 'event.dart';
 import 'arrays.dart';
 
 /// EventTimeline wrapper
-class EventTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class EventTimeline extends Timeline {
   final Pointer<spine_event_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  EventTimeline.fromPointer(this._ptr);
+  EventTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory EventTimeline(int frameCount) {
-    final ptr = _bindings.spine_event_timeline_create(frameCount);
+    final ptr = SpineBindings.bindings.spine_event_timeline_create(frameCount);
     return EventTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_event_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_event_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_event_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
   ArrayEvent get events {
-    final result = _bindings.spine_event_timeline_get_events(_ptr);
+    final result = SpineBindings.bindings.spine_event_timeline_get_events(_ptr);
     return ArrayEvent.fromPointer(result);
   }
 
   void setFrame(int frame, Event event) {
-    _bindings.spine_event_timeline_set_frame(_ptr, frame, event.nativePtr.cast());
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_event_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_event_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_event_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_event_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_event_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_event_timeline_set_frame(_ptr, frame, event.nativePtr.cast());
   }
 
+  @override
   void dispose() {
-    _bindings.spine_event_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_event_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/event_type.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/format.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/from_property.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,61 +23,56 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'arrays.dart';
 
 /// FromProperty wrapper
-class FromProperty implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class FromProperty implements Finalizable {
   final Pointer<spine_from_property_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   FromProperty.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   Rtti get rtti {
-    final result = _bindings.spine_from_property_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_from_property_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_from_property_rtti();
+    final result = SpineBindings.bindings.spine_from_property_rtti();
     return Rtti.fromPointer(result);
   }
 
   double get offset {
-    final result = _bindings.spine_from_property_get__offset(_ptr);
+    final result = SpineBindings.bindings.spine_from_property_get__offset(_ptr);
     return result;
   }
 
   set offset(double value) {
-    _bindings.spine_from_property_set__offset(_ptr, value);
+    SpineBindings.bindings.spine_from_property_set__offset(_ptr, value);
   }
 
   ArrayToProperty get to {
-    final result = _bindings.spine_from_property_get__to(_ptr);
+    final result = SpineBindings.bindings.spine_from_property_get__to(_ptr);
     return ArrayToProperty.fromPointer(result);
   }
 
   set to(ArrayToProperty value) {
-    _bindings.spine_from_property_set__to(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_from_property_set__to(_ptr, value.nativePtr.cast());
   }
 
   void dispose() {
-    _bindings.spine_from_property_dispose(_ptr);
+    SpineBindings.bindings.spine_from_property_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/from_rotate.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,47 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'from_property.dart';
 
 /// FromRotate wrapper
-class FromRotate implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class FromRotate extends FromProperty {
   final Pointer<spine_from_rotate_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  FromRotate.fromPointer(this._ptr);
+  FromRotate.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory FromRotate() {
-    final ptr = _bindings.spine_from_rotate_create();
+    final ptr = SpineBindings.bindings.spine_from_rotate_create();
     return FromRotate.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_from_rotate_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_from_rotate_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_from_rotate_dispose(_ptr);
+    SpineBindings.bindings.spine_from_rotate_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/from_scale_x.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,47 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'from_property.dart';
 
 /// FromScaleX wrapper
-class FromScaleX implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class FromScaleX extends FromProperty {
   final Pointer<spine_from_scale_x_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  FromScaleX.fromPointer(this._ptr);
+  FromScaleX.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory FromScaleX() {
-    final ptr = _bindings.spine_from_scale_x_create();
+    final ptr = SpineBindings.bindings.spine_from_scale_x_create();
     return FromScaleX.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_from_scale_x_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_from_scale_x_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_from_scale_x_dispose(_ptr);
+    SpineBindings.bindings.spine_from_scale_x_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/from_scale_y.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,47 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'from_property.dart';
 
 /// FromScaleY wrapper
-class FromScaleY implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class FromScaleY extends FromProperty {
   final Pointer<spine_from_scale_y_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  FromScaleY.fromPointer(this._ptr);
+  FromScaleY.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory FromScaleY() {
-    final ptr = _bindings.spine_from_scale_y_create();
+    final ptr = SpineBindings.bindings.spine_from_scale_y_create();
     return FromScaleY.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_from_scale_y_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_from_scale_y_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_from_scale_y_dispose(_ptr);
+    SpineBindings.bindings.spine_from_scale_y_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/from_shear_y.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,47 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'from_property.dart';
 
 /// FromShearY wrapper
-class FromShearY implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class FromShearY extends FromProperty {
   final Pointer<spine_from_shear_y_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  FromShearY.fromPointer(this._ptr);
+  FromShearY.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory FromShearY() {
-    final ptr = _bindings.spine_from_shear_y_create();
+    final ptr = SpineBindings.bindings.spine_from_shear_y_create();
     return FromShearY.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_from_shear_y_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_from_shear_y_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_from_shear_y_dispose(_ptr);
+    SpineBindings.bindings.spine_from_shear_y_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/from_x.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,47 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'from_property.dart';
 
 /// FromX wrapper
-class FromX implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class FromX extends FromProperty {
   final Pointer<spine_from_x_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  FromX.fromPointer(this._ptr);
+  FromX.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory FromX() {
-    final ptr = _bindings.spine_from_x_create();
+    final ptr = SpineBindings.bindings.spine_from_x_create();
     return FromX.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_from_x_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_from_x_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_from_x_dispose(_ptr);
+    SpineBindings.bindings.spine_from_x_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/from_y.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,47 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'from_property.dart';
 
 /// FromY wrapper
-class FromY implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class FromY extends FromProperty {
   final Pointer<spine_from_y_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  FromY.fromPointer(this._ptr);
+  FromY.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory FromY() {
-    final ptr = _bindings.spine_from_y_create();
+    final ptr = SpineBindings.bindings.spine_from_y_create();
     return FromY.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_from_y_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_from_y_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_from_y_dispose(_ptr);
+    SpineBindings.bindings.spine_from_y_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/ik_constraint.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,14 +23,15 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'skeleton.dart';
 import 'physics.dart';
@@ -42,112 +43,106 @@ import 'arrays.dart';
 
 /// IkConstraint wrapper
 class IkConstraint implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_ik_constraint_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   IkConstraint.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory IkConstraint(IkConstraintData data, Skeleton skeleton) {
-    final ptr = _bindings.spine_ik_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_ik_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
     return IkConstraint.fromPointer(ptr);
   }
 
   Rtti get rtti {
-    final result = _bindings.spine_ik_constraint_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   IkConstraint copy(Skeleton skeleton) {
-    final result = _bindings.spine_ik_constraint_copy(_ptr, skeleton.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_ik_constraint_copy(_ptr, skeleton.nativePtr.cast());
     return IkConstraint.fromPointer(result);
   }
 
   void update(Skeleton skeleton, Physics physics) {
-    _bindings.spine_ik_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings.spine_ik_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   void sort(Skeleton skeleton) {
-    _bindings.spine_ik_constraint_sort(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_ik_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
   bool get isSourceActive {
-    final result = _bindings.spine_ik_constraint_is_source_active(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_is_source_active(_ptr);
     return result;
   }
 
   IkConstraintData get data {
-    final result = _bindings.spine_ik_constraint_get_data(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_get_data(_ptr);
     return IkConstraintData.fromPointer(result);
   }
 
   ArrayBonePose get bones {
-    final result = _bindings.spine_ik_constraint_get_bones(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_get_bones(_ptr);
     return ArrayBonePose.fromPointer(result);
   }
 
   Bone get target {
-    final result = _bindings.spine_ik_constraint_get_target(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_get_target(_ptr);
     return Bone.fromPointer(result);
   }
 
   set target(Bone value) {
-    _bindings.spine_ik_constraint_set_target(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_ik_constraint_set_target(_ptr, value.nativePtr.cast());
   }
 
   IkConstraintPose get pose {
-    final result = _bindings.spine_ik_constraint_get_pose(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_get_pose(_ptr);
     return IkConstraintPose.fromPointer(result);
   }
 
   IkConstraintPose get appliedPose {
-    final result = _bindings.spine_ik_constraint_get_applied_pose(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_get_applied_pose(_ptr);
     return IkConstraintPose.fromPointer(result);
   }
 
   void resetConstrained() {
-    _bindings.spine_ik_constraint_reset_constrained(_ptr);
+    SpineBindings.bindings.spine_ik_constraint_reset_constrained(_ptr);
   }
 
   void constrained() {
-    _bindings.spine_ik_constraint_constrained(_ptr);
+    SpineBindings.bindings.spine_ik_constraint_constrained(_ptr);
   }
 
   bool get isPoseEqualToApplied {
-    final result = _bindings.spine_ik_constraint_is_pose_equal_to_applied(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
   bool get isActive {
-    final result = _bindings.spine_ik_constraint_is_active(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_is_active(_ptr);
     return result;
   }
 
   set active(bool value) {
-    _bindings.spine_ik_constraint_set_active(_ptr, value);
+    SpineBindings.bindings.spine_ik_constraint_set_active(_ptr, value);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_ik_constraint_rtti();
+    final result = SpineBindings.bindings.spine_ik_constraint_rtti();
     return Rtti.fromPointer(result);
   }
 
   static void apply1(Skeleton skeleton, BonePose bone, double targetX, double targetY, bool compress, bool stretch, bool uniform, double mix) {
-    _bindings.spine_ik_constraint_apply_1(skeleton.nativePtr.cast(), bone.nativePtr.cast(), targetX, targetY, compress, stretch, uniform, mix);
+    SpineBindings.bindings.spine_ik_constraint_apply_1(skeleton.nativePtr.cast(), bone.nativePtr.cast(), targetX, targetY, compress, stretch, uniform, mix);
   }
 
   static void apply2(Skeleton skeleton, BonePose parent, BonePose child, double targetX, double targetY, int bendDirection, bool stretch, bool uniform, double softness, double mix) {
-    _bindings.spine_ik_constraint_apply_2(skeleton.nativePtr.cast(), parent.nativePtr.cast(), child.nativePtr.cast(), targetX, targetY, bendDirection, stretch, uniform, softness, mix);
+    SpineBindings.bindings.spine_ik_constraint_apply_2(skeleton.nativePtr.cast(), parent.nativePtr.cast(), child.nativePtr.cast(), targetX, targetY, bendDirection, stretch, uniform, softness, mix);
   }
 
   void dispose() {
-    _bindings.spine_ik_constraint_dispose(_ptr);
+    SpineBindings.bindings.spine_ik_constraint_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/ik_constraint_data.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,15 +23,16 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'constraint.dart';
 import 'skeleton.dart';
@@ -41,82 +42,76 @@ import 'arrays.dart';
 
 /// IkConstraintData wrapper
 class IkConstraintData implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_ik_constraint_data_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   IkConstraintData.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory IkConstraintData(String name) {
-    final ptr = _bindings.spine_ik_constraint_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_ik_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return IkConstraintData.fromPointer(ptr);
   }
 
   Rtti get rtti {
-    final result = _bindings.spine_ik_constraint_data_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   Constraint createMethod(Skeleton skeleton) {
-    final result = _bindings.spine_ik_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-    return Constraint.fromPointer(result);
+    final result = SpineBindings.bindings.spine_ik_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
+    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
   }
 
   ArrayBoneData get bones {
-    final result = _bindings.spine_ik_constraint_data_get_bones(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_bones(_ptr);
     return ArrayBoneData.fromPointer(result);
   }
 
   BoneData get target {
-    final result = _bindings.spine_ik_constraint_data_get_target(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_target(_ptr);
     return BoneData.fromPointer(result);
   }
 
   set target(BoneData value) {
-    _bindings.spine_ik_constraint_data_set_target(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_ik_constraint_data_set_target(_ptr, value.nativePtr.cast());
   }
 
   bool get uniform {
-    final result = _bindings.spine_ik_constraint_data_get_uniform(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_uniform(_ptr);
     return result;
   }
 
   set uniform(bool value) {
-    _bindings.spine_ik_constraint_data_set_uniform(_ptr, value);
+    SpineBindings.bindings.spine_ik_constraint_data_set_uniform(_ptr, value);
   }
 
   String get name {
-    final result = _bindings.spine_ik_constraint_data_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   bool get skinRequired {
-    final result = _bindings.spine_ik_constraint_data_get_skin_required(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_skin_required(_ptr);
     return result;
   }
 
   IkConstraintPose get setupPose {
-    final result = _bindings.spine_ik_constraint_data_get_setup_pose(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_setup_pose(_ptr);
     return IkConstraintPose.fromPointer(result);
   }
 
   set skinRequired(bool value) {
-    _bindings.spine_ik_constraint_data_set_skin_required(_ptr, value);
+    SpineBindings.bindings.spine_ik_constraint_data_set_skin_required(_ptr, value);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_ik_constraint_data_rtti();
+    final result = SpineBindings.bindings.spine_ik_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_ik_constraint_data_dispose(_ptr);
+    SpineBindings.bindings.spine_ik_constraint_data_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/ik_constraint_pose.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,85 +23,80 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// IkConstraintPose wrapper
 class IkConstraintPose implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_ik_constraint_pose_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   IkConstraintPose.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory IkConstraintPose() {
-    final ptr = _bindings.spine_ik_constraint_pose_create();
+    final ptr = SpineBindings.bindings.spine_ik_constraint_pose_create();
     return IkConstraintPose.fromPointer(ptr);
   }
 
   void set(IkConstraintPose pose) {
-    _bindings.spine_ik_constraint_pose_set(_ptr, pose.nativePtr.cast());
+    SpineBindings.bindings.spine_ik_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get mix {
-    final result = _bindings.spine_ik_constraint_pose_get_mix(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_mix(_ptr);
     return result;
   }
 
   set mix(double value) {
-    _bindings.spine_ik_constraint_pose_set_mix(_ptr, value);
+    SpineBindings.bindings.spine_ik_constraint_pose_set_mix(_ptr, value);
   }
 
   double get softness {
-    final result = _bindings.spine_ik_constraint_pose_get_softness(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_softness(_ptr);
     return result;
   }
 
   set softness(double value) {
-    _bindings.spine_ik_constraint_pose_set_softness(_ptr, value);
+    SpineBindings.bindings.spine_ik_constraint_pose_set_softness(_ptr, value);
   }
 
   int get bendDirection {
-    final result = _bindings.spine_ik_constraint_pose_get_bend_direction(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_bend_direction(_ptr);
     return result;
   }
 
   set bendDirection(int value) {
-    _bindings.spine_ik_constraint_pose_set_bend_direction(_ptr, value);
+    SpineBindings.bindings.spine_ik_constraint_pose_set_bend_direction(_ptr, value);
   }
 
   bool get compress {
-    final result = _bindings.spine_ik_constraint_pose_get_compress(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_compress(_ptr);
     return result;
   }
 
   set compress(bool value) {
-    _bindings.spine_ik_constraint_pose_set_compress(_ptr, value);
+    SpineBindings.bindings.spine_ik_constraint_pose_set_compress(_ptr, value);
   }
 
   bool get stretch {
-    final result = _bindings.spine_ik_constraint_pose_get_stretch(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_stretch(_ptr);
     return result;
   }
 
   set stretch(bool value) {
-    _bindings.spine_ik_constraint_pose_set_stretch(_ptr, value);
+    SpineBindings.bindings.spine_ik_constraint_pose_set_stretch(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_ik_constraint_pose_dispose(_ptr);
+    SpineBindings.bindings.spine_ik_constraint_pose_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/ik_constraint_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,115 +23,47 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline.dart';
 
 /// IkConstraintTimeline wrapper
-class IkConstraintTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class IkConstraintTimeline extends CurveTimeline {
   final Pointer<spine_ik_constraint_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  IkConstraintTimeline.fromPointer(this._ptr);
+  IkConstraintTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory IkConstraintTimeline(int frameCount, int bezierCount, int constraintIndex) {
-    final ptr = _bindings.spine_ik_constraint_timeline_create(frameCount, bezierCount, constraintIndex);
+    final ptr = SpineBindings.bindings.spine_ik_constraint_timeline_create(frameCount, bezierCount, constraintIndex);
     return IkConstraintTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_ik_constraint_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_ik_constraint_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
   void setFrame(int frame, double time, double mix, double softness, int bendDirection, bool compress, bool stretch) {
-    _bindings.spine_ik_constraint_timeline_set_frame(_ptr, frame, time, mix, softness, bendDirection, compress, stretch);
-  }
-
-  set linear(int value) {
-    _bindings.spine_ik_constraint_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_ik_constraint_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_ik_constraint_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_ik_constraint_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_ik_constraint_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_ik_constraint_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_ik_constraint_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_ik_constraint_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_ik_constraint_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_ik_constraint_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
+    SpineBindings.bindings.spine_ik_constraint_timeline_set_frame(_ptr, frame, time, mix, softness, bendDirection, compress, stretch);
   }
 
   int get constraintIndex {
-    final result = _bindings.spine_ik_constraint_timeline_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings.spine_ik_constraint_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   set constraintIndex(int value) {
-    _bindings.spine_ik_constraint_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_ik_constraint_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_ik_constraint_timeline_set_constraint_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_ik_constraint_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_ik_constraint_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/inherit.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/inherit_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,94 +23,48 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'timeline.dart';
 import 'inherit.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
 
 /// InheritTimeline wrapper
-class InheritTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class InheritTimeline extends Timeline {
   final Pointer<spine_inherit_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  InheritTimeline.fromPointer(this._ptr);
+  InheritTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory InheritTimeline(int frameCount, int boneIndex) {
-    final ptr = _bindings.spine_inherit_timeline_create(frameCount, boneIndex);
+    final ptr = SpineBindings.bindings.spine_inherit_timeline_create(frameCount, boneIndex);
     return InheritTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_inherit_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void setFrame(int frame, double time, Inherit inherit) {
-    _bindings.spine_inherit_timeline_set_frame(_ptr, frame, time, inherit.value);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_inherit_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_inherit_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_inherit_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_inherit_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_inherit_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_inherit_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
+    SpineBindings.bindings.spine_inherit_timeline_set_frame(_ptr, frame, time, inherit.value);
   }
 
   int get boneIndex {
-    final result = _bindings.spine_inherit_timeline_get_bone_index(_ptr);
+    final result = SpineBindings.bindings.spine_inherit_timeline_get_bone_index(_ptr);
     return result;
   }
 
   set boneIndex(int value) {
-    _bindings.spine_inherit_timeline_set_bone_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_inherit_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_inherit_timeline_set_bone_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_inherit_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_inherit_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/linked_mesh.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,43 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'mesh_attachment.dart';
 
 /// LinkedMesh wrapper
 class LinkedMesh implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_linked_mesh_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   LinkedMesh.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory LinkedMesh(MeshAttachment mesh, dynamic skinIndex, int slotIndex, String parent, bool inheritTimelines) {
-    final ptr = _bindings.spine_linked_mesh_create(mesh.nativePtr.cast(), skinIndex, slotIndex, parent.toNativeUtf8().cast<Char>(), inheritTimelines);
+    final ptr = SpineBindings.bindings.spine_linked_mesh_create(mesh.nativePtr.cast(), skinIndex, slotIndex, parent.toNativeUtf8().cast<Char>(), inheritTimelines);
     return LinkedMesh.fromPointer(ptr);
   }
 
   factory LinkedMesh.variant2(MeshAttachment mesh, String skin, int slotIndex, String parent, bool inheritTimelines) {
-    final ptr = _bindings.spine_linked_mesh_create2(mesh.nativePtr.cast(), skin.toNativeUtf8().cast<Char>(), slotIndex, parent.toNativeUtf8().cast<Char>(), inheritTimelines);
+    final ptr = SpineBindings.bindings.spine_linked_mesh_create2(mesh.nativePtr.cast(), skin.toNativeUtf8().cast<Char>(), slotIndex, parent.toNativeUtf8().cast<Char>(), inheritTimelines);
     return LinkedMesh.fromPointer(ptr);
   }
 
   void dispose() {
-    _bindings.spine_linked_mesh_dispose(_ptr);
+    SpineBindings.bindings.spine_linked_mesh_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/mesh_attachment.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,237 +23,148 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'slot.dart';
+import '../spine_bindings.dart';
+import 'vertex_attachment.dart';
 import 'color.dart';
 import 'texture_region.dart';
 import 'sequence.dart';
-import 'attachment.dart';
-import 'vertex_attachment.dart';
 import 'arrays.dart';
 
 /// MeshAttachment wrapper
-class MeshAttachment implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class MeshAttachment extends VertexAttachment {
   final Pointer<spine_mesh_attachment_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  MeshAttachment.fromPointer(this._ptr);
+  MeshAttachment.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory MeshAttachment(String name) {
-    final ptr = _bindings.spine_mesh_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_mesh_attachment_create(name.toNativeUtf8().cast<Char>());
     return MeshAttachment.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_mesh_attachment_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void updateRegion() {
-    _bindings.spine_mesh_attachment_update_region(_ptr);
+    SpineBindings.bindings.spine_mesh_attachment_update_region(_ptr);
   }
 
   int get hullLength {
-    final result = _bindings.spine_mesh_attachment_get_hull_length(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_hull_length(_ptr);
     return result;
   }
 
   set hullLength(int value) {
-    _bindings.spine_mesh_attachment_set_hull_length(_ptr, value);
+    SpineBindings.bindings.spine_mesh_attachment_set_hull_length(_ptr, value);
   }
 
   ArrayFloat get regionUVs {
-    final result = _bindings.spine_mesh_attachment_get_region_u_vs(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_region_u_vs(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   set regionUVs(ArrayFloat value) {
-    _bindings.spine_mesh_attachment_set_region_u_vs(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_mesh_attachment_set_region_u_vs(_ptr, value.nativePtr.cast());
   }
 
   ArrayFloat get uVs {
-    final result = _bindings.spine_mesh_attachment_get_u_vs(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_u_vs(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   ArrayUnsignedShort get triangles {
-    final result = _bindings.spine_mesh_attachment_get_triangles(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_triangles(_ptr);
     return ArrayUnsignedShort.fromPointer(result);
   }
 
   set triangles(ArrayUnsignedShort value) {
-    _bindings.spine_mesh_attachment_set_triangles(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_mesh_attachment_set_triangles(_ptr, value.nativePtr.cast());
   }
 
   Color get color {
-    final result = _bindings.spine_mesh_attachment_get_color(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
   String get path {
-    final result = _bindings.spine_mesh_attachment_get_path(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_path(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set path(String value) {
-    _bindings.spine_mesh_attachment_set_path(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_mesh_attachment_set_path(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   TextureRegion get region {
-    final result = _bindings.spine_mesh_attachment_get_region(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_region(_ptr);
     return TextureRegion.fromPointer(result);
   }
 
   set region(TextureRegion value) {
-    _bindings.spine_mesh_attachment_set_region(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_mesh_attachment_set_region(_ptr, value.nativePtr.cast());
   }
 
   Sequence get sequence {
-    final result = _bindings.spine_mesh_attachment_get_sequence(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_sequence(_ptr);
     return Sequence.fromPointer(result);
   }
 
   set sequence(Sequence value) {
-    _bindings.spine_mesh_attachment_set_sequence(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_mesh_attachment_set_sequence(_ptr, value.nativePtr.cast());
   }
 
   MeshAttachment get parentMesh {
-    final result = _bindings.spine_mesh_attachment_get_parent_mesh(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_parent_mesh(_ptr);
     return MeshAttachment.fromPointer(result);
   }
 
   set parentMesh(MeshAttachment value) {
-    _bindings.spine_mesh_attachment_set_parent_mesh(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_mesh_attachment_set_parent_mesh(_ptr, value.nativePtr.cast());
   }
 
   ArrayUnsignedShort get edges {
-    final result = _bindings.spine_mesh_attachment_get_edges(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_edges(_ptr);
     return ArrayUnsignedShort.fromPointer(result);
   }
 
   set edges(ArrayUnsignedShort value) {
-    _bindings.spine_mesh_attachment_set_edges(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_mesh_attachment_set_edges(_ptr, value.nativePtr.cast());
   }
 
   double get width {
-    final result = _bindings.spine_mesh_attachment_get_width(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_width(_ptr);
     return result;
   }
 
   set width(double value) {
-    _bindings.spine_mesh_attachment_set_width(_ptr, value);
+    SpineBindings.bindings.spine_mesh_attachment_set_width(_ptr, value);
   }
 
   double get height {
-    final result = _bindings.spine_mesh_attachment_get_height(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_height(_ptr);
     return result;
   }
 
   set height(double value) {
-    _bindings.spine_mesh_attachment_set_height(_ptr, value);
-  }
-
-  Attachment copy() {
-    final result = _bindings.spine_mesh_attachment_copy(_ptr);
-    return Attachment.fromPointer(result);
+    SpineBindings.bindings.spine_mesh_attachment_set_height(_ptr, value);
   }
 
   MeshAttachment newLinkedMesh() {
-    final result = _bindings.spine_mesh_attachment_new_linked_mesh(_ptr);
+    final result = SpineBindings.bindings.spine_mesh_attachment_new_linked_mesh(_ptr);
     return MeshAttachment.fromPointer(result);
   }
 
-  int get id {
-    final result = _bindings.spine_mesh_attachment_get_id(_ptr);
-    return result;
-  }
-
-  ArrayInt get bones {
-    final result = _bindings.spine_mesh_attachment_get_bones(_ptr);
-    return ArrayInt.fromPointer(result);
-  }
-
-  set bones(ArrayInt value) {
-    _bindings.spine_mesh_attachment_set_bones(_ptr, value.nativePtr.cast());
-  }
-
-  ArrayFloat get vertices {
-    final result = _bindings.spine_mesh_attachment_get_vertices(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  set vertices(ArrayFloat value) {
-    _bindings.spine_mesh_attachment_set_vertices(_ptr, value.nativePtr.cast());
-  }
-
-  int get worldVerticesLength {
-    final result = _bindings.spine_mesh_attachment_get_world_vertices_length(_ptr);
-    return result;
-  }
-
-  set worldVerticesLength(int value) {
-    _bindings.spine_mesh_attachment_set_world_vertices_length(_ptr, value);
-  }
-
-  Attachment get timelineAttachment {
-    final result = _bindings.spine_mesh_attachment_get_timeline_attachment(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  set timelineAttachment(Attachment value) {
-    _bindings.spine_mesh_attachment_set_timeline_attachment(_ptr, value.nativePtr.cast());
-  }
-
-  void copyTo(VertexAttachment other) {
-    _bindings.spine_mesh_attachment_copy_to(_ptr, other.nativePtr.cast());
-  }
-
-  String get name {
-    final result = _bindings.spine_mesh_attachment_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  int get refCount {
-    final result = _bindings.spine_mesh_attachment_get_ref_count(_ptr);
-    return result;
-  }
-
-  void reference() {
-    _bindings.spine_mesh_attachment_reference(_ptr);
-  }
-
-  void dereference() {
-    _bindings.spine_mesh_attachment_dereference(_ptr);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_mesh_attachment_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  void computeWorldVertices(Skeleton skeleton, Slot slot, int start, int count, ArrayFloat worldVertices, int offset, int stride) {
-    _bindings.spine_mesh_attachment_compute_world_vertices_2(_ptr, skeleton.nativePtr.cast(), slot.nativePtr.cast(), start, count, worldVertices.nativePtr.cast(), offset, stride);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_mesh_attachment_dispose(_ptr);
+    SpineBindings.bindings.spine_mesh_attachment_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/mix_blend.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/mix_direction.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/path_attachment.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,158 +23,69 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'color.dart';
-import 'attachment.dart';
-import 'skeleton.dart';
-import 'slot.dart';
+import '../spine_bindings.dart';
 import 'vertex_attachment.dart';
+import 'color.dart';
 import 'arrays.dart';
 
 /// PathAttachment wrapper
-class PathAttachment implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PathAttachment extends VertexAttachment {
   final Pointer<spine_path_attachment_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PathAttachment.fromPointer(this._ptr);
+  PathAttachment.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PathAttachment(String name) {
-    final ptr = _bindings.spine_path_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_path_attachment_create(name.toNativeUtf8().cast<Char>());
     return PathAttachment.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_path_attachment_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   ArrayFloat get lengths {
-    final result = _bindings.spine_path_attachment_get_lengths(_ptr);
+    final result = SpineBindings.bindings.spine_path_attachment_get_lengths(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   set lengths(ArrayFloat value) {
-    _bindings.spine_path_attachment_set_lengths(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_path_attachment_set_lengths(_ptr, value.nativePtr.cast());
   }
 
   bool get closed {
-    final result = _bindings.spine_path_attachment_get_closed(_ptr);
+    final result = SpineBindings.bindings.spine_path_attachment_get_closed(_ptr);
     return result;
   }
 
   set closed(bool value) {
-    _bindings.spine_path_attachment_set_closed(_ptr, value);
+    SpineBindings.bindings.spine_path_attachment_set_closed(_ptr, value);
   }
 
   bool get constantSpeed {
-    final result = _bindings.spine_path_attachment_get_constant_speed(_ptr);
+    final result = SpineBindings.bindings.spine_path_attachment_get_constant_speed(_ptr);
     return result;
   }
 
   set constantSpeed(bool value) {
-    _bindings.spine_path_attachment_set_constant_speed(_ptr, value);
+    SpineBindings.bindings.spine_path_attachment_set_constant_speed(_ptr, value);
   }
 
   Color get color {
-    final result = _bindings.spine_path_attachment_get_color(_ptr);
+    final result = SpineBindings.bindings.spine_path_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
-  Attachment copy() {
-    final result = _bindings.spine_path_attachment_copy(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  int get id {
-    final result = _bindings.spine_path_attachment_get_id(_ptr);
-    return result;
-  }
-
-  ArrayInt get bones {
-    final result = _bindings.spine_path_attachment_get_bones(_ptr);
-    return ArrayInt.fromPointer(result);
-  }
-
-  set bones(ArrayInt value) {
-    _bindings.spine_path_attachment_set_bones(_ptr, value.nativePtr.cast());
-  }
-
-  ArrayFloat get vertices {
-    final result = _bindings.spine_path_attachment_get_vertices(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  set vertices(ArrayFloat value) {
-    _bindings.spine_path_attachment_set_vertices(_ptr, value.nativePtr.cast());
-  }
-
-  int get worldVerticesLength {
-    final result = _bindings.spine_path_attachment_get_world_vertices_length(_ptr);
-    return result;
-  }
-
-  set worldVerticesLength(int value) {
-    _bindings.spine_path_attachment_set_world_vertices_length(_ptr, value);
-  }
-
-  Attachment get timelineAttachment {
-    final result = _bindings.spine_path_attachment_get_timeline_attachment(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  set timelineAttachment(Attachment value) {
-    _bindings.spine_path_attachment_set_timeline_attachment(_ptr, value.nativePtr.cast());
-  }
-
-  void copyTo(VertexAttachment other) {
-    _bindings.spine_path_attachment_copy_to(_ptr, other.nativePtr.cast());
-  }
-
-  String get name {
-    final result = _bindings.spine_path_attachment_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  int get refCount {
-    final result = _bindings.spine_path_attachment_get_ref_count(_ptr);
-    return result;
-  }
-
-  void reference() {
-    _bindings.spine_path_attachment_reference(_ptr);
-  }
-
-  void dereference() {
-    _bindings.spine_path_attachment_dereference(_ptr);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_path_attachment_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  void computeWorldVertices(Skeleton skeleton, Slot slot, int start, int count, ArrayFloat worldVertices, int offset, int stride) {
-    _bindings.spine_path_attachment_compute_world_vertices_2(_ptr, skeleton.nativePtr.cast(), slot.nativePtr.cast(), start, count, worldVertices.nativePtr.cast(), offset, stride);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_path_attachment_dispose(_ptr);
+    SpineBindings.bindings.spine_path_attachment_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/path_constraint.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,14 +23,15 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'skeleton.dart';
 import 'physics.dart';
@@ -41,104 +42,98 @@ import 'arrays.dart';
 
 /// PathConstraint wrapper
 class PathConstraint implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_path_constraint_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   PathConstraint.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory PathConstraint(PathConstraintData data, Skeleton skeleton) {
-    final ptr = _bindings.spine_path_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_path_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
     return PathConstraint.fromPointer(ptr);
   }
 
   Rtti get rtti {
-    final result = _bindings.spine_path_constraint_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   PathConstraint copy(Skeleton skeleton) {
-    final result = _bindings.spine_path_constraint_copy(_ptr, skeleton.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_path_constraint_copy(_ptr, skeleton.nativePtr.cast());
     return PathConstraint.fromPointer(result);
   }
 
   void update(Skeleton skeleton, Physics physics) {
-    _bindings.spine_path_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings.spine_path_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   void sort(Skeleton skeleton) {
-    _bindings.spine_path_constraint_sort(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_path_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
   bool get isSourceActive {
-    final result = _bindings.spine_path_constraint_is_source_active(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_is_source_active(_ptr);
     return result;
   }
 
   ArrayBonePose get bones {
-    final result = _bindings.spine_path_constraint_get_bones(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_get_bones(_ptr);
     return ArrayBonePose.fromPointer(result);
   }
 
   Slot get slot {
-    final result = _bindings.spine_path_constraint_get_slot(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_get_slot(_ptr);
     return Slot.fromPointer(result);
   }
 
   set slot(Slot value) {
-    _bindings.spine_path_constraint_set_slot(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_path_constraint_set_slot(_ptr, value.nativePtr.cast());
   }
 
   PathConstraintData get data {
-    final result = _bindings.spine_path_constraint_get_data(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_get_data(_ptr);
     return PathConstraintData.fromPointer(result);
   }
 
   PathConstraintPose get pose {
-    final result = _bindings.spine_path_constraint_get_pose(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_get_pose(_ptr);
     return PathConstraintPose.fromPointer(result);
   }
 
   PathConstraintPose get appliedPose {
-    final result = _bindings.spine_path_constraint_get_applied_pose(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_get_applied_pose(_ptr);
     return PathConstraintPose.fromPointer(result);
   }
 
   void resetConstrained() {
-    _bindings.spine_path_constraint_reset_constrained(_ptr);
+    SpineBindings.bindings.spine_path_constraint_reset_constrained(_ptr);
   }
 
   void constrained() {
-    _bindings.spine_path_constraint_constrained(_ptr);
+    SpineBindings.bindings.spine_path_constraint_constrained(_ptr);
   }
 
   bool get isPoseEqualToApplied {
-    final result = _bindings.spine_path_constraint_is_pose_equal_to_applied(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
   bool get isActive {
-    final result = _bindings.spine_path_constraint_is_active(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_is_active(_ptr);
     return result;
   }
 
   set active(bool value) {
-    _bindings.spine_path_constraint_set_active(_ptr, value);
+    SpineBindings.bindings.spine_path_constraint_set_active(_ptr, value);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_path_constraint_rtti();
+    final result = SpineBindings.bindings.spine_path_constraint_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_path_constraint_dispose(_ptr);
+    SpineBindings.bindings.spine_path_constraint_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/path_constraint_data.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,15 +23,16 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'constraint.dart';
 import 'skeleton.dart';
@@ -44,109 +45,103 @@ import 'arrays.dart';
 
 /// PathConstraintData wrapper
 class PathConstraintData implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_path_constraint_data_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   PathConstraintData.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory PathConstraintData(String name) {
-    final ptr = _bindings.spine_path_constraint_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_path_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return PathConstraintData.fromPointer(ptr);
   }
 
   Rtti get rtti {
-    final result = _bindings.spine_path_constraint_data_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   Constraint createMethod(Skeleton skeleton) {
-    final result = _bindings.spine_path_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-    return Constraint.fromPointer(result);
+    final result = SpineBindings.bindings.spine_path_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
+    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
   }
 
   ArrayBoneData get bones {
-    final result = _bindings.spine_path_constraint_data_get_bones(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_bones(_ptr);
     return ArrayBoneData.fromPointer(result);
   }
 
   SlotData get slot {
-    final result = _bindings.spine_path_constraint_data_get_slot(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_slot(_ptr);
     return SlotData.fromPointer(result);
   }
 
   set slot(SlotData value) {
-    _bindings.spine_path_constraint_data_set_slot(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_path_constraint_data_set_slot(_ptr, value.nativePtr.cast());
   }
 
   PositionMode get positionMode {
-    final result = _bindings.spine_path_constraint_data_get_position_mode(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_position_mode(_ptr);
     return PositionMode.fromValue(result);
   }
 
   set positionMode(PositionMode value) {
-    _bindings.spine_path_constraint_data_set_position_mode(_ptr, value.value);
+    SpineBindings.bindings.spine_path_constraint_data_set_position_mode(_ptr, value.value);
   }
 
   SpacingMode get spacingMode {
-    final result = _bindings.spine_path_constraint_data_get_spacing_mode(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_spacing_mode(_ptr);
     return SpacingMode.fromValue(result);
   }
 
   set spacingMode(SpacingMode value) {
-    _bindings.spine_path_constraint_data_set_spacing_mode(_ptr, value.value);
+    SpineBindings.bindings.spine_path_constraint_data_set_spacing_mode(_ptr, value.value);
   }
 
   RotateMode get rotateMode {
-    final result = _bindings.spine_path_constraint_data_get_rotate_mode(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_rotate_mode(_ptr);
     return RotateMode.fromValue(result);
   }
 
   set rotateMode(RotateMode value) {
-    _bindings.spine_path_constraint_data_set_rotate_mode(_ptr, value.value);
+    SpineBindings.bindings.spine_path_constraint_data_set_rotate_mode(_ptr, value.value);
   }
 
   double get offsetRotation {
-    final result = _bindings.spine_path_constraint_data_get_offset_rotation(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_offset_rotation(_ptr);
     return result;
   }
 
   set offsetRotation(double value) {
-    _bindings.spine_path_constraint_data_set_offset_rotation(_ptr, value);
+    SpineBindings.bindings.spine_path_constraint_data_set_offset_rotation(_ptr, value);
   }
 
   String get name {
-    final result = _bindings.spine_path_constraint_data_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   bool get skinRequired {
-    final result = _bindings.spine_path_constraint_data_get_skin_required(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_skin_required(_ptr);
     return result;
   }
 
   PathConstraintPose get setupPose {
-    final result = _bindings.spine_path_constraint_data_get_setup_pose(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_setup_pose(_ptr);
     return PathConstraintPose.fromPointer(result);
   }
 
   set skinRequired(bool value) {
-    _bindings.spine_path_constraint_data_set_skin_required(_ptr, value);
+    SpineBindings.bindings.spine_path_constraint_data_set_skin_required(_ptr, value);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_path_constraint_data_rtti();
+    final result = SpineBindings.bindings.spine_path_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_path_constraint_data_dispose(_ptr);
+    SpineBindings.bindings.spine_path_constraint_data_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/path_constraint_mix_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,115 +23,47 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline.dart';
 
 /// PathConstraintMixTimeline wrapper
-class PathConstraintMixTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PathConstraintMixTimeline extends CurveTimeline {
   final Pointer<spine_path_constraint_mix_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PathConstraintMixTimeline.fromPointer(this._ptr);
+  PathConstraintMixTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PathConstraintMixTimeline(int frameCount, int bezierCount, int constraintIndex) {
-    final ptr = _bindings.spine_path_constraint_mix_timeline_create(frameCount, bezierCount, constraintIndex);
+    final ptr = SpineBindings.bindings.spine_path_constraint_mix_timeline_create(frameCount, bezierCount, constraintIndex);
     return PathConstraintMixTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_path_constraint_mix_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
   void setFrame(int frame, double time, double mixRotate, double mixX, double mixY) {
-    _bindings.spine_path_constraint_mix_timeline_set_frame(_ptr, frame, time, mixRotate, mixX, mixY);
-  }
-
-  set linear(int value) {
-    _bindings.spine_path_constraint_mix_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_path_constraint_mix_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_path_constraint_mix_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
+    SpineBindings.bindings.spine_path_constraint_mix_timeline_set_frame(_ptr, frame, time, mixRotate, mixX, mixY);
   }
 
   int get constraintIndex {
-    final result = _bindings.spine_path_constraint_mix_timeline_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_mix_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   set constraintIndex(int value) {
-    _bindings.spine_path_constraint_mix_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_path_constraint_mix_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_path_constraint_mix_timeline_set_constraint_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_path_constraint_mix_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_path_constraint_mix_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/path_constraint_pose.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,85 +23,80 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// PathConstraintPose wrapper
 class PathConstraintPose implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_path_constraint_pose_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   PathConstraintPose.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory PathConstraintPose() {
-    final ptr = _bindings.spine_path_constraint_pose_create();
+    final ptr = SpineBindings.bindings.spine_path_constraint_pose_create();
     return PathConstraintPose.fromPointer(ptr);
   }
 
   void set(PathConstraintPose pose) {
-    _bindings.spine_path_constraint_pose_set(_ptr, pose.nativePtr.cast());
+    SpineBindings.bindings.spine_path_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get position {
-    final result = _bindings.spine_path_constraint_pose_get_position(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_position(_ptr);
     return result;
   }
 
   set position(double value) {
-    _bindings.spine_path_constraint_pose_set_position(_ptr, value);
+    SpineBindings.bindings.spine_path_constraint_pose_set_position(_ptr, value);
   }
 
   double get spacing {
-    final result = _bindings.spine_path_constraint_pose_get_spacing(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_spacing(_ptr);
     return result;
   }
 
   set spacing(double value) {
-    _bindings.spine_path_constraint_pose_set_spacing(_ptr, value);
+    SpineBindings.bindings.spine_path_constraint_pose_set_spacing(_ptr, value);
   }
 
   double get mixRotate {
-    final result = _bindings.spine_path_constraint_pose_get_mix_rotate(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_rotate(_ptr);
     return result;
   }
 
   set mixRotate(double value) {
-    _bindings.spine_path_constraint_pose_set_mix_rotate(_ptr, value);
+    SpineBindings.bindings.spine_path_constraint_pose_set_mix_rotate(_ptr, value);
   }
 
   double get mixX {
-    final result = _bindings.spine_path_constraint_pose_get_mix_x(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_x(_ptr);
     return result;
   }
 
   set mixX(double value) {
-    _bindings.spine_path_constraint_pose_set_mix_x(_ptr, value);
+    SpineBindings.bindings.spine_path_constraint_pose_set_mix_x(_ptr, value);
   }
 
   double get mixY {
-    final result = _bindings.spine_path_constraint_pose_get_mix_y(_ptr);
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_y(_ptr);
     return result;
   }
 
   set mixY(double value) {
-    _bindings.spine_path_constraint_pose_set_mix_y(_ptr, value);
+    SpineBindings.bindings.spine_path_constraint_pose_set_mix_y(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_path_constraint_pose_dispose(_ptr);
+    SpineBindings.bindings.spine_path_constraint_pose_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/path_constraint_position_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'constraint_timeline1.dart';
 
 /// PathConstraintPositionTimeline wrapper
-class PathConstraintPositionTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PathConstraintPositionTimeline extends ConstraintTimeline1 {
   final Pointer<spine_path_constraint_position_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PathConstraintPositionTimeline.fromPointer(this._ptr);
+  PathConstraintPositionTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PathConstraintPositionTimeline(int frameCount, int bezierCount, int constraintIndex) {
-    final ptr = _bindings.spine_path_constraint_position_timeline_create(frameCount, bezierCount, constraintIndex);
+    final ptr = SpineBindings.bindings.spine_path_constraint_position_timeline_create(frameCount, bezierCount, constraintIndex);
     return PathConstraintPositionTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_path_constraint_position_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_path_constraint_position_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_path_constraint_position_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_path_constraint_position_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_path_constraint_position_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_path_constraint_position_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_path_constraint_position_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_path_constraint_position_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_path_constraint_position_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_path_constraint_position_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_path_constraint_position_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_path_constraint_position_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_path_constraint_position_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_path_constraint_position_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_path_constraint_position_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_path_constraint_position_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_path_constraint_position_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_path_constraint_position_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_path_constraint_position_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_path_constraint_position_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_path_constraint_position_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_path_constraint_position_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_path_constraint_position_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/path_constraint_spacing_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'constraint_timeline1.dart';
 
 /// PathConstraintSpacingTimeline wrapper
-class PathConstraintSpacingTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PathConstraintSpacingTimeline extends ConstraintTimeline1 {
   final Pointer<spine_path_constraint_spacing_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PathConstraintSpacingTimeline.fromPointer(this._ptr);
+  PathConstraintSpacingTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PathConstraintSpacingTimeline(int frameCount, int bezierCount, int constraintIndex) {
-    final ptr = _bindings.spine_path_constraint_spacing_timeline_create(frameCount, bezierCount, constraintIndex);
+    final ptr = SpineBindings.bindings.spine_path_constraint_spacing_timeline_create(frameCount, bezierCount, constraintIndex);
     return PathConstraintSpacingTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_path_constraint_spacing_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_path_constraint_spacing_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_path_constraint_spacing_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_path_constraint_spacing_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_path_constraint_spacing_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_path_constraint_spacing_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_path_constraint_spacing_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_path_constraint_spacing_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_path_constraint_spacing_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_path_constraint_spacing_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/physics_constraint.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,14 +23,15 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'skeleton.dart';
 import 'physics.dart';
@@ -40,111 +41,105 @@ import 'physics_constraint_pose.dart';
 
 /// PhysicsConstraint wrapper
 class PhysicsConstraint implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_physics_constraint_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   PhysicsConstraint.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraint(PhysicsConstraintData data, Skeleton skeleton) {
-    final ptr = _bindings.spine_physics_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_physics_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
     return PhysicsConstraint.fromPointer(ptr);
   }
 
   Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   void update(Skeleton skeleton, Physics physics) {
-    _bindings.spine_physics_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings.spine_physics_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   void sort(Skeleton skeleton) {
-    _bindings.spine_physics_constraint_sort(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_physics_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
   bool get isSourceActive {
-    final result = _bindings.spine_physics_constraint_is_source_active(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_is_source_active(_ptr);
     return result;
   }
 
   PhysicsConstraint copy(Skeleton skeleton) {
-    final result = _bindings.spine_physics_constraint_copy(_ptr, skeleton.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_physics_constraint_copy(_ptr, skeleton.nativePtr.cast());
     return PhysicsConstraint.fromPointer(result);
   }
 
   void reset(Skeleton skeleton) {
-    _bindings.spine_physics_constraint_reset(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_physics_constraint_reset(_ptr, skeleton.nativePtr.cast());
   }
 
   void translate(double x, double y) {
-    _bindings.spine_physics_constraint_translate(_ptr, x, y);
+    SpineBindings.bindings.spine_physics_constraint_translate(_ptr, x, y);
   }
 
   void rotate(double x, double y, double degrees) {
-    _bindings.spine_physics_constraint_rotate(_ptr, x, y, degrees);
+    SpineBindings.bindings.spine_physics_constraint_rotate(_ptr, x, y, degrees);
   }
 
   BonePose get bone {
-    final result = _bindings.spine_physics_constraint_get_bone(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_get_bone(_ptr);
     return BonePose.fromPointer(result);
   }
 
   set bone(BonePose value) {
-    _bindings.spine_physics_constraint_set_bone(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_physics_constraint_set_bone(_ptr, value.nativePtr.cast());
   }
 
   PhysicsConstraintData get data {
-    final result = _bindings.spine_physics_constraint_get_data(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_get_data(_ptr);
     return PhysicsConstraintData.fromPointer(result);
   }
 
   PhysicsConstraintPose get pose {
-    final result = _bindings.spine_physics_constraint_get_pose(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_get_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 
   PhysicsConstraintPose get appliedPose {
-    final result = _bindings.spine_physics_constraint_get_applied_pose(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_get_applied_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 
   void resetConstrained() {
-    _bindings.spine_physics_constraint_reset_constrained(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_reset_constrained(_ptr);
   }
 
   void constrained() {
-    _bindings.spine_physics_constraint_constrained(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_constrained(_ptr);
   }
 
   bool get isPoseEqualToApplied {
-    final result = _bindings.spine_physics_constraint_is_pose_equal_to_applied(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
   bool get isActive {
-    final result = _bindings.spine_physics_constraint_is_active(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_is_active(_ptr);
     return result;
   }
 
   set active(bool value) {
-    _bindings.spine_physics_constraint_set_active(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_set_active(_ptr, value);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_rtti();
+    final result = SpineBindings.bindings.spine_physics_constraint_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_physics_constraint_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_damping_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'physics_constraint_timeline.dart';
 
 /// PhysicsConstraintDampingTimeline wrapper
-class PhysicsConstraintDampingTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PhysicsConstraintDampingTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_damping_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintDampingTimeline.fromPointer(this._ptr);
+  PhysicsConstraintDampingTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintDampingTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = _bindings.spine_physics_constraint_damping_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+    final ptr = SpineBindings.bindings.spine_physics_constraint_damping_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintDampingTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_damping_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_physics_constraint_damping_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_physics_constraint_damping_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_physics_constraint_damping_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_physics_constraint_damping_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_damping_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_damping_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_physics_constraint_damping_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_damping_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_damping_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_data.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,15 +23,16 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'constraint.dart';
 import 'skeleton.dart';
@@ -40,194 +41,188 @@ import 'physics_constraint_pose.dart';
 
 /// PhysicsConstraintData wrapper
 class PhysicsConstraintData implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_physics_constraint_data_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   PhysicsConstraintData.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintData(String name) {
-    final ptr = _bindings.spine_physics_constraint_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_physics_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return PhysicsConstraintData.fromPointer(ptr);
   }
 
   Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_data_get_rtti(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   Constraint createMethod(Skeleton skeleton) {
-    final result = _bindings.spine_physics_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-    return Constraint.fromPointer(result);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
+    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
   }
 
   BoneData get bone {
-    final result = _bindings.spine_physics_constraint_data_get_bone(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_bone(_ptr);
     return BoneData.fromPointer(result);
   }
 
   set bone(BoneData value) {
-    _bindings.spine_physics_constraint_data_set_bone(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_physics_constraint_data_set_bone(_ptr, value.nativePtr.cast());
   }
 
   double get step {
-    final result = _bindings.spine_physics_constraint_data_get_step(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_step(_ptr);
     return result;
   }
 
   set step(double value) {
-    _bindings.spine_physics_constraint_data_set_step(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_step(_ptr, value);
   }
 
   double get x {
-    final result = _bindings.spine_physics_constraint_data_get_x(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_x(_ptr);
     return result;
   }
 
   set x(double value) {
-    _bindings.spine_physics_constraint_data_set_x(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_x(_ptr, value);
   }
 
   double get y {
-    final result = _bindings.spine_physics_constraint_data_get_y(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_y(_ptr);
     return result;
   }
 
   set y(double value) {
-    _bindings.spine_physics_constraint_data_set_y(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_y(_ptr, value);
   }
 
   double get rotate {
-    final result = _bindings.spine_physics_constraint_data_get_rotate(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_rotate(_ptr);
     return result;
   }
 
   set rotate(double value) {
-    _bindings.spine_physics_constraint_data_set_rotate(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_rotate(_ptr, value);
   }
 
   double get scaleX {
-    final result = _bindings.spine_physics_constraint_data_get_scale_x(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_scale_x(_ptr);
     return result;
   }
 
   set scaleX(double value) {
-    _bindings.spine_physics_constraint_data_set_scale_x(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_scale_x(_ptr, value);
   }
 
   double get shearX {
-    final result = _bindings.spine_physics_constraint_data_get_shear_x(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_shear_x(_ptr);
     return result;
   }
 
   set shearX(double value) {
-    _bindings.spine_physics_constraint_data_set_shear_x(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_shear_x(_ptr, value);
   }
 
   double get limit {
-    final result = _bindings.spine_physics_constraint_data_get_limit(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_limit(_ptr);
     return result;
   }
 
   set limit(double value) {
-    _bindings.spine_physics_constraint_data_set_limit(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_limit(_ptr, value);
   }
 
   bool get inertiaGlobal {
-    final result = _bindings.spine_physics_constraint_data_get_inertia_global(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_inertia_global(_ptr);
     return result;
   }
 
   set inertiaGlobal(bool value) {
-    _bindings.spine_physics_constraint_data_set_inertia_global(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_inertia_global(_ptr, value);
   }
 
   bool get strengthGlobal {
-    final result = _bindings.spine_physics_constraint_data_get_strength_global(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_strength_global(_ptr);
     return result;
   }
 
   set strengthGlobal(bool value) {
-    _bindings.spine_physics_constraint_data_set_strength_global(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_strength_global(_ptr, value);
   }
 
   bool get dampingGlobal {
-    final result = _bindings.spine_physics_constraint_data_get_damping_global(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_damping_global(_ptr);
     return result;
   }
 
   set dampingGlobal(bool value) {
-    _bindings.spine_physics_constraint_data_set_damping_global(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_damping_global(_ptr, value);
   }
 
   bool get massGlobal {
-    final result = _bindings.spine_physics_constraint_data_get_mass_global(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_mass_global(_ptr);
     return result;
   }
 
   set massGlobal(bool value) {
-    _bindings.spine_physics_constraint_data_set_mass_global(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_mass_global(_ptr, value);
   }
 
   bool get windGlobal {
-    final result = _bindings.spine_physics_constraint_data_get_wind_global(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_wind_global(_ptr);
     return result;
   }
 
   set windGlobal(bool value) {
-    _bindings.spine_physics_constraint_data_set_wind_global(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_wind_global(_ptr, value);
   }
 
   bool get gravityGlobal {
-    final result = _bindings.spine_physics_constraint_data_get_gravity_global(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_gravity_global(_ptr);
     return result;
   }
 
   set gravityGlobal(bool value) {
-    _bindings.spine_physics_constraint_data_set_gravity_global(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_gravity_global(_ptr, value);
   }
 
   bool get mixGlobal {
-    final result = _bindings.spine_physics_constraint_data_get_mix_global(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_mix_global(_ptr);
     return result;
   }
 
   set mixGlobal(bool value) {
-    _bindings.spine_physics_constraint_data_set_mix_global(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_mix_global(_ptr, value);
   }
 
   String get name {
-    final result = _bindings.spine_physics_constraint_data_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   bool get skinRequired {
-    final result = _bindings.spine_physics_constraint_data_get_skin_required(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_skin_required(_ptr);
     return result;
   }
 
   PhysicsConstraintPose get setupPose {
-    final result = _bindings.spine_physics_constraint_data_get_setup_pose(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_setup_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 
   set skinRequired(bool value) {
-    _bindings.spine_physics_constraint_data_set_skin_required(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_data_set_skin_required(_ptr, value);
   }
 
   static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_data_rtti();
+    final result = SpineBindings.bindings.spine_physics_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_physics_constraint_data_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_data_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_gravity_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'physics_constraint_timeline.dart';
 
 /// PhysicsConstraintGravityTimeline wrapper
-class PhysicsConstraintGravityTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PhysicsConstraintGravityTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_gravity_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintGravityTimeline.fromPointer(this._ptr);
+  PhysicsConstraintGravityTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintGravityTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = _bindings.spine_physics_constraint_gravity_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+    final ptr = SpineBindings.bindings.spine_physics_constraint_gravity_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintGravityTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_gravity_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_physics_constraint_gravity_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_physics_constraint_gravity_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_physics_constraint_gravity_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_physics_constraint_gravity_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_gravity_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_physics_constraint_gravity_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_gravity_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_gravity_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_inertia_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'physics_constraint_timeline.dart';
 
 /// PhysicsConstraintInertiaTimeline wrapper
-class PhysicsConstraintInertiaTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PhysicsConstraintInertiaTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_inertia_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintInertiaTimeline.fromPointer(this._ptr);
+  PhysicsConstraintInertiaTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintInertiaTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = _bindings.spine_physics_constraint_inertia_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+    final ptr = SpineBindings.bindings.spine_physics_constraint_inertia_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintInertiaTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_inertia_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_physics_constraint_inertia_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_physics_constraint_inertia_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_physics_constraint_inertia_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_physics_constraint_inertia_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_inertia_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_physics_constraint_inertia_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_inertia_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_inertia_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_mass_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'physics_constraint_timeline.dart';
 
 /// PhysicsConstraintMassTimeline wrapper
-class PhysicsConstraintMassTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PhysicsConstraintMassTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_mass_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintMassTimeline.fromPointer(this._ptr);
+  PhysicsConstraintMassTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintMassTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = _bindings.spine_physics_constraint_mass_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+    final ptr = SpineBindings.bindings.spine_physics_constraint_mass_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintMassTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_mass_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_physics_constraint_mass_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_physics_constraint_mass_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_physics_constraint_mass_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_physics_constraint_mass_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_mass_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_mass_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_physics_constraint_mass_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_mass_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_mass_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_mix_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'physics_constraint_timeline.dart';
 
 /// PhysicsConstraintMixTimeline wrapper
-class PhysicsConstraintMixTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PhysicsConstraintMixTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_mix_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintMixTimeline.fromPointer(this._ptr);
+  PhysicsConstraintMixTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintMixTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = _bindings.spine_physics_constraint_mix_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+    final ptr = SpineBindings.bindings.spine_physics_constraint_mix_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintMixTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_mix_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_physics_constraint_mix_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_physics_constraint_mix_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_physics_constraint_mix_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_physics_constraint_mix_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_mix_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_mix_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_physics_constraint_mix_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_mix_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_mix_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_pose.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,103 +23,98 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// PhysicsConstraintPose wrapper
 class PhysicsConstraintPose implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_physics_constraint_pose_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   PhysicsConstraintPose.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintPose() {
-    final ptr = _bindings.spine_physics_constraint_pose_create();
+    final ptr = SpineBindings.bindings.spine_physics_constraint_pose_create();
     return PhysicsConstraintPose.fromPointer(ptr);
   }
 
   void set(PhysicsConstraintPose pose) {
-    _bindings.spine_physics_constraint_pose_set(_ptr, pose.nativePtr.cast());
+    SpineBindings.bindings.spine_physics_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get inertia {
-    final result = _bindings.spine_physics_constraint_pose_get_inertia(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_inertia(_ptr);
     return result;
   }
 
   set inertia(double value) {
-    _bindings.spine_physics_constraint_pose_set_inertia(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_pose_set_inertia(_ptr, value);
   }
 
   double get strength {
-    final result = _bindings.spine_physics_constraint_pose_get_strength(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_strength(_ptr);
     return result;
   }
 
   set strength(double value) {
-    _bindings.spine_physics_constraint_pose_set_strength(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_pose_set_strength(_ptr, value);
   }
 
   double get damping {
-    final result = _bindings.spine_physics_constraint_pose_get_damping(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_damping(_ptr);
     return result;
   }
 
   set damping(double value) {
-    _bindings.spine_physics_constraint_pose_set_damping(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_pose_set_damping(_ptr, value);
   }
 
   double get massInverse {
-    final result = _bindings.spine_physics_constraint_pose_get_mass_inverse(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_mass_inverse(_ptr);
     return result;
   }
 
   set massInverse(double value) {
-    _bindings.spine_physics_constraint_pose_set_mass_inverse(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_pose_set_mass_inverse(_ptr, value);
   }
 
   double get wind {
-    final result = _bindings.spine_physics_constraint_pose_get_wind(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_wind(_ptr);
     return result;
   }
 
   set wind(double value) {
-    _bindings.spine_physics_constraint_pose_set_wind(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_pose_set_wind(_ptr, value);
   }
 
   double get gravity {
-    final result = _bindings.spine_physics_constraint_pose_get_gravity(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_gravity(_ptr);
     return result;
   }
 
   set gravity(double value) {
-    _bindings.spine_physics_constraint_pose_set_gravity(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_pose_set_gravity(_ptr, value);
   }
 
   double get mix {
-    final result = _bindings.spine_physics_constraint_pose_get_mix(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_mix(_ptr);
     return result;
   }
 
   set mix(double value) {
-    _bindings.spine_physics_constraint_pose_set_mix(_ptr, value);
+    SpineBindings.bindings.spine_physics_constraint_pose_set_mix(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_physics_constraint_pose_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_pose_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_reset_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,93 +23,47 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'timeline.dart';
 
 /// PhysicsConstraintResetTimeline wrapper
-class PhysicsConstraintResetTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PhysicsConstraintResetTimeline extends Timeline {
   final Pointer<spine_physics_constraint_reset_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintResetTimeline.fromPointer(this._ptr);
+  PhysicsConstraintResetTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintResetTimeline(int frameCount, int constraintIndex) {
-    final ptr = _bindings.spine_physics_constraint_reset_timeline_create(frameCount, constraintIndex);
+    final ptr = SpineBindings.bindings.spine_physics_constraint_reset_timeline_create(frameCount, constraintIndex);
     return PhysicsConstraintResetTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_reset_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_reset_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_reset_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
   int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_reset_timeline_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_reset_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   void setFrame(int frame, double time) {
-    _bindings.spine_physics_constraint_reset_timeline_set_frame(_ptr, frame, time);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_reset_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_reset_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_reset_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_reset_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
+    SpineBindings.bindings.spine_physics_constraint_reset_timeline_set_frame(_ptr, frame, time);
   }
 
   set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_reset_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_reset_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_physics_constraint_reset_timeline_set_constraint_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_reset_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_reset_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_strength_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'physics_constraint_timeline.dart';
 
 /// PhysicsConstraintStrengthTimeline wrapper
-class PhysicsConstraintStrengthTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PhysicsConstraintStrengthTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_strength_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintStrengthTimeline.fromPointer(this._ptr);
+  PhysicsConstraintStrengthTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintStrengthTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = _bindings.spine_physics_constraint_strength_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+    final ptr = SpineBindings.bindings.spine_physics_constraint_strength_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintStrengthTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_strength_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_physics_constraint_strength_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_physics_constraint_strength_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_physics_constraint_strength_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_physics_constraint_strength_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_strength_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_strength_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_physics_constraint_strength_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_strength_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_strength_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,135 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'curve_timeline1.dart';
 
 /// PhysicsConstraintTimeline wrapper
-class PhysicsConstraintTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class PhysicsConstraintTimeline extends CurveTimeline1 {
   final Pointer<spine_physics_constraint_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintTimeline.fromPointer(this._ptr);
+  PhysicsConstraintTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_physics_constraint_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_physics_constraint_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_physics_constraint_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_physics_constraint_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_physics_constraint_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_physics_constraint_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_physics_constraint_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
   int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_timeline_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings.spine_physics_constraint_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_physics_constraint_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
+    SpineBindings.bindings.spine_physics_constraint_timeline_set_constraint_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_wind_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'physics_constraint_timeline.dart';
 
 /// PhysicsConstraintWindTimeline wrapper
-class PhysicsConstraintWindTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PhysicsConstraintWindTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_wind_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PhysicsConstraintWindTimeline.fromPointer(this._ptr);
+  PhysicsConstraintWindTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintWindTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = _bindings.spine_physics_constraint_wind_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+    final ptr = SpineBindings.bindings.spine_physics_constraint_wind_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintWindTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_physics_constraint_wind_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_physics_constraint_wind_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_physics_constraint_wind_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_physics_constraint_wind_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_physics_constraint_wind_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    _bindings.spine_physics_constraint_wind_timeline_set_constraint_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_physics_constraint_wind_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_physics_constraint_wind_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_physics_constraint_wind_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_physics_constraint_wind_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/point_attachment.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,111 +23,74 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'attachment.dart';
 import 'color.dart';
 import 'bone_pose.dart';
-import 'attachment.dart';
 
 /// PointAttachment wrapper
-class PointAttachment implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class PointAttachment extends Attachment {
   final Pointer<spine_point_attachment_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  PointAttachment.fromPointer(this._ptr);
+  PointAttachment.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PointAttachment(String name) {
-    final ptr = _bindings.spine_point_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_point_attachment_create(name.toNativeUtf8().cast<Char>());
     return PointAttachment.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_point_attachment_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   double get x {
-    final result = _bindings.spine_point_attachment_get_x(_ptr);
+    final result = SpineBindings.bindings.spine_point_attachment_get_x(_ptr);
     return result;
   }
 
   set x(double value) {
-    _bindings.spine_point_attachment_set_x(_ptr, value);
+    SpineBindings.bindings.spine_point_attachment_set_x(_ptr, value);
   }
 
   double get y {
-    final result = _bindings.spine_point_attachment_get_y(_ptr);
+    final result = SpineBindings.bindings.spine_point_attachment_get_y(_ptr);
     return result;
   }
 
   set y(double value) {
-    _bindings.spine_point_attachment_set_y(_ptr, value);
+    SpineBindings.bindings.spine_point_attachment_set_y(_ptr, value);
   }
 
   double get rotation {
-    final result = _bindings.spine_point_attachment_get_rotation(_ptr);
+    final result = SpineBindings.bindings.spine_point_attachment_get_rotation(_ptr);
     return result;
   }
 
   set rotation(double value) {
-    _bindings.spine_point_attachment_set_rotation(_ptr, value);
+    SpineBindings.bindings.spine_point_attachment_set_rotation(_ptr, value);
   }
 
   Color get color {
-    final result = _bindings.spine_point_attachment_get_color(_ptr);
+    final result = SpineBindings.bindings.spine_point_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
   double computeWorldRotation(BonePose bone) {
-    final result = _bindings.spine_point_attachment_compute_world_rotation(_ptr, bone.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_point_attachment_compute_world_rotation(_ptr, bone.nativePtr.cast());
     return result;
   }
 
-  Attachment copy() {
-    final result = _bindings.spine_point_attachment_copy(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  String get name {
-    final result = _bindings.spine_point_attachment_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  int get refCount {
-    final result = _bindings.spine_point_attachment_get_ref_count(_ptr);
-    return result;
-  }
-
-  void reference() {
-    _bindings.spine_point_attachment_reference(_ptr);
-  }
-
-  void dereference() {
-    _bindings.spine_point_attachment_dereference(_ptr);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_point_attachment_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_point_attachment_dispose(_ptr);
+    SpineBindings.bindings.spine_point_attachment_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/polygon.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,55 +23,50 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'arrays.dart';
 
 /// Polygon wrapper
 class Polygon implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_polygon_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Polygon.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory Polygon() {
-    final ptr = _bindings.spine_polygon_create();
+    final ptr = SpineBindings.bindings.spine_polygon_create();
     return Polygon.fromPointer(ptr);
   }
 
   ArrayFloat get vertices {
-    final result = _bindings.spine_polygon_get__vertices(_ptr);
+    final result = SpineBindings.bindings.spine_polygon_get__vertices(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   set vertices(ArrayFloat value) {
-    _bindings.spine_polygon_set__vertices(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_polygon_set__vertices(_ptr, value.nativePtr.cast());
   }
 
   int get count {
-    final result = _bindings.spine_polygon_get__count(_ptr);
+    final result = SpineBindings.bindings.spine_polygon_get__count(_ptr);
     return result;
   }
 
   set count(int value) {
-    _bindings.spine_polygon_set__count(_ptr, value);
+    SpineBindings.bindings.spine_polygon_set__count(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_polygon_dispose(_ptr);
+    SpineBindings.bindings.spine_polygon_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/posed.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,44 +23,39 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// Posed wrapper
-class Posed implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+abstract class Posed implements Finalizable {
   final Pointer<spine_posed_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Posed.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   void constrained() {
-    _bindings.spine_posed_constrained(_ptr);
+    SpineBindings.bindings.spine_posed_constrained(_ptr);
   }
 
   void resetConstrained() {
-    _bindings.spine_posed_reset_constrained(_ptr);
+    SpineBindings.bindings.spine_posed_reset_constrained(_ptr);
   }
 
   bool get isPoseEqualToApplied {
-    final result = _bindings.spine_posed_is_pose_equal_to_applied(_ptr);
+    final result = SpineBindings.bindings.spine_posed_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
   void dispose() {
-    _bindings.spine_posed_dispose(_ptr);
+    SpineBindings.bindings.spine_posed_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/posed_active.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,40 +23,35 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// PosedActive wrapper
 class PosedActive implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_posed_active_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   PosedActive.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   bool get isActive {
-    final result = _bindings.spine_posed_active_is_active(_ptr);
+    final result = SpineBindings.bindings.spine_posed_active_is_active(_ptr);
     return result;
   }
 
   set active(bool value) {
-    _bindings.spine_posed_active_set_active(_ptr, value);
+    SpineBindings.bindings.spine_posed_active_set_active(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_posed_active_dispose(_ptr);
+    SpineBindings.bindings.spine_posed_active_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/posed_data.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,51 +23,46 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// PosedData wrapper
 class PosedData implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_posed_data_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   PosedData.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory PosedData(String name) {
-    final ptr = _bindings.spine_posed_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_posed_data_create(name.toNativeUtf8().cast<Char>());
     return PosedData.fromPointer(ptr);
   }
 
   String get name {
-    final result = _bindings.spine_posed_data_get_name(_ptr);
+    final result = SpineBindings.bindings.spine_posed_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   bool get skinRequired {
-    final result = _bindings.spine_posed_data_get_skin_required(_ptr);
+    final result = SpineBindings.bindings.spine_posed_data_get_skin_required(_ptr);
     return result;
   }
 
   set skinRequired(bool value) {
-    _bindings.spine_posed_data_set_skin_required(_ptr, value);
+    SpineBindings.bindings.spine_posed_data_set_skin_required(_ptr, value);
   }
 
   void dispose() {
-    _bindings.spine_posed_data_dispose(_ptr);
+    SpineBindings.bindings.spine_posed_data_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/position_mode.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/property.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/region_attachment.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,190 +23,153 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
+import '../spine_bindings.dart';
+import 'attachment.dart';
 import 'slot.dart';
 import 'color.dart';
 import 'texture_region.dart';
 import 'sequence.dart';
-import 'attachment.dart';
 import 'arrays.dart';
 
 /// RegionAttachment wrapper
-class RegionAttachment implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class RegionAttachment extends Attachment {
   final Pointer<spine_region_attachment_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  RegionAttachment.fromPointer(this._ptr);
+  RegionAttachment.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory RegionAttachment(String name) {
-    final ptr = _bindings.spine_region_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings.spine_region_attachment_create(name.toNativeUtf8().cast<Char>());
     return RegionAttachment.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_region_attachment_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void updateRegion() {
-    _bindings.spine_region_attachment_update_region(_ptr);
+    SpineBindings.bindings.spine_region_attachment_update_region(_ptr);
   }
 
   double get x {
-    final result = _bindings.spine_region_attachment_get_x(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_x(_ptr);
     return result;
   }
 
   set x(double value) {
-    _bindings.spine_region_attachment_set_x(_ptr, value);
+    SpineBindings.bindings.spine_region_attachment_set_x(_ptr, value);
   }
 
   double get y {
-    final result = _bindings.spine_region_attachment_get_y(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_y(_ptr);
     return result;
   }
 
   set y(double value) {
-    _bindings.spine_region_attachment_set_y(_ptr, value);
+    SpineBindings.bindings.spine_region_attachment_set_y(_ptr, value);
   }
 
   double get rotation {
-    final result = _bindings.spine_region_attachment_get_rotation(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_rotation(_ptr);
     return result;
   }
 
   set rotation(double value) {
-    _bindings.spine_region_attachment_set_rotation(_ptr, value);
+    SpineBindings.bindings.spine_region_attachment_set_rotation(_ptr, value);
   }
 
   double get scaleX {
-    final result = _bindings.spine_region_attachment_get_scale_x(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_scale_x(_ptr);
     return result;
   }
 
   set scaleX(double value) {
-    _bindings.spine_region_attachment_set_scale_x(_ptr, value);
+    SpineBindings.bindings.spine_region_attachment_set_scale_x(_ptr, value);
   }
 
   double get scaleY {
-    final result = _bindings.spine_region_attachment_get_scale_y(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_scale_y(_ptr);
     return result;
   }
 
   set scaleY(double value) {
-    _bindings.spine_region_attachment_set_scale_y(_ptr, value);
+    SpineBindings.bindings.spine_region_attachment_set_scale_y(_ptr, value);
   }
 
   double get width {
-    final result = _bindings.spine_region_attachment_get_width(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_width(_ptr);
     return result;
   }
 
   set width(double value) {
-    _bindings.spine_region_attachment_set_width(_ptr, value);
+    SpineBindings.bindings.spine_region_attachment_set_width(_ptr, value);
   }
 
   double get height {
-    final result = _bindings.spine_region_attachment_get_height(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_height(_ptr);
     return result;
   }
 
   set height(double value) {
-    _bindings.spine_region_attachment_set_height(_ptr, value);
+    SpineBindings.bindings.spine_region_attachment_set_height(_ptr, value);
   }
 
   Color get color {
-    final result = _bindings.spine_region_attachment_get_color(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
   String get path {
-    final result = _bindings.spine_region_attachment_get_path(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_path(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set path(String value) {
-    _bindings.spine_region_attachment_set_path(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_region_attachment_set_path(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   TextureRegion get region {
-    final result = _bindings.spine_region_attachment_get_region(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_region(_ptr);
     return TextureRegion.fromPointer(result);
   }
 
   set region(TextureRegion value) {
-    _bindings.spine_region_attachment_set_region(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_region_attachment_set_region(_ptr, value.nativePtr.cast());
   }
 
   Sequence get sequence {
-    final result = _bindings.spine_region_attachment_get_sequence(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_sequence(_ptr);
     return Sequence.fromPointer(result);
   }
 
   set sequence(Sequence value) {
-    _bindings.spine_region_attachment_set_sequence(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings.spine_region_attachment_set_sequence(_ptr, value.nativePtr.cast());
   }
 
   ArrayFloat get offset {
-    final result = _bindings.spine_region_attachment_get_offset(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_offset(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   ArrayFloat get uVs {
-    final result = _bindings.spine_region_attachment_get_u_vs(_ptr);
+    final result = SpineBindings.bindings.spine_region_attachment_get_u_vs(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
-  Attachment copy() {
-    final result = _bindings.spine_region_attachment_copy(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  String get name {
-    final result = _bindings.spine_region_attachment_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  int get refCount {
-    final result = _bindings.spine_region_attachment_get_ref_count(_ptr);
-    return result;
-  }
-
-  void reference() {
-    _bindings.spine_region_attachment_reference(_ptr);
-  }
-
-  void dereference() {
-    _bindings.spine_region_attachment_dereference(_ptr);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_region_attachment_rtti();
-    return Rtti.fromPointer(result);
-  }
-
   void computeWorldVertices(Slot slot, ArrayFloat worldVertices, int offset, int stride) {
-    _bindings.spine_region_attachment_compute_world_vertices_2(_ptr, slot.nativePtr.cast(), worldVertices.nativePtr.cast(), offset, stride);
+    SpineBindings.bindings.spine_region_attachment_compute_world_vertices_2(_ptr, slot.nativePtr.cast(), worldVertices.nativePtr.cast(), offset, stride);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_region_attachment_dispose(_ptr);
+    SpineBindings.bindings.spine_region_attachment_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/render_command.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,52 +23,47 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'blend_mode.dart';
 
 /// RenderCommand wrapper
 class RenderCommand implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_render_command_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   RenderCommand.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   int get numVertices {
-    final result = _bindings.spine_render_command_get_num_vertices(_ptr);
+    final result = SpineBindings.bindings.spine_render_command_get_num_vertices(_ptr);
     return result;
   }
 
   int get numIndices {
-    final result = _bindings.spine_render_command_get_num_indices(_ptr);
+    final result = SpineBindings.bindings.spine_render_command_get_num_indices(_ptr);
     return result;
   }
 
   BlendMode get blendMode {
-    final result = _bindings.spine_render_command_get_blend_mode(_ptr);
+    final result = SpineBindings.bindings.spine_render_command_get_blend_mode(_ptr);
     return BlendMode.fromValue(result);
   }
 
   RenderCommand get next {
-    final result = _bindings.spine_render_command_get_next(_ptr);
+    final result = SpineBindings.bindings.spine_render_command_get_next(_ptr);
     return RenderCommand.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_render_command_dispose(_ptr);
+    SpineBindings.bindings.spine_render_command_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/rgb2_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,115 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'slot_curve_timeline.dart';
 
 /// Rgb2Timeline wrapper
-class Rgb2Timeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class Rgb2Timeline extends SlotCurveTimeline {
   final Pointer<spine_rgb2_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  Rgb2Timeline.fromPointer(this._ptr);
+  Rgb2Timeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory Rgb2Timeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = _bindings.spine_rgb2_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings.spine_rgb2_timeline_create(frameCount, bezierCount, slotIndex);
     return Rgb2Timeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_rgb2_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void setFrame(int frame, double time, double r, double g, double b, double r2, double g2, double b2) {
-    _bindings.spine_rgb2_timeline_set_frame(_ptr, frame, time, r, g, b, r2, g2, b2);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_rgb2_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  set linear(int value) {
-    _bindings.spine_rgb2_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_rgb2_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_rgb2_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_rgb2_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_rgb2_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_rgb2_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_rgb2_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_rgb2_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_rgb2_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_rgb2_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get slotIndex {
-    final result = _bindings.spine_rgb2_timeline_get_slot_index(_ptr);
-    return result;
-  }
-
-  set slotIndex(int value) {
-    _bindings.spine_rgb2_timeline_set_slot_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_rgb2_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_rgb2_timeline_set_frame(_ptr, frame, time, r, g, b, r2, g2, b2);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_rgb2_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_rgb2_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/rgb_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,115 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'slot_curve_timeline.dart';
 
 /// RgbTimeline wrapper
-class RgbTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class RgbTimeline extends SlotCurveTimeline {
   final Pointer<spine_rgb_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  RgbTimeline.fromPointer(this._ptr);
+  RgbTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory RgbTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = _bindings.spine_rgb_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings.spine_rgb_timeline_create(frameCount, bezierCount, slotIndex);
     return RgbTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_rgb_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void setFrame(int frame, double time, double r, double g, double b) {
-    _bindings.spine_rgb_timeline_set_frame(_ptr, frame, time, r, g, b);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_rgb_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  set linear(int value) {
-    _bindings.spine_rgb_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_rgb_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_rgb_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_rgb_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_rgb_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_rgb_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_rgb_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_rgb_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_rgb_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_rgb_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get slotIndex {
-    final result = _bindings.spine_rgb_timeline_get_slot_index(_ptr);
-    return result;
-  }
-
-  set slotIndex(int value) {
-    _bindings.spine_rgb_timeline_set_slot_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_rgb_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_rgb_timeline_set_frame(_ptr, frame, time, r, g, b);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_rgb_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_rgb_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/rgba2_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,115 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'slot_curve_timeline.dart';
 
 /// Rgba2Timeline wrapper
-class Rgba2Timeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class Rgba2Timeline extends SlotCurveTimeline {
   final Pointer<spine_rgba2_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  Rgba2Timeline.fromPointer(this._ptr);
+  Rgba2Timeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory Rgba2Timeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = _bindings.spine_rgba2_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings.spine_rgba2_timeline_create(frameCount, bezierCount, slotIndex);
     return Rgba2Timeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_rgba2_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void setFrame(int frame, double time, double r, double g, double b, double a, double r2, double g2, double b2) {
-    _bindings.spine_rgba2_timeline_set_frame(_ptr, frame, time, r, g, b, a, r2, g2, b2);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_rgba2_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  set linear(int value) {
-    _bindings.spine_rgba2_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_rgba2_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_rgba2_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_rgba2_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_rgba2_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_rgba2_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_rgba2_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_rgba2_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_rgba2_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_rgba2_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get slotIndex {
-    final result = _bindings.spine_rgba2_timeline_get_slot_index(_ptr);
-    return result;
-  }
-
-  set slotIndex(int value) {
-    _bindings.spine_rgba2_timeline_set_slot_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_rgba2_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_rgba2_timeline_set_frame(_ptr, frame, time, r, g, b, a, r2, g2, b2);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_rgba2_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_rgba2_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/rgba_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,115 +23,38 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'slot_curve_timeline.dart';
 
 /// RgbaTimeline wrapper
-class RgbaTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class RgbaTimeline extends SlotCurveTimeline {
   final Pointer<spine_rgba_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  RgbaTimeline.fromPointer(this._ptr);
+  RgbaTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory RgbaTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = _bindings.spine_rgba_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings.spine_rgba_timeline_create(frameCount, bezierCount, slotIndex);
     return RgbaTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_rgba_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
   void setFrame(int frame, double time, double r, double g, double b, double a) {
-    _bindings.spine_rgba_timeline_set_frame(_ptr, frame, time, r, g, b, a);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_rgba_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  set linear(int value) {
-    _bindings.spine_rgba_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_rgba_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_rgba_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_rgba_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_rgba_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_rgba_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_rgba_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_rgba_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_rgba_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_rgba_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get slotIndex {
-    final result = _bindings.spine_rgba_timeline_get_slot_index(_ptr);
-    return result;
-  }
-
-  set slotIndex(int value) {
-    _bindings.spine_rgba_timeline_set_slot_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_rgba_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_rgba_timeline_set_frame(_ptr, frame, time, r, g, b, a);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_rgba_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_rgba_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/rotate_mode.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/rotate_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'bone_timeline1.dart';
 
 /// RotateTimeline wrapper
-class RotateTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class RotateTimeline extends BoneTimeline1 {
   final Pointer<spine_rotate_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  RotateTimeline.fromPointer(this._ptr);
+  RotateTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory RotateTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = _bindings.spine_rotate_timeline_create(frameCount, bezierCount, boneIndex);
+    final ptr = SpineBindings.bindings.spine_rotate_timeline_create(frameCount, bezierCount, boneIndex);
     return RotateTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_rotate_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_rotate_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_rotate_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_rotate_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_rotate_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_rotate_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_rotate_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_rotate_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_rotate_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_rotate_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_rotate_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_rotate_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_rotate_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_rotate_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_rotate_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_rotate_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get boneIndex {
-    final result = _bindings.spine_rotate_timeline_get_bone_index(_ptr);
-    return result;
-  }
-
-  set boneIndex(int value) {
-    _bindings.spine_rotate_timeline_set_bone_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_rotate_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_rotate_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_rotate_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_rotate_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_rotate_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/rtti.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,47 +23,42 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 
 /// Rtti wrapper
 class Rtti implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_rtti_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Rtti.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   String get className {
-    final result = _bindings.spine_rtti_get_class_name(_ptr);
+    final result = SpineBindings.bindings.spine_rtti_get_class_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   bool isExactly(Rtti rtti) {
-    final result = _bindings.spine_rtti_is_exactly(_ptr, rtti.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_rtti_is_exactly(_ptr, rtti.nativePtr.cast());
     return result;
   }
 
   bool instanceOf(Rtti rtti) {
-    final result = _bindings.spine_rtti_instance_of(_ptr, rtti.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_rtti_instance_of(_ptr, rtti.nativePtr.cast());
     return result;
   }
 
   void dispose() {
-    _bindings.spine_rtti_dispose(_ptr);
+    SpineBindings.bindings.spine_rtti_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/scale_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,120 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'bone_timeline2.dart';
 
 /// ScaleTimeline wrapper
-class ScaleTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class ScaleTimeline extends BoneTimeline2 {
   final Pointer<spine_scale_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  ScaleTimeline.fromPointer(this._ptr);
+  ScaleTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory ScaleTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = _bindings.spine_scale_timeline_create(frameCount, bezierCount, boneIndex);
+    final ptr = SpineBindings.bindings.spine_scale_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_scale_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_scale_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value1, double value2) {
-    _bindings.spine_scale_timeline_set_frame(_ptr, frame, time, value1, value2);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_scale_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_scale_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_scale_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_scale_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_scale_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_scale_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_scale_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_scale_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_scale_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_scale_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_scale_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get boneIndex {
-    final result = _bindings.spine_scale_timeline_get_bone_index(_ptr);
-    return result;
-  }
-
-  set boneIndex(int value) {
-    _bindings.spine_scale_timeline_set_bone_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_scale_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_scale_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_scale_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/scale_x_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'bone_timeline1.dart';
 
 /// ScaleXTimeline wrapper
-class ScaleXTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class ScaleXTimeline extends BoneTimeline1 {
   final Pointer<spine_scale_x_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  ScaleXTimeline.fromPointer(this._ptr);
+  ScaleXTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory ScaleXTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = _bindings.spine_scale_x_timeline_create(frameCount, bezierCount, boneIndex);
+    final ptr = SpineBindings.bindings.spine_scale_x_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleXTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_scale_x_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_scale_x_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_scale_x_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_scale_x_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_scale_x_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_scale_x_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_scale_x_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_scale_x_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_scale_x_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_scale_x_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_scale_x_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_scale_x_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_scale_x_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_scale_x_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_scale_x_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_scale_x_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get boneIndex {
-    final result = _bindings.spine_scale_x_timeline_get_bone_index(_ptr);
-    return result;
-  }
-
-  set boneIndex(int value) {
-    _bindings.spine_scale_x_timeline_set_bone_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_scale_x_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_scale_x_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_scale_x_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_scale_x_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_scale_x_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/scale_y_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,140 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'bone_timeline1.dart';
 
 /// ScaleYTimeline wrapper
-class ScaleYTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class ScaleYTimeline extends BoneTimeline1 {
   final Pointer<spine_scale_y_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  ScaleYTimeline.fromPointer(this._ptr);
+  ScaleYTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory ScaleYTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = _bindings.spine_scale_y_timeline_create(frameCount, bezierCount, boneIndex);
+    final ptr = SpineBindings.bindings.spine_scale_y_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleYTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_scale_y_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_scale_y_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value) {
-    _bindings.spine_scale_y_timeline_set_frame(_ptr, frame, time, value);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_scale_y_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_scale_y_timeline_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = _bindings.spine_scale_y_timeline_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_scale_y_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_scale_y_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_scale_y_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_scale_y_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_scale_y_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_scale_y_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_scale_y_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_scale_y_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_scale_y_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_scale_y_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get boneIndex {
-    final result = _bindings.spine_scale_y_timeline_get_bone_index(_ptr);
-    return result;
-  }
-
-  set boneIndex(int value) {
-    _bindings.spine_scale_y_timeline_set_bone_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_scale_y_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = _bindings.spine_scale_y_timeline_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-    return result;
-  }
-
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = _bindings.spine_scale_y_timeline_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-    return result;
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_scale_y_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_scale_y_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/sequence.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,95 +23,90 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
+import '../spine_bindings.dart';
 import 'slot_pose.dart';
 import 'attachment.dart';
 import 'arrays.dart';
 
 /// Sequence wrapper
 class Sequence implements Finalizable {
-  static late SpineFlutterBindings _bindings;
   final Pointer<spine_sequence_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
   Sequence.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
   factory Sequence(int count) {
-    final ptr = _bindings.spine_sequence_create(count);
+    final ptr = SpineBindings.bindings.spine_sequence_create(count);
     return Sequence.fromPointer(ptr);
   }
 
   Sequence copy() {
-    final result = _bindings.spine_sequence_copy(_ptr);
+    final result = SpineBindings.bindings.spine_sequence_copy(_ptr);
     return Sequence.fromPointer(result);
   }
 
   void apply(SlotPose slot, Attachment attachment) {
-    _bindings.spine_sequence_apply(_ptr, slot.nativePtr.cast(), attachment.nativePtr.cast());
+    SpineBindings.bindings.spine_sequence_apply(_ptr, slot.nativePtr.cast(), attachment.nativePtr.cast());
   }
 
   String getPath(String basePath, int index) {
-    final result = _bindings.spine_sequence_get_path(_ptr, basePath.toNativeUtf8().cast<Char>(), index);
+    final result = SpineBindings.bindings.spine_sequence_get_path(_ptr, basePath.toNativeUtf8().cast<Char>(), index);
     return result.cast<Utf8>().toDartString();
   }
 
   int get id {
-    final result = _bindings.spine_sequence_get_id(_ptr);
+    final result = SpineBindings.bindings.spine_sequence_get_id(_ptr);
     return result;
   }
 
   set id(int value) {
-    _bindings.spine_sequence_set_id(_ptr, value);
+    SpineBindings.bindings.spine_sequence_set_id(_ptr, value);
   }
 
   int get start {
-    final result = _bindings.spine_sequence_get_start(_ptr);
+    final result = SpineBindings.bindings.spine_sequence_get_start(_ptr);
     return result;
   }
 
   set start(int value) {
-    _bindings.spine_sequence_set_start(_ptr, value);
+    SpineBindings.bindings.spine_sequence_set_start(_ptr, value);
   }
 
   int get digits {
-    final result = _bindings.spine_sequence_get_digits(_ptr);
+    final result = SpineBindings.bindings.spine_sequence_get_digits(_ptr);
     return result;
   }
 
   set digits(int value) {
-    _bindings.spine_sequence_set_digits(_ptr, value);
+    SpineBindings.bindings.spine_sequence_set_digits(_ptr, value);
   }
 
   int get setupIndex {
-    final result = _bindings.spine_sequence_get_setup_index(_ptr);
+    final result = SpineBindings.bindings.spine_sequence_get_setup_index(_ptr);
     return result;
   }
 
   set setupIndex(int value) {
-    _bindings.spine_sequence_set_setup_index(_ptr, value);
+    SpineBindings.bindings.spine_sequence_set_setup_index(_ptr, value);
   }
 
   ArrayTextureRegion get regions {
-    final result = _bindings.spine_sequence_get_regions(_ptr);
+    final result = SpineBindings.bindings.spine_sequence_get_regions(_ptr);
     return ArrayTextureRegion.fromPointer(result);
   }
 
   void dispose() {
-    _bindings.spine_sequence_dispose(_ptr);
+    SpineBindings.bindings.spine_sequence_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/sequence_mode.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,9 +23,9 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 

spine-flutter/lib/generated/sequence_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,100 +23,78 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
+import 'package:ffi/ffi.dart';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
+import '../spine_bindings.dart';
+import 'timeline.dart';
 import 'sequence_mode.dart';
 import 'attachment.dart';
-import 'arrays.dart';
+import 'point_attachment.dart';
+import 'region_attachment.dart';
+import 'bounding_box_attachment.dart';
+import 'clipping_attachment.dart';
+import 'mesh_attachment.dart';
+import 'path_attachment.dart';
 
 /// SequenceTimeline wrapper
-class SequenceTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class SequenceTimeline extends Timeline {
   final Pointer<spine_sequence_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  SequenceTimeline.fromPointer(this._ptr);
+  SequenceTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory SequenceTimeline(int frameCount, int slotIndex, Attachment attachment) {
-    final ptr = _bindings.spine_sequence_timeline_create(frameCount, slotIndex, attachment.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_sequence_timeline_create(frameCount, slotIndex, attachment.nativePtr.cast());
     return SequenceTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_sequence_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_sequence_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
   void setFrame(int frame, double time, SequenceMode mode, int index, double delay) {
-    _bindings.spine_sequence_timeline_set_frame(_ptr, frame, time, mode.value, index, delay);
+    SpineBindings.bindings.spine_sequence_timeline_set_frame(_ptr, frame, time, mode.value, index, delay);
   }
 
   Attachment get attachment {
-    final result = _bindings.spine_sequence_timeline_get_attachment(_ptr);
-    return Attachment.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_sequence_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_sequence_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_sequence_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_sequence_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_sequence_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
+    final result = SpineBindings.bindings.spine_sequence_timeline_get_attachment(_ptr);
+    final rtti = SpineBindings.bindings.spine_attachment_get_rtti(result);
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    switch (className) {
+      case 'spine_point_attachment':
+        return PointAttachment.fromPointer(result.cast());
+      case 'spine_region_attachment':
+        return RegionAttachment.fromPointer(result.cast());
+      case 'spine_bounding_box_attachment':
+        return BoundingBoxAttachment.fromPointer(result.cast());
+      case 'spine_clipping_attachment':
+        return ClippingAttachment.fromPointer(result.cast());
+      case 'spine_mesh_attachment':
+        return MeshAttachment.fromPointer(result.cast());
+      case 'spine_path_attachment':
+        return PathAttachment.fromPointer(result.cast());
+      default:
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
+    }
   }
 
   int get slotIndex {
-    final result = _bindings.spine_sequence_timeline_get_slot_index(_ptr);
+    final result = SpineBindings.bindings.spine_sequence_timeline_get_slot_index(_ptr);
     return result;
   }
 
   set slotIndex(int value) {
-    _bindings.spine_sequence_timeline_set_slot_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_sequence_timeline_rtti();
-    return Rtti.fromPointer(result);
+    SpineBindings.bindings.spine_sequence_timeline_set_slot_index(_ptr, value);
   }
 
+  @override
   void dispose() {
-    _bindings.spine_sequence_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_sequence_timeline_dispose(_ptr);
   }
 }

spine-flutter/lib/generated/shear_timeline.dart

@@ -1,16 +1,16 @@
-// ******************************************************************************
+//
 // Spine Runtimes License Agreement
-// Last updated July 28, 2023. Replaces all prior versions.
+// Last updated April 5, 2025. Replaces all prior versions.
 //
-// Copyright (c) 2013-2023, Esoteric Software LLC
+// Copyright (c) 2013-2025, Esoteric Software LLC
 //
 // Integration of the Spine Runtimes into software or otherwise creating
 // derivative works of the Spine Runtimes is permitted under the terms and
 // conditions of Section 2 of the Spine Editor License Agreement:
 // http://esotericsoftware.com/spine-editor-license
 //
-// Otherwise, it is permitted to integrate the Spine Runtimes into software or
-// otherwise create derivative works of the Spine Runtimes (collectively,
+// Otherwise, it is permitted to integrate the Spine Runtimes into software
+// or otherwise create derivative works of the Spine Runtimes (collectively,
 // "Products"), provided that each user of the Products must obtain their own
 // Spine Editor license and redistribution of the Products in any form must
 // include this license and copyright notice.
@@ -23,120 +23,34 @@
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 // BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
-// SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// *****************************************************************************/
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
 import 'spine_flutter_bindings_generated.dart';
-import 'rtti.dart';
-import 'skeleton.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
-import 'arrays.dart';
+import '../spine_bindings.dart';
+import 'bone_timeline2.dart';
 
 /// ShearTimeline wrapper
-class ShearTimeline implements Finalizable {
-  static late SpineFlutterBindings _bindings;
+class ShearTimeline extends BoneTimeline2 {
   final Pointer<spine_shear_timeline_wrapper> _ptr;
 
-  /// Initialize the bindings for all spine-flutter classes
-  static void init(SpineFlutterBindings bindings) {
-    _bindings = bindings;
-  }
-
-  ShearTimeline.fromPointer(this._ptr);
+  ShearTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory ShearTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = _bindings.spine_shear_timeline_create(frameCount, bezierCount, boneIndex);
+    final ptr = SpineBindings.bindings.spine_shear_timeline_create(frameCount, bezierCount, boneIndex);
     return ShearTimeline.fromPointer(ptr);
   }
 
-  Rtti get rtti {
-    final result = _bindings.spine_shear_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend, MixDirection direction, bool appliedPose) {
-    _bindings.spine_shear_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-  }
-
-  void setFrame(int frame, double time, double value1, double value2) {
-    _bindings.spine_shear_timeline_set_frame(_ptr, frame, time, value1, value2);
-  }
-
-  double getCurveValue(double time) {
-    final result = _bindings.spine_shear_timeline_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  set linear(int value) {
-    _bindings.spine_shear_timeline_set_linear(_ptr, value);
-  }
-
-  set stepped(int value) {
-    _bindings.spine_shear_timeline_set_stepped(_ptr, value);
-  }
-
-  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2, double cy2, double time2, double value2) {
-    _bindings.spine_shear_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-  }
-
-  double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = _bindings.spine_shear_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-    return result;
-  }
-
-  ArrayFloat get curves {
-    final result = _bindings.spine_shear_timeline_get_curves(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  int get frameEntries {
-    final result = _bindings.spine_shear_timeline_get_frame_entries(_ptr);
-    return result;
-  }
-
-  int get frameCount {
-    final result = _bindings.spine_shear_timeline_get_frame_count(_ptr);
-    return result;
-  }
-
-  ArrayFloat get frames {
-    final result = _bindings.spine_shear_timeline_get_frames(_ptr);
-    return ArrayFloat.fromPointer(result);
-  }
-
-  double get duration {
-    final result = _bindings.spine_shear_timeline_get_duration(_ptr);
-    return result;
-  }
-
-  ArrayPropertyId get propertyIds {
-    final result = _bindings.spine_shear_timeline_get_property_ids(_ptr);
-    return ArrayPropertyId.fromPointer(result);
-  }
-
-  int get boneIndex {
-    final result = _bindings.spine_shear_timeline_get_bone_index(_ptr);
-    return result;
-  }
-
-  set boneIndex(int value) {
-    _bindings.spine_shear_timeline_set_bone_index(_ptr, value);
-  }
-
-  static Rtti rttiStatic() {
-    final result = _bindings.spine_shear_timeline_rtti();
-    return Rtti.fromPointer(result);
-  }
-
+  @override
   void dispose() {
-    _bindings.spine_shear_timeline_dispose(_ptr);
+    SpineBindings.bindings.spine_shear_timeline_dispose(_ptr);
   }
 }