[dart] types are not Finalizable, invoke formatters/format-dart.sh, build test spine_flutter shared lib

spine-flutter/.vscode/launch.json

@@ -4,6 +4,13 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "name": "headless-test (dart)",
+            "type": "dart",
+            "request": "launch",
+            "program": "headless_test.dart",
+            "cwd": "${workspaceFolder}/test"
+        },
         {
             "name": "spine-flutter",
             "request": "launch",
@@ -40,13 +47,6 @@
             "request": "launch",
             "type": "dart",
             "flutterMode": "release"
-        },
-        {
-            "name": "headless-test (dart)",
-            "cwd": "test",
-            "request": "launch",
-            "type": "dart",
-            "program": "bin/headless_test.dart"
         }
     ]
 }

spine-flutter/codegen/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "scripts": {
     "format": "npx -y typescript-formatter -r **/*.ts",
-    "build": "npx tsx src/index.ts"
+    "generate": "npx tsx src/index.ts"
   },
   "dependencies": {
     "spine-c-codegen": "file:../../spine-c/codegen"

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

@@ -246,6 +246,11 @@ export class DartWriter {
 			}
 		}
 
+		// Add destructor as dispose method for concrete classes
+		if (classType === 'concrete' && cType.destructor) {
+			members.push(this.createDisposeMethod(cType.destructor, cType));
+		}
+
 		// Process methods with unified logic - Apply SAME logic for ALL class types
 		const validMethods = cType.methods.filter(method => {
 			if (this.hasRawPointerParameters(method)) {
@@ -339,6 +344,20 @@ export class DartWriter {
 		return overloadedSetters;
 	}
 
+	private createDisposeMethod (destructor: CMethod, cType: CClassOrStruct): DartMember {
+		const implementation = `SpineBindings.bindings.${destructor.name}(_ptr);`;
+
+		return {
+			type: 'method',
+			name: 'dispose',
+			dartReturnType: 'void',
+			parameters: [],
+			isOverride: false,
+			implementation,
+			cMethodName: destructor.name
+		};
+	}
+
 	private createConstructor (constr: CMethod, cType: CClassOrStruct): DartMember {
 		const dartClassName = this.toDartTypeName(cType.name);
 		const params = constr.parameters.map(p => ({
@@ -530,15 +549,10 @@ export class DartWriter {
 			declaration += ` extends ${dartClass.inheritance.extends}`;
 		}
 
-		// Implements clause - combine Finalizable with other interfaces
+		// Implements clause
 		const implementsClasses: string[] = [];
 
-		// Add Finalizable for non-interface classes that don't extend another class
+		// Add interfaces
-		if (dartClass.type !== 'interface' && !dartClass.inheritance.extends) {
-			implementsClasses.push('Finalizable');
-		}
-
-		// Add other interfaces
 		implementsClasses.push(...dartClass.inheritance.implements);
 
 		if (implementsClasses.length > 0) {
@@ -1305,6 +1319,12 @@ ${declaration} {`;
 		}
 
 		const methodSuffix = this.getMethodSuffix(method.name, cType.name);
+		
+		// Don't consider dispose methods as inherited - they're type-specific
+		if (methodSuffix === 'dispose') {
+			return false;
+		}
+		
 		const parentMethodName = `${parentName}_${methodSuffix}`;
 
 		const hasInParent = parent.methods.some(m => m.name === parentMethodName);

spine-flutter/codegen/src/index.ts

@@ -155,7 +155,7 @@ async function main() {
 
     if (justGenerateYaml) {
         console.log('Generating ffigen.yaml only...\n');
-        
+
         // Generate FFI bindings YAML config only
         const spineCDir = path.join(__dirname, '../../src/spine-c');
         await generateFFigenYamlOnly(spineCDir);
@@ -197,9 +197,9 @@ async function main() {
                 stdio: 'inherit'
             });
 
-            // Run dart format to format the code
+            // Run custom dart format script
             console.log('Running dart format...');
-            execSync('dart format lib/generated/', {
+            execSync(path.join(__dirname, '../../../formatters/format-dart.sh lib/generated/'), {
                 cwd: projectRoot,
                 stdio: 'inherit'
             });

spine-flutter/generate-bindings.sh

@@ -20,4 +20,9 @@ fi
 # Run the codegen
 npx tsx codegen/src/index.ts
 
+# Build test spine_flutter shared library
+pushd ../spine_flutter/test > /dev/null
+./build.sh
+popd
+
 popd > /dev/null

spine-flutter/lib/generated/alpha_timeline.dart

@@ -50,6 +50,10 @@ class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
     return AlphaTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_alpha_timeline_dispose(_ptr);
+  }
+
   @override
   int get slotIndex {
     final result = SpineBindings.bindings.spine_alpha_timeline_get_slot_index(_ptr);

spine-flutter/lib/generated/animation.dart

@@ -39,7 +39,7 @@ import 'mix_direction.dart';
 import 'skeleton.dart';
 
 /// Animation wrapper
-class Animation implements Finalizable {
+class Animation {
   final Pointer<spine_animation_wrapper> _ptr;
 
   Animation.fromPointer(this._ptr);
@@ -53,6 +53,10 @@ class Animation implements Finalizable {
     return Animation.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_animation_dispose(_ptr);
+  }
+
   ArrayTimeline get timelines {
     final result = SpineBindings.bindings.spine_animation_get_timelines(_ptr);
     return ArrayTimeline.fromPointer(result);

spine-flutter/lib/generated/animation_state.dart

@@ -40,7 +40,7 @@ import 'skeleton.dart';
 import 'track_entry.dart';
 
 /// AnimationState wrapper
-class AnimationState implements Finalizable {
+class AnimationState {
   final Pointer<spine_animation_state_wrapper> _ptr;
 
   AnimationState.fromPointer(this._ptr);
@@ -53,6 +53,10 @@ class AnimationState implements Finalizable {
     return AnimationState.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_animation_state_dispose(_ptr);
+  }
+
   void update(double delta) {
     SpineBindings.bindings.spine_animation_state_update(_ptr, delta);
   }

spine-flutter/lib/generated/animation_state_data.dart

@@ -37,7 +37,7 @@ import 'animation.dart';
 import 'skeleton_data.dart';
 
 /// AnimationStateData wrapper
-class AnimationStateData implements Finalizable {
+class AnimationStateData {
   final Pointer<spine_animation_state_data_wrapper> _ptr;
 
   AnimationStateData.fromPointer(this._ptr);
@@ -50,6 +50,10 @@ class AnimationStateData implements Finalizable {
     return AnimationStateData.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_animation_state_data_dispose(_ptr);
+  }
+
   SkeletonData get skeletonData {
     final result = SpineBindings.bindings.spine_animation_state_data_get_skeleton_data(_ptr);
     return SkeletonData.fromPointer(result);

spine-flutter/lib/generated/atlas.dart

@@ -37,7 +37,7 @@ import 'arrays.dart';
 import 'atlas_region.dart';
 
 /// Atlas wrapper
-class Atlas implements Finalizable {
+class Atlas {
   final Pointer<spine_atlas_wrapper> _ptr;
 
   Atlas.fromPointer(this._ptr);

spine-flutter/lib/generated/atlas_attachment_loader.dart

@@ -46,7 +46,7 @@ import 'sequence.dart';
 import 'skin.dart';
 
 /// AtlasAttachmentLoader wrapper
-class AtlasAttachmentLoader implements Finalizable, AttachmentLoader {
+class AtlasAttachmentLoader implements AttachmentLoader {
   final Pointer<spine_atlas_attachment_loader_wrapper> _ptr;
 
   AtlasAttachmentLoader.fromPointer(this._ptr);
@@ -60,6 +60,10 @@ class AtlasAttachmentLoader implements Finalizable, AttachmentLoader {
     return AtlasAttachmentLoader.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_atlas_attachment_loader_dispose(_ptr);
+  }
+
   @override
   RegionAttachment newRegionAttachment(Skin skin, String name, String path, Sequence sequence) {
     final result = SpineBindings.bindings.spine_atlas_attachment_loader_new_region_attachment(

spine-flutter/lib/generated/atlas_page.dart

@@ -38,7 +38,7 @@ import 'texture_filter.dart';
 import 'texture_wrap.dart';
 
 /// AtlasPage wrapper
-class AtlasPage implements Finalizable {
+class AtlasPage {
   final Pointer<spine_atlas_page_wrapper> _ptr;
 
   AtlasPage.fromPointer(this._ptr);
@@ -51,6 +51,10 @@ class AtlasPage implements Finalizable {
     return AtlasPage.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_atlas_page_dispose(_ptr);
+  }
+
   String get name {
     final result = SpineBindings.bindings.spine_atlas_page_get_name(_ptr);
     return result.cast<Utf8>().toDartString();

spine-flutter/lib/generated/atlas_region.dart

@@ -52,6 +52,11 @@ class AtlasRegion extends TextureRegion {
     return AtlasRegion.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_atlas_region_dispose(_ptr);
+  }
+
   AtlasPage get page {
     final result = SpineBindings.bindings.spine_atlas_region_get_page(_ptr);
     return AtlasPage.fromPointer(result);

spine-flutter/lib/generated/attachment.dart

@@ -42,7 +42,7 @@ import 'point_attachment.dart';
 import 'region_attachment.dart';
 
 /// Attachment wrapper
-abstract class Attachment implements Finalizable {
+abstract class Attachment {
   final Pointer<spine_attachment_wrapper> _ptr;
 
   Attachment.fromPointer(this._ptr);

spine-flutter/lib/generated/attachment_timeline.dart

@@ -51,6 +51,10 @@ class AttachmentTimeline extends Timeline implements SlotTimeline {
     return AttachmentTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_attachment_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, String attachmentName) {
     SpineBindings.bindings
         .spine_attachment_timeline_set_frame(_ptr, frame, time, attachmentName.toNativeUtf8().cast<Char>());

spine-flutter/lib/generated/bone.dart

@@ -63,6 +63,11 @@ class Bone extends PosedActive implements Posed, Update {
     return Bone.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_bone_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_bone_get_rtti(_ptr);

spine-flutter/lib/generated/bone_data.dart

@@ -53,6 +53,11 @@ class BoneData extends PosedData {
     return BoneData.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_bone_data_dispose(_ptr);
+  }
+
   int get index {
     final result = SpineBindings.bindings.spine_bone_data_get_index(_ptr);
     return result;

spine-flutter/lib/generated/bone_local.dart

@@ -35,7 +35,7 @@ import '../spine_bindings.dart';
 import 'inherit.dart';
 
 /// BoneLocal wrapper
-class BoneLocal implements Finalizable {
+class BoneLocal {
   final Pointer<spine_bone_local_wrapper> _ptr;
 
   BoneLocal.fromPointer(this._ptr);
@@ -48,6 +48,10 @@ class BoneLocal implements Finalizable {
     return BoneLocal.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_bone_local_dispose(_ptr);
+  }
+
   void set(BoneLocal pose) {
     SpineBindings.bindings.spine_bone_local_set(_ptr, pose.nativePtr.cast());
   }

spine-flutter/lib/generated/bone_pose.dart

@@ -53,6 +53,11 @@ class BonePose extends BoneLocal implements Update {
     return BonePose.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_bone_pose_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_bone_pose_get_rtti(_ptr);

spine-flutter/lib/generated/bounding_box_attachment.dart

@@ -51,6 +51,10 @@ class BoundingBoxAttachment extends VertexAttachment {
     return BoundingBoxAttachment.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_bounding_box_attachment_dispose(_ptr);
+  }
+
   Color get color {
     final result = SpineBindings.bindings.spine_bounding_box_attachment_get_color(_ptr);
     return Color.fromPointer(result);

spine-flutter/lib/generated/clipping_attachment.dart

@@ -52,6 +52,10 @@ class ClippingAttachment extends VertexAttachment {
     return ClippingAttachment.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_clipping_attachment_dispose(_ptr);
+  }
+
   SlotData get endSlot {
     final result = SpineBindings.bindings.spine_clipping_attachment_get_end_slot(_ptr);
     return SlotData.fromPointer(result);

spine-flutter/lib/generated/color.dart

@@ -35,7 +35,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// Color wrapper
-class Color implements Finalizable {
+class Color {
   final Pointer<spine_color_wrapper> _ptr;
 
   Color.fromPointer(this._ptr);
@@ -53,6 +53,10 @@ class Color implements Finalizable {
     return Color.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_color_dispose(_ptr);
+  }
+
   Color clamp() {
     final result = SpineBindings.bindings.spine_color_clamp(_ptr);
     return Color.fromPointer(result);

spine-flutter/lib/generated/deform_timeline.dart

@@ -57,6 +57,10 @@ class DeformTimeline extends SlotCurveTimeline {
     return DeformTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_deform_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frameIndex, double time, ArrayFloat vertices) {
     SpineBindings.bindings.spine_deform_timeline_set_frame(_ptr, frameIndex, time, vertices.nativePtr.cast());
   }

spine-flutter/lib/generated/draw_order_timeline.dart

@@ -50,6 +50,10 @@ class DrawOrderTimeline extends Timeline {
     return DrawOrderTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_draw_order_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, ArrayInt drawOrder) {
     SpineBindings.bindings.spine_draw_order_timeline_set_frame(_ptr, frame, time, drawOrder.nativePtr.cast());
   }

spine-flutter/lib/generated/event.dart

@@ -36,7 +36,7 @@ import '../spine_bindings.dart';
 import 'event_data.dart';
 
 /// Event wrapper
-class Event implements Finalizable {
+class Event {
   final Pointer<spine_event_wrapper> _ptr;
 
   Event.fromPointer(this._ptr);
@@ -49,6 +49,10 @@ class Event implements Finalizable {
     return Event.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_event_dispose(_ptr);
+  }
+
   EventData get data {
     final result = SpineBindings.bindings.spine_event_get_data(_ptr);
     return EventData.fromPointer(result);

spine-flutter/lib/generated/event_data.dart

@@ -35,7 +35,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// EventData wrapper
-class EventData implements Finalizable {
+class EventData {
   final Pointer<spine_event_data_wrapper> _ptr;
 
   EventData.fromPointer(this._ptr);
@@ -48,6 +48,10 @@ class EventData implements Finalizable {
     return EventData.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_event_data_dispose(_ptr);
+  }
+
   String get name {
     final result = SpineBindings.bindings.spine_event_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();

spine-flutter/lib/generated/event_queue_entry.dart

@@ -37,7 +37,7 @@ import 'event_type.dart';
 import 'track_entry.dart';
 
 /// EventQueueEntry wrapper
-class EventQueueEntry implements Finalizable {
+class EventQueueEntry {
   final Pointer<spine_event_queue_entry_wrapper> _ptr;
 
   EventQueueEntry.fromPointer(this._ptr);
@@ -51,6 +51,10 @@ class EventQueueEntry implements Finalizable {
     return EventQueueEntry.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_event_queue_entry_dispose(_ptr);
+  }
+
   EventType get type {
     final result = SpineBindings.bindings.spine_event_queue_entry_get__type(_ptr);
     return EventType.fromValue(result);

spine-flutter/lib/generated/event_timeline.dart

@@ -51,6 +51,10 @@ class EventTimeline extends Timeline {
     return EventTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_event_timeline_dispose(_ptr);
+  }
+
   ArrayEvent get events {
     final result = SpineBindings.bindings.spine_event_timeline_get_events(_ptr);
     return ArrayEvent.fromPointer(result);

spine-flutter/lib/generated/from_property.dart

@@ -36,7 +36,7 @@ import 'rtti.dart';
 import 'arrays.dart';
 
 /// FromProperty wrapper
-abstract class FromProperty implements Finalizable {
+abstract class FromProperty {
   final Pointer<spine_from_property_wrapper> _ptr;
 
   FromProperty.fromPointer(this._ptr);

spine-flutter/lib/generated/from_rotate.dart

@@ -48,4 +48,8 @@ class FromRotate extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_rotate_create();
     return FromRotate.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_from_rotate_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/from_scale_x.dart

@@ -48,4 +48,8 @@ class FromScaleX extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_scale_x_create();
     return FromScaleX.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_from_scale_x_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/from_scale_y.dart

@@ -48,4 +48,8 @@ class FromScaleY extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_scale_y_create();
     return FromScaleY.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_from_scale_y_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/from_shear_y.dart

@@ -48,4 +48,8 @@ class FromShearY extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_shear_y_create();
     return FromShearY.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_from_shear_y_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/from_x.dart

@@ -48,4 +48,8 @@ class FromX extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_x_create();
     return FromX.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_from_x_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/from_y.dart

@@ -48,4 +48,8 @@ class FromY extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_y_create();
     return FromY.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_from_y_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/ik_constraint.dart

@@ -59,6 +59,11 @@ class IkConstraint extends PosedActive implements Posed, Constraint {
     return IkConstraint.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_ik_constraint_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_ik_constraint_get_rtti(_ptr);

spine-flutter/lib/generated/ik_constraint_data.dart

@@ -62,6 +62,11 @@ class IkConstraintData extends PosedData implements ConstraintData {
     return IkConstraintData.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_ik_constraint_data_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_ik_constraint_data_get_rtti(_ptr);

spine-flutter/lib/generated/ik_constraint_pose.dart

@@ -34,7 +34,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// IkConstraintPose wrapper
-class IkConstraintPose implements Finalizable {
+class IkConstraintPose {
   final Pointer<spine_ik_constraint_pose_wrapper> _ptr;
 
   IkConstraintPose.fromPointer(this._ptr);
@@ -47,6 +47,10 @@ class IkConstraintPose implements Finalizable {
     return IkConstraintPose.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_ik_constraint_pose_dispose(_ptr);
+  }
+
   void set(IkConstraintPose pose) {
     SpineBindings.bindings.spine_ik_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }

spine-flutter/lib/generated/ik_constraint_timeline.dart

@@ -50,6 +50,10 @@ class IkConstraintTimeline extends CurveTimeline implements ConstraintTimeline {
     return IkConstraintTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_ik_constraint_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, double mix, double softness, int bendDirection, bool compress, bool stretch) {
     SpineBindings.bindings
         .spine_ik_constraint_timeline_set_frame(_ptr, frame, time, mix, softness, bendDirection, compress, stretch);

spine-flutter/lib/generated/inherit_timeline.dart

@@ -51,6 +51,10 @@ class InheritTimeline extends Timeline implements BoneTimeline {
     return InheritTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_inherit_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, Inherit inherit) {
     SpineBindings.bindings.spine_inherit_timeline_set_frame(_ptr, frame, time, inherit.value);
   }

spine-flutter/lib/generated/mesh_attachment.dart

@@ -54,6 +54,10 @@ class MeshAttachment extends VertexAttachment {
     return MeshAttachment.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_mesh_attachment_dispose(_ptr);
+  }
+
   void updateRegion() {
     SpineBindings.bindings.spine_mesh_attachment_update_region(_ptr);
   }

spine-flutter/lib/generated/path_attachment.dart

@@ -52,6 +52,10 @@ class PathAttachment extends VertexAttachment {
     return PathAttachment.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_path_attachment_dispose(_ptr);
+  }
+
   ArrayFloat get lengths {
     final result = SpineBindings.bindings.spine_path_attachment_get_lengths(_ptr);
     return ArrayFloat.fromPointer(result);

spine-flutter/lib/generated/path_constraint.dart

@@ -58,6 +58,11 @@ class PathConstraint extends PosedActive implements Posed, Constraint {
     return PathConstraint.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_path_constraint_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_path_constraint_get_rtti(_ptr);

spine-flutter/lib/generated/path_constraint_data.dart

@@ -65,6 +65,11 @@ class PathConstraintData extends PosedData implements ConstraintData {
     return PathConstraintData.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_path_constraint_data_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_path_constraint_data_get_rtti(_ptr);

spine-flutter/lib/generated/path_constraint_mix_timeline.dart

@@ -51,6 +51,10 @@ class PathConstraintMixTimeline extends CurveTimeline implements ConstraintTimel
     return PathConstraintMixTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_path_constraint_mix_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, double mixRotate, double mixX, double mixY) {
     SpineBindings.bindings.spine_path_constraint_mix_timeline_set_frame(_ptr, frame, time, mixRotate, mixX, mixY);
   }

spine-flutter/lib/generated/path_constraint_pose.dart

@@ -34,7 +34,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// PathConstraintPose wrapper
-class PathConstraintPose implements Finalizable {
+class PathConstraintPose {
   final Pointer<spine_path_constraint_pose_wrapper> _ptr;
 
   PathConstraintPose.fromPointer(this._ptr);
@@ -47,6 +47,10 @@ class PathConstraintPose implements Finalizable {
     return PathConstraintPose.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_path_constraint_pose_dispose(_ptr);
+  }
+
   void set(PathConstraintPose pose) {
     SpineBindings.bindings.spine_path_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }

spine-flutter/lib/generated/path_constraint_position_timeline.dart

@@ -49,4 +49,8 @@ class PathConstraintPositionTimeline extends ConstraintTimeline1 {
         SpineBindings.bindings.spine_path_constraint_position_timeline_create(frameCount, bezierCount, constraintIndex);
     return PathConstraintPositionTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_path_constraint_position_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/path_constraint_spacing_timeline.dart

@@ -49,4 +49,8 @@ class PathConstraintSpacingTimeline extends ConstraintTimeline1 {
         SpineBindings.bindings.spine_path_constraint_spacing_timeline_create(frameCount, bezierCount, constraintIndex);
     return PathConstraintSpacingTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_path_constraint_spacing_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/physics_constraint.dart

@@ -58,6 +58,11 @@ class PhysicsConstraint extends PosedActive implements Posed, Constraint {
     return PhysicsConstraint.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_physics_constraint_get_rtti(_ptr);

spine-flutter/lib/generated/physics_constraint_damping_timeline.dart

@@ -49,4 +49,8 @@ class PhysicsConstraintDampingTimeline extends PhysicsConstraintTimeline {
         .spine_physics_constraint_damping_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintDampingTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_damping_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/physics_constraint_data.dart

@@ -61,6 +61,11 @@ class PhysicsConstraintData extends PosedData implements ConstraintData {
     return PhysicsConstraintData.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_data_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_physics_constraint_data_get_rtti(_ptr);

spine-flutter/lib/generated/physics_constraint_gravity_timeline.dart

@@ -49,4 +49,8 @@ class PhysicsConstraintGravityTimeline extends PhysicsConstraintTimeline {
         .spine_physics_constraint_gravity_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintGravityTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_gravity_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/physics_constraint_inertia_timeline.dart

@@ -49,4 +49,8 @@ class PhysicsConstraintInertiaTimeline extends PhysicsConstraintTimeline {
         .spine_physics_constraint_inertia_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintInertiaTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_inertia_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/physics_constraint_mass_timeline.dart

@@ -49,4 +49,8 @@ class PhysicsConstraintMassTimeline extends PhysicsConstraintTimeline {
         .spine_physics_constraint_mass_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintMassTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_mass_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/physics_constraint_mix_timeline.dart

@@ -49,4 +49,8 @@ class PhysicsConstraintMixTimeline extends PhysicsConstraintTimeline {
         .spine_physics_constraint_mix_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintMixTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_mix_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/physics_constraint_pose.dart

@@ -34,7 +34,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// PhysicsConstraintPose wrapper
-class PhysicsConstraintPose implements Finalizable {
+class PhysicsConstraintPose {
   final Pointer<spine_physics_constraint_pose_wrapper> _ptr;
 
   PhysicsConstraintPose.fromPointer(this._ptr);
@@ -47,6 +47,10 @@ class PhysicsConstraintPose implements Finalizable {
     return PhysicsConstraintPose.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_pose_dispose(_ptr);
+  }
+
   void set(PhysicsConstraintPose pose) {
     SpineBindings.bindings.spine_physics_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }

spine-flutter/lib/generated/physics_constraint_reset_timeline.dart

@@ -50,6 +50,10 @@ class PhysicsConstraintResetTimeline extends Timeline implements ConstraintTimel
     return PhysicsConstraintResetTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_reset_timeline_dispose(_ptr);
+  }
+
   @override
   int get constraintIndex {
     final result = SpineBindings.bindings.spine_physics_constraint_reset_timeline_get_constraint_index(_ptr);

spine-flutter/lib/generated/physics_constraint_strength_timeline.dart

@@ -49,4 +49,8 @@ class PhysicsConstraintStrengthTimeline extends PhysicsConstraintTimeline {
         .spine_physics_constraint_strength_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintStrengthTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_strength_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/physics_constraint_wind_timeline.dart

@@ -49,4 +49,8 @@ class PhysicsConstraintWindTimeline extends PhysicsConstraintTimeline {
         .spine_physics_constraint_wind_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintWindTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_physics_constraint_wind_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/point_attachment.dart

@@ -52,6 +52,10 @@ class PointAttachment extends Attachment {
     return PointAttachment.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_point_attachment_dispose(_ptr);
+  }
+
   double get x {
     final result = SpineBindings.bindings.spine_point_attachment_get_x(_ptr);
     return result;

spine-flutter/lib/generated/polygon.dart

@@ -35,7 +35,7 @@ import '../spine_bindings.dart';
 import 'arrays.dart';
 
 /// Polygon wrapper
-class Polygon implements Finalizable {
+class Polygon {
   final Pointer<spine_polygon_wrapper> _ptr;
 
   Polygon.fromPointer(this._ptr);
@@ -48,6 +48,10 @@ class Polygon implements Finalizable {
     return Polygon.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_polygon_dispose(_ptr);
+  }
+
   ArrayFloat get vertices {
     final result = SpineBindings.bindings.spine_polygon_get__vertices(_ptr);
     return ArrayFloat.fromPointer(result);

spine-flutter/lib/generated/posed_active.dart

@@ -34,7 +34,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// PosedActive wrapper
-class PosedActive implements Finalizable {
+class PosedActive {
   final Pointer<spine_posed_active_wrapper> _ptr;
 
   PosedActive.fromPointer(this._ptr);
@@ -42,6 +42,10 @@ class PosedActive implements Finalizable {
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
+  void dispose() {
+    SpineBindings.bindings.spine_posed_active_dispose(_ptr);
+  }
+
   bool get isActive {
     final result = SpineBindings.bindings.spine_posed_active_is_active(_ptr);
     return result;

spine-flutter/lib/generated/posed_data.dart

@@ -35,7 +35,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// PosedData wrapper
-class PosedData implements Finalizable {
+class PosedData {
   final Pointer<spine_posed_data_wrapper> _ptr;
 
   PosedData.fromPointer(this._ptr);
@@ -48,6 +48,10 @@ class PosedData implements Finalizable {
     return PosedData.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_posed_data_dispose(_ptr);
+  }
+
   String get name {
     final result = SpineBindings.bindings.spine_posed_data_get_name(_ptr);
     return result.cast<Utf8>().toDartString();

spine-flutter/lib/generated/region_attachment.dart

@@ -55,6 +55,10 @@ class RegionAttachment extends Attachment {
     return RegionAttachment.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_region_attachment_dispose(_ptr);
+  }
+
   void updateRegion() {
     SpineBindings.bindings.spine_region_attachment_update_region(_ptr);
   }

spine-flutter/lib/generated/render_command.dart

@@ -35,7 +35,7 @@ import '../spine_bindings.dart';
 import 'blend_mode.dart';
 
 /// RenderCommand wrapper
-class RenderCommand implements Finalizable {
+class RenderCommand {
   final Pointer<spine_render_command_wrapper> _ptr;
 
   RenderCommand.fromPointer(this._ptr);
@@ -43,6 +43,10 @@ class RenderCommand implements Finalizable {
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
+  void dispose() {
+    SpineBindings.bindings.spine_render_command_dispose(_ptr);
+  }
+
   Pointer<Float> get positions {
     final result = SpineBindings.bindings.spine_render_command_get_positions(_ptr);
     return result;

spine-flutter/lib/generated/rgb2_timeline.dart

@@ -49,6 +49,10 @@ class Rgb2Timeline extends SlotCurveTimeline {
     return Rgb2Timeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_rgb2_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, double r, double g, double b, double r2, double g2, double b2) {
     SpineBindings.bindings.spine_rgb2_timeline_set_frame(_ptr, frame, time, r, g, b, r2, g2, b2);
   }

spine-flutter/lib/generated/rgb_timeline.dart

@@ -49,6 +49,10 @@ class RgbTimeline extends SlotCurveTimeline {
     return RgbTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_rgb_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, double r, double g, double b) {
     SpineBindings.bindings.spine_rgb_timeline_set_frame(_ptr, frame, time, r, g, b);
   }

spine-flutter/lib/generated/rgba2_timeline.dart

@@ -49,6 +49,10 @@ class Rgba2Timeline extends SlotCurveTimeline {
     return Rgba2Timeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_rgba2_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, double r, double g, double b, double a, double r2, double g2, double b2) {
     SpineBindings.bindings.spine_rgba2_timeline_set_frame(_ptr, frame, time, r, g, b, a, r2, g2, b2);
   }

spine-flutter/lib/generated/rgba_timeline.dart

@@ -49,6 +49,10 @@ class RgbaTimeline extends SlotCurveTimeline {
     return RgbaTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_rgba_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, double r, double g, double b, double a) {
     SpineBindings.bindings.spine_rgba_timeline_set_frame(_ptr, frame, time, r, g, b, a);
   }

spine-flutter/lib/generated/rotate_timeline.dart

@@ -48,4 +48,8 @@ class RotateTimeline extends BoneTimeline1 {
     final ptr = SpineBindings.bindings.spine_rotate_timeline_create(frameCount, bezierCount, boneIndex);
     return RotateTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_rotate_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/rtti.dart

@@ -35,7 +35,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// Rtti wrapper
-class Rtti implements Finalizable {
+class Rtti {
   final Pointer<spine_rtti_wrapper> _ptr;
 
   Rtti.fromPointer(this._ptr);
@@ -43,6 +43,10 @@ class Rtti implements Finalizable {
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
+  void dispose() {
+    SpineBindings.bindings.spine_rtti_dispose(_ptr);
+  }
+
   String get className {
     final result = SpineBindings.bindings.spine_rtti_get_class_name(_ptr);
     return result.cast<Utf8>().toDartString();

spine-flutter/lib/generated/scale_timeline.dart

@@ -48,4 +48,8 @@ class ScaleTimeline extends BoneTimeline2 {
     final ptr = SpineBindings.bindings.spine_scale_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_scale_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/scale_x_timeline.dart

@@ -48,4 +48,8 @@ class ScaleXTimeline extends BoneTimeline1 {
     final ptr = SpineBindings.bindings.spine_scale_x_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleXTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_scale_x_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/scale_y_timeline.dart

@@ -48,4 +48,8 @@ class ScaleYTimeline extends BoneTimeline1 {
     final ptr = SpineBindings.bindings.spine_scale_y_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleYTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_scale_y_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/sequence.dart

@@ -38,7 +38,7 @@ import 'attachment.dart';
 import 'slot_pose.dart';
 
 /// Sequence wrapper
-class Sequence implements Finalizable {
+class Sequence {
   final Pointer<spine_sequence_wrapper> _ptr;
 
   Sequence.fromPointer(this._ptr);
@@ -51,6 +51,10 @@ class Sequence implements Finalizable {
     return Sequence.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_sequence_dispose(_ptr);
+  }
+
   Sequence copy() {
     final result = SpineBindings.bindings.spine_sequence_copy(_ptr);
     return Sequence.fromPointer(result);

spine-flutter/lib/generated/sequence_timeline.dart

@@ -60,6 +60,10 @@ class SequenceTimeline extends Timeline implements SlotTimeline {
     return SequenceTimeline.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_sequence_timeline_dispose(_ptr);
+  }
+
   void setFrame(int frame, double time, SequenceMode mode, int index, double delay) {
     SpineBindings.bindings.spine_sequence_timeline_set_frame(_ptr, frame, time, mode.value, index, delay);
   }

spine-flutter/lib/generated/shear_timeline.dart

@@ -48,4 +48,8 @@ class ShearTimeline extends BoneTimeline2 {
     final ptr = SpineBindings.bindings.spine_shear_timeline_create(frameCount, bezierCount, boneIndex);
     return ShearTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_shear_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/shear_x_timeline.dart

@@ -48,4 +48,8 @@ class ShearXTimeline extends BoneTimeline1 {
     final ptr = SpineBindings.bindings.spine_shear_x_timeline_create(frameCount, bezierCount, boneIndex);
     return ShearXTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_shear_x_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/shear_y_timeline.dart

@@ -48,4 +48,8 @@ class ShearYTimeline extends BoneTimeline1 {
     final ptr = SpineBindings.bindings.spine_shear_y_timeline_create(frameCount, bezierCount, boneIndex);
     return ShearYTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_shear_y_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/skeleton.dart

@@ -51,7 +51,7 @@ import 'skin.dart';
 import 'slot.dart';
 
 /// Skeleton wrapper
-class Skeleton implements Finalizable {
+class Skeleton {
   final Pointer<spine_skeleton_wrapper> _ptr;
 
   Skeleton.fromPointer(this._ptr);
@@ -64,6 +64,10 @@ class Skeleton implements Finalizable {
     return Skeleton.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_skeleton_dispose(_ptr);
+  }
+
   void updateCache() {
     SpineBindings.bindings.spine_skeleton_update_cache(_ptr);
   }

spine-flutter/lib/generated/skeleton_binary.dart

@@ -38,7 +38,7 @@ import 'attachment_loader.dart';
 import 'skeleton_data.dart';
 
 /// SkeletonBinary wrapper
-class SkeletonBinary implements Finalizable {
+class SkeletonBinary {
   final Pointer<spine_skeleton_binary_wrapper> _ptr;
 
   SkeletonBinary.fromPointer(this._ptr);
@@ -56,6 +56,10 @@ class SkeletonBinary implements Finalizable {
     return SkeletonBinary.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_skeleton_binary_dispose(_ptr);
+  }
+
   SkeletonData readSkeletonDataFile(String path) {
     final result =
         SpineBindings.bindings.spine_skeleton_binary_read_skeleton_data_file(_ptr, path.toNativeUtf8().cast<Char>());

spine-flutter/lib/generated/skeleton_bounds.dart

@@ -38,7 +38,7 @@ import 'polygon.dart';
 import 'skeleton.dart';
 
 /// SkeletonBounds wrapper
-class SkeletonBounds implements Finalizable {
+class SkeletonBounds {
   final Pointer<spine_skeleton_bounds_wrapper> _ptr;
 
   SkeletonBounds.fromPointer(this._ptr);
@@ -51,6 +51,10 @@ class SkeletonBounds implements Finalizable {
     return SkeletonBounds.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_skeleton_bounds_dispose(_ptr);
+  }
+
   void update(Skeleton skeleton, bool updateAabb) {
     SpineBindings.bindings.spine_skeleton_bounds_update(_ptr, skeleton.nativePtr.cast(), updateAabb);
   }

spine-flutter/lib/generated/skeleton_clipping.dart

@@ -38,7 +38,7 @@ import 'skeleton.dart';
 import 'slot.dart';
 
 /// SkeletonClipping wrapper
-class SkeletonClipping implements Finalizable {
+class SkeletonClipping {
   final Pointer<spine_skeleton_clipping_wrapper> _ptr;
 
   SkeletonClipping.fromPointer(this._ptr);
@@ -51,6 +51,10 @@ class SkeletonClipping implements Finalizable {
     return SkeletonClipping.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_skeleton_clipping_dispose(_ptr);
+  }
+
   int clipStart(Skeleton skeleton, Slot slot, ClippingAttachment clip) {
     final result = SpineBindings.bindings.spine_skeleton_clipping_clip_start(
         _ptr, skeleton.nativePtr.cast(), slot.nativePtr.cast(), clip.nativePtr.cast());

spine-flutter/lib/generated/skeleton_data.dart

@@ -41,7 +41,7 @@ import 'skin.dart';
 import 'slot_data.dart';
 
 /// SkeletonData wrapper
-class SkeletonData implements Finalizable {
+class SkeletonData {
   final Pointer<spine_skeleton_data_wrapper> _ptr;
 
   SkeletonData.fromPointer(this._ptr);
@@ -54,6 +54,10 @@ class SkeletonData implements Finalizable {
     return SkeletonData.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_skeleton_data_dispose(_ptr);
+  }
+
   BoneData findBone(String boneName) {
     final result = SpineBindings.bindings.spine_skeleton_data_find_bone(_ptr, boneName.toNativeUtf8().cast<Char>());
     return BoneData.fromPointer(result);

spine-flutter/lib/generated/skeleton_json.dart

@@ -38,7 +38,7 @@ import 'attachment_loader.dart';
 import 'skeleton_data.dart';
 
 /// SkeletonJson wrapper
-class SkeletonJson implements Finalizable {
+class SkeletonJson {
   final Pointer<spine_skeleton_json_wrapper> _ptr;
 
   SkeletonJson.fromPointer(this._ptr);
@@ -56,6 +56,10 @@ class SkeletonJson implements Finalizable {
     return SkeletonJson.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_skeleton_json_dispose(_ptr);
+  }
+
   SkeletonData readSkeletonDataFile(String path) {
     final result =
         SpineBindings.bindings.spine_skeleton_json_read_skeleton_data_file(_ptr, path.toNativeUtf8().cast<Char>());

spine-flutter/lib/generated/skeleton_renderer.dart

@@ -36,7 +36,7 @@ import 'render_command.dart';
 import 'skeleton.dart';
 
 /// SkeletonRenderer wrapper
-class SkeletonRenderer implements Finalizable {
+class SkeletonRenderer {
   final Pointer<spine_skeleton_renderer_wrapper> _ptr;
 
   SkeletonRenderer.fromPointer(this._ptr);
@@ -49,6 +49,10 @@ class SkeletonRenderer implements Finalizable {
     return SkeletonRenderer.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_skeleton_renderer_dispose(_ptr);
+  }
+
   RenderCommand render(Skeleton skeleton) {
     final result = SpineBindings.bindings.spine_skeleton_renderer_render(_ptr, skeleton.nativePtr.cast());
     return RenderCommand.fromPointer(result);

spine-flutter/lib/generated/skin.dart

@@ -44,7 +44,7 @@ import 'point_attachment.dart';
 import 'region_attachment.dart';
 
 /// Skin wrapper
-class Skin implements Finalizable {
+class Skin {
   final Pointer<spine_skin_wrapper> _ptr;
 
   Skin.fromPointer(this._ptr);
@@ -57,6 +57,10 @@ class Skin implements Finalizable {
     return Skin.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_skin_dispose(_ptr);
+  }
+
   void setAttachment(int slotIndex, String name, Attachment attachment) {
     SpineBindings.bindings
         .spine_skin_set_attachment(_ptr, slotIndex, name.toNativeUtf8().cast<Char>(), attachment.nativePtr.cast());

spine-flutter/lib/generated/slider.dart

@@ -57,6 +57,11 @@ class Slider extends PosedActive implements Posed, Constraint {
     return Slider.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_slider_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_slider_get_rtti(_ptr);

spine-flutter/lib/generated/slider_data.dart

@@ -69,6 +69,11 @@ class SliderData extends PosedData implements ConstraintData {
     return SliderData.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_slider_data_dispose(_ptr);
+  }
+
   @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_slider_data_get_rtti(_ptr);

spine-flutter/lib/generated/slider_mix_timeline.dart

@@ -48,4 +48,8 @@ class SliderMixTimeline extends ConstraintTimeline1 {
     final ptr = SpineBindings.bindings.spine_slider_mix_timeline_create(frameCount, bezierCount, sliderIndex);
     return SliderMixTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_slider_mix_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/slider_pose.dart

@@ -34,7 +34,7 @@ import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// SliderPose wrapper
-class SliderPose implements Finalizable {
+class SliderPose {
   final Pointer<spine_slider_pose_wrapper> _ptr;
 
   SliderPose.fromPointer(this._ptr);
@@ -47,6 +47,10 @@ class SliderPose implements Finalizable {
     return SliderPose.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_slider_pose_dispose(_ptr);
+  }
+
   void set(SliderPose pose) {
     SpineBindings.bindings.spine_slider_pose_set(_ptr, pose.nativePtr.cast());
   }

spine-flutter/lib/generated/slider_timeline.dart

@@ -48,4 +48,8 @@ class SliderTimeline extends ConstraintTimeline1 {
     final ptr = SpineBindings.bindings.spine_slider_timeline_create(frameCount, bezierCount, sliderIndex);
     return SliderTimeline.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_slider_timeline_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/slot.dart

@@ -39,7 +39,7 @@ import 'slot_data.dart';
 import 'slot_pose.dart';
 
 /// Slot wrapper
-class Slot implements Finalizable, Posed {
+class Slot implements Posed {
   final Pointer<spine_slot_wrapper> _ptr;
 
   Slot.fromPointer(this._ptr);
@@ -53,6 +53,10 @@ class Slot implements Finalizable, Posed {
     return Slot.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_slot_dispose(_ptr);
+  }
+
   Bone get bone {
     final result = SpineBindings.bindings.spine_slot_get_bone(_ptr);
     return Bone.fromPointer(result);

spine-flutter/lib/generated/slot_data.dart

@@ -54,6 +54,11 @@ class SlotData extends PosedData {
     return SlotData.fromPointer(ptr);
   }
 
+  @override
+  void dispose() {
+    SpineBindings.bindings.spine_slot_data_dispose(_ptr);
+  }
+
   int get index {
     final result = SpineBindings.bindings.spine_slot_data_get_index(_ptr);
     return result;

spine-flutter/lib/generated/slot_pose.dart

@@ -44,7 +44,7 @@ import 'point_attachment.dart';
 import 'region_attachment.dart';
 
 /// SlotPose wrapper
-class SlotPose implements Finalizable {
+class SlotPose {
   final Pointer<spine_slot_pose_wrapper> _ptr;
 
   SlotPose.fromPointer(this._ptr);
@@ -57,6 +57,10 @@ class SlotPose implements Finalizable {
     return SlotPose.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_slot_pose_dispose(_ptr);
+  }
+
   void set(SlotPose pose) {
     SpineBindings.bindings.spine_slot_pose_set(_ptr, pose.nativePtr.cast());
   }

spine-flutter/lib/generated/texture_region.dart

@@ -35,7 +35,7 @@ import '../spine_bindings.dart';
 import 'rtti.dart';
 
 /// TextureRegion wrapper
-class TextureRegion implements Finalizable {
+class TextureRegion {
   final Pointer<spine_texture_region_wrapper> _ptr;
 
   TextureRegion.fromPointer(this._ptr);
@@ -48,6 +48,10 @@ class TextureRegion implements Finalizable {
     return TextureRegion.fromPointer(ptr);
   }
 
+  void dispose() {
+    SpineBindings.bindings.spine_texture_region_dispose(_ptr);
+  }
+
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_texture_region_get_rtti(_ptr);
     return Rtti.fromPointer(result);

spine-flutter/lib/generated/timeline.dart

@@ -39,7 +39,7 @@ import 'mix_direction.dart';
 import 'skeleton.dart';
 
 /// Timeline wrapper
-abstract class Timeline implements Finalizable {
+abstract class Timeline {
   final Pointer<spine_timeline_wrapper> _ptr;
 
   Timeline.fromPointer(this._ptr);

spine-flutter/lib/generated/to_property.dart

@@ -38,7 +38,7 @@ import 'skeleton.dart';
 import 'transform_constraint_pose.dart';
 
 /// ToProperty wrapper
-abstract class ToProperty implements Finalizable {
+abstract class ToProperty {
   final Pointer<spine_to_property_wrapper> _ptr;
 
   ToProperty.fromPointer(this._ptr);

spine-flutter/lib/generated/to_rotate.dart

@@ -48,4 +48,8 @@ class ToRotate extends ToProperty {
     final ptr = SpineBindings.bindings.spine_to_rotate_create();
     return ToRotate.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_to_rotate_dispose(_ptr);
+  }
 }

spine-flutter/lib/generated/to_scale_x.dart

@@ -48,4 +48,8 @@ class ToScaleX extends ToProperty {
     final ptr = SpineBindings.bindings.spine_to_scale_x_create();
     return ToScaleX.fromPointer(ptr);
   }
+
+  void dispose() {
+    SpineBindings.bindings.spine_to_scale_x_dispose(_ptr);
+  }
 }